compiler: de-lhs hsSyn/
authorAustin Seipp <austin@well-typed.com>
Wed, 3 Dec 2014 18:45:05 +0000 (12:45 -0600)
committerAustin Seipp <austin@well-typed.com>
Wed, 3 Dec 2014 19:52:27 +0000 (13:52 -0600)
Signed-off-by: Austin Seipp <austin@well-typed.com>
12 files changed:
compiler/hsSyn/Convert.hs [moved from compiler/hsSyn/Convert.lhs with 99% similarity]
compiler/hsSyn/HsBinds.hs [moved from compiler/hsSyn/HsBinds.lhs with 95% similarity]
compiler/hsSyn/HsDecls.hs [moved from compiler/hsSyn/HsDecls.lhs with 93% similarity]
compiler/hsSyn/HsExpr.hs [moved from compiler/hsSyn/HsExpr.lhs with 95% similarity]
compiler/hsSyn/HsExpr.hs-boot [moved from compiler/hsSyn/HsExpr.lhs-boot with 92% similarity]
compiler/hsSyn/HsImpExp.hs [moved from compiler/hsSyn/HsImpExp.lhs with 88% similarity]
compiler/hsSyn/HsLit.hs [moved from compiler/hsSyn/HsLit.lhs with 93% similarity]
compiler/hsSyn/HsPat.hs [moved from compiler/hsSyn/HsPat.lhs with 92% similarity]
compiler/hsSyn/HsPat.hs-boot [moved from compiler/hsSyn/HsPat.lhs-boot with 96% similarity]
compiler/hsSyn/HsSyn.hs [moved from compiler/hsSyn/HsSyn.lhs with 96% similarity]
compiler/hsSyn/HsTypes.hs [moved from compiler/hsSyn/HsTypes.lhs with 91% similarity]
compiler/hsSyn/HsUtils.hs [moved from compiler/hsSyn/HsUtils.lhs with 94% similarity]

similarity index 99%
rename from compiler/hsSyn/Convert.lhs
rename to compiler/hsSyn/Convert.hs
index 56282db..8dc60d6 100644 (file)
@@ -1,11 +1,11 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+
 
 This module converts Template Haskell syntax into HsSyn
+-}
 
-\begin{code}
 {-# LANGUAGE CPP #-}
 
 module Convert( convertToHsExpr, convertToPat, convertToHsDecls,
@@ -1140,7 +1140,7 @@ okOcc ns str
   | OccName.isVarNameSpace ns     = okVarOcc str
   | OccName.isDataConNameSpace ns = okConOcc str
   | otherwise                     = okTcOcc  str
-            
+
 -- Determine the name space of a name in a type
 --
 isVarName :: TH.Name -> Bool
@@ -1216,8 +1216,8 @@ mk_pkg pkg = stringToPackageKey (TH.pkgString pkg)
 
 mk_uniq :: Int -> Unique
 mk_uniq u = mkUniqueGrimily u
-\end{code}
 
+{-
 Note [Binders in Template Haskell]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider this TH term construction:
@@ -1270,3 +1270,4 @@ the way System Names are printed.
 
 There's a small complication of course; see Note [Looking up Exact
 RdrNames] in RnEnv.
+-}
similarity index 95%
rename from compiler/hsSyn/HsBinds.lhs
rename to compiler/hsSyn/HsBinds.hs
index cc68870..555139a 100644 (file)
@@ -1,12 +1,12 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+
 \section[HsBinds]{Abstract syntax: top-level bindings and signatures}
 
 Datatype for: @BindGroup@, @Bind@, @Sig@, @Bind@.
+-}
 
-\begin{code}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE FlexibleContexts #-}
@@ -50,17 +50,17 @@ import Control.Applicative hiding (empty)
 #else
 import Control.Applicative ((<$>))
 #endif
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Bindings: @BindGroup@}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 Global bindings (where clauses)
+-}
 
-\begin{code}
 -- During renaming, we need bindings where the left-hand sides
 -- have been renamed but the the right-hand sides have not.
 -- the ...LR datatypes are parametrized by two id types,
@@ -234,8 +234,7 @@ data PatSynBind idL idR
 deriving instance (DataId idL, DataId idR )
   => Data (PatSynBind idL idR)
 
-\end{code}
-
+{-
 Note [AbsBinds]
 ~~~~~~~~~~~~~~~
 The AbsBinds constructor is used in the output of the type checker, to record
@@ -333,8 +332,8 @@ Specifically,
 
   * Before renaming, and after typechecking, the field is unused;
     it's just an error thunk
+-}
 
-\begin{code}
 instance (OutputableBndr idL, OutputableBndr idR) => Outputable (HsLocalBindsLR idL idR) where
   ppr (HsValBinds bs) = ppr bs
   ppr (HsIPBinds bs)  = ppr bs
@@ -427,8 +426,8 @@ getTypeSigNames (ValBindsOut _ sigs)
   = mkNameSet [unLoc n | L _ (TypeSig names _ _) <- sigs, n <- names]
 getTypeSigNames _
   = panic "HsBinds.getTypeSigNames"
-\end{code}
 
+{-
 What AbsBinds means
 ~~~~~~~~~~~~~~~~~~~
          AbsBinds tvs
@@ -452,8 +451,8 @@ So the desugarer tries to do a better job:
 
         tp = /\ [a,b] -> \ [d1,d2] -> letrec DBINDS and BIND
                                       in (fm,gm)
+-}
 
-\begin{code}
 instance (OutputableBndr idL, OutputableBndr idR) => Outputable (HsBindLR idL idR) where
     ppr mbind = ppr_monobind mbind
 
@@ -507,10 +506,7 @@ instance (OutputableBndr idL, OutputableBndr idR) => Outputable (PatSynBind idL
           ImplicitBidirectional    -> ppr_simple equals
           ExplicitBidirectional mg -> ppr_simple (ptext (sLit "<-")) <+> ptext (sLit "where") $$
                                       (nest 2 $ pprFunBind psyn is_infix mg)
-\end{code}
 
-
-\begin{code}
 pprTicks :: SDoc -> SDoc -> SDoc
 -- Print stuff about ticks only when -dppr-debug is on, to avoid
 -- them appearing in error messages (from the desugarer); see Trac # 3263
@@ -520,15 +516,15 @@ pprTicks pp_no_debug pp_when_debug
   = getPprStyle (\ sty -> if debugStyle sty || dumpStyle sty
                              then pp_when_debug
                              else pp_no_debug)
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Implicit parameter bindings
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 data HsIPBinds id
   = IPBinds
         [LIPBind id]
@@ -565,21 +561,20 @@ instance (OutputableBndr id) => Outputable (IPBind id) where
     where name = case lr of
                    Left ip  -> pprBndr LetBind ip
                    Right id -> pprBndr LetBind id
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{@Sig@: type signatures and value-modifying user pragmas}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 It is convenient to lump ``value-modifying'' user-pragmas (e.g.,
 ``specialise this function to these four types...'') in with type
 signatures.  Then all the machinery to move them into place, etc.,
 serves for both.
+-}
 
-\begin{code}
 type LSig name = Located (Sig name)
 
 -- | Signatures and pragmas
@@ -769,13 +764,13 @@ hsSigDoc (InlineSig _ prag)     = ppr (inlinePragmaSpec prag) <+> ptext (sLit "p
 hsSigDoc (SpecInstSig {})       = ptext (sLit "SPECIALISE instance pragma")
 hsSigDoc (FixSig {})            = ptext (sLit "fixity declaration")
 hsSigDoc (MinimalSig {})        = ptext (sLit "MINIMAL pragma")
-\end{code}
 
+{-
 Check if signatures overlap; this is used when checking for duplicate
 signatures. Since some of the signatures contain a list of names, testing for
 equality is not enough -- we have to check if they overlap.
+-}
 
-\begin{code}
 instance (OutputableBndr name) => Outputable (Sig name) where
     ppr sig = ppr_sig sig
 
@@ -835,15 +830,15 @@ instance Outputable TcSpecPrag where
 
 pprMinimalSig :: OutputableBndr name => BooleanFormula (Located name) -> SDoc
 pprMinimalSig bf = ptext (sLit "MINIMAL") <+> ppr (fmap unLoc bf)
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[PatSynBind]{A pattern synonym definition}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 data HsPatSynDetails a
   = InfixPatSyn a a
   | PrefixPatSyn [a]
@@ -885,4 +880,3 @@ data HsPatSynDir id
   | ExplicitBidirectional (MatchGroup id (LHsExpr id))
   deriving (Typeable)
 deriving instance (DataId id) => Data (HsPatSynDir id)
-\end{code}
similarity index 93%
rename from compiler/hsSyn/HsDecls.lhs
rename to compiler/hsSyn/HsDecls.hs
index f4e5a46..f81d0a1 100644 (file)
@@ -1,9 +1,8 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+-}
 
-\begin{code}
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE DeriveDataTypeable, DeriveFunctor, DeriveFoldable,
              DeriveTraversable #-}
@@ -107,15 +106,15 @@ import Data.Foldable ( Foldable )
 import Data.Traversable ( Traversable )
 #endif
 import Data.Maybe
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[HsDecl]{Declarations}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type LHsDecl id = Located (HsDecl id)
         -- ^ When in a list this may have
         --
@@ -246,9 +245,7 @@ appendGroups
         hs_ruleds = rulds1 ++ rulds2,
         hs_vects  = vects1 ++ vects2,
         hs_docs   = docs1  ++ docs2 }
-\end{code}
 
-\begin{code}
 instance OutputableBndr name => Outputable (HsDecl name) where
     ppr (TyClD dcl)             = ppr dcl
     ppr (ValD binds)            = ppr binds
@@ -315,14 +312,13 @@ deriving instance (DataId id) => Data (SpliceDecl id)
 
 instance OutputableBndr name => Outputable (SpliceDecl name) where
    ppr (SpliceDecl (L _ e) _) = pprUntypedSplice e
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[SynDecl]{@data@, @newtype@ or @type@ (synonym) type declaration}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
                 --------------------------------
                         THE NAMING STORY
@@ -455,9 +451,8 @@ Interface file code:
 
   - RnHsSyn.instDeclFVs treats the dict fun name as free in the decl, so that we
     suck in the dfun binding
+-}
 
-
-\begin{code}
 type LTyClDecl name = Located (TyClDecl name)
 
 -- | A type or class declaration.
@@ -555,12 +550,11 @@ data FamilyInfo name
   deriving( Typeable )
 deriving instance (DataId name) => Data (FamilyInfo name)
 
-\end{code}
-
+{-
 ------------------------------
 Simple classifiers
+-}
 
-\begin{code}
 -- | @True@ <=> argument is a @data@\/@newtype@
 -- declaration.
 isDataDecl :: TyClDecl name -> Bool
@@ -605,11 +599,8 @@ isDataFamilyDecl :: TyClDecl name -> Bool
 isDataFamilyDecl (FamDecl (FamilyDecl { fdInfo = DataFamily })) = True
 isDataFamilyDecl _other      = False
 
-\end{code}
-
-Dealing with names
+-- Dealing with names
 
-\begin{code}
 tyFamInstDeclName :: OutputableBndr name
                   => TyFamInstDecl name -> name
 tyFamInstDeclName = unLoc . tyFamInstDeclLName
@@ -630,9 +621,7 @@ tcdName = unLoc . tyClDeclLName
 tyClDeclTyVars :: OutputableBndr name => TyClDecl name -> LHsTyVarBndrs name
 tyClDeclTyVars (FamDecl { tcdFam = FamilyDecl { fdTyVars = tvs } }) = tvs
 tyClDeclTyVars d = tcdTyVars d
-\end{code}
 
-\begin{code}
 countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int, Int)
         -- class, synonym decls, data, newtype, family decls
 countTyClDecls decls
@@ -669,8 +658,8 @@ famDeclHasCusk (FamilyDecl { fdInfo = ClosedTypeFamily _
                            , fdKindSig = m_sig })
   = hsTvbAllKinded tyvars && isJust m_sig
 famDeclHasCusk _ = True  -- all open families have CUSKs!
-\end{code}
 
+{-
 Note [Complete user-supplied kind signatures]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 We kind-check declarations differently if they have a complete, user-supplied
@@ -693,8 +682,8 @@ RHS are annotated with kinds.
 variables and its return type are annotated.
 
  - An open type family always has a CUSK -- unannotated type variables (and return type) default to *.
+-}
 
-\begin{code}
 instance OutputableBndr name
               => Outputable (TyClDecl name) where
 
@@ -777,15 +766,14 @@ pprTyClDeclFlavour (FamDecl { tcdFam = FamilyDecl { fdInfo = info }})
   = pprFlavour info
 pprTyClDeclFlavour (DataDecl { tcdDataDefn = HsDataDefn { dd_ND = nd } })
   = ppr nd
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[ConDecl]{A data-constructor declaration}
-%*                                                                      *
-%************************************************************************
-
-\begin{code}
+*                                                                      *
+************************************************************************
+-}
 
 data HsDataDefn name   -- The payload of a data type defn
                        -- Used *both* for vanilla data declarations,
@@ -920,10 +908,7 @@ instance Outputable ty => Outputable (ResType ty) where
          -- Debugging only
    ppr ResTyH98       = ptext (sLit "ResTyH98")
    ppr (ResTyGADT ty) = ptext (sLit "ResTyGADT") <+> ppr ty
-\end{code}
-
 
-\begin{code}
 pp_data_defn :: OutputableBndr name
                   => (HsContext name -> SDoc)   -- Printing the header
                   -> HsDataDefn name
@@ -1005,13 +990,13 @@ instance (Outputable name) => OutputableBndr [Located name] where
 
   pprInfixOcc [x] = ppr x
   pprInfixOcc xs  = cat $ punctuate comma (map ppr xs)
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Instance declarations
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 Note [Type family instance declarations in HsSyn]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1029,8 +1014,8 @@ It is parameterised over its tfe_pats field:
         type T a b
         type T a b = a -> b   -- The default instance
    It is represented by a TyFamDefltEqn, with *type variables8 in the tfe_pats field.
+-}
 
-\begin{code}
 ----------------- Type synonym family instances -------------
 type LTyFamInstEqn  name = Located (TyFamInstEqn  name)
   -- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSemi'
@@ -1125,8 +1110,8 @@ data InstDecl name  -- Both class and family instances
       { tfid_inst :: TyFamInstDecl name }
   deriving (Typeable)
 deriving instance (DataId id) => Data (InstDecl id)
-\end{code}
 
+{-
 Note [Family instance declaration binders]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 A {Ty|Data}FamInstDecl is a data/type family instance declaration
@@ -1145,8 +1130,8 @@ tvs are fv(pat_tys), *including* ones that are already in scope
           type F (a8,b9) x10 = x10->a8
    so that we can compare the type patter in the 'instance' decl and
    in the associated 'type' decl
+-}
 
-\begin{code}
 instance (OutputableBndr name) => Outputable (TyFamInstDecl name) where
   ppr = pprTyFamInstDecl TopLevel
 
@@ -1231,15 +1216,15 @@ instDeclDataFamInsts inst_decls
       = map unLoc fam_insts
     do_one (L _ (DataFamInstD { dfid_inst = fam_inst }))      = [fam_inst]
     do_one (L _ (TyFamInstD {}))                              = []
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[DerivDecl]{A stand-alone instance deriving declaration}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type LDerivDecl name = Located (DerivDecl name)
 
 data DerivDecl name = DerivDecl
@@ -1256,19 +1241,19 @@ deriving instance (DataId name) => Data (DerivDecl name)
 instance (OutputableBndr name) => Outputable (DerivDecl name) where
     ppr (DerivDecl ty o)
         = hsep [ptext (sLit "deriving instance"), ppOverlapPragma o, ppr ty]
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[DefaultDecl]{A @default@ declaration}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 There can only be one default declaration per module, but it is hard
 for the parser to check that; we pass them all through in the abstract
 syntax, and that restriction must be checked in the front end.
+-}
 
-\begin{code}
 type LDefaultDecl name = Located (DefaultDecl name)
 
 data DefaultDecl name
@@ -1284,15 +1269,14 @@ instance (OutputableBndr name)
 
     ppr (DefaultDecl tys)
       = ptext (sLit "default") <+> parens (interpp'SP tys)
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Foreign function interface declaration}
-%*                                                                      *
-%************************************************************************
-
-\begin{code}
+*                                                                      *
+************************************************************************
+-}
 
 -- foreign declarations are distinguished as to whether they define or use a
 -- Haskell name
@@ -1408,16 +1392,15 @@ instance Outputable ForeignImport where
 instance Outputable ForeignExport where
   ppr (CExport  (L _ (CExportStatic lbl cconv)) _) =
     ppr cconv <+> char '"' <> ppr lbl <> char '"'
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Transformation rules}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type LRuleDecl name = Located (RuleDecl name)
 
 data RuleDecl name
@@ -1464,14 +1447,13 @@ instance OutputableBndr name => Outputable (RuleDecl name) where
 instance OutputableBndr name => Outputable (RuleBndr name) where
    ppr (RuleBndr name) = ppr name
    ppr (RuleBndrSig name ty) = ppr name <> dcolon <> ppr ty
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Vectorisation declarations}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 A vectorisation pragma, one of
 
@@ -1481,8 +1463,8 @@ A vectorisation pragma, one of
 
   {-# VECTORISE type T = ty #-}
   {-# VECTORISE SCALAR type T #-}
+-}
 
-\begin{code}
 type LVectDecl name = Located (VectDecl name)
 
 data VectDecl name
@@ -1565,15 +1547,14 @@ instance OutputableBndr name => Outputable (VectDecl name) where
     = sep [text "{-# VECTORISE SCALAR instance" <+> ppr ty <+> text "#-}" ]
   ppr (HsVectInstOut i)
     = sep [text "{-# VECTORISE SCALAR instance" <+> ppr i <+> text "#-}" ]
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[DocDecl]{Document comments}
-%*                                                                      *
-%************************************************************************
-
-\begin{code}
+*                                                                      *
+************************************************************************
+-}
 
 type LDocDecl = Located (DocDecl)
 
@@ -1594,17 +1575,16 @@ docDeclDoc (DocCommentPrev d) = d
 docDeclDoc (DocCommentNamed _ d) = d
 docDeclDoc (DocGroup _ d) = d
 
-\end{code}
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[DeprecDecl]{Deprecations}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 We use exported entities for things to deprecate.
+-}
 
-\begin{code}
 type LWarnDecl name = Located (WarnDecl name)
 
 data WarnDecl name = Warning name WarningTxt
@@ -1613,15 +1593,15 @@ data WarnDecl name = Warning name WarningTxt
 instance OutputableBndr name => Outputable (WarnDecl name) where
     ppr (Warning thing txt)
       = hsep [text "{-# DEPRECATED", ppr thing, doubleQuotes (ppr txt), text "#-}"]
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[AnnDecl]{Annotations}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type LAnnDecl name = Located (AnnDecl name)
 
 data AnnDecl name = HsAnnotation (AnnProvenance name) (Located (HsExpr name))
@@ -1651,15 +1631,15 @@ pprAnnProvenance :: OutputableBndr name => AnnProvenance name -> SDoc
 pprAnnProvenance ModuleAnnProvenance       = ptext (sLit "ANN module")
 pprAnnProvenance (ValueAnnProvenance name) = ptext (sLit "ANN") <+> ppr name
 pprAnnProvenance (TypeAnnProvenance name)  = ptext (sLit "ANN type") <+> ppr name
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[RoleAnnot]{Role annotations}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type LRoleAnnotDecl name = Located (RoleAnnotDecl name)
 
 -- See #8185 for more info about why role annotations are
@@ -1681,5 +1661,3 @@ instance OutputableBndr name => Outputable (RoleAnnotDecl name) where
 
 roleAnnotDeclName :: RoleAnnotDecl name -> name
 roleAnnotDeclName (RoleAnnotDecl (L _ name) _) = name
-
-\end{code}
similarity index 95%
rename from compiler/hsSyn/HsExpr.lhs
rename to compiler/hsSyn/HsExpr.hs
index 82098e2..1861811 100644 (file)
@@ -1,8 +1,8 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
-\begin{code}
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+-}
+
 {-# LANGUAGE CPP, DeriveDataTypeable, ScopedTypeVariables #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE FlexibleContexts #-}
@@ -40,15 +40,15 @@ import Type
 
 -- libraries:
 import Data.Data hiding (Fixity)
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Expressions proper}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 -- * Expressions proper
 
 type LHsExpr id = Located (HsExpr id)
@@ -87,8 +87,7 @@ noSyntaxExpr = HsLit (HsString "" (fsLit "noSyntaxExpr"))
 type CmdSyntaxTable id = [(Name, SyntaxExpr id)]
 -- See Note [CmdSyntaxTable]
 
-\end{code}
-
+{-
 Note [CmdSyntaxtable]
 ~~~~~~~~~~~~~~~~~~~~~
 Used only for arrow-syntax stuff (HsCmdTop), the CmdSyntaxTable keeps
@@ -122,9 +121,8 @@ is Less Cool because
     than the rest of rebindable syntax, where the type is less
     pre-ordained.  (And this flexibility is useful; for example we can
     typecheck do-notation with (>>=) :: m1 a -> (a -> m2 b) -> m2 b.)
+-}
 
-
-\begin{code}
 -- | A Haskell expression.
 data HsExpr id
   = HsVar     id                        -- ^ Variable
@@ -296,7 +294,7 @@ data HsExpr id
                 (ArithSeqInfo id)
 
   -- | Arithmetic sequence for parallel array
-  | PArrSeq                             
+  | PArrSeq
                 PostTcExpr              -- [:e1..e2:] or [:e1, e2..e3:]
                 (ArithSeqInfo id)
 
@@ -442,8 +440,8 @@ deriving instance (DataId id) => Data (HsTupArg id)
 tupArgPresent :: LHsTupArg id -> Bool
 tupArgPresent (L _ (Present {})) = True
 tupArgPresent (L _ (Missing {})) = False
-\end{code}
 
+{-
 Note [Parens in HsSyn]
 ~~~~~~~~~~~~~~~~~~~~~~
 HsPar (and ParPat in patterns, HsParTy in types) is used as follows
@@ -478,13 +476,11 @@ whereas that would not be possible using a all to a polymorphic function
 (because you can't call a polymorphic function at an unboxed type).
 
 So we use Nothing to mean "use the old built-in typing rule".
+-}
 
-\begin{code}
 instance OutputableBndr id => Outputable (HsExpr id) where
     ppr expr = pprExpr expr
-\end{code}
 
-\begin{code}
 -----------------------
 -- pprExpr, pprLExpr, pprBinds call pprDeeper;
 -- the underscore versions do not
@@ -696,8 +692,7 @@ ppr_expr (HsArrForm op _ args)
 ppr_expr (HsUnboundVar nm)
   = ppr nm
 
-\end{code}
-
+{-
 HsSyn records exactly where the user put parens, with HsPar.
 So generally speaking we print without adding any parens.
 However, some code is internally generated, and in some places
@@ -707,8 +702,8 @@ pprParendExpr (but don't print double parens of course).
 For operator applications we don't add parens, because the oprerator
 fixities should do the job, except in debug mode (-dppr-debug) so we
 can see the structure of the parse tree.
+-}
 
-\begin{code}
 pprDebugParendExpr :: OutputableBndr id => LHsExpr id -> SDoc
 pprDebugParendExpr expr
   = getPprStyle (\sty ->
@@ -754,17 +749,17 @@ isAtomicHsExpr (HsUnboundVar {}) = True
 isAtomicHsExpr (HsWrap _ e)   = isAtomicHsExpr e
 isAtomicHsExpr (HsPar e)      = isAtomicHsExpr (unLoc e)
 isAtomicHsExpr _              = False
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Commands (in arrow abstractions)}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 We re-use HsExpr to represent these.
+-}
 
-\begin{code}
 type LHsCmd id = Located (HsCmd id)
 
 data HsCmd id
@@ -816,13 +811,12 @@ deriving instance (DataId id) => Data (HsCmd id)
 data HsArrAppType = HsHigherOrderApp | HsFirstOrderApp
   deriving (Data, Typeable)
 
-\end{code}
-
+{-
 Top-level command, introducing a new arrow.
 This may occur inside a proc (where the stack is empty) or as an
 argument of a command-forming operator.
+-}
 
-\begin{code}
 type LHsCmdTop id = Located (HsCmdTop id)
 
 data HsCmdTop id
@@ -832,10 +826,7 @@ data HsCmdTop id
              (CmdSyntaxTable id) -- See Note [CmdSyntaxTable]
   deriving (Typeable)
 deriving instance (DataId id) => Data (HsCmdTop id)
-\end{code}
 
-
-\begin{code}
 instance OutputableBndr id => Outputable (HsCmd id) where
     ppr cmd = pprCmd cmd
 
@@ -923,24 +914,22 @@ pprCmdArg (HsCmdTop cmd _ _ _)
 instance OutputableBndr id => Outputable (HsCmdTop id) where
     ppr = pprCmdArg
 
-\end{code}
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Record binds}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type HsRecordBinds id = HsRecFields id (LHsExpr id)
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{@Match@, @GRHSs@, and @GRHS@ datatypes}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 @Match@es are sets of pattern bindings and right hand sides for
 functions, patterns or case branches. For example, if a function @g@
@@ -955,8 +944,8 @@ It is always the case that each element of an @[Match]@ list has the
 same number of @pats@s inside it.  This corresponds to saying that
 a function defined by pattern matching must have the same number of
 patterns in each equation.
+-}
 
-\begin{code}
 data MatchGroup id body
   = MG { mg_alts    :: [LMatch id body]  -- The alternatives
        , mg_arg_tys :: [PostTc id Type]  -- Types of the arguments, t1..tn
@@ -1013,11 +1002,9 @@ data GRHS id body = GRHS [GuardLStmt id] -- Guards
                          body            -- Right hand side
   deriving (Typeable)
 deriving instance (Data body,DataId id) => Data (GRHS id body)
-\end{code}
 
-We know the list must have at least one @Match@ in it.
+-- We know the list must have at least one @Match@ in it.
 
-\begin{code}
 pprMatches :: (OutputableBndr idL, OutputableBndr idR, Outputable body)
            => HsMatchContext idL -> MatchGroup idR body -> SDoc
 pprMatches ctxt (MG { mg_alts = matches })
@@ -1087,15 +1074,15 @@ pprGRHS ctxt (GRHS guards body)
 
 pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc
 pp_rhs ctxt rhs = matchSeparator ctxt <+> pprDeeper (ppr rhs)
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Do stmts and list comprehensions}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type LStmt id body = Located (StmtLR id id body)
 type LStmtLR idL idR body = Located (StmtLR idL idR body)
 
@@ -1223,8 +1210,8 @@ data ParStmtBlock idL idR
         (SyntaxExpr idR)   -- The return operator
   deriving( Typeable )
 deriving instance (DataId idL, DataId idR) => Data (ParStmtBlock idL idR)
-\end{code}
 
+{-
 Note [The type of bind in Stmts]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Some Stmts, notably BindStmt, keep the (>>=) bind operator.
@@ -1359,9 +1346,8 @@ Parallel statements require the 'Control.Monad.Zip.mzip' function:
 
 In any other context than 'MonadComp', the fields for most of these
 'SyntaxExpr's stay bottom.
+-}
 
-
-\begin{code}
 instance (OutputableBndr idL, OutputableBndr idR)
     => Outputable (ParStmtBlock idL idR) where
   ppr (ParStmtBlock stmts _ _) = interpp'SP stmts
@@ -1436,15 +1422,15 @@ pprQuals :: (OutputableBndr id, Outputable body)
         => [LStmt id body] -> SDoc
 -- Show list comprehension qualifiers separated by commas
 pprQuals quals = interpp'SP quals
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Template Haskell quotation brackets
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 data HsSplice id
    = HsSplice            --  $z  or $(f 4)
         id               -- A unique name to identify this splice point
@@ -1471,8 +1457,8 @@ type PendingTcSplice = PendingSplice Id
 
 deriving instance (DataId id) => Data (HsSplice id)
 deriving instance (DataId id) => Data (PendingSplice id)
-\end{code}
 
+{-
 Note [Pending Splices]
 ~~~~~~~~~~~~~~~~~~~~~~
 When we rename an untyped bracket, we name and lift out all the nested
@@ -1529,8 +1515,8 @@ e.g., in a type error message, we *do not* want to print out the pending
 splices. In contrast, when pretty printing the output of the type checker, we
 *do* want to print the pending splices. So splitting them up seems to make
 sense, although I hate to add another constructor to HsExpr.
+-}
 
-\begin{code}
 instance OutputableBndr id => Outputable (HsSplice id) where
   ppr (HsSplice n e) = angleBrackets (ppr n <> comma <+> ppr e)
 
@@ -1599,15 +1585,15 @@ instance Outputable PendingRnSplice where
   ppr (PendingRnTypeSplice s)  = ppr s
   ppr (PendingRnDeclSplice s)  = ppr s
   ppr (PendingRnCrossStageSplice name) = ppr name
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Enumerations and list comprehensions}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 data ArithSeqInfo id
   = From            (LHsExpr id)
   | FromThen        (LHsExpr id)
@@ -1619,9 +1605,7 @@ data ArithSeqInfo id
                     (LHsExpr id)
   deriving (Typeable)
 deriving instance (DataId id) => Data (ArithSeqInfo id)
-\end{code}
 
-\begin{code}
 instance OutputableBndr id => Outputable (ArithSeqInfo id) where
     ppr (From e1)             = hcat [ppr e1, pp_dotdot]
     ppr (FromThen e1 e2)      = hcat [ppr e1, comma, space, ppr e2, pp_dotdot]
@@ -1631,16 +1615,15 @@ instance OutputableBndr id => Outputable (ArithSeqInfo id) where
 
 pp_dotdot :: SDoc
 pp_dotdot = ptext (sLit " .. ")
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{HsMatchCtxt}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 data HsMatchContext id  -- Context of a Match
   = FunRhs id Bool              -- Function binding for f; True <=> written infix
   | LambdaExpr                  -- Patterns of a lambda
@@ -1675,9 +1658,7 @@ data HsStmtContext id
   | ParStmtCtxt (HsStmtContext id)       -- A branch of a parallel stmt
   | TransStmtCtxt (HsStmtContext id)     -- A branch of a transform stmt
   deriving (Data, Typeable)
-\end{code}
 
-\begin{code}
 isListCompExpr :: HsStmtContext id -> Bool
 -- Uses syntax [ e | quals ]
 isListCompExpr ListComp          = True
@@ -1692,9 +1673,7 @@ isMonadCompExpr MonadComp            = True
 isMonadCompExpr (ParStmtCtxt ctxt)   = isMonadCompExpr ctxt
 isMonadCompExpr (TransStmtCtxt ctxt) = isMonadCompExpr ctxt
 isMonadCompExpr _                    = False
-\end{code}
 
-\begin{code}
 matchSeparator :: HsMatchContext id -> SDoc
 matchSeparator (FunRhs {})  = ptext (sLit "=")
 matchSeparator CaseAlt      = ptext (sLit "->")
@@ -1707,9 +1686,7 @@ matchSeparator RecUpd       = panic "unused"
 matchSeparator ThPatSplice  = panic "unused"
 matchSeparator ThPatQuote   = panic "unused"
 matchSeparator PatSyn       = panic "unused"
-\end{code}
 
-\begin{code}
 pprMatchContext :: Outputable id => HsMatchContext id -> SDoc
 pprMatchContext ctxt
   | want_an ctxt = ptext (sLit "an") <+> pprMatchContextNoun ctxt
@@ -1792,9 +1769,7 @@ matchContextErrString (StmtCtxt MDoExpr)           = ptext (sLit "'mdo' block")
 matchContextErrString (StmtCtxt ListComp)          = ptext (sLit "list comprehension")
 matchContextErrString (StmtCtxt MonadComp)         = ptext (sLit "monad comprehension")
 matchContextErrString (StmtCtxt PArrComp)          = ptext (sLit "array comprehension")
-\end{code}
 
-\begin{code}
 pprMatchInCtxt :: (OutputableBndr idL, OutputableBndr idR, Outputable body)
                => HsMatchContext idL -> Match idR body -> SDoc
 pprMatchInCtxt ctxt match  = hang (ptext (sLit "In") <+> pprMatchContext ctxt <> colon)
@@ -1814,4 +1789,3 @@ pprStmtInCtxt ctxt stmt
     ppr_stmt (TransStmt { trS_by = by, trS_using = using
                         , trS_form = form }) = pprTransStmt by using form
     ppr_stmt stmt = pprStmt stmt
-\end{code}
similarity index 92%
rename from compiler/hsSyn/HsExpr.lhs-boot
rename to compiler/hsSyn/HsExpr.hs-boot
index 387a83e..51cbd29 100644 (file)
@@ -1,4 +1,3 @@
-\begin{code}
 {-# LANGUAGE CPP, KindSignatures #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]
@@ -54,18 +53,17 @@ instance OutputableBndr id => Outputable (HsCmd id)
 type LHsExpr a = Located (HsExpr a)
 type SyntaxExpr a = HsExpr a
 
-pprLExpr :: (OutputableBndr i) => 
+pprLExpr :: (OutputableBndr i) =>
         LHsExpr i -> SDoc
 
-pprExpr :: (OutputableBndr i) => 
+pprExpr :: (OutputableBndr i) =>
         HsExpr i -> SDoc
 
-pprUntypedSplice :: (OutputableBndr i) => 
+pprUntypedSplice :: (OutputableBndr i) =>
                     HsSplice i -> SDoc
 
 pprPatBind :: (OutputableBndr bndr, OutputableBndr id, Outputable body)
            => LPat bndr -> GRHSs id body -> SDoc
 
-pprFunBind :: (OutputableBndr idL, OutputableBndr idR, Outputable body) 
+pprFunBind :: (OutputableBndr idL, OutputableBndr idR, Outputable body)
            => idL -> Bool -> MatchGroup idR body -> SDoc
-\end{code}
similarity index 88%
rename from compiler/hsSyn/HsImpExp.lhs
rename to compiler/hsSyn/HsImpExp.hs
index d627591..166dddc 100644 (file)
@@ -1,11 +1,11 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+
 
 HsImpExp: Abstract syntax: imports, exports, interfaces
+-}
 
-\begin{code}
 {-# LANGUAGE DeriveDataTypeable #-}
 
 module HsImpExp where
@@ -19,16 +19,17 @@ import FastString
 import SrcLoc
 
 import Data.Data
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Import and export declaration lists}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 One per \tr{import} declaration in a module.
-\begin{code}
+-}
+
 type LImportDecl name = Located (ImportDecl name)
         -- ^ When in a list this may have
         --
@@ -76,9 +77,7 @@ simpleImportDecl mn = ImportDecl {
       ideclAs        = Nothing,
       ideclHiding    = Nothing
     }
-\end{code}
 
-\begin{code}
 instance (OutputableBndr name, HasOccName name) => Outputable (ImportDecl name) where
     ppr (ImportDecl { ideclName = mod', ideclPkgQual = pkg
                     , ideclSource = from, ideclSafe = safe
@@ -112,15 +111,15 @@ instance (OutputableBndr name, HasOccName name) => Outputable (ImportDecl name)
 
         ppr_ies []  = ptext (sLit "()")
         ppr_ies ies = char '(' <+> interpp'SP ies <+> char ')'
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Imported and exported entities}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type LIE name = Located (IE name)
         -- ^ When in a list this may have
         --
@@ -154,9 +153,7 @@ data IE name
   | IEDoc               HsDocString      -- ^ Some documentation
   | IEDocNamed          String           -- ^ Reference to named doc
   deriving (Eq, Data, Typeable)
-\end{code}
 
-\begin{code}
 ieName :: IE name -> name
 ieName (IEVar (L _ n))         = n
 ieName (IEThingAbs  n)         = n
@@ -173,9 +170,6 @@ ieNames (IEModuleContents _    ) = []
 ieNames (IEGroup          _ _  ) = []
 ieNames (IEDoc            _    ) = []
 ieNames (IEDocNamed       _    ) = []
-\end{code}
-
-\begin{code}
 
 pprImpExp :: (HasOccName name, OutputableBndr name) => name -> SDoc
 pprImpExp name = type_pref <+> pprPrefixOcc name
@@ -196,4 +190,3 @@ instance (HasOccName name, OutputableBndr name) => Outputable (IE name) where
     ppr (IEGroup n _)           = text ("<IEGroup: " ++ (show n) ++ ">")
     ppr (IEDoc doc)             = ppr doc
     ppr (IEDocNamed string)     = text ("<IEDocNamed: " ++ string ++ ">")
-\end{code}
similarity index 93%
rename from compiler/hsSyn/HsLit.lhs
rename to compiler/hsSyn/HsLit.hs
index 2bde0cd..5e673ad 100644 (file)
@@ -1,10 +1,10 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+
 \section[HsLit]{Abstract syntax: source-language literals}
+-}
 
-\begin{code}
 {-# LANGUAGE CPP, DeriveDataTypeable #-}
 {-# LANGUAGE TypeSynonymInstances #-}
 {-# LANGUAGE StandaloneDeriving #-}
@@ -28,20 +28,15 @@ import Lexer       ( SourceText )
 
 import Data.ByteString (ByteString)
 import Data.Data hiding ( Fixity )
-\end{code}
-
-
 
-
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection[HsLit]{Literals}
-%*                                                                      *
-%************************************************************************
-
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 -- Note [literal source text] for SourceText fields in the following
 data HsLit
   = HsChar          SourceText Char        -- Character
@@ -98,8 +93,8 @@ data OverLitVal
 
 overLitType :: HsOverLit a -> PostTc a Type
 overLitType = ol_type
-\end{code}
 
+{-
 Note [literal source text]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -157,8 +152,8 @@ calls, which wouldn't be possible if the desguarar made the application.
 
 The PostTcType in each branch records the type the overload literal is
 found to have.
+-}
 
-\begin{code}
 -- Comparison operations are needed when grouping literals
 -- for compiling pattern-matching (module MatchLit)
 instance Eq (HsOverLit id) where
@@ -183,9 +178,7 @@ instance Ord OverLitVal where
   compare (HsIsString _ s1)   (HsIsString _ s2)   = s1 `compare` s2
   compare (HsIsString _ _)    (HsIntegral _ _)    = GT
   compare (HsIsString _ _)    (HsFractional _)    = GT
-\end{code}
 
-\begin{code}
 instance Outputable HsLit where
         -- Use "show" because it puts in appropriate escapes
     ppr (HsChar _ c)       = pprHsChar c
@@ -211,4 +204,3 @@ instance Outputable OverLitVal where
   ppr (HsIntegral _ i)   = integer i
   ppr (HsFractional f)   = ppr f
   ppr (HsIsString _ s)   = pprHsString s
-\end{code}
similarity index 92%
rename from compiler/hsSyn/HsPat.lhs
rename to compiler/hsSyn/HsPat.hs
index 48c707b..f38665f 100644 (file)
@@ -1,10 +1,10 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+
 \section[PatSyntax]{Abstract Haskell syntax---patterns}
+-}
 
-\begin{code}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE StandaloneDeriving #-}
@@ -52,10 +52,7 @@ import FastString
 -- libraries:
 import Data.Data hiding (TyCon,Fixity)
 import Data.Maybe
-\end{code}
-
 
-\begin{code}
 type InPat id  = LPat id        -- No 'Out' constructors
 type OutPat id = LPat id        -- No 'In' constructors
 
@@ -114,7 +111,7 @@ data Pat id
         pat_con     :: Located ConLike,
         pat_arg_tys :: [Type],          -- The univeral arg types, 1-1 with the universal
                                         -- tyvars of the constructor/pattern synonym
-                                        --   Use (conLikeResTy pat_con pat_arg_tys) to get 
+                                        --   Use (conLikeResTy pat_con pat_arg_tys) to get
                                         --   the type of the pattern
 
         pat_tvs   :: [TyVar],           -- Existentially bound type variables (tyvars only)
@@ -173,11 +170,9 @@ data Pat id
         -- the scrutinee, followed by a match on 'pat'
   deriving (Typeable)
 deriving instance (DataId id) => Data (Pat id)
-\end{code}
 
-HsConDetails is use for patterns/expressions *and* for data type declarations
+-- HsConDetails is use for patterns/expressions *and* for data type declarations
 
-\begin{code}
 data HsConDetails arg rec
   = PrefixCon [arg]             -- C p1 p2 p3
   | RecCon    rec               -- C { x = p1, y = p2 }
@@ -190,12 +185,12 @@ hsConPatArgs :: HsConPatDetails id -> [LPat id]
 hsConPatArgs (PrefixCon ps)   = ps
 hsConPatArgs (RecCon fs)      = map (hsRecFieldArg . unLoc) (rec_flds fs)
 hsConPatArgs (InfixCon p1 p2) = [p1,p2]
-\end{code}
 
+{-
 However HsRecFields is used only for patterns and expressions
 (not data type declarations)
+-}
 
-\begin{code}
 data HsRecFields id arg         -- A bunch of record fields
                                 --      { x = 3, y = True }
         -- Used for both expressions and patterns
@@ -239,15 +234,15 @@ data HsRecField id arg = HsRecField {
 
 hsRecFields :: HsRecFields id arg -> [id]
 hsRecFields rbinds = map (unLoc . hsRecFieldId . unLoc) (rec_flds rbinds)
-\end{code}
 
-%************************************************************************
-%*                                                                      *
-%*              Printing patterns
-%*                                                                      *
-%************************************************************************
+{-
+************************************************************************
+*                                                                      *
+*              Printing patterns
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 instance (OutputableBndr name) => Outputable (Pat name) where
     ppr = pprPat
 
@@ -324,16 +319,15 @@ instance (OutputableBndr id, Outputable arg)
   ppr (HsRecField { hsRecFieldId = f, hsRecFieldArg = arg,
                     hsRecPun = pun })
     = ppr f <+> (ppUnless pun $ equals <+> ppr arg)
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
-%*              Building patterns
-%*                                                                      *
-%************************************************************************
+{-
+************************************************************************
+*                                                                      *
+*              Building patterns
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 mkPrefixConPat :: DataCon -> [OutPat id] -> [Type] -> OutPat id
 -- Make a vanilla Prefix constructor pattern
 mkPrefixConPat dc pats tys
@@ -347,14 +341,13 @@ mkNilPat ty = mkPrefixConPat nilDataCon [] [ty]
 mkCharLitPat :: String -> Char -> OutPat id
 mkCharLitPat src c = mkPrefixConPat charDataCon
                                     [noLoc $ LitPat (HsCharPrim src c)] []
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
-%* Predicates for checking things about pattern-lists in EquationInfo   *
-%*                                                                      *
-%************************************************************************
+{-
+************************************************************************
+*                                                                      *
+* Predicates for checking things about pattern-lists in EquationInfo   *
+*                                                                      *
+************************************************************************
 
 \subsection[Pat-list-predicates]{Look for interesting things in patterns}
 
@@ -379,7 +372,8 @@ A pattern is in {\em exactly one} of the above three categories; `as'
 patterns are treated specially, of course.
 
 The 1.3 report defines what ``irrefutable'' and ``failure-free'' patterns are.
-\begin{code}
+-}
+
 isStrictLPat :: LPat id -> Bool
 isStrictLPat (L _ (ParPat p))             = isStrictLPat p
 isStrictLPat (L _ (BangPat {}))           = True
@@ -394,7 +388,7 @@ isStrictHsBind _                         = False
 
 looksLazyPatBind :: HsBind id -> Bool
 -- Returns True of anything *except*
---     a StrictHsBind (as above) or 
+--     a StrictHsBind (as above) or
 --     a VarPat
 -- In particular, returns True of a pattern binding with a compound pattern, like (I# x)
 looksLazyPatBind (PatBind { pat_lhs = p }) = looksLazyLPat p
@@ -452,7 +446,7 @@ isIrrefutableHsPat pat
 
     -- Both should be gotten rid of by renamer before
     -- isIrrefutablePat is called
-    go1 (SplicePat {})     = urk pat    
+    go1 (SplicePat {})     = urk pat
     go1 (QuasiQuotePat {}) = urk pat
 
     urk pat = pprPanic "isIrrefutableHsPat:" (ppr pat)
@@ -483,4 +477,3 @@ conPatNeedsParens :: HsConDetails a b -> Bool
 conPatNeedsParens (PrefixCon args) = not (null args)
 conPatNeedsParens (InfixCon {})    = True
 conPatNeedsParens (RecCon {})      = True
-\end{code}
similarity index 96%
rename from compiler/hsSyn/HsPat.lhs-boot
rename to compiler/hsSyn/HsPat.hs-boot
index cb8cb0a..114425b 100644 (file)
@@ -1,4 +1,3 @@
-\begin{code}
 {-# LANGUAGE CPP, KindSignatures #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]
@@ -29,4 +28,3 @@ instance Typeable1 Pat
 
 instance (DataId id) => Data (Pat id)
 instance (OutputableBndr name) => Outputable (Pat name)
-\end{code}
similarity index 96%
rename from compiler/hsSyn/HsSyn.lhs
rename to compiler/hsSyn/HsSyn.hs
index fe31bd5..e75939e 100644 (file)
@@ -1,14 +1,14 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+
 \section{Haskell abstract syntax definition}
 
 This module glues together the pieces of the Haskell abstract syntax,
 which is declared in the various \tr{Hs*} modules.  This module,
 therefore, is almost nothing but re-exporting.
+-}
 
-\begin{code}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE FlexibleContexts #-}
@@ -54,9 +54,7 @@ import FastString
 
 -- libraries:
 import Data.Data hiding ( Fixity )
-\end{code}
 
-\begin{code}
 -- | All we actually declare here is the top-level structure for a module.
 data HsModule name
   = HsModule {
@@ -105,10 +103,7 @@ data HsModule name
      --
       deriving (Typeable)
 deriving instance (DataId name) => Data (HsModule name)
-\end{code}
-
 
-\begin{code}
 instance (OutputableBndr name, HasOccName name)
         => Outputable (HsModule name) where
 
@@ -143,4 +138,3 @@ pp_mb Nothing  = empty
 pp_nonnull :: Outputable t => [t] -> SDoc
 pp_nonnull [] = empty
 pp_nonnull xs = vcat (map ppr xs)
-\end{code}
similarity index 91%
rename from compiler/hsSyn/HsTypes.lhs
rename to compiler/hsSyn/HsTypes.hs
index 37aaa56..5d368b3 100644 (file)
@@ -1,11 +1,11 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+
 
 HsTypes: Abstract syntax: user-defined types
+-}
 
-\begin{code}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
@@ -18,7 +18,7 @@ HsTypes: Abstract syntax: user-defined types
 module HsTypes (
         HsType(..), LHsType, HsKind, LHsKind,
         HsTyOp,LHsTyOp,
-        HsTyVarBndr(..), LHsTyVarBndr, 
+        HsTyVarBndr(..), LHsTyVarBndr,
         LHsTyVarBndrs(..),
         HsWithBndrs(..),
         HsTupleSort(..), HsExplicitFlag(..),
@@ -28,11 +28,11 @@ module HsTypes (
         HsTyLit(..),
         HsIPName(..), hsIPNameFS,
 
-        LBangType, BangType, HsBang(..), 
-        getBangType, getBangStrictness, 
+        LBangType, BangType, HsBang(..),
+        getBangType, getBangStrictness,
 
         ConDeclField(..), LConDeclField, pprConDeclFields,
-        
+
         mkHsQTvs, hsQTvBndrs, isHsKindedTyVar, hsTvbAllKinded,
         mkExplicitHsForAllTy, mkImplicitHsForAllTy, mkQualifiedHsForAllTy,
         hsExplicitTvs,
@@ -68,17 +68,16 @@ import Maybes( isJust )
 
 import Data.Data hiding ( Fixity )
 import Data.Maybe ( fromMaybe )
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
         Quasi quotes; used in types and elsewhere
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
-data HsQuasiQuote id = HsQuasiQuote 
+data HsQuasiQuote id = HsQuasiQuote
                            id           -- The quasi-quoter
                            SrcSpan      -- The span of the enclosed string
                            FastString   -- The enclosed string
@@ -91,16 +90,15 @@ ppr_qq :: OutputableBndr id => HsQuasiQuote id -> SDoc
 ppr_qq (HsQuasiQuote quoter _ quote) =
     char '[' <> ppr quoter <> ptext (sLit "|") <>
     ppr quote <> ptext (sLit "|]")
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Bang annotations}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type LBangType name = Located (BangType name)
 type BangType name  = HsType name       -- Bangs are in the HsType data type
 
@@ -111,20 +109,19 @@ getBangType ty                    = ty
 getBangStrictness :: LHsType a -> HsBang
 getBangStrictness (L _ (HsBangTy s _)) = s
 getBangStrictness _                    = HsNoBang
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Data types}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 This is the syntax for types as seen in type signatures.
 
 Note [HsBSig binder lists]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider a binder (or pattern) decoarated with a type or kind, 
+Consider a binder (or pattern) decoarated with a type or kind,
    \ (x :: a -> a). blah
    forall (a :: k -> *) (b :: k). blah
 Then we use a LHsBndrSig on the binder, so that the
@@ -132,8 +129,8 @@ renamer can decorate it with the variables bound
 by the pattern ('a' in the first example, 'k' in the second),
 assuming that neither of them is in scope already
 See also Note [Kind and type-variable binders] in RnTypes
+-}
 
-\begin{code}
 type LHsContext name = Located (HsContext name)
 
 type HsContext name = [LHsType name]
@@ -274,16 +271,16 @@ data HsType name
 
   | HsQuasiQuoteTy      (HsQuasiQuote name)
 
-  | HsSpliceTy          (HsSplice name) 
+  | HsSpliceTy          (HsSplice name)
                         (PostTc name Kind)
 
   | HsDocTy             (LHsType name) LHsDocString -- A documented type
 
-  | HsBangTy    HsBang (LHsType name)   -- Bang-style type annotations 
+  | HsBangTy    HsBang (LHsType name)   -- Bang-style type annotations
   | HsRecTy     [LConDeclField name]    -- Only in data type declarations
 
-  | HsCoreTy Type       -- An escape hatch for tunnelling a *closed* 
-                        -- Core Type through HsSyn.  
+  | HsCoreTy Type       -- An escape hatch for tunnelling a *closed*
+                        -- Core Type through HsSyn.
 
   | HsExplicitListTy       -- A promoted explicit list
         (PostTc name Kind) -- See Note [Promoted lists and tuples]
@@ -318,8 +315,8 @@ type HsTyOp name = (HsTyWrapper, name)
 
 mkHsOpTy :: LHsType name -> Located name -> LHsType name -> HsType name
 mkHsOpTy ty1 op ty2 = HsOpTy ty1 (WpKiApps [], op) ty2
-\end{code}
 
+{-
 Note [HsForAllTy tyvar binders]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 After parsing:
@@ -347,8 +344,8 @@ Note [Unit tuples]
 ~~~~~~~~~~~~~~~~~~
 Consider the type
     type instance F Int = ()
-We want to parse that "()" 
-    as HsTupleTy HsBoxedOrConstraintTuple [], 
+We want to parse that "()"
+    as HsTupleTy HsBoxedOrConstraintTuple [],
 NOT as HsTyVar unitTyCon
 
 Why? Because F might have kind (* -> Constraint), so we when parsing we
@@ -378,18 +375,18 @@ Notice the difference between
    HsListTy    HsExplicitListTy
    HsTupleTy   HsExplicitListTupleTy
 
-E.g.    f :: [Int]                      HsListTy                
+E.g.    f :: [Int]                      HsListTy
 
-        g3  :: T '[]                   All these use  
-        g2  :: T '[True]                  HsExplicitListTy        
-        g1  :: T '[True,False]          
+        g3  :: T '[]                   All these use
+        g2  :: T '[True]                  HsExplicitListTy
+        g1  :: T '[True,False]
         g1a :: T [True,False]             (can omit ' where unambiguous)
 
   kind of T :: [Bool] -> *        This kind uses HsListTy!
 
-E.g.    h :: (Int,Bool)                 HsTupleTy; f is a pair               
-        k :: S '(True,False)            HsExplicitTypleTy; S is indexed by   
-                                           a type-level pair of booleans 
+E.g.    h :: (Int,Bool)                 HsTupleTy; f is a pair
+        k :: S '(True,False)            HsExplicitTypleTy; S is indexed by
+                                           a type-level pair of booleans
         kind of S :: (Bool,Bool) -> *   This kind uses HsExplicitTupleTy
 
 Note [Distinguishing tuple kinds]
@@ -407,15 +404,15 @@ HsTupleTy, a HsTupleSort). We can tell if a tuple is unboxed while parsing,
 because of the #. However, with -XConstraintKinds we can only distinguish
 between constraint and boxed tuples during type checking, in general. Hence the
 four constructors of HsTupleSort:
-        
+
         HsUnboxedTuple                  -> Produced by the parser
         HsBoxedTuple                    -> Certainly a boxed tuple
         HsConstraintTuple               -> Certainly a constraint tuple
-        HsBoxedOrConstraintTuple        -> Could be a boxed or a constraint 
+        HsBoxedOrConstraintTuple        -> Could be a boxed or a constraint
                                         tuple. Produced by the parser only,
                                         disappears after type checking
+-}
 
-\begin{code}
 data HsTupleSort = HsUnboxedTuple
                  | HsBoxedTuple
                  | HsConstraintTuple
@@ -436,7 +433,7 @@ data ConDeclField name  -- Record fields have Haddoc docs on them
 deriving instance (DataId name) => Data (ConDeclField name)
 
 -----------------------
--- Combine adjacent for-alls. 
+-- Combine adjacent for-alls.
 -- The following awkward situation can happen otherwise:
 --      f :: forall a. ((Num a) => Int)
 -- might generate HsForAll (Just [a]) [] (HsForAll Nothing [Num a] t)
@@ -474,7 +471,7 @@ mk_forall_ty exp  tvs  (L _ (HsParTy ty)) = mk_forall_ty exp tvs ty
 mk_forall_ty exp  tvs  ty                 = HsForAllTy exp Nothing (mkHsQTvs tvs) (noLoc []) ty
         -- Even if tvs is empty, we still make a HsForAll!
         -- In the Implicit case, this signals the place to do implicit quantification
-        -- In the Explicit case, it prevents implicit quantification    
+        -- In the Explicit case, it prevents implicit quantification
         --      (see the sigtype production in Parser.y)
         --      so that (forall. ty) isn't implicitly quantified
 
@@ -520,10 +517,7 @@ isWildcardTy _ = False
 isNamedWildcardTy :: HsType a -> Bool
 isNamedWildcardTy (HsNamedWildcardTy _) = True
 isNamedWildcardTy _ = False
-\end{code}
-
 
-\begin{code}
 splitHsAppTys :: LHsType n -> [LHsType n] -> (LHsType n, [LHsType n])
 splitHsAppTys (L _ (HsAppTy f a)) as = splitHsAppTys f (a:as)
 splitHsAppTys (L _ (HsParTy f))   as = splitHsAppTys f as
@@ -548,12 +542,12 @@ mkHsAppTys fun_ty [] = pprPanic "mkHsAppTys" (ppr fun_ty)
 mkHsAppTys fun_ty (arg_ty:arg_tys)
   = foldl mk_app (HsAppTy fun_ty arg_ty) arg_tys
   where
-    mk_app fun arg = HsAppTy (noLoc fun) arg    
-       -- Add noLocs for inner nodes of the application; 
-       -- they are never used 
+    mk_app fun arg = HsAppTy (noLoc fun) arg
+       -- Add noLocs for inner nodes of the application;
+       -- they are never used
 
 splitLHsInstDeclTy_maybe
-    :: LHsType name 
+    :: LHsType name
     -> Maybe (LHsTyVarBndrs name, HsContext name, Located name, [LHsType name])
         -- Split up an instance decl type, returning the pieces
 splitLHsInstDeclTy_maybe inst_ty = do
@@ -562,7 +556,7 @@ splitLHsInstDeclTy_maybe inst_ty = do
     return (tvs, cxt, cls, tys)
 
 splitLHsForAllTy
-    :: LHsType name 
+    :: LHsType name
     -> (LHsTyVarBndrs name, HsContext name, LHsType name)
 splitLHsForAllTy poly_ty
   = case unLoc poly_ty of
@@ -575,7 +569,7 @@ splitHsClassTy_maybe :: HsType name -> Maybe (name, [LHsType name])
 splitHsClassTy_maybe ty = fmap (\(L _ n, tys) -> (n, tys)) $ splitLHsClassTy_maybe (noLoc ty)
 
 splitLHsClassTy_maybe :: LHsType name -> Maybe (Located name, [LHsType name])
---- Watch out.. in ...deriving( Show )... we use this on 
+--- Watch out.. in ...deriving( Show )... we use this on
 --- the list of partially applied predicates in the deriving,
 --- so there can be zero args.
 
@@ -593,19 +587,19 @@ splitLHsClassTy_maybe ty
         _                  -> Nothing
 
 -- splitHsFunType decomposes a type (t1 -> t2 ... -> tn)
--- Breaks up any parens in the result type: 
+-- Breaks up any parens in the result type:
 --      splitHsFunType (a -> (b -> c)) = ([a,b], c)
 -- Also deals with (->) t1 t2; that is why it only works on LHsType Name
 --   (see Trac #9096)
 splitHsFunType :: LHsType Name -> ([LHsType Name], LHsType Name)
-splitHsFunType (L _ (HsParTy ty)) 
+splitHsFunType (L _ (HsParTy ty))
   = splitHsFunType ty
 
 splitHsFunType (L _ (HsFunTy x y))
   | (args, res) <- splitHsFunType y
   = (x:args, res)
 
-splitHsFunType orig_ty@(L _ (HsAppTy t1 t2)) 
+splitHsFunType orig_ty@(L _ (HsAppTy t1 t2))
   = go t1 [t2]
   where  -- Look for (->) t1 t2, possibly with parenthesisation
     go (L _ (HsTyVar fn))    tys | fn == funTyConName
@@ -617,16 +611,15 @@ splitHsFunType orig_ty@(L _ (HsAppTy t1 t2))
     go _                     _   = ([], orig_ty)  -- Failure to match
 
 splitHsFunType other = ([], other)
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Pretty printing}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 instance (OutputableBndr name) => Outputable (HsType name) where
     ppr ty = pprHsType ty
 
@@ -634,7 +627,7 @@ instance Outputable HsTyLit where
     ppr = ppr_tylit
 
 instance (OutputableBndr name) => Outputable (LHsTyVarBndrs name) where
-    ppr (HsQTvs { hsq_kvs = kvs, hsq_tvs = tvs }) 
+    ppr (HsQTvs { hsq_kvs = kvs, hsq_tvs = tvs })
       = sep [ ifPprDebug $ braces (interppSP kvs), interppSP tvs ]
 
 instance (OutputableBndr name) => Outputable (HsTyVarBndr name) where
@@ -693,8 +686,8 @@ pprConDeclFields fields = braces (sep (punctuate comma (map ppr_fld fields)))
         = ppr_names ns <+> dcolon <+> ppr ty <+> ppr_mbDoc doc
     ppr_names [n] = ppr n
     ppr_names ns = sep (punctuate comma (map ppr ns))
-\end{code}
 
+{-
 Note [Printing KindedTyVars]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Trac #3830 reminded me that we should really only print the kind
@@ -705,8 +698,8 @@ rather than converting to KindedTyVars as before.
 (As it happens, the message in #3830 comes out a different way now,
 and the problem doesn't show up; but having the flag on a KindedTyVar
 seems like the Right Thing anyway.)
+-}
 
-\begin{code}
 -- Printing works more-or-less as for Types
 
 pprHsType, pprParendHsType :: (OutputableBndr name) => HsType name -> SDoc
@@ -786,7 +779,7 @@ ppr_mono_ty _         (HsParTy ty)
   -- But we still use the precedence stuff to add parens because
   --    toHsType doesn't put in any HsParTys, so we may still need them
 
-ppr_mono_ty ctxt_prec (HsDocTy ty doc) 
+ppr_mono_ty ctxt_prec (HsDocTy ty doc)
   = maybeParen ctxt_prec TyOpPrec $
     ppr_mono_lty TyOpPrec ty <+> ppr (unLoc doc)
   -- we pretty print Haddock comments on types as if they were
@@ -805,6 +798,3 @@ ppr_fun_ty ctxt_prec ty1 ty2
 ppr_tylit :: HsTyLit -> SDoc
 ppr_tylit (HsNumTy i) = integer i
 ppr_tylit (HsStrTy s) = text (show s)
-\end{code}
-
-
similarity index 94%
rename from compiler/hsSyn/HsUtils.lhs
rename to compiler/hsSyn/HsUtils.hs
index ed78964..57109fb 100644 (file)
@@ -1,7 +1,6 @@
+{-
+(c) The University of Glasgow, 1992-2006
 
-%
-% (c) The University of Glasgow, 1992-2006
-%
 
 Here we collect a variety of helper functions that construct or
 analyse HsSyn.  All these functions deal with generic HsSyn; functions
@@ -12,8 +11,8 @@ which deal with the instantiated versions are located elsewhere:
    RdrName              parser/RdrHsSyn
    Name                 rename/RnHsSyn
    Id                   typecheck/TcHsSyn
+-}
 
-\begin{code}
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE FlexibleContexts #-}
@@ -103,20 +102,19 @@ import Outputable
 import Data.Either
 import Data.Function
 import Data.List
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
         Some useful helpers for constructing syntax
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 These functions attempt to construct a not-completely-useless SrcSpan
 from their components, compared with the nl* functions below which
 just attach noSrcSpan to everything.
+-}
 
-\begin{code}
 mkHsPar :: LHsExpr id -> LHsExpr id
 mkHsPar e = L (getLoc e) (HsPar e)
 
@@ -312,16 +310,15 @@ mkHsString s = HsString s (mkFastString s)
 userHsTyVarBndrs :: SrcSpan -> [name] -> [Located (HsTyVarBndr name)]
 -- Caller sets location
 userHsTyVarBndrs loc bndrs = [ L loc (UserTyVar v) | v <- bndrs ]
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
         Constructing syntax with no location info
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 nlHsVar :: id -> LHsExpr id
 nlHsVar n = noLoc (HsVar n)
 
@@ -407,12 +404,12 @@ nlHsFunTy a b           = noLoc (HsFunTy a b)
 
 nlHsTyConApp :: name -> [LHsType name] -> LHsType name
 nlHsTyConApp tycon tys  = foldl nlHsAppTy (nlHsTyVar tycon) tys
-\end{code}
 
+{-
 Tuples.  All these functions are *pre-typechecker* because they lack
 types on the tuple.
+-}
 
-\begin{code}
 mkLHsTupleExpr :: [LHsExpr a] -> LHsExpr a
 -- Makes a pre-typechecker boxed tuple, deals with 1 case
 mkLHsTupleExpr [e] = e
@@ -426,18 +423,17 @@ nlTuplePat pats box = noLoc (TuplePat pats box [])
 
 missingTupArg :: HsTupArg RdrName
 missingTupArg = Missing placeHolderType
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
         Converting a Type to an HsType RdrName
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 This is needed to implement GeneralizedNewtypeDeriving.
+-}
 
-\begin{code}
 toHsType :: Type -> LHsType RdrName
 toHsType ty
   | [] <- tvs_only
@@ -471,9 +467,6 @@ toHsType ty
 toHsKind :: Kind -> LHsKind RdrName
 toHsKind = toHsType
 
-\end{code}
-
-\begin{code}
 --------- HsWrappers: type args, dict args, casts ---------
 mkLHsWrap :: HsWrapper -> LHsExpr id -> LHsExpr id
 mkLHsWrap co_fn (L loc e) = L loc (mkHsWrap co_fn e)
@@ -515,15 +508,16 @@ mkHsWrapPatCo co pat ty | isTcReflCo co = pat
 
 mkHsDictLet :: TcEvBinds -> LHsExpr Id -> LHsExpr Id
 mkHsDictLet ev_binds expr = mkLHsWrap (mkWpLet ev_binds) expr
-\end{code}
+
+{-
 l
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
                 Bindings; with a location at the top
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 mkFunBind :: Located RdrName -> [LMatch RdrName (LHsExpr RdrName)]
           -> HsBind RdrName
 -- Not infix, with place holders for coercion and free vars
@@ -574,14 +568,13 @@ mkMatch pats expr binds
   where
     paren lp@(L l p) | hsPatNeedsParens p = L l (ParPat lp)
                      | otherwise          = lp
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
         Collecting binders
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 Get all the binders in some HsBindGroups, IN THE ORDER OF APPEARANCE. eg.
 
@@ -599,8 +592,8 @@ These functions should only be used on HsSyn *after* the renamer,
 to return a [Name] or [Id].  Before renaming the record punning
 and wild-card mechanism makes it hard to know what is bound.
 So these functions should not be applied to (HsSyn RdrName)
+-}
 
-\begin{code}
 ----------------- Bindings --------------------------
 collectLocalBinders :: HsLocalBindsLR idL idR -> [idL]
 collectLocalBinders (HsValBinds val_binds) = collectHsValBinders val_binds
@@ -703,8 +696,8 @@ collect_lpat (L _ pat) bndrs
     go (SplicePat _)              = bndrs
     go (QuasiQuotePat _)          = bndrs
     go (CoPat _ pat _)            = go pat
-\end{code}
 
+{-
 Note [Dictionary binders in ConPatOut] See also same Note in DsArrows
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Do *not* gather (a) dictionary and (b) dictionary bindings as binders
@@ -730,8 +723,8 @@ Here, the pattern (C (n+1)) binds a hidden dictionary (d::Num a),
 and *also* uses that dictionary to match the (n+1) pattern.  Yet, the
 variables bound by the lazy pattern are n,m, *not* the dictionary d.
 So in mkSelectorBinds in DsUtils, we want just m,n as the variables bound.
+-}
 
-\begin{code}
 hsGroupBinders :: HsGroup Name -> [Name]
 hsGroupBinders (HsGroup { hs_valds = val_decls, hs_tyclds = tycl_decls,
                           hs_instds = inst_decls, hs_fords = foreign_decls })
@@ -817,8 +810,7 @@ hsConDeclsBinders cons = go id cons
              L loc (ConDecl { con_names = names }) ->
                 (map (L loc . unLoc) names) ++ go remSeen rs
 
-\end{code}
-
+{-
 Note [Binders in family instances]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 In a type or data family instance declaration, the type
@@ -827,19 +819,19 @@ constructor is an *occurrence* not a binding site
     data instance S Bool = S1 | S2     -- Binders are S1,S2
 
 
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
         Collecting binders the user did not write
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 The job of this family of functions is to run through binding sites and find the set of all Names
 that were defined "implicitly", without being explicitly written by the user.
 
 The main purpose is to find names introduced by record wildcards so that we can avoid
 warning the user when they don't use those names (#4404)
+-}
 
-\begin{code}
 lStmtsImplicits :: [LStmtLR Name idR (Located (body idR))] -> NameSet
 lStmtsImplicits = hs_lstmts
   where
@@ -903,4 +895,3 @@ lPatImplicits = hs_lpat
                                                                      (unLoc fld)
                                                           pat_explicit = maybe True (i<) (rec_dotdot fs)]
     details (InfixCon p1 p2) = hs_lpat p1 `unionNameSet` hs_lpat p2
-\end{code}