compiler: de-lhs iface/
authorAustin Seipp <austin@well-typed.com>
Wed, 3 Dec 2014 18:44:13 +0000 (12:44 -0600)
committerAustin Seipp <austin@well-typed.com>
Wed, 3 Dec 2014 18:44:13 +0000 (12:44 -0600)
Signed-off-by: Austin Seipp <austin@well-typed.com>
compiler/iface/BuildTyCl.hs [moved from compiler/iface/BuildTyCl.lhs with 98% similarity]
compiler/iface/IfaceEnv.hs [moved from compiler/iface/IfaceEnv.lhs with 89% similarity]
compiler/iface/IfaceSyn.hs [moved from compiler/iface/IfaceSyn.lhs with 96% similarity]
compiler/iface/IfaceType.hs [moved from compiler/iface/IfaceType.lhs with 93% similarity]
compiler/iface/LoadIface.hs [moved from compiler/iface/LoadIface.lhs with 88% similarity]
compiler/iface/MkIface.hs [moved from compiler/iface/MkIface.lhs with 97% similarity]
compiler/iface/TcIface.hs [moved from compiler/iface/TcIface.lhs with 92% similarity]
compiler/iface/TcIface.hs-boot [moved from compiler/iface/TcIface.lhs-boot with 96% similarity]

similarity index 98%
rename from compiler/iface/BuildTyCl.lhs
rename to compiler/iface/BuildTyCl.hs
index 460dc2b..33be51f 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 #-}
 
 module BuildTyCl (
@@ -41,10 +40,7 @@ import TcRnMonad
 import UniqSupply
 import Util
 import Outputable
-\end{code}
 
-
-\begin{code}
 ------------------------------------------------------
 buildSynonymTyCon :: Name -> [TyVar] -> [Role]
                   -> Type
@@ -213,11 +209,9 @@ buildPatSyn src_name declared_infix matcher@(matcher_id,_) builder
     ([pat_ty', cont_sigma, _], _) = tcSplitFunTys tau
     (ex_tvs', prov_theta', cont_tau) = tcSplitSigmaTy cont_sigma
     (arg_tys', _) = tcSplitFunTys cont_tau
-\end{code}
 
+-- ------------------------------------------------------
 
-------------------------------------------------------
-\begin{code}
 type TcMethInfo = (Name, DefMethSpec, Type)
         -- A temporary intermediate, to communicate between
         -- tcClassSigs and buildClass.
@@ -319,8 +313,8 @@ buildClass tycon_name tvs roles sc_theta fds at_items sig_stuff mindef tc_isrec
                           VanillaDM -> do { dm_name <- newImplicitBinder op_name mkDefaultMethodOcc
                                           ; return (DefMeth dm_name) }
            ; return (mkDictSelId op_name rec_clas, dm_info) }
-\end{code}
 
+{-
 Note [Class newtypes and equality predicates]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider
@@ -336,3 +330,4 @@ Moreover,
 Here we can't use a newtype either, even though there is only
 one field, because equality predicates are unboxed, and classes
 are boxed.
+-}
similarity index 89%
rename from compiler/iface/IfaceEnv.lhs
rename to compiler/iface/IfaceEnv.hs
index 6c93f50..efd4956 100644 (file)
@@ -1,6 +1,5 @@
-(c) The University of Glasgow 2002-2006
+-- (c) The University of Glasgow 2002-2006
 
-\begin{code}
 {-# LANGUAGE CPP, RankNTypes #-}
 
 module IfaceEnv (
@@ -38,14 +37,13 @@ import Outputable
 import Exception     ( evaluate )
 
 import Data.IORef    ( atomicModifyIORef, readIORef )
-\end{code}
 
-
-%*********************************************************
-%*                                                      *
+{-
+*********************************************************
+*                                                      *
         Allocating new Names in the Name Cache
-%*                                                      *
-%*********************************************************
+*                                                      *
+*********************************************************
 
 Note [The Name Cache]
 ~~~~~~~~~~~~~~~~~~~~~
@@ -61,9 +59,8 @@ External Name "M.x" has one, and only one globally-agreed Unique.
 The functions newGlobalBinder, allocateGlobalBinder do the main work.
 When you make an External name, you should probably be calling one
 of them.
+-}
 
-
-\begin{code}
 newGlobalBinder :: Module -> OccName -> SrcSpan -> TcRnIf a b Name
 -- Used for source code and interface files, to make the
 -- Name for a thing, given its Module and OccName
@@ -165,13 +162,13 @@ lookupOrig mod occ
                     new_cache = extendNameCache (nsNames name_cache) mod occ name
                   in (name_cache{ nsUniqs = us, nsNames = new_cache }, name)
     }}}
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Name cache access
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 See Note [The Name Cache] above.
 
@@ -192,8 +189,8 @@ However, there are two reasons why we might look up an Orig RdrName:
     (DsMeta.globalVar), and parses a NameG into an Orig RdrName
     (Convert.thRdrName).  So, eg $(do { reify '(,); ... }) will
     go this route (Trac #8954).
+-}
 
-\begin{code}
 lookupOrigNameCache :: OrigNameCache -> Module -> OccName -> Maybe Name
 lookupOrigNameCache nc mod occ
   | Just name <- isBuiltInOcc_maybe occ
@@ -240,10 +237,7 @@ mkNameCacheUpdater = do
                        _ <- evaluate =<< readIORef nc_var
                        return r
   return (NCU update_nc)
-\end{code}
-
 
-\begin{code}
 initNameCache :: UniqSupply -> [Name] -> NameCache
 initNameCache us names
   = NameCache { nsUniqs = us,
@@ -251,17 +245,15 @@ initNameCache us names
 
 initOrigNames :: [Name] -> OrigNameCache
 initOrigNames names = foldl extendOrigNameCache emptyModuleEnv names
-\end{code}
 
-
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Type variables and local Ids
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcIfaceLclId :: FastString -> IfL Id
 tcIfaceLclId occ
   = do  { lcl <- getLclEnv
@@ -297,16 +289,15 @@ extendIfaceTyVarEnv tyvars thing_inside
         ; let { tv_env' = addListToUFM (if_tv_env env) pairs
               ; pairs   = [(occNameFS (getOccName tv), tv) | tv <- tyvars] }
         ; setLclEnv (env { if_tv_env = tv_env' }) thing_inside }
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Getting from RdrNames to Names
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 lookupIfaceTop :: OccName -> IfL Name
 -- Look up a top-level name from the current Iface module
 lookupIfaceTop occ
@@ -322,4 +313,3 @@ newIfaceNames occs
   = do  { uniqs <- newUniqueSupply
         ; return [ mkInternalName uniq occ noSrcSpan
                  | (occ,uniq) <- occs `zip` uniqsFromSupply uniqs] }
-\end{code}
similarity index 96%
rename from compiler/iface/IfaceSyn.lhs
rename to compiler/iface/IfaceSyn.hs
index 790556f..6bb3483 100644 (file)
@@ -1,9 +1,8 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1993-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1993-1998
+-}
 
-\begin{code}
 {-# LANGUAGE CPP #-}
 
 module IfaceSyn (
@@ -63,16 +62,15 @@ import System.IO.Unsafe
 import Data.Maybe (isJust)
 
 infixl 3 &&&
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                     Declarations
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type IfaceTopBndr = OccName
   -- It's convenient to have an OccName in the IfaceSyn, altough in each
   -- case the namespace is implied by the context. However, having an
@@ -300,29 +298,26 @@ data IfaceIdDetails
   = IfVanillaId
   | IfRecSelId IfaceTyCon Bool
   | IfDFunId Int          -- Number of silent args
-\end{code}
-
 
+{-
 Note [Versioning of instances]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 See [http://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/RecompilationAvoidance#Instances]
 
 
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
                 Functions over declarations
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 visibleIfConDecls :: IfaceConDecls -> [IfaceConDecl]
 visibleIfConDecls (IfAbstractTyCon {}) = []
 visibleIfConDecls IfDataFamTyCon       = []
 visibleIfConDecls (IfDataTyCon cs)     = cs
 visibleIfConDecls (IfNewTyCon c)       = [c]
-\end{code}
 
-\begin{code}
 ifaceDeclImplicitBndrs :: IfaceDecl -> [OccName]
 --  *Excludes* the 'main' name, but *includes* the implicitly-bound names
 -- Deeply revolting, because it has to predict what gets bound,
@@ -403,15 +398,15 @@ ifaceDeclFingerprints hash decl
      computeFingerprint' =
        unsafeDupablePerformIO
         . computeFingerprint (panic "ifaceDeclFingerprints")
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Expressions
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 data IfaceExpr
   = IfaceLcl    IfLclName
   | IfaceExt    IfExtName
@@ -450,8 +445,8 @@ data IfaceBinding
 -- It's used for *non-top-level* let/rec binders
 -- See Note [IdInfo on nested let-bindings]
 data IfaceLetBndr = IfLetBndr IfLclName IfaceType IfaceIdInfo
-\end{code}
 
+{-
 Note [Empty case alternatives]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 In IfaceSyn an IfaceCase does not record the types of the alternatives,
@@ -476,13 +471,13 @@ In general we retain all info that is left by CoreTidy.tidyLetBndr, since
 that is what is seen by importing module with --make
 
 
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
               Printing IfaceDecl
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 pprAxBranch :: SDoc -> IfaceAxBranch -> SDoc
 -- The TyCon might be local (just an OccName), or this might
 -- be a branch for an imported TyCon, so it would be an ExtName
@@ -544,8 +539,8 @@ showSub :: HasOccName n => ShowSub -> n -> Bool
 showSub (ShowSub { ss_how_much = ShowHeader })     _     = False
 showSub (ShowSub { ss_how_much = ShowSome (n:_) }) thing = n == occName thing
 showSub (ShowSub { ss_how_much = _ })              _     = True
-\end{code}
 
+{-
 Note [Printing IfaceDecl binders]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The binders in an IfaceDecl are just OccNames, so we don't know what module they
@@ -556,8 +551,8 @@ binders.
 
 When printing an interface file (--show-iface), we want to print
 everything unqualified, so we can just print the OccName directly.
+-}
 
-\begin{code}
 ppr_trim :: [Maybe SDoc] -> [SDoc]
 -- Collapse a group of Nothings to a single "..."
 ppr_trim xs
@@ -860,8 +855,8 @@ instance Outputable IfaceFamInst where
 ppr_rough :: Maybe IfaceTyCon -> SDoc
 ppr_rough Nothing   = dot
 ppr_rough (Just tc) = ppr tc
-\end{code}
 
+{-
 Note [Result type of a data family GADT]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider
@@ -884,8 +879,8 @@ Remember that in IfaceSyn, the TyCon and DataCon share the same
 universal type variables.
 
 ----------------------------- Printing IfaceExpr ------------------------------------
+-}
 
-\begin{code}
 instance Outputable IfaceExpr where
     ppr e = pprIfaceExpr noParens e
 
@@ -1021,13 +1016,13 @@ instance Outputable IfaceUnfolding where
                                         pprParendIfaceExpr e]
   ppr (IfDFunUnfold bs es) = hang (ptext (sLit "DFun:") <+> sep (map ppr bs) <> dot)
                                 2 (sep (map pprParendIfaceExpr es))
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
               Finding the Names in IfaceSyn
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 This is used for dependency analysis in MkIface, so that we
 fingerprint a declaration before the things that depend on it.  It
@@ -1035,8 +1030,8 @@ is specific to interface-file fingerprinting in the sense that we
 don't collect *all* Names: for example, the DFun of an instance is
 recorded textually rather than by its fingerprint when
 fingerprinting the instance, so DFuns are not dependencies.
+-}
 
-\begin{code}
 freeNamesIfDecl :: IfaceDecl -> NameSet
 freeNamesIfDecl (IfaceId _s t d i) =
   freeNamesIfType t &&&
@@ -1269,8 +1264,8 @@ freeNamesIfaceTyConParent (IfDataInstance ax tc tys)
 
 fnList :: (a -> NameSet) -> [a] -> NameSet
 fnList f = foldr (&&&) emptyNameSet . map f
-\end{code}
 
+{-
 Note [Tracking data constructors]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 In a case expression
@@ -1297,13 +1292,13 @@ on the *locally-defined* type PackageState is not visible. We need
 to take account of the use of the data constructor PS in the pattern match.
 
 
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
                 Binary instances
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 instance Binary IfaceDecl where
     put_ bh (IfaceId name ty details idinfo) = do
         putByte bh 0
@@ -1839,4 +1834,3 @@ instance Binary IfaceTyConParent where
                 pr <- get bh
                 ty <- get bh
                 return $ IfDataInstance ax pr ty
-\end{code}
similarity index 93%
rename from compiler/iface/IfaceType.lhs
rename to compiler/iface/IfaceType.hs
index 223a25b..5345453 100644 (file)
@@ -1,11 +1,11 @@
-%
-(c) The University of Glasgow 2006
-(c) The GRASP/AQUA Project, Glasgow University, 1993-1998
-%
+{-
+(c) The University of Glasgow 2006
+(c) The GRASP/AQUA Project, Glasgow University, 1993-1998
+
 
 This module defines interface types and binders
+-}
 
-\begin{code}
 {-# LANGUAGE CPP #-}
 module IfaceType (
         IfExtName, IfLclName,
@@ -65,15 +65,15 @@ import Outputable
 import FastString
 import UniqSet
 import Data.Maybe( fromMaybe )
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Local (nested) binders
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 type IfLclName = FastString     -- A local name in iface syntax
 
 type IfExtName = Name   -- An External or WiredIn Name can appear in IfaceSyn
@@ -150,17 +150,14 @@ data IfaceCoercion
   | IfaceSubCo       IfaceCoercion
   | IfaceAxiomRuleCo IfLclName [IfaceType] [IfaceCoercion]
 
-
-\end{code}
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Functions over IFaceTypes
-%*                                                                      *
-%************************************************************************
-
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 splitIfaceSigmaTy :: IfaceType -> ([IfaceTvBndr], [IfacePredType], IfaceType)
 -- Mainly for printing purposes
 splitIfaceSigmaTy ty
@@ -219,13 +216,13 @@ ifTyVarsOfArgs args = argv emptyUniqSet args
      argv vs (ITC_Type t ts) = argv (vs `unionUniqSets` (ifTyVarsOfType t)) ts
      argv vs (ITC_Kind k ks) = argv (vs `unionUniqSets` (ifTyVarsOfType k)) ks
      argv vs ITC_Nil         = vs
-\end{code}
 
+{-
 Substitutions on IfaceType. This is only used during pretty-printing to construct
 the result type of a GADT, and does not deal with binders (eg IfaceForAll), so
 it doesn't need fancy capture stuff.
+-}
 
-\begin{code}
 type IfaceTySubst = FastStringEnv IfaceType
 
 mkIfaceTySubst :: [IfaceTvBndr] -> [IfaceType] -> IfaceTySubst
@@ -255,16 +252,15 @@ substIfaceTyVar :: IfaceTySubst -> IfLclName -> IfaceType
 substIfaceTyVar env tv
   | Just ty <- lookupFsEnv env tv = ty
   | otherwise                     = IfaceTyVar tv
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Functions over IFaceTcArgs
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-
-\begin{code}
 stripKindArgs :: DynFlags -> IfaceTcArgs -> IfaceTcArgs
 stripKindArgs dflags tys
   | gopt Opt_PrintExplicitKinds dflags = tys
@@ -290,8 +286,8 @@ tcArgsIfaceTypes :: IfaceTcArgs -> [IfaceType]
 tcArgsIfaceTypes ITC_Nil = []
 tcArgsIfaceTypes (ITC_Kind t ts) = t : tcArgsIfaceTypes ts
 tcArgsIfaceTypes (ITC_Type t ts) = t : tcArgsIfaceTypes ts
-\end{code}
 
+{-
 Note [Suppressing kinds]
 ~~~~~~~~~~~~~~~~~~~~~~~~
 We use the IfaceTcArgs to specify which of the arguments to a type
@@ -306,24 +302,25 @@ we want
   'Just *         prints as    Just *
 
 
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
                 Functions over IFaceTyCon
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 --isPromotedIfaceTyCon :: IfaceTyCon -> Bool
 --isPromotedIfaceTyCon (IfacePromotedTyCon _) = True
 --isPromotedIfaceTyCon _ = False
-\end{code}
-%************************************************************************
-%*                                                                      *
+
+{-
+************************************************************************
+*                                                                      *
                 Pretty-printing
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 pprIfaceInfixApp :: (TyPrec -> a -> SDoc) -> TyPrec -> SDoc -> a -> a -> SDoc
 pprIfaceInfixApp pp p pp_tc ty1 ty2
   = maybeParen p FunPrec $
@@ -334,12 +331,9 @@ pprIfacePrefixApp p pp_fun pp_tys
   | null pp_tys = pp_fun
   | otherwise   = maybeParen p TyConPrec $
                   hang pp_fun 2 (sep pp_tys)
-\end{code}
 
+-- ----------------------------- Printing binders ------------------------------------
 
------------------------------ Printing binders ------------------------------------
-
-\begin{code}
 instance Outputable IfaceBndr where
     ppr (IfaceIdBndr bndr) = pprIfaceIdBndr bndr
     ppr (IfaceTvBndr bndr) = char '@' <+> pprIfaceTvBndr bndr
@@ -387,11 +381,9 @@ instance Binary IfaceOneShot where
             case h of
               0 -> do return IfaceNoOneShot
               _ -> do return IfaceOneShot
-\end{code}
 
------------------------------ Printing IfaceType ------------------------------------
+-- ----------------------------- Printing IfaceType ------------------------------------
 
-\begin{code}
 ---------------------------------
 instance Outputable IfaceType where
   ppr ty = pprIfaceType ty
@@ -881,15 +873,14 @@ instance Binary IfaceCoercion where
                    return $ IfaceAxiomRuleCo a b c
            _ -> panic ("get IfaceCoercion " ++ show tag)
 
-\end{code}
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
         Conversion from Type to IfaceType
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 ----------------
 toIfaceTvBndr :: TyVar -> (IfLclName, IfaceType)
 toIfaceTvBndr tyvar   = (occNameFS (getOccName tyvar), toIfaceKind (tyVarKind tyvar))
@@ -978,4 +969,3 @@ toIfaceCoercion (AxiomRuleCo co ts cs) = IfaceAxiomRuleCo
                                           (coaxrName co)
                                           (map toIfaceType ts)
                                           (map toIfaceCoercion cs)
-\end{code}
similarity index 88%
rename from compiler/iface/LoadIface.lhs
rename to compiler/iface/LoadIface.hs
index 250ef2f..34ae3d5 100644 (file)
@@ -1,21 +1,21 @@
-%
-(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
+
 
 Loading interface files
+-}
 
-\begin{code}
 {-# LANGUAGE CPP #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module LoadIface (
         -- RnM/TcM functions
-        loadModuleInterface, loadModuleInterfaces, 
-        loadSrcInterface, loadSrcInterface_maybe, 
+        loadModuleInterface, loadModuleInterfaces,
+        loadSrcInterface, loadSrcInterface_maybe,
         loadInterfaceForName, loadInterfaceForModule,
 
         -- IfM functions
-        loadInterface, loadWiredInHomeIface, 
+        loadInterface, loadWiredInHomeIface,
         loadSysInterface, loadUserInterface, loadPluginInterface,
         findAndReadIface, readIface,    -- Used when reading the module's old interface
         loadDecls,      -- Should move to TcIface and be renamed
@@ -26,7 +26,7 @@ module LoadIface (
 
 #include "HsVersions.h"
 
-import {-# SOURCE #-}   TcIface( tcIfaceDecl, tcIfaceRules, tcIfaceInst, 
+import {-# SOURCE #-}   TcIface( tcIfaceDecl, tcIfaceRules, tcIfaceInst,
                                  tcIfaceFamInst, tcIfaceVectInfo, tcIfaceAnnotations )
 
 import DynFlags
@@ -66,18 +66,17 @@ import Hooks
 import Control.Monad
 import Data.IORef
 import System.FilePath
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
         loadSrcInterface, loadOrphanModules, loadInterfaceForName
 
-                These three are called from TcM-land    
-%*                                                                      *
-%************************************************************************
+                These three are called from TcM-land
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 -- Note [Un-ambiguous multiple interfaces]
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- When a user writes an import statement, this usually causes a *single*
@@ -110,7 +109,7 @@ import System.FilePath
 -- two signatures are the same (a condition which is checked by 'Packages'.)
 
 
--- | Load the interface corresponding to an @import@ directive in 
+-- | Load the interface corresponding to an @import@ directive in
 -- source code.  On a failure, fail in the monad with an error message.
 -- See Note [Un-ambiguous multiple interfaces] for why the return type
 -- is @[ModIface]@
@@ -167,13 +166,13 @@ loadModuleInterfaces doc mods
 -- | Loads the interface for a given Name.
 loadInterfaceForName :: SDoc -> Name -> TcRn ModIface
 loadInterfaceForName doc name
-  = do { 
+  = do {
     when debugIsOn $ do
         -- Should not be called with a name from the module being compiled
         { this_mod <- getModule
         ; MASSERT2( not (nameIsLocalOrFrom this_mod name), ppr name <+> parens doc )
         }
-  ; ASSERT2( isExternalName name, ppr name ) 
+  ; ASSERT2( isExternalName name, ppr name )
     initIfaceTcRn $ loadSysInterface doc (nameModule name)
   }
 
@@ -186,20 +185,19 @@ loadInterfaceForModule doc m
       this_mod <- getModule
       MASSERT2( this_mod /= m, ppr m <+> parens doc )
     initIfaceTcRn $ loadSysInterface doc m
-\end{code}
 
-
-%*********************************************************
-%*                                                      *
+{-
+*********************************************************
+*                                                      *
                 loadInterface
 
         The main function to load an interface
         for an imported module, and put it in
         the External Package State
-%*                                                      *
-%*********************************************************
+*                                                      *
+*********************************************************
+-}
 
-\begin{code}
 -- | An 'IfM' function to load the home interface for a wired-in thing,
 -- so that we're sure that we see its instance declarations and rules
 -- See Note [Loading instances for wired-in things] in TcIface
@@ -219,7 +217,7 @@ loadSysInterface doc mod_name = loadInterfaceWithException doc mod_name ImportBy
 -- | Loads a user interface and throws an exception if it fails. The first parameter indicates
 -- whether we should import the boot variant of the module
 loadUserInterface :: Bool -> SDoc -> Module -> IfM lcl ModIface
-loadUserInterface is_boot doc mod_name 
+loadUserInterface is_boot doc mod_name
   = loadInterfaceWithException doc mod_name (ImportByUser is_boot)
 
 loadPluginInterface :: SDoc -> Module -> IfM lcl ModIface
@@ -232,7 +230,7 @@ loadInterfaceWithException :: SDoc -> Module -> WhereFrom -> IfM lcl ModIface
 loadInterfaceWithException doc mod_name where_from
   = do  { mb_iface <- loadInterface doc mod_name where_from
         ; dflags <- getDynFlags
-        ; case mb_iface of 
+        ; case mb_iface of
             Failed err      -> liftIO $ throwGhcExceptionIO (ProgramError (showSDoc dflags err))
             Succeeded iface -> return iface }
 
@@ -241,7 +239,7 @@ loadInterface :: SDoc -> Module -> WhereFrom
               -> IfM lcl (MaybeErr MsgDoc ModIface)
 
 -- loadInterface looks in both the HPT and PIT for the required interface
--- If not found, it loads it, and puts it in the PIT (always). 
+-- If not found, it loads it, and puts it in the PIT (always).
 
 -- If it can't find a suitable interface file, we
 --      a) modify the PackageIfaceTable to have an empty entry
@@ -249,7 +247,7 @@ loadInterface :: SDoc -> Module -> WhereFrom
 --      b) return (Left message)
 --
 -- It's not necessarily an error for there not to be an interface
--- file -- perhaps the module has changed, and that interface 
+-- file -- perhaps the module has changed, and that interface
 -- is no longer used
 
 loadInterface doc_str mod from
@@ -261,7 +259,7 @@ loadInterface doc_str mod from
                 -- Check whether we have the interface already
         ; dflags <- getDynFlags
         ; case lookupIfaceByModule dflags hpt (eps_PIT eps) mod of {
-            Just iface 
+            Just iface
                 -> return (Succeeded iface) ;   -- Already loaded
                         -- The (src_imp == mi_boot iface) test checks that the already-loaded
                         -- interface isn't a boot iface.  This can conceivably happen,
@@ -278,9 +276,9 @@ loadInterface doc_str mod from
 
                 ; updateEps_ $ \eps ->
                         eps { eps_PIT = extendModuleEnv (eps_PIT eps) (mi_module fake_iface) fake_iface }
-                        -- Not found, so add an empty iface to 
+                        -- Not found, so add an empty iface to
                         -- the EPS map so that we don't look again
-                                
+
                 ; return (Failed err) } ;
 
         -- Found and parsed!
@@ -294,14 +292,14 @@ loadInterface doc_str mod from
         -- Template Haskell original-name).
             Succeeded (iface, file_path) ->
 
-        let 
+        let
             loc_doc = text file_path
-        in 
+        in
         initIfaceLcl mod loc_doc $ do
 
         --      Load the new ModIface into the External Package State
-        -- Even home-package interfaces loaded by loadInterface 
-        --      (which only happens in OneShot mode; in Batch/Interactive 
+        -- Even home-package interfaces loaded by loadInterface
+        --      (which only happens in OneShot mode; in Batch/Interactive
         --      mode, home-package modules are loaded one by one into the HPT)
         -- are put in the EPS.
         --
@@ -323,7 +321,7 @@ loadInterface doc_str mod from
         ; new_eps_anns      <- tcIfaceAnnotations (mi_anns iface)
         ; new_eps_vect_info <- tcIfaceVectInfo mod (mkNameEnv new_eps_decls) (mi_vect_info iface)
 
-        ; let { final_iface = iface {   
+        ; let { final_iface = iface {
                                 mi_decls     = panic "No mi_decls in PIT",
                                 mi_insts     = panic "No mi_insts in PIT",
                                 mi_fam_insts = panic "No mi_fam_insts in PIT",
@@ -332,7 +330,7 @@ loadInterface doc_str mod from
                               }
                }
 
-        ; updateEps_  $ \ eps -> 
+        ; updateEps_  $ \ eps ->
            if elemModuleEnv mod (eps_PIT eps) then eps else
               case from of  -- See Note [Care with plugin imports]
                 ImportByPlugin -> eps {
@@ -341,26 +339,26 @@ loadInterface doc_str mod from
                 _              -> eps {
                   eps_PIT          = extendModuleEnv (eps_PIT eps) mod final_iface,
                   eps_PTE          = addDeclsToPTE   (eps_PTE eps) new_eps_decls,
-                  eps_rule_base    = extendRuleBaseList (eps_rule_base eps) 
+                  eps_rule_base    = extendRuleBaseList (eps_rule_base eps)
                                                         new_eps_rules,
-                  eps_inst_env     = extendInstEnvList (eps_inst_env eps)  
+                  eps_inst_env     = extendInstEnvList (eps_inst_env eps)
                                                        new_eps_insts,
                   eps_fam_inst_env = extendFamInstEnvList (eps_fam_inst_env eps)
                                                           new_eps_fam_insts,
-                  eps_vect_info    = plusVectInfo (eps_vect_info eps) 
+                  eps_vect_info    = plusVectInfo (eps_vect_info eps)
                                                   new_eps_vect_info,
                   eps_ann_env      = extendAnnEnvList (eps_ann_env eps)
                                                       new_eps_anns,
                   eps_mod_fam_inst_env
                                    = let
-                                       fam_inst_env = 
+                                       fam_inst_env =
                                          extendFamInstEnvList emptyFamInstEnv
                                                               new_eps_fam_insts
                                      in
                                      extendModuleEnv (eps_mod_fam_inst_env eps)
                                                      mod
                                                      fam_inst_env,
-                  eps_stats        = addEpsInStats (eps_stats eps) 
+                  eps_stats        = addEpsInStats (eps_stats eps)
                                                    (length new_eps_decls)
                                                    (length new_eps_insts)
                                                    (length new_eps_rules) }
@@ -373,7 +371,7 @@ wantHiBootFile :: DynFlags -> ExternalPackageState -> Module -> WhereFrom
 -- Figure out whether we want Foo.hi or Foo.hi-boot
 wantHiBootFile dflags eps mod from
   = case from of
-       ImportByUser usr_boot 
+       ImportByUser usr_boot
           | usr_boot && not this_package
           -> Failed (badSourceImport mod)
           | otherwise -> Succeeded usr_boot
@@ -384,14 +382,14 @@ wantHiBootFile dflags eps mod from
        ImportBySystem
           | not this_package   -- If the module to be imported is not from this package
           -> Succeeded False   -- don't look it up in eps_is_boot, because that is keyed
-                               -- on the ModuleName of *home-package* modules only. 
+                               -- on the ModuleName of *home-package* modules only.
                                -- We never import boot modules from other packages!
 
           | otherwise
           -> case lookupUFM (eps_is_boot eps) (moduleName mod) of
                 Just (_, is_boot) -> Succeeded is_boot
                 Nothing           -> Succeeded False
-                     -- The boot-ness of the requested interface, 
+                     -- The boot-ness of the requested interface,
                      -- based on the dependencies in directly-imported modules
   where
     this_package = thisPackage dflags == modulePackageKey mod
@@ -401,13 +399,13 @@ badSourceImport mod
   = hang (ptext (sLit "You cannot {-# SOURCE #-} import a module from another package"))
        2 (ptext (sLit "but") <+> quotes (ppr mod) <+> ptext (sLit "is from package")
           <+> quotes (ppr (modulePackageKey mod)))
-\end{code}
 
+{-
 Note [Care with plugin imports]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 When dynamically loading a plugin (via loadPluginInterface) we
 populate the same External Package State (EPS), even though plugin
-modules are to link with the compiler itself, and not with the 
+modules are to link with the compiler itself, and not with the
 compiled program.  That's fine: mostly the EPS is just a cache for
 the interace files on disk.
 
@@ -421,9 +419,8 @@ Solution: when loading plugins, do not extend the rule and instance
 environments.  We are only interested in the type environment, so that
 we can check that the plugin exports a function with the type that the
 compiler expects.
+-}
 
-
-\begin{code}
 -----------------------------------------------------
 --      Loading type/class/value decls
 -- We pass the full Module name here, replete with
@@ -455,13 +452,13 @@ loadDecl :: Bool                    -- Don't load pragmas into the decl pool
           -> IfL [(Name,TyThing)]   -- The list can be poked eagerly, but the
                                     -- TyThings are forkM'd thunks
 loadDecl ignore_prags mod (_version, decl)
-  = do  {       -- Populate the name cache with final versions of all 
+  = do  {       -- Populate the name cache with final versions of all
                 -- the names associated with the decl
           main_name      <- lookupOrig mod (ifName decl)
 
         -- Typecheck the thing, lazily
         -- NB. Firstly, the laziness is there in case we never need the
-        -- declaration (in one-shot mode), and secondly it is there so that 
+        -- declaration (in one-shot mode), and secondly it is there so that
         -- we don't look up the occurrence of a name before calling mk_new_bndr
         -- on the binder.  This is important because we must get the right name
         -- which includes its nameParent.
@@ -470,7 +467,7 @@ loadDecl ignore_prags mod (_version, decl)
                                   ; tcIfaceDecl ignore_prags decl }
 
         -- Populate the type environment with the implicitTyThings too.
-        -- 
+        --
         -- Note [Tricky iface loop]
         -- ~~~~~~~~~~~~~~~~~~~~~~~~
         -- Summary: The delicate point here is that 'mini-env' must be
@@ -481,8 +478,8 @@ loadDecl ignore_prags mod (_version, decl)
         --      data T a = MkT { x :: T a }
         -- The implicitTyThings of T are:  [ <datacon MkT>, <selector x>]
         -- (plus their workers, wrappers, coercions etc etc)
-        -- 
-        -- We want to return an environment 
+        --
+        -- We want to return an environment
         --      [ "MkT" -> <datacon MkT>, "x" -> <selector x>, ... ]
         -- (where the "MkT" is the *Name* associated with MkT, etc.)
         --
@@ -498,7 +495,7 @@ loadDecl ignore_prags mod (_version, decl)
         --
         -- However, there is a subtlety: due to how type checking needs
         -- to be staged, we can't poke on the forkM'd thunks inside the
-        -- implicitTyThings while building this mini-env.  
+        -- implicitTyThings while building this mini-env.
         -- If we poke these thunks too early, two problems could happen:
         --    (1) When processing mutually recursive modules across
         --        hs-boot boundaries, poking too early will do the
@@ -506,7 +503,7 @@ loadDecl ignore_prags mod (_version, decl)
         --        so things will be type-checked in the wrong
         --        environment, and necessary variables won't be in
         --        scope.
-        --        
+        --
         --    (2) Looking up one OccName in the mini_env will cause
         --        others to be looked up, which might cause that
         --        original one to be looked up again, and hence loop.
@@ -527,7 +524,7 @@ loadDecl ignore_prags mod (_version, decl)
         ; let mini_env = mkOccEnv [(getOccName t, t) | t <- implicitTyThings thing]
               lookup n = case lookupOccEnv mini_env (getOccName n) of
                            Just thing -> thing
-                           Nothing    -> 
+                           Nothing    ->
                              pprPanic "loadDecl" (ppr main_name <+> ppr n $$ ppr (decl))
 
         ; implicit_names <- mapM (lookupOrig mod) (ifaceDeclImplicitBndrs decl)
@@ -547,14 +544,13 @@ bumpDeclStats name
         ; updateEps_ (\eps -> let stats = eps_stats eps
                               in eps { eps_stats = stats { n_decls_out = n_decls_out stats + 1 } })
         }
-\end{code}
 
-
-%*********************************************************
-%*                                                      *
+{-
+*********************************************************
+*                                                      *
 \subsection{Reading an interface file}
-%*                                                      *
-%*********************************************************
+*                                                      *
+*********************************************************
 
 Note [Home module load error]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -566,32 +562,32 @@ in one-shot mode; see notes with hsc_HPT decl in HscTypes).
 It is possible (though hard) to get this error through user behaviour.
   * Suppose package P (modules P1, P2) depends on package Q (modules Q1,
     Q2, with Q2 importing Q1)
-  * We compile both packages.  
+  * We compile both packages.
   * Now we edit package Q so that it somehow depends on P
-  * Now recompile Q with --make (without recompiling P).  
+  * Now recompile Q with --make (without recompiling P).
   * Then Q1 imports, say, P1, which in turn depends on Q2. So Q2
     is a home-package module which is not yet in the HPT!  Disaster.
 
 This actually happened with P=base, Q=ghc-prim, via the AMP warnings.
 See Trac #8320.
+-}
 
-\begin{code}
 findAndReadIface :: SDoc -> Module
                  -> IsBootInterface     -- True  <=> Look for a .hi-boot file
                                         -- False <=> Look for .hi file
                  -> TcRnIf gbl lcl (MaybeErr MsgDoc (ModIface, FilePath))
         -- Nothing <=> file not found, or unreadable, or illegible
-        -- Just x  <=> successfully found and parsed 
+        -- Just x  <=> successfully found and parsed
 
-        -- It *doesn't* add an error to the monad, because 
+        -- It *doesn't* add an error to the monad, because
         -- sometimes it's ok to fail... see notes with loadInterface
 
 findAndReadIface doc_str mod hi_boot_file
-  = do traceIf (sep [hsep [ptext (sLit "Reading"), 
-                           if hi_boot_file 
-                             then ptext (sLit "[boot]") 
+  = do traceIf (sep [hsep [ptext (sLit "Reading"),
+                           if hi_boot_file
+                             then ptext (sLit "[boot]")
                              else Outputable.empty,
-                           ptext (sLit "interface for"), 
+                           ptext (sLit "interface for"),
                            ppr mod <> semi],
                      nest 4 (ptext (sLit "reason:") <+> doc_str)])
 
@@ -607,7 +603,7 @@ findAndReadIface doc_str mod hi_boot_file
                hsc_env <- getTopEnv
                mb_found <- liftIO (findExactModule hsc_env mod)
                case mb_found of
-                   Found loc mod -> do 
+                   Found loc mod -> do
 
                        -- Found file, so read it
                        let file_path = addBootSuffix_maybe hi_boot_file
@@ -623,14 +619,14 @@ findAndReadIface doc_str mod hi_boot_file
                    err -> do
                        traceIf (ptext (sLit "...not found"))
                        dflags <- getDynFlags
-                       return (Failed (cannotFindInterface dflags 
+                       return (Failed (cannotFindInterface dflags
                                            (moduleName mod) err))
     where read_file file_path = do
               traceIf (ptext (sLit "readIFace") <+> text file_path)
               read_result <- readIface mod file_path
               case read_result of
                 Failed err -> return (Failed (badIfaceFile file_path err))
-                Succeeded iface 
+                Succeeded iface
                     | mi_module iface /= mod ->
                       return (Failed (wrongIfaceModErr iface mod file_path))
                     | otherwise ->
@@ -654,21 +650,19 @@ findAndReadIface doc_str mod hi_boot_file
                           do traceIf (text "Failed to load dynamic interface file:" $$ err)
                              liftIO $ writeIORef ref False
           checkBuildDynamicToo _ = return ()
-\end{code}
 
-@readIface@ tries just the one file.
+-- @readIface@ tries just the one file.
 
-\begin{code}
 readIface :: Module -> FilePath
           -> TcRnIf gbl lcl (MaybeErr MsgDoc ModIface)
         -- Failed err    <=> file not found, or unreadable, or illegible
-        -- Succeeded iface <=> successfully found and parsed 
+        -- Succeeded iface <=> successfully found and parsed
 
 readIface wanted_mod file_path
   = do  { res <- tryMostM $
                  readBinIface CheckHiWay QuietBinIFaceReading file_path
         ; case res of
-            Right iface 
+            Right iface
                 | wanted_mod == actual_mod -> return (Succeeded iface)
                 | otherwise                -> return (Failed err)
                 where
@@ -677,19 +671,18 @@ readIface wanted_mod file_path
 
             Left exn    -> return (Failed (text (showException exn)))
     }
-\end{code}
-
 
-%*********************************************************
-%*                                                       *
+{-
+*********************************************************
+*                                                       *
         Wired-in interface for GHC.Prim
-%*                                                       *
-%*********************************************************
+*                                                       *
+*********************************************************
+-}
 
-\begin{code}
 initExternalPackageState :: ExternalPackageState
 initExternalPackageState
-  = EPS { 
+  = EPS {
       eps_is_boot      = emptyUFM,
       eps_PIT          = emptyPackageIfaceTable,
       eps_PTE          = emptyTypeEnv,
@@ -705,16 +698,15 @@ initExternalPackageState
                            , n_insts_in = 0, n_insts_out = 0
                            , n_rules_in = length builtinRules, n_rules_out = 0 }
     }
-\end{code}
 
-
-%*********************************************************
-%*                                                       *
+{-
+*********************************************************
+*                                                       *
         Wired-in interface for GHC.Prim
-%*                                                       *
-%*********************************************************
+*                                                       *
+*********************************************************
+-}
 
-\begin{code}
 ghcPrimIface :: ModIface
 ghcPrimIface
   = (emptyModIface gHC_PRIM) {
@@ -722,44 +714,43 @@ ghcPrimIface
         mi_decls    = [],
         mi_fixities = fixities,
         mi_fix_fn  = mkIfaceFixCache fixities
-    }           
+    }
   where
     fixities = (getOccName seqId, Fixity 0 InfixR)  -- seq is infixr 0
              : mapMaybe mkFixity allThePrimOps
     mkFixity op = (,) (primOpOcc op) <$> primOpFixity op
-\end{code}
 
-%*********************************************************
-%*                                                      *
+{-
+*********************************************************
+*                                                      *
 \subsection{Statistics}
-%*                                                      *
-%*********************************************************
+*                                                      *
+*********************************************************
+-}
 
-\begin{code}
 ifaceStats :: ExternalPackageState -> SDoc
-ifaceStats eps 
+ifaceStats eps
   = hcat [text "Renamer stats: ", msg]
   where
     stats = eps_stats eps
-    msg = vcat 
+    msg = vcat
         [int (n_ifaces_in stats) <+> text "interfaces read",
-         hsep [ int (n_decls_out stats), text "type/class/variable imported, out of", 
+         hsep [ int (n_decls_out stats), text "type/class/variable imported, out of",
                 int (n_decls_in stats), text "read"],
-         hsep [ int (n_insts_out stats), text "instance decls imported, out of",  
+         hsep [ int (n_insts_out stats), text "instance decls imported, out of",
                 int (n_insts_in stats), text "read"],
-         hsep [ int (n_rules_out stats), text "rule decls imported, out of",  
+         hsep [ int (n_rules_out stats), text "rule decls imported, out of",
                 int (n_rules_in stats), text "read"]
         ]
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Printing interfaces
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 -- | Read binary interface, and print it out
 showIface :: HscEnv -> FilePath -> IO ()
 showIface hsc_env filename = do
@@ -769,9 +760,7 @@ showIface hsc_env filename = do
        readBinIface IgnoreHiWay TraceBinIFaceReading filename
    let dflags = hsc_dflags hsc_env
    log_action dflags dflags SevDump noSrcSpan defaultDumpStyle (pprModIface iface)
-\end{code}
 
-\begin{code}
 pprModIface :: ModIface -> SDoc
 -- Show a ModIface
 pprModIface iface
@@ -807,21 +796,21 @@ pprModIface iface
   where
     pp_boot | mi_boot iface = ptext (sLit "[boot]")
             | otherwise     = Outputable.empty
-\end{code}
 
+{-
 When printing export lists, we print like this:
         Avail   f               f
         AvailTC C [C, x, y]     C(x,y)
         AvailTC C [x, y]        C!(x,y)         -- Exporting x, y but not C
+-}
 
-\begin{code}
 pprExport :: IfaceExport -> SDoc
 pprExport (Avail n)      = ppr n
 pprExport (AvailTC _ []) = Outputable.empty
-pprExport (AvailTC n (n':ns)) 
+pprExport (AvailTC n (n':ns))
   | n==n'     = ppr n <> pp_export ns
   | otherwise = ppr n <> char '|' <> pp_export (n':ns)
-  where  
+  where
     pp_export []    = Outputable.empty
     pp_export names = braces (hsep (map ppr names))
 
@@ -865,7 +854,7 @@ pprFixities :: [(OccName, Fixity)] -> SDoc
 pprFixities []    = Outputable.empty
 pprFixities fixes = ptext (sLit "fixities") <+> pprWithCommas pprFix fixes
                   where
-                    pprFix (occ,fix) = ppr fix <+> ppr occ 
+                    pprFix (occ,fix) = ppr fix <+> ppr occ
 
 pprVectInfo :: IfaceVectInfo -> SDoc
 pprVectInfo (IfaceVectInfo { ifaceVectInfoVar            = vars
@@ -873,8 +862,8 @@ pprVectInfo (IfaceVectInfo { ifaceVectInfoVar            = vars
                            , ifaceVectInfoTyConReuse     = tyconsReuse
                            , ifaceVectInfoParallelVars   = parallelVars
                            , ifaceVectInfoParallelTyCons = parallelTyCons
-                           }) = 
-  vcat 
+                           }) =
+  vcat
   [ ptext (sLit "vectorised variables:") <+> hsep (map ppr vars)
   , ptext (sLit "vectorised tycons:") <+> hsep (map ppr tycons)
   , ptext (sLit "vectorised reused tycons:") <+> hsep (map ppr tyconsReuse)
@@ -901,23 +890,22 @@ pprWarns (WarnSome prs) = ptext (sLit "Warnings")
 pprIfaceAnnotation :: IfaceAnnotation -> SDoc
 pprIfaceAnnotation (IfaceAnnotation { ifAnnotatedTarget = target, ifAnnotatedValue = serialized })
   = ppr target <+> ptext (sLit "annotated by") <+> ppr serialized
-\end{code}
 
-
-%*********************************************************
-%*                                                       *
+{-
+*********************************************************
+*                                                       *
 \subsection{Errors}
-%*                                                       *
-%*********************************************************
+*                                                       *
+*********************************************************
+-}
 
-\begin{code}
 badIfaceFile :: String -> SDoc -> SDoc
 badIfaceFile file err
-  = vcat [ptext (sLit "Bad interface file:") <+> text file, 
+  = vcat [ptext (sLit "Bad interface file:") <+> text file,
           nest 4 err]
 
 hiModuleNameMismatchWarn :: Module -> Module -> MsgDoc
-hiModuleNameMismatchWarn requested_mod read_mod = 
+hiModuleNameMismatchWarn requested_mod read_mod =
   -- ToDo: This will fail to have enough qualification when the package IDs
   -- are the same
   withPprStyle (mkUserStyle alwaysQualify AllTheWay) $
@@ -930,7 +918,7 @@ hiModuleNameMismatchWarn requested_mod read_mod =
          ]
 
 wrongIfaceModErr :: ModIface -> Module -> String -> SDoc
-wrongIfaceModErr iface mod_name file_path 
+wrongIfaceModErr iface mod_name file_path
   = sep [ptext (sLit "Interface file") <+> iface_file,
          ptext (sLit "contains module") <+> quotes (ppr (mi_module iface)) <> comma,
          ptext (sLit "but we were expecting module") <+> quotes (ppr mod_name),
@@ -949,5 +937,3 @@ homeModError mod location
            Just file -> space <> parens (text file)
            Nothing   -> Outputable.empty)
     <+> ptext (sLit "which is not loaded")
-\end{code}
-
similarity index 97%
rename from compiler/iface/MkIface.lhs
rename to compiler/iface/MkIface.hs
index 8614d1f..b3321c1 100644 (file)
@@ -1,9 +1,8 @@
-%
-(c) The University of Glasgow 2006-2008
-(c) The GRASP/AQUA Project, Glasgow University, 1993-1998
-%
+{-
+(c) The University of Glasgow 2006-2008
+(c) The GRASP/AQUA Project, Glasgow University, 1993-1998
+-}
 
-\begin{code}
 {-# LANGUAGE CPP, NondecreasingIndentation #-}
 
 -- | Module for constructing @ModIface@ values (interface files),
@@ -25,8 +24,8 @@ module MkIface (
 
         tyThingToIfaceDecl -- Converting things to their Iface equivalents
  ) where
-\end{code}
 
+{-
   -----------------------------------------------
           Recompilation checking
   -----------------------------------------------
@@ -56,8 +55,8 @@ Basic idea:
 
   * In checkOldIface we compare the mi_usages for the module with
     the actual fingerprint for all each thing recorded in mi_usages
+-}
 
-\begin{code}
 #include "HsVersions.h"
 
 import IfaceSyn
@@ -123,17 +122,15 @@ import Data.Ord
 import Data.IORef
 import System.Directory
 import System.FilePath
-\end{code}
-
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
 \subsection{Completing an interface}
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 mkIface :: HscEnv
         -> Maybe Fingerprint    -- The old fingerprint, if we have it
         -> ModDetails           -- The trimmed, tidied interface
@@ -669,10 +666,7 @@ sortDependencies d
           dep_pkgs   = sortBy (stablePackageKeyCmp `on` fst) (dep_pkgs d),
           dep_orphs  = sortBy stableModuleCmp (dep_orphs d),
           dep_finsts = sortBy stableModuleCmp (dep_finsts d) }
-\end{code}
-
 
-\begin{code}
 -- | Creates cached lookup for the 'mi_anns' field of ModIface
 -- Hackily, we use "module" as the OccName for any module-level annotations
 mkIfaceAnnCache :: [IfaceAnnotation] -> OccName -> [AnnPayload]
@@ -686,8 +680,8 @@ mkIfaceAnnCache anns
       , [value])
     -- flipping (++), so the first argument is always short
     env = mkOccEnv_C (flip (++)) (map pair anns)
-\end{code}
 
+{-
 Note [Orphans and auto-generated rules]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 When we specialise an INLINEABLE function, or when we have
@@ -707,11 +701,11 @@ module M will be used in other modules only if M.hi has been read for
 some other reason, which is actually pretty likely.
 
 
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
           The ABI of an IfaceDecl
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 Note [The ABI of an IfaceDecl]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -734,8 +728,8 @@ Items (c)-(f) are not stored in the IfaceDecl, but instead appear
 elsewhere in the interface file.  But they are *fingerprinted* with
 the declaration itself. This is done by grouping (c)-(f) in IfaceDeclExtras,
 and fingerprinting that as part of the declaration.
+-}
 
-\begin{code}
 type IfaceDeclABI = (Module, IfaceDecl, IfaceDeclExtras)
 
 data IfaceDeclExtras
@@ -946,16 +940,15 @@ mkOrphMap get_key decls
         | NotOrphan occ <- get_key d
         = (extendOccEnv_Acc (:) singleton non_orphs occ d, orphs)
         | otherwise = (non_orphs, d:orphs)
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
        Keeping track of what we've slurped, and fingerprints
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 mkUsageInfo :: HscEnv -> Module -> ImportedMods -> NameSet -> [FilePath] -> IO [Usage]
 mkUsageInfo hsc_env this_mod dir_imp_mods used_names dependent_files
   = do
@@ -1093,18 +1086,14 @@ mk_mod_usage_info pit hsc_env this_mod direct_imports used_names
               from generating many of these usages (at least in
               one-shot mode), but that's even more bogus!
         -}
-\end{code}
 
-\begin{code}
 mkIfaceAnnotation :: Annotation -> IfaceAnnotation
 mkIfaceAnnotation (Annotation { ann_target = target, ann_value = payload })
   = IfaceAnnotation {
         ifAnnotatedTarget = fmap nameOccName target,
         ifAnnotatedValue = payload
     }
-\end{code}
 
-\begin{code}
 mkIfaceExports :: [AvailInfo] -> [IfaceExport]  -- Sort to make canonical
 mkIfaceExports exports
   = sortBy stableAvailCmp (map sort_subs exports)
@@ -1116,8 +1105,8 @@ mkIfaceExports exports
        | n==m      = AvailTC n (m:sortBy stableNameCmp ms)
        | otherwise = AvailTC n (sortBy stableNameCmp (m:ms))
        -- Maintain the AvailTC Invariant
-\end{code}
 
+{-
 Note [Orignal module]
 ~~~~~~~~~~~~~~~~~~~~~
 Consider this:
@@ -1143,14 +1132,14 @@ Trac #5362 for an example.  Such Names are always
   - They are always System Names, hence the assert, just as a double check.
 
 
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
         Load the old interface file for this module (unless
         we have it already), and check whether it is up to date
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 data RecompileRequired
   = UpToDate
        -- ^ everything is up to date, recompilation is not required
@@ -1500,15 +1489,15 @@ checkList (check:checks) = do recompile <- check
                               if recompileRequired recompile
                                 then return recompile
                                 else checkList checks
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Converting things to their Iface equivalents
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tyThingToIfaceDecl :: TyThing -> IfaceDecl
 tyThingToIfaceDecl (AnId id)      = idToIfaceDecl id
 tyThingToIfaceDecl (ATyCon tycon) = snd (tyConToIfaceDecl emptyTidyEnv tycon)
@@ -2041,4 +2030,3 @@ toIfaceVar v
     | isExternalName name                        = IfaceExt name
     | otherwise                                  = IfaceLcl (getFS name)
   where name = idName v
-\end{code}
similarity index 92%
rename from compiler/iface/TcIface.lhs
rename to compiler/iface/TcIface.hs
index 10984ec..692bfad 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
+
 
 Type checking of type signatures in interface files
+-}
 
-\begin{code}
 {-# LANGUAGE CPP #-}
 
 module TcIface (
@@ -75,8 +75,8 @@ import qualified Data.Map as Map
 #if __GLASGOW_HASKELL__ < 709
 import Data.Traversable ( traverse )
 #endif
-\end{code}
 
+{-
 This module takes
 
         IfaceDecl -> TyThing
@@ -96,12 +96,12 @@ Names before typechecking, because there should be no scope errors etc.
         -- bound in this module (and hence not yet processed).
         -- The discarding happens when forkM finds a type error.
 
-%************************************************************************
-%*                                                                      *
-%*      tcImportDecl is the key function for "faulting in"              *
-%*      imported things
-%*                                                                      *
-%************************************************************************
+************************************************************************
+*                                                                      *
+*      tcImportDecl is the key function for "faulting in"              *
+*      imported things
+*                                                                      *
+************************************************************************
 
 The main idea is this.  We are chugging along type-checking source code, and
 find a reference to GHC.Base.map.  We call tcLookupGlobal, which doesn't find
@@ -119,8 +119,8 @@ mutable variable.  This is important in situations like
         ...$(e1)...$(e2)...
 where the code that e1 expands to might import some defns that
 also turn out to be needed by the code that e2 expands to.
+-}
 
-\begin{code}
 tcLookupImported_maybe :: Name -> TcM (MaybeErr MsgDoc TyThing)
 -- Returns (Failed err) if we can't find the interface file for the thing
 tcLookupImported_maybe name
@@ -167,13 +167,13 @@ importDecl name
                                 pprNameSpace (occNameSpace (nameOccName name)) <+> ppr name)
                        2 (vcat [ptext (sLit "Probable cause: bug in .hi-boot file, or inconsistent .hi file"),
                                 ptext (sLit "Use -ddump-if-trace to get an idea of which file caused the error")])
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
            Checks for wired-in things
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 Note [Loading instances for wired-in things]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -200,9 +200,8 @@ for any module with an instance decl or RULE that we might want.
 
 All of this is done by the type checker. The renamer plays no role.
 (It used to, but no longer.)
+-}
 
-
-\begin{code}
 checkWiredInTyCon :: TyCon -> TcM ()
 -- Ensure that the home module of the TyCon (and hence its instances)
 -- are loaded. See Note [Loading instances for wired-in things]
@@ -244,13 +243,13 @@ needWiredInHomeIface :: TyThing -> Bool
 -- Only for TyCons; see Note [Loading instances for wired-in things]
 needWiredInHomeIface (ATyCon {}) = True
 needWiredInHomeIface _           = False
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Type-checking a complete interface
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 Suppose we discover we don't need to recompile.  Then we must type
 check the old interface file.  This is a bit different to the
@@ -259,8 +258,8 @@ we do things similarly as when we are typechecking source decls: we
 bring into scope the type envt for the interface all at once, using a
 knot.  Remember, the decls aren't necessarily in dependency order --
 and even if they were, the type decls might be mutually recursive.
+-}
 
-\begin{code}
 typecheckIface :: ModIface      -- Get the decls from here
                -> TcRnIf gbl lcl ModDetails
 typecheckIface iface
@@ -306,16 +305,15 @@ typecheckIface iface
                               , md_exports   = exports
                               }
     }
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Type and class declarations
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcHiBootIface :: HscSource -> Module -> TcRn ModDetails
 -- Load the hi-boot iface for the module being compiled,
 -- if it indeed exists in the transitive closure of imports
@@ -384,14 +382,13 @@ tcHiBootIface hsc_src mod
 
     elaborate err = hang (ptext (sLit "Could not find hi-boot interface for") <+>
                           quotes (ppr mod) <> colon) 4 err
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Type and class declarations
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 When typechecking a data type decl, we *lazily* (via forkM) typecheck
 the constructor argument types.  This is in the hope that we may never
@@ -435,9 +432,8 @@ type envt by accident, because they look at it later.
 
 What this means is that the implicitTyThings MUST NOT DEPEND on any of
 the forkM stuff.
+-}
 
-
-\begin{code}
 tcIfaceDecl :: Bool     -- True <=> discard IdInfo on IfaceId bindings
             -> IfaceDecl
             -> IfL TyThing
@@ -706,8 +702,8 @@ tcIfaceEqSpec spec
     do_item (occ, if_ty) = do { tv <- tcIfaceTyVar occ
                               ; ty <- tcIfaceType if_ty
                               ; return (tv,ty) }
-\end{code}
 
+{-
 Note [Synonym kind loop]
 ~~~~~~~~~~~~~~~~~~~~~~~~
 Notice that we eagerly grab the *kind* from the interface file, but
@@ -726,13 +722,13 @@ be defined, and we must not do that until we've finished with M.T.
 Solution: record S's kind in the interface file; now we can safely
 look at it.
 
-%************************************************************************
-%*                                                                      *
+************************************************************************
+*                                                                      *
                 Instances
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcIfaceInst :: IfaceClsInst -> IfL ClsInst
 tcIfaceInst (IfaceClsInst { ifDFun = dfun_occ, ifOFlag = oflag
                           , ifInstCls = cls, ifInstTys = mb_tcs
@@ -751,20 +747,19 @@ tcIfaceFamInst (IfaceFamInst { ifFamInstFam = fam, ifFamInstTys = mb_tcs
          ; let axiom'' = toUnbranchedAxiom axiom'
                mb_tcs' = map (fmap ifaceTyConName) mb_tcs
          ; return (mkImportedFamInst fam mb_tcs' axiom'') }
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Rules
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
 
 We move a IfaceRule from eps_rules to eps_rule_base when all its LHS free vars
 are in the type environment.  However, remember that typechecking a Rule may
 (as a side effect) augment the type envt, and so we may need to iterate the process.
+-}
 
-\begin{code}
 tcIfaceRules :: Bool            -- True <=> ignore rules
              -> [IfaceRule]
              -> IfL [CoreRule]
@@ -805,16 +800,15 @@ tcIfaceRule (IfaceRule {ifRuleName = name, ifActivation = act, ifRuleBndrs = bnd
     ifTopFreeName (IfaceApp f _)                    = ifTopFreeName f
     ifTopFreeName (IfaceExt n)                      = Just n
     ifTopFreeName _                                 = Nothing
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Annotations
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcIfaceAnnotations :: [IfaceAnnotation] -> IfL [Annotation]
 tcIfaceAnnotations = mapM tcIfaceAnnotation
 
@@ -833,16 +827,14 @@ tcIfaceAnnTarget (NamedTarget occ) = do
 tcIfaceAnnTarget (ModuleTarget mod) = do
     return $ ModuleTarget mod
 
-\end{code}
-
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Vectorisation information
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 -- We need access to the type environment as we need to look up information about type constructors
 -- (i.e., their data constructors and whether they are class type constructors).  If a vectorised
 -- type constructor or class is defined in the same module as where it is vectorised, we cannot
@@ -962,15 +954,15 @@ tcIfaceVectInfo mod typeEnv (IfaceVectInfo
                }
 
         notATyConErr = pprPanic "TcIface.tcIfaceVectInfo: not a tycon" (ppr name)
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                         Types
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcIfaceType :: IfaceType -> IfL Type
 tcIfaceType (IfaceTyVar n)         = do { tv <- tcIfaceTyVar n; return (TyVarTy tv) }
 tcIfaceType (IfaceAppTy t1 t2)     = do { t1' <- tcIfaceType t1; t2' <- tcIfaceType t2; return (AppTy t1' t2') }
@@ -1015,16 +1007,15 @@ tcIfaceCtxt sts = mapM tcIfaceType sts
 tcIfaceTyLit :: IfaceTyLit -> IfL TyLit
 tcIfaceTyLit (IfaceNumTyLit n) = return (NumTyLit n)
 tcIfaceTyLit (IfaceStrTyLit n) = return (StrTyLit n)
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                         Coercions
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcIfaceCo :: IfaceCoercion -> IfL Coercion
 tcIfaceCo (IfaceReflCo r t)         = mkReflCo r <$> tcIfaceType t
 tcIfaceCo (IfaceFunCo r c1 c2)      = mkFunCo r <$> tcIfaceCo c1 <*> tcIfaceCo c2
@@ -1061,16 +1052,15 @@ tcIfaceCoAxiomRule n =
   case Map.lookup n typeNatCoAxiomRules of
     Just ax -> return ax
     _  -> pprPanic "tcIfaceCoAxiomRule" (ppr n)
-\end{code}
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                         Core
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcIfaceExpr :: IfaceExpr -> IfL CoreExpr
 tcIfaceExpr (IfaceType ty)
   = Type <$> tcIfaceType ty
@@ -1247,16 +1237,15 @@ tcIfaceDataAlt con inst_tys arg_strs rhs
                   extendIfaceIdEnv arg_ids      $
                   tcIfaceExpr rhs
         ; return (DataAlt con, ex_tvs ++ arg_ids, rhs') }
-\end{code}
 
-
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 IdInfo
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcIdDetails :: Type -> IfaceIdDetails -> IfL IdDetails
 tcIdDetails _  IfVanillaId = return VanillaId
 tcIdDetails ty (IfDFunId ns)
@@ -1291,9 +1280,7 @@ tcIdInfo ignore_prags name ty info
            ; let info1 | lb        = info `setOccInfo` strongLoopBreaker
                        | otherwise = info
            ; return (info1 `setUnfoldingInfoLazily` unf) }
-\end{code}
 
-\begin{code}
 tcUnfolding :: Name -> Type -> IdInfo -> IfaceUnfolding -> IfL Unfolding
 tcUnfolding name _ info (IfCoreUnfold stable if_expr)
   = do  { dflags <- getDynFlags
@@ -1333,12 +1320,12 @@ tcUnfolding name dfun_ty _ (IfDFunUnfold bs ops)
   where
     doc = text "Class ops for dfun" <+> ppr name
     (_, _, cls, _) = tcSplitDFunTy dfun_ty
-\end{code}
 
+{-
 For unfoldings we try to do the job lazily, so that we never type check
 an unfolding that isn't going to be looked at.
+-}
 
-\begin{code}
 tcPragExpr :: Name -> IfaceExpr -> IfL (Maybe CoreExpr)
 tcPragExpr name expr
   = forkM_maybe doc $ do
@@ -1370,17 +1357,15 @@ tcPragExpr name expr
              ; return (varEnvElts (if_tv_env lcl_env) ++
                        varEnvElts (if_id_env lcl_env) ++
                        rec_ids) }
-\end{code}
-
-
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Getting from Names to TyThings
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 tcIfaceGlobal :: Name -> IfL TyThing
 tcIfaceGlobal name
   | Just thing <- wiredInNameTyThing_maybe name
@@ -1461,15 +1446,15 @@ tcIfaceExtId name = do { thing <- tcIfaceGlobal name
                        ; case thing of
                           AnId id -> return id
                           _       -> pprPanic "tcIfaceExtId" (ppr name$$ ppr thing) }
-\end{code}
 
-%************************************************************************
-%*                                                                      *
+{-
+************************************************************************
+*                                                                      *
                 Bindings
-%*                                                                      *
-%************************************************************************
+*                                                                      *
+************************************************************************
+-}
 
-\begin{code}
 bindIfaceBndr :: IfaceBndr -> (CoreBndr -> IfL a) -> IfL a
 bindIfaceBndr (IfaceIdBndr (fs, ty)) thing_inside
   = do  { name <- newIfaceName (mkVarOccFS fs)
@@ -1532,4 +1517,3 @@ bindIfaceTyVars_AT (b@(tv_occ,_) : bs) thing_inside
        ; bind_b $ \b' ->
          bindIfaceTyVars_AT bs $ \bs' ->
          thing_inside (b':bs') }
-\end{code}
similarity index 96%
rename from compiler/iface/TcIface.lhs-boot
rename to compiler/iface/TcIface.hs-boot
index 591419a..619e3ef 100644 (file)
@@ -1,4 +1,3 @@
-\begin{code}
 module TcIface where
 
 import IfaceSyn    ( IfaceDecl, IfaceClsInst, IfaceFamInst, IfaceRule, IfaceAnnotation )
@@ -17,5 +16,3 @@ tcIfaceVectInfo    :: Module -> TypeEnv -> IfaceVectInfo -> IfL VectInfo
 tcIfaceInst        :: IfaceClsInst -> IfL ClsInst
 tcIfaceFamInst     :: IfaceFamInst -> IfL FamInst
 tcIfaceAnnotations :: [IfaceAnnotation] -> IfL [Annotation]
-\end{code}
-