Tabs -> spaces
authorManuel M T Chakravarty <chak@cse.unsw.edu.au>
Sun, 16 Oct 2011 10:19:55 +0000 (21:19 +1100)
committerManuel M T Chakravarty <chak@cse.unsw.edu.au>
Tue, 25 Oct 2011 03:50:01 +0000 (14:50 +1100)
compiler/iface/LoadIface.lhs

index bbee042..cc95762 100644 (file)
@@ -12,19 +12,19 @@ module LoadIface (
         loadSrcInterface, loadInterfaceForName, 
 
         -- IfM functions
-       loadInterface, loadWiredInHomeIface, 
-       loadSysInterface, loadUserInterface, 
-       findAndReadIface, readIface,    -- Used when reading the module's old interface
-       loadDecls,      -- Should move to TcIface and be renamed
-       initExternalPackageState,
+        loadInterface, loadWiredInHomeIface, 
+        loadSysInterface, loadUserInterface, 
+        findAndReadIface, readIface,    -- Used when reading the module's old interface
+        loadDecls,      -- Should move to TcIface and be renamed
+        initExternalPackageState,
 
-       ifaceStats, pprModIface, showIface
+        ifaceStats, pprModIface, showIface
    ) where
 
 #include "HsVersions.h"
 
-import {-# SOURCE #-}  TcIface( tcIfaceDecl, tcIfaceRules, tcIfaceInst, 
-                                tcIfaceFamInst, tcIfaceVectInfo, tcIfaceAnnotations )
+import {-# SOURCE #-}   TcIface( tcIfaceDecl, tcIfaceRules, tcIfaceInst, 
+                                 tcIfaceFamInst, tcIfaceVectInfo, tcIfaceAnnotations )
 
 import DynFlags
 import IfaceSyn
@@ -36,7 +36,7 @@ import TcRnMonad
 
 import PrelNames
 import PrelInfo
-import MkId    ( seqId )
+import MkId     ( seqId )
 import Rules
 import Annotations
 import InstEnv
@@ -62,11 +62,11 @@ import Control.Monad
 
 
 %************************************************************************
-%*                                                                     *
-       loadSrcInterface, loadOrphanModules, loadHomeInterface
+%*                                                                      *
+        loadSrcInterface, loadOrphanModules, loadHomeInterface
 
-               These three are called from TcM-land    
-%*                                                                     *
+                These three are called from TcM-land    
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -90,11 +90,11 @@ loadSrcInterface doc mod want_boot maybe_pkg  = do
     Found _ mod -> do
       mb_iface <- initIfaceTcRn $ loadInterface doc mod (ImportByUser want_boot)
       case mb_iface of
-       Failed err      -> failWithTc err
-       Succeeded iface -> return iface
+        Failed err      -> failWithTc err
+        Succeeded iface -> return iface
     err ->
         let dflags = hsc_dflags hsc_env in
-       failWithTc (cannotFindInterface dflags mod err)
+        failWithTc (cannotFindInterface dflags mod err)
 
 -- | Load interface for a module.
 loadModuleInterface :: SDoc -> Module -> TcM ModIface
@@ -124,13 +124,13 @@ loadInterfaceForName doc name
 
 
 %*********************************************************
-%*                                                     *
-               loadInterface
+%*                                                      *
+                loadInterface
 
-       The main function to load an interface
-       for an imported module, and put it in
-       the External Package State
-%*                                                     *
+        The main function to load an interface
+        for an imported module, and put it in
+        the External Package State
+%*                                                      *
 %*********************************************************
 
 \begin{code}
@@ -160,142 +160,142 @@ loadUserInterface is_boot doc mod_name
 -- | A wrapper for 'loadInterface' that throws an exception if it fails
 loadInterfaceWithException :: SDoc -> Module -> WhereFrom -> IfM lcl ModIface
 loadInterfaceWithException doc mod_name where_from
-  = do { mb_iface <- loadInterface doc mod_name where_from
-       ; case mb_iface of 
-           Failed err      -> ghcError (ProgramError (showSDoc err))
-           Succeeded iface -> return iface }
+  = do  { mb_iface <- loadInterface doc mod_name where_from
+        ; case mb_iface of 
+            Failed err      -> ghcError (ProgramError (showSDoc err))
+            Succeeded iface -> return iface }
 
 ------------------
 loadInterface :: SDoc -> Module -> WhereFrom
-             -> IfM lcl (MaybeErr Message ModIface)
+              -> IfM lcl (MaybeErr Message 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 it can't find a suitable interface file, we
---     a) modify the PackageIfaceTable to have an empty entry
---             (to avoid repeated complaints)
---     b) return (Left message)
+--      a) modify the PackageIfaceTable to have an empty entry
+--              (to avoid repeated complaints)
+--      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 
 -- is no longer used
 
 loadInterface doc_str mod from
-  = do {       -- Read the state
-         (eps,hpt) <- getEpsAndHpt
-
-       ; traceIf (text "Considering whether to load" <+> ppr mod <+> ppr from)
-
-               -- Check whether we have the interface already
-       ; dflags <- getDOpts
-       ; case lookupIfaceByModule dflags hpt (eps_PIT eps) mod of {
-           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,
-                       -- if an earlier import had a before we got to real imports.   I think.
-           _ -> do {
-
-       -- READ THE MODULE IN
-       ; read_result <- case (wantHiBootFile dflags eps mod from) of
+  = do  {       -- Read the state
+          (eps,hpt) <- getEpsAndHpt
+
+        ; traceIf (text "Considering whether to load" <+> ppr mod <+> ppr from)
+
+                -- Check whether we have the interface already
+        ; dflags <- getDOpts
+        ; case lookupIfaceByModule dflags hpt (eps_PIT eps) mod of {
+            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,
+                        -- if an earlier import had a before we got to real imports.   I think.
+            _ -> do {
+
+        -- READ THE MODULE IN
+        ; read_result <- case (wantHiBootFile dflags eps mod from) of
                            Failed err             -> return (Failed err)
                            Succeeded hi_boot_file -> findAndReadIface doc_str mod hi_boot_file
-       ; case read_result of {
-           Failed err -> do
-               { let fake_iface = emptyModIface mod
-
-               ; updateEps_ $ \eps ->
-                       eps { eps_PIT = extendModuleEnv (eps_PIT eps) (mi_module fake_iface) fake_iface }
-                       -- Not found, so add an empty iface to 
-                       -- the EPS map so that we don't look again
-                               
-               ; return (Failed err) } ;
-
-       -- Found and parsed!
-       -- We used to have a sanity check here that looked for:
-       --  * System importing ..
-       --  * a home package module ..
-       --  * that we know nothing about (mb_dep == Nothing)!
-       --
-       -- But this is no longer valid because thNameToGhcName allows users to
-       -- cause the system to load arbitrary interfaces (by supplying an appropriate
-       -- Template Haskell original-name).
-           Succeeded (iface, file_path) ->
-
-       let 
-           loc_doc = text file_path
-       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 
-       --      mode, home-package modules are loaded one by one into the HPT)
-       -- are put in the EPS.
-       --
-       -- The main thing is to add the ModIface to the PIT, but
-       -- we also take the
-       --      IfaceDecls, IfaceInst, IfaceFamInst, IfaceRules, IfaceVectInfo
-       -- out of the ModIface and put them into the big EPS pools
-
-       -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
-       ---    names is done correctly (notably, whether this is an .hi file or .hi-boot file).
-       --     If we do loadExport first the wrong info gets into the cache (unless we
-       --      explicitly tag each export which seems a bit of a bore)
-
-       ; ignore_prags      <- doptM Opt_IgnoreInterfacePragmas
-       ; new_eps_decls     <- loadDecls ignore_prags (mi_decls iface)
-       ; new_eps_insts     <- mapM tcIfaceInst (mi_insts iface)
-       ; new_eps_fam_insts <- mapM tcIfaceFamInst (mi_fam_insts iface)
-       ; new_eps_rules     <- tcIfaceRules ignore_prags (mi_rules iface)
-       ; new_eps_anns      <- tcIfaceAnnotations (mi_anns iface)
+        ; case read_result of {
+            Failed err -> do
+                { let fake_iface = emptyModIface mod
+
+                ; updateEps_ $ \eps ->
+                        eps { eps_PIT = extendModuleEnv (eps_PIT eps) (mi_module fake_iface) fake_iface }
+                        -- Not found, so add an empty iface to 
+                        -- the EPS map so that we don't look again
+                                
+                ; return (Failed err) } ;
+
+        -- Found and parsed!
+        -- We used to have a sanity check here that looked for:
+        --  * System importing ..
+        --  * a home package module ..
+        --  * that we know nothing about (mb_dep == Nothing)!
+        --
+        -- But this is no longer valid because thNameToGhcName allows users to
+        -- cause the system to load arbitrary interfaces (by supplying an appropriate
+        -- Template Haskell original-name).
+            Succeeded (iface, file_path) ->
+
+        let 
+            loc_doc = text file_path
+        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 
+        --      mode, home-package modules are loaded one by one into the HPT)
+        -- are put in the EPS.
+        --
+        -- The main thing is to add the ModIface to the PIT, but
+        -- we also take the
+        --      IfaceDecls, IfaceInst, IfaceFamInst, IfaceRules, IfaceVectInfo
+        -- out of the ModIface and put them into the big EPS pools
+
+        -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
+        ---    names is done correctly (notably, whether this is an .hi file or .hi-boot file).
+        --     If we do loadExport first the wrong info gets into the cache (unless we
+        --      explicitly tag each export which seems a bit of a bore)
+
+        ; ignore_prags      <- doptM Opt_IgnoreInterfacePragmas
+        ; new_eps_decls     <- loadDecls ignore_prags (mi_decls iface)
+        ; new_eps_insts     <- mapM tcIfaceInst (mi_insts iface)
+        ; new_eps_fam_insts <- mapM tcIfaceFamInst (mi_fam_insts iface)
+        ; new_eps_rules     <- tcIfaceRules ignore_prags (mi_rules iface)
+        ; 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 {   
-                               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",
-                               mi_rules     = panic "No mi_rules in PIT",
-                               mi_anns      = panic "No mi_anns in PIT"
+        ; 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",
+                                mi_rules     = panic "No mi_rules in PIT",
+                                mi_anns      = panic "No mi_anns in PIT"
                               }
                }
 
-       ; updateEps_  $ \ eps -> 
+        ; updateEps_  $ \ eps -> 
            if elemModuleEnv mod (eps_PIT eps) then eps else
-           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) 
-                                                   new_eps_rules,
-             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 { 
+              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) 
+                                                    new_eps_rules,
+              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) 
                                               new_eps_vect_info,
               eps_ann_env      = extendAnnEnvList (eps_ann_env eps)
                                                   new_eps_anns,
               eps_mod_fam_inst_env
-                              = let
-                                  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) 
-                                              (length new_eps_decls)
-                                              (length new_eps_insts)
-                                              (length new_eps_rules) }
-
-       ; return (Succeeded final_iface)
+                               = let
+                                   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) 
+                                               (length new_eps_decls)
+                                               (length new_eps_insts)
+                                               (length new_eps_rules) }
+
+        ; return (Succeeded final_iface)
     }}}}
 
 wantHiBootFile :: DynFlags -> ExternalPackageState -> Module -> WhereFrom
-              -> MaybeErr Message IsBootInterface
+               -> MaybeErr Message IsBootInterface
 -- Figure out whether we want Foo.hi or Foo.hi-boot
 wantHiBootFile dflags eps mod from
   = case from of
@@ -312,10 +312,10 @@ wantHiBootFile dflags eps mod from
 
           | 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, 
-                    -- based on the dependencies in directly-imported modules
+                Just (_, is_boot) -> Succeeded is_boot
+                Nothing           -> Succeeded False
+                     -- The boot-ness of the requested interface, 
+                     -- based on the dependencies in directly-imported modules
   where
     this_package = thisPackage dflags == modulePackageId mod
 
@@ -334,12 +334,12 @@ badDepMsg :: Module -> SDoc
 badDepMsg mod 
   = hang (ptext (sLit "Interface file inconsistency:"))
        2 (sep [ptext (sLit "home-package module") <+> quotes (ppr mod) <+> ptext (sLit "is needed,"), 
-              ptext (sLit "but is not listed in the dependencies of the interfaces directly imported by the module being compiled")])
+               ptext (sLit "but is not listed in the dependencies of the interfaces directly imported by the module being compiled")])
 -}
 
 \begin{code}
 -----------------------------------------------------
---     Loading type/class/value decls
+--      Loading type/class/value decls
 -- We pass the full Module name here, replete with
 -- its package info, so that we can build a Name for
 -- each binder with the right package info in it
@@ -355,35 +355,35 @@ addDeclsToPTE :: PackageTypeEnv -> [(Name,TyThing)] -> PackageTypeEnv
 addDeclsToPTE pte things = extendNameEnvList pte things
 
 loadDecls :: Bool
-         -> [(Fingerprint, IfaceDecl)]
-         -> IfL [(Name,TyThing)]
+          -> [(Fingerprint, IfaceDecl)]
+          -> IfL [(Name,TyThing)]
 loadDecls ignore_prags ver_decls
    = do { mod <- getIfModule
-       ; thingss <- mapM (loadDecl ignore_prags mod) ver_decls
-       ; return (concat thingss)
-       }
-
-loadDecl :: Bool                   -- Don't load pragmas into the decl pool
-        -> Module
-         -> (Fingerprint, IfaceDecl)
-         -> IfL [(Name,TyThing)]   -- The list can be poked eagerly, but the
-                                   -- TyThings are forkM'd thunks
+        ; thingss <- mapM (loadDecl ignore_prags mod) ver_decls
+        ; return (concat thingss)
+        }
+
+loadDecl :: Bool                    -- Don't load pragmas into the decl pool
+         -> Module
+          -> (Fingerprint, IfaceDecl)
+          -> 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 
-               -- the names associated with the decl
-         main_name      <- lookupOrig mod (ifName decl)
+  = do  {       -- Populate the name cache with final versions of all 
+                -- the names associated with the decl
+          main_name      <- lookupOrig mod (ifName decl)
 --        ; traceIf (text "Loading decl for " <> ppr main_name)
-       ; implicit_names <- mapM (lookupOrig mod) (ifaceDeclSubBndrs decl)
+        ; implicit_names <- mapM (lookupOrig mod) (ifaceDeclSubBndrs 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 
-       -- 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.
+        -- 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 
+        -- 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.
 
-       ; thing <- forkM doc $ do { bumpDeclStats main_name
-                                 ; tcIfaceDecl ignore_prags decl }
+        ; thing <- forkM doc $ do { bumpDeclStats main_name
+                                  ; tcIfaceDecl ignore_prags decl }
 
         -- Populate the type environment with the implicitTyThings too.
         -- 
@@ -394,12 +394,12 @@ loadDecl ignore_prags mod (_version, decl)
         -- 'forkM'd by tcIfaceDecl.
         --
         -- In more detail: Consider the example
-        --     data T a = MkT { x :: T a }
+        --      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 
-        --     [ "MkT" -> <datacon MkT>, "x" -> <selector x>, ... ]
+        --      [ "MkT" -> <datacon MkT>, "x" -> <selector x>, ... ]
         -- (where the "MkT" is the *Name* associated with MkT, etc.)
         --
         -- We do this by mapping the implict_names to the associated
@@ -440,71 +440,71 @@ loadDecl ignore_prags mod (_version, decl)
 
         -- This mini-env and lookup function mediates between the
         --'Name's n and the map from 'OccName's to the implicit TyThings
-       ; let mini_env = mkOccEnv [(getOccName t, t) | t <- implicitTyThings thing]
-             lookup n = case lookupOccEnv mini_env (getOccName n) of
-                          Just thing -> thing
-                          Nothing    -> 
-                            pprPanic "loadDecl" (ppr main_name <+> ppr n $$ ppr (decl))
+        ; let mini_env = mkOccEnv [(getOccName t, t) | t <- implicitTyThings thing]
+              lookup n = case lookupOccEnv mini_env (getOccName n) of
+                           Just thing -> thing
+                           Nothing    -> 
+                             pprPanic "loadDecl" (ppr main_name <+> ppr n $$ ppr (decl))
 
-       ; return $ (main_name, thing) :
+        ; return $ (main_name, thing) :
                       -- uses the invariant that implicit_names and
                       -- implictTyThings are bijective
                       [(n, lookup n) | n <- implicit_names]
-       }
+        }
   where
     doc = ptext (sLit "Declaration for") <+> ppr (ifName decl)
 
-bumpDeclStats :: Name -> IfL ()                -- Record that one more declaration has actually been used
+bumpDeclStats :: Name -> IfL ()         -- Record that one more declaration has actually been used
 bumpDeclStats name
-  = do { traceIf (text "Loading decl for" <+> ppr name)
-       ; updateEps_ (\eps -> let stats = eps_stats eps
-                             in eps { eps_stats = stats { n_decls_out = n_decls_out stats + 1 } })
-       }
+  = do  { traceIf (text "Loading decl for" <+> ppr 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}
-%*                                                     *
+%*                                                      *
 %*********************************************************
 
 \begin{code}
 findAndReadIface :: SDoc -> Module
-                -> IsBootInterface     -- True  <=> Look for a .hi-boot file
-                                       -- False <=> Look for .hi file
-                -> TcRnIf gbl lcl (MaybeErr Message (ModIface, FilePath))
-       -- Nothing <=> file not found, or unreadable, or illegible
-       -- Just x  <=> successfully found and parsed 
+                 -> IsBootInterface     -- True  <=> Look for a .hi-boot file
+                                        -- False <=> Look for .hi file
+                 -> TcRnIf gbl lcl (MaybeErr Message (ModIface, FilePath))
+        -- Nothing <=> file not found, or unreadable, or illegible
+        -- Just x  <=> successfully found and parsed 
 
-       -- It *doesn't* add an error to the monad, because 
-       -- sometimes it's ok to fail... see notes with loadInterface
+        -- 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]") 
-                               else empty,
-                             ptext (sLit "interface for"), 
-                             ppr mod <> semi],
-                       nest 4 (ptext (sLit "reason:") <+> doc_str)])
-
-       -- Check for GHC.Prim, and return its static interface
-       ; dflags <- getDOpts
-       ; if mod == gHC_PRIM
-         then return (Succeeded (ghcPrimIface,
-                                  "<built in interface for GHC.Prim>"))
-         else do
-
-       -- Look for the file
-       ; hsc_env <- getTopEnv
-       ; mb_found <- liftIO (findExactModule hsc_env mod)
-       ; case mb_found of {
+  = do  { traceIf (sep [hsep [ptext (sLit "Reading"), 
+                              if hi_boot_file 
+                                then ptext (sLit "[boot]") 
+                                else empty,
+                              ptext (sLit "interface for"), 
+                              ppr mod <> semi],
+                        nest 4 (ptext (sLit "reason:") <+> doc_str)])
+
+        -- Check for GHC.Prim, and return its static interface
+        ; dflags <- getDOpts
+        ; if mod == gHC_PRIM
+          then return (Succeeded (ghcPrimIface,
+                                   "<built in interface for GHC.Prim>"))
+          else do
+
+        -- Look for the 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 (ml_hi_file loc) }
+        -- Found file, so read it
+        { let { file_path = addBootSuffix_maybe hi_boot_file (ml_hi_file loc) }
 
         -- If the interface is in the current package then if we could
         -- load it would already be in the HPT and we assume that our
@@ -515,21 +515,21 @@ findAndReadIface doc_str mod hi_boot_file
             else do {
 
         ; traceIf (ptext (sLit "readIFace") <+> text file_path)
-       ; read_result <- readIface mod file_path hi_boot_file
-       ; case read_result of
-           Failed err -> return (Failed (badIfaceFile file_path err))
-           Succeeded iface 
-               | mi_module iface /= mod ->
-                 return (Failed (wrongIfaceModErr iface mod file_path))
-               | otherwise ->
-                 return (Succeeded (iface, file_path))
-                       -- Don't forget to fill in the package name...
-       }}
-           ; err -> do
-               { traceIf (ptext (sLit "...not found"))
-               ; dflags <- getDOpts
-               ; return (Failed (cannotFindInterface dflags 
-                                       (moduleName mod) err)) }
+        ; read_result <- readIface mod file_path hi_boot_file
+        ; case read_result of
+            Failed err -> return (Failed (badIfaceFile file_path err))
+            Succeeded iface 
+                | mi_module iface /= mod ->
+                  return (Failed (wrongIfaceModErr iface mod file_path))
+                | otherwise ->
+                  return (Succeeded (iface, file_path))
+                        -- Don't forget to fill in the package name...
+        }}
+            ; err -> do
+                { traceIf (ptext (sLit "...not found"))
+                ; dflags <- getDOpts
+                ; return (Failed (cannotFindInterface dflags 
+                                        (moduleName mod) err)) }
         }
         }
 \end{code}
@@ -538,30 +538,30 @@ findAndReadIface doc_str mod hi_boot_file
 
 \begin{code}
 readIface :: Module -> FilePath -> IsBootInterface 
-         -> TcRnIf gbl lcl (MaybeErr Message ModIface)
-       -- Failed err    <=> file not found, or unreadable, or illegible
-       -- Succeeded iface <=> successfully found and parsed 
+          -> TcRnIf gbl lcl (MaybeErr Message ModIface)
+        -- Failed err    <=> file not found, or unreadable, or illegible
+        -- Succeeded iface <=> successfully found and parsed 
 
 readIface wanted_mod file_path _
-  = do { res <- tryMostM $
+  = do  { res <- tryMostM $
                  readBinIface CheckHiWay QuietBinIFaceReading file_path
-       ; case res of
-           Right iface 
-               | wanted_mod == actual_mod -> return (Succeeded iface)
-               | otherwise                -> return (Failed err)
-               where
-                 actual_mod = mi_module iface
-                 err = hiModuleNameMismatchWarn wanted_mod actual_mod
-
-           Left exn    -> return (Failed (text (showException exn)))
+        ; case res of
+            Right iface 
+                | wanted_mod == actual_mod -> return (Succeeded iface)
+                | otherwise                -> return (Failed err)
+                where
+                  actual_mod = mi_module iface
+                  err = hiModuleNameMismatchWarn wanted_mod actual_mod
+
+            Left exn    -> return (Failed (text (showException exn)))
     }
 \end{code}
 
 
 %*********************************************************
-%*                                                      *
-       Wired-in interface for GHC.Prim
-%*                                                      *
+%*                                                       *
+        Wired-in interface for GHC.Prim
+%*                                                       *
 %*********************************************************
 
 \begin{code}
@@ -574,42 +574,42 @@ initExternalPackageState
       eps_inst_env     = emptyInstEnv,
       eps_fam_inst_env = emptyFamInstEnv,
       eps_rule_base    = mkRuleBase builtinRules,
-       -- Initialise the EPS rule pool with the built-in rules
+        -- Initialise the EPS rule pool with the built-in rules
       eps_mod_fam_inst_env
                        = emptyModuleEnv,
       eps_vect_info    = noVectInfo,
       eps_ann_env      = emptyAnnEnv,
       eps_stats = EpsStats { n_ifaces_in = 0, n_decls_in = 0, n_decls_out = 0
-                          , n_insts_in = 0, n_insts_out = 0
-                          , n_rules_in = length builtinRules, n_rules_out = 0 }
+                           , 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
-%*                                                      *
+%*                                                       *
+        Wired-in interface for GHC.Prim
+%*                                                       *
 %*********************************************************
 
 \begin{code}
 ghcPrimIface :: ModIface
 ghcPrimIface
   = (emptyModIface gHC_PRIM) {
-       mi_exports  = ghcPrimExports,
-       mi_decls    = [],
-       mi_fixities = fixities,
-       mi_fix_fn  = mkIfaceFixCache fixities
-    }          
+        mi_exports  = ghcPrimExports,
+        mi_decls    = [],
+        mi_fixities = fixities,
+        mi_fix_fn  = mkIfaceFixCache fixities
+    }           
   where
     fixities = [(getOccName seqId, Fixity 0 InfixR)]
-                       -- seq is infixr 0
+                        -- seq is infixr 0
 \end{code}
 
 %*********************************************************
-%*                                                     *
+%*                                                      *
 \subsection{Statistics}
-%*                                                     *
+%*                                                      *
 %*********************************************************
 
 \begin{code}
@@ -619,21 +619,21 @@ ifaceStats eps
   where
     stats = eps_stats eps
     msg = vcat 
-       [int (n_ifaces_in stats) <+> text "interfaces read",
-        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",  
-               int (n_insts_in stats), text "read"],
-        hsep [ int (n_rules_out stats), text "rule decls imported, out of",  
-               int (n_rules_in stats), text "read"]
-       ]
+        [int (n_ifaces_in stats) <+> text "interfaces read",
+         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",  
+                int (n_insts_in stats), text "read"],
+         hsep [ int (n_rules_out stats), text "rule decls imported, out of",  
+                int (n_rules_in stats), text "read"]
+        ]
 \end{code}
 
 
 %************************************************************************
-%*                                                                     *
-               Printing interfaces
-%*                                                                     *
+%*                                                                      *
+                Printing interfaces
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -652,23 +652,23 @@ pprModIface :: ModIface -> SDoc
 -- Show a ModIface
 pprModIface iface
  = vcat [ ptext (sLit "interface")
-               <+> ppr (mi_module iface) <+> pp_boot
-               <+> (if mi_orphan iface then ptext (sLit "[orphan module]") else empty)
-               <+> (if mi_finsts iface then ptext (sLit "[family instance module]") else empty)
-               <+> (if mi_hpc    iface then ptext (sLit "[hpc]") else empty)
-               <+> integer opt_HiVersion
+                <+> ppr (mi_module iface) <+> pp_boot
+                <+> (if mi_orphan iface then ptext (sLit "[orphan module]") else empty)
+                <+> (if mi_finsts iface then ptext (sLit "[family instance module]") else empty)
+                <+> (if mi_hpc    iface then ptext (sLit "[hpc]") else empty)
+                <+> integer opt_HiVersion
         , nest 2 (text "interface hash:" <+> ppr (mi_iface_hash iface))
         , nest 2 (text "ABI hash:" <+> ppr (mi_mod_hash iface))
         , nest 2 (text "export-list hash:" <+> ppr (mi_exp_hash iface))
         , nest 2 (text "orphan hash:" <+> ppr (mi_orphan_hash iface))
         , nest 2 (text "used TH splices:" <+> ppr (mi_used_th iface))
         , nest 2 (ptext (sLit "where"))
-       , ptext (sLit "exports:")
+        , ptext (sLit "exports:")
         , nest 2 (vcat (map pprExport (mi_exports iface)))
-       , pprDeps (mi_deps iface)
-       , vcat (map pprUsage (mi_usages iface))
-       , vcat (map pprIfaceAnnotation (mi_anns iface))
-       , pprFixities (mi_fixities iface)
+        , pprDeps (mi_deps iface)
+        , vcat (map pprUsage (mi_usages iface))
+        , vcat (map pprIfaceAnnotation (mi_anns iface))
+        , pprFixities (mi_fixities iface)
         , vcat (map pprIfaceDecl (mi_decls iface))
         , vcat (map ppr (mi_insts iface))
         , vcat (map ppr (mi_fam_insts iface))
@@ -684,9 +684,9 @@ pprModIface iface
 \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
+        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
@@ -705,7 +705,7 @@ pprUsage usage@UsagePackageModule{}
 pprUsage usage@UsageHomeModule{}
   = pprUsageImport usage usg_mod_name $$
     nest 2 (
-       maybe empty (\v -> text "exports: " <> ppr v) (usg_exports usage) $$
+        maybe empty (\v -> text "exports: " <> ppr v) (usg_exports usage) $$
         vcat [ ppr n <+> ppr v | (n,v) <- usg_entities usage ]
         )
 
@@ -719,12 +719,12 @@ pprUsageImport usage usg_mod'
 
 pprDeps :: Dependencies -> SDoc
 pprDeps (Deps { dep_mods = mods, dep_pkgs = pkgs, dep_orphs = orphs,
-               dep_finsts = finsts })
+                dep_finsts = finsts })
   = vcat [ptext (sLit "module dependencies:") <+> fsep (map ppr_mod mods),
-         ptext (sLit "package dependencies:") <+> fsep (map ppr_pkg pkgs),
-         ptext (sLit "orphans:") <+> fsep (map ppr orphs),
-         ptext (sLit "family instance modules:") <+> fsep (map ppr finsts)
-       ]
+          ptext (sLit "package dependencies:") <+> fsep (map ppr_pkg pkgs),
+          ptext (sLit "orphans:") <+> fsep (map ppr orphs),
+          ptext (sLit "family instance modules:") <+> fsep (map ppr finsts)
+        ]
   where
     ppr_mod (mod_name, boot) = ppr mod_name <+> ppr_boot boot
     ppr_pkg (pkg,trust_req)  = ppr pkg <>
@@ -739,8 +739,8 @@ pprIfaceDecl (ver, decl)
 pprFixities :: [(OccName, Fixity)] -> SDoc
 pprFixities []    = empty
 pprFixities fixes = ptext (sLit "fixities") <+> pprWithCommas pprFix fixes
-                 where
-                   pprFix (occ,fix) = ppr fix <+> ppr occ 
+                  where
+                    pprFix (occ,fix) = ppr fix <+> ppr occ 
 
 pprVectInfo :: IfaceVectInfo -> SDoc
 pprVectInfo (IfaceVectInfo { ifaceVectInfoVar          = vars
@@ -767,7 +767,7 @@ instance Outputable Warnings where
     ppr = pprWarns
 
 pprWarns :: Warnings -> SDoc
-pprWarns NoWarnings        = empty
+pprWarns NoWarnings         = empty
 pprWarns (WarnAll txt)  = ptext (sLit "Warn all") <+> ppr txt
 pprWarns (WarnSome prs) = ptext (sLit "Warnings")
                         <+> vcat (map pprWarning prs)
@@ -780,16 +780,16 @@ pprIfaceAnnotation (IfaceAnnotation { ifAnnotatedTarget = target, ifAnnotatedVal
 
 
 %*********************************************************
-%*                                                      *
+%*                                                       *
 \subsection{Errors}
-%*                                                      *
+%*                                                       *
 %*********************************************************
 
 \begin{code}
 badIfaceFile :: String -> SDoc -> SDoc
 badIfaceFile file err
   = vcat [ptext (sLit "Bad interface file:") <+> text file, 
-         nest 4 err]
+          nest 4 err]
 
 hiModuleNameMismatchWarn :: Module -> Module -> Message
 hiModuleNameMismatchWarn requested_mod read_mod = 
@@ -797,21 +797,21 @@ hiModuleNameMismatchWarn requested_mod read_mod =
     -- we want the Modules below to be qualified with package names,
     -- so reset the PrintUnqualified setting.
     hsep [ ptext (sLit "Something is amiss; requested module ")
-        , ppr requested_mod
-        , ptext (sLit "differs from name found in the interface file")
-        , ppr read_mod
-        ]
+         , ppr requested_mod
+         , ptext (sLit "differs from name found in the interface file")
+         , ppr read_mod
+         ]
 
 wrongIfaceModErr :: ModIface -> Module -> String -> SDoc
 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),
-        sep [ptext (sLit "Probable cause: the source code which generated"),
-            nest 2 iface_file,
-            ptext (sLit "has an incompatible module name")
-           ]
-       ]
+         sep [ptext (sLit "Probable cause: the source code which generated"),
+             nest 2 iface_file,
+             ptext (sLit "has an incompatible module name")
+            ]
+        ]
   where iface_file = doubleQuotes (text file_path)
 
 homeModError :: Module -> ModLocation -> SDoc