Tabs -> Spaces
authorDavid Terei <davidterei@gmail.com>
Thu, 26 Jan 2012 02:43:09 +0000 (18:43 -0800)
committerDavid Terei <davidterei@gmail.com>
Thu, 26 Jan 2012 02:43:09 +0000 (18:43 -0800)
compiler/typecheck/TcRnDriver.lhs

index 908588b..1efce78 100644 (file)
@@ -5,26 +5,19 @@
 \section[TcMovectle]{Typechecking a whole module}
 
 \begin{code}
-{-# OPTIONS -fno-warn-tabs #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and
--- detab the module (please do the detabbing in a separate patch). See
---     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
--- for details
-
 module TcRnDriver (
 #ifdef GHCI
-       tcRnStmt, tcRnExpr, tcRnType,
-       tcRnImportDecls,
-       tcRnLookupRdrName,
-       getModuleInterface,
-       tcRnDeclsi,
+        tcRnStmt, tcRnExpr, tcRnType,
+        tcRnImportDecls,
+        tcRnLookupRdrName,
+        getModuleInterface,
+        tcRnDeclsi,
 #endif
-       tcRnLookupName,
-       tcRnGetInfo,
-       tcRnModule, 
-       tcTopSrcDecls,
-       tcRnExtCore
+        tcRnLookupName,
+        tcRnGetInfo,
+        tcRnModule, 
+        tcTopSrcDecls,
+        tcRnExtCore
     ) where
 
 #ifdef GHCI
@@ -47,7 +40,7 @@ import FamInstEnv
 import TcAnnotations
 import TcBinds
 import HeaderInfo       ( mkPrelImports )
-import TcType  ( tidyTopType )
+import TcType   ( tidyTopType )
 import TcDefaults
 import TcEnv
 import TcRules
@@ -84,7 +77,7 @@ import DataCon
 import Type
 import Class
 import TcType   ( orphNamesOfDFunHead )
-import Inst    ( tcGetInstEnvs )
+import Inst     ( tcGetInstEnvs )
 import Data.List ( sortBy )
 import Data.IORef ( readIORef )
 
@@ -96,7 +89,7 @@ import RnTypes
 import RnExpr
 import MkId
 import BasicTypes
-import TidyPgm   ( globaliseAndTidyId )
+import TidyPgm    ( globaliseAndTidyId )
 import TysWiredIn ( unitTy, mkListTy )
 #endif
 
@@ -111,25 +104,25 @@ import Control.Monad
 \end{code}
 
 %************************************************************************
-%*                                                                     *
-       Typecheck and rename a module
-%*                                                                     *
+%*                                                                      *
+        Typecheck and rename a module
+%*                                                                      *
 %************************************************************************
 
 
 \begin{code}
 -- | Top level entry point for typechecker and renamer
 tcRnModule :: HscEnv 
-          -> HscSource
-          -> Bool              -- True <=> save renamed syntax
+           -> HscSource
+           -> Bool              -- True <=> save renamed syntax
            -> HsParsedModule
-          -> IO (Messages, Maybe TcGblEnv)
+           -> IO (Messages, Maybe TcGblEnv)
 
 tcRnModule hsc_env hsc_src save_rn_syntax
    HsParsedModule {
       hpm_module =
          (L loc (HsModule maybe_mod export_ies
-                         import_decls local_decls mod_deprec
+                          import_decls local_decls mod_deprec
                           maybe_doc_hdr)),
       hpm_src_files =
          src_files
@@ -137,17 +130,17 @@ tcRnModule hsc_env hsc_src save_rn_syntax
  = do { showPass (hsc_dflags hsc_env) "Renamer/typechecker" ;
 
    let { this_pkg = thisPackage (hsc_dflags hsc_env) ;
-        (this_mod, prel_imp_loc) 
+         (this_mod, prel_imp_loc) 
             = case maybe_mod of
-               Nothing -- 'module M where' is omitted  
-                    ->  (mAIN, srcLocSpan (srcSpanStart loc))  
-                                  
-               Just (L mod_loc mod)  -- The normal case
+                Nothing -- 'module M where' is omitted  
+                    ->  (mAIN, srcLocSpan (srcSpanStart loc))   
+                                   
+                Just (L mod_loc mod)  -- The normal case
                     -> (mkModule this_pkg mod, mod_loc) } ;
-               
+                
    initTc hsc_env hsc_src save_rn_syntax this_mod $ 
    setSrcSpan loc $
-   do {                -- Deal with imports; first add implicit prelude
+   do {         -- Deal with imports; first add implicit prelude
         implicit_prelude <- xoptM Opt_ImplicitPrelude;
         let { prel_imports = mkPrelImports (moduleName this_mod) prel_imp_loc
                                          implicit_prelude import_decls } ;
@@ -155,70 +148,70 @@ tcRnModule hsc_env hsc_src save_rn_syntax
         ifWOptM Opt_WarnImplicitPrelude $
              when (notNull prel_imports) $ addWarn (implicitPreludeWarn) ;
 
-       tcg_env <- {-# SCC "tcRnImports" #-}
+        tcg_env <- {-# SCC "tcRnImports" #-}
                    tcRnImports hsc_env this_mod (prel_imports ++ import_decls) ;
-       setGblEnv tcg_env               $ do {
-
-               -- Load the hi-boot interface for this module, if any
-               -- We do this now so that the boot_names can be passed
-               -- to tcTyAndClassDecls, because the boot_names are 
-               -- automatically considered to be loop breakers
-               --
-               -- Do this *after* tcRnImports, so that we know whether
-               -- a module that we import imports us; and hence whether to
-               -- look for a hi-boot file
-       boot_iface <- tcHiBootIface hsc_src this_mod ;
-
-               -- Rename and type check the declarations
-       traceRn (text "rn1a") ;
-       tcg_env <- if isHsBoot hsc_src then
-                       tcRnHsBootDecls local_decls
-                  else 
-                       {-# SCC "tcRnSrcDecls" #-}
+        setGblEnv tcg_env               $ do {
+
+                -- Load the hi-boot interface for this module, if any
+                -- We do this now so that the boot_names can be passed
+                -- to tcTyAndClassDecls, because the boot_names are 
+                -- automatically considered to be loop breakers
+                --
+                -- Do this *after* tcRnImports, so that we know whether
+                -- a module that we import imports us; and hence whether to
+                -- look for a hi-boot file
+        boot_iface <- tcHiBootIface hsc_src this_mod ;
+
+                -- Rename and type check the declarations
+        traceRn (text "rn1a") ;
+        tcg_env <- if isHsBoot hsc_src then
+                        tcRnHsBootDecls local_decls
+                   else 
+                        {-# SCC "tcRnSrcDecls" #-}
                         tcRnSrcDecls boot_iface local_decls ;
-       setGblEnv tcg_env               $ do {
-
-               -- Report the use of any deprecated things
-               -- We do this *before* processsing the export list so
-               -- that we don't bleat about re-exporting a deprecated
-               -- thing (especially via 'module Foo' export item)
-               -- That is, only uses in the *body* of the module are complained about
-       traceRn (text "rn3") ;
-       failIfErrsM ;   -- finishWarnings crashes sometimes 
-                       -- as a result of typechecker repairs (e.g. unboundNames)
-       tcg_env <- finishWarnings (hsc_dflags hsc_env) mod_deprec tcg_env ;
-
-               -- Process the export list
+        setGblEnv tcg_env               $ do {
+
+                -- Report the use of any deprecated things
+                -- We do this *before* processsing the export list so
+                -- that we don't bleat about re-exporting a deprecated
+                -- thing (especially via 'module Foo' export item)
+                -- That is, only uses in the *body* of the module are complained about
+        traceRn (text "rn3") ;
+        failIfErrsM ;   -- finishWarnings crashes sometimes 
+                        -- as a result of typechecker repairs (e.g. unboundNames)
+        tcg_env <- finishWarnings (hsc_dflags hsc_env) mod_deprec tcg_env ;
+
+                -- Process the export list
         traceRn (text "rn4a: before exports");
-       tcg_env <- rnExports (isJust maybe_mod) export_ies tcg_env ;
-       traceRn (text "rn4b: after exports") ;
+        tcg_env <- rnExports (isJust maybe_mod) export_ies tcg_env ;
+        traceRn (text "rn4b: after exports") ;
 
                 -- Check that main is exported (must be after rnExports)
         checkMainExported tcg_env ;
 
-       -- Compare the hi-boot iface (if any) with the real thing
-       -- Must be done after processing the exports
-       tcg_env <- checkHiBootIface tcg_env boot_iface ;
+        -- Compare the hi-boot iface (if any) with the real thing
+        -- Must be done after processing the exports
+        tcg_env <- checkHiBootIface tcg_env boot_iface ;
 
-       -- The new type env is already available to stuff slurped from 
-       -- interface files, via TcEnv.updateGlobalTypeEnv
-       -- It's important that this includes the stuff in checkHiBootIface, 
-       -- because the latter might add new bindings for boot_dfuns, 
-       -- which may be mentioned in imported unfoldings
+        -- The new type env is already available to stuff slurped from 
+        -- interface files, via TcEnv.updateGlobalTypeEnv
+        -- It's important that this includes the stuff in checkHiBootIface, 
+        -- because the latter might add new bindings for boot_dfuns, 
+        -- which may be mentioned in imported unfoldings
 
-               -- Don't need to rename the Haddock documentation,
-               -- it's not parsed by GHC anymore.
-       tcg_env <- return (tcg_env { tcg_doc_hdr = maybe_doc_hdr }) ;
+                -- Don't need to rename the Haddock documentation,
+                -- it's not parsed by GHC anymore.
+        tcg_env <- return (tcg_env { tcg_doc_hdr = maybe_doc_hdr }) ;
 
-               -- Report unused names
-       reportUnusedNames export_ies tcg_env ;
+                -- Report unused names
+        reportUnusedNames export_ies tcg_env ;
 
                 -- add extra source files to tcg_dependent_files
         addDependentFiles src_files ;
 
                 -- Dump output and return
-       tcDump tcg_env ;
-       return tcg_env
+        tcDump tcg_env ;
+        return tcg_env
     }}}}
 
 
@@ -229,94 +222,94 @@ implicitPreludeWarn
 
 
 %************************************************************************
-%*                                                                     *
-               Import declarations
-%*                                                                     *
+%*                                                                      *
+                Import declarations
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
 tcRnImports :: HscEnv -> Module 
             -> [LImportDecl RdrName] -> TcM TcGblEnv
 tcRnImports hsc_env this_mod import_decls
-  = do { (rn_imports, rdr_env, imports,hpc_info) <- rnImports import_decls ;
-
-       ; let { dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface)
-               -- Make sure we record the dependencies from the DynFlags in the EPS or we
-               -- end up hitting the sanity check in LoadIface.loadInterface that
-               -- checks for unknown home-package modules being loaded. We put
-               -- these dependencies on the left so their (non-source) imports
-               -- take precedence over the (possibly-source) imports on the right.
-               -- We don't add them to any other field (e.g. the imp_dep_mods of
-               -- imports) because we don't want to load their instances etc.
-             ; dep_mods = listToUFM [(mod_nm, (mod_nm, False)) | mod_nm <- dynFlagDependencies (hsc_dflags hsc_env)]
-                               `plusUFM` imp_dep_mods imports
-
-               -- We want instance declarations from all home-package
-               -- modules below this one, including boot modules, except
-               -- ourselves.  The 'except ourselves' is so that we don't
-               -- get the instances from this module's hs-boot file
-             ; want_instances :: ModuleName -> Bool
-             ; want_instances mod = mod `elemUFM` dep_mods
-                                  && mod /= moduleName this_mod
-             ; (home_insts, home_fam_insts) = hptInstances hsc_env 
+  = do  { (rn_imports, rdr_env, imports,hpc_info) <- rnImports import_decls ;
+
+        ; let { dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface)
+                -- Make sure we record the dependencies from the DynFlags in the EPS or we
+                -- end up hitting the sanity check in LoadIface.loadInterface that
+                -- checks for unknown home-package modules being loaded. We put
+                -- these dependencies on the left so their (non-source) imports
+                -- take precedence over the (possibly-source) imports on the right.
+                -- We don't add them to any other field (e.g. the imp_dep_mods of
+                -- imports) because we don't want to load their instances etc.
+              ; dep_mods = listToUFM [(mod_nm, (mod_nm, False)) | mod_nm <- dynFlagDependencies (hsc_dflags hsc_env)]
+                                `plusUFM` imp_dep_mods imports
+
+                -- We want instance declarations from all home-package
+                -- modules below this one, including boot modules, except
+                -- ourselves.  The 'except ourselves' is so that we don't
+                -- get the instances from this module's hs-boot file
+              ; want_instances :: ModuleName -> Bool
+              ; want_instances mod = mod `elemUFM` dep_mods
+                                   && mod /= moduleName this_mod
+              ; (home_insts, home_fam_insts) = hptInstances hsc_env 
                                                             want_instances
-             } ;
+              } ;
 
-               -- Record boot-file info in the EPS, so that it's 
-               -- visible to loadHiBootInterface in tcRnSrcDecls,
-               -- and any other incrementally-performed imports
-       ; updateEps_ (\eps -> eps { eps_is_boot = dep_mods }) ;
+                -- Record boot-file info in the EPS, so that it's 
+                -- visible to loadHiBootInterface in tcRnSrcDecls,
+                -- and any other incrementally-performed imports
+        ; updateEps_ (\eps -> eps { eps_is_boot = dep_mods }) ;
 
-               -- Update the gbl env
-       ; updGblEnv ( \ gbl -> 
-           gbl { 
+                -- Update the gbl env
+        ; updGblEnv ( \ gbl -> 
+            gbl { 
               tcg_rdr_env      = plusOccEnv (tcg_rdr_env gbl) rdr_env,
-             tcg_imports      = tcg_imports gbl `plusImportAvails` imports,
+              tcg_imports      = tcg_imports gbl `plusImportAvails` imports,
               tcg_rn_imports   = rn_imports,
-             tcg_inst_env     = extendInstEnvList (tcg_inst_env gbl) home_insts,
-             tcg_fam_inst_env = extendFamInstEnvList (tcg_fam_inst_env gbl) 
+              tcg_inst_env     = extendInstEnvList (tcg_inst_env gbl) home_insts,
+              tcg_fam_inst_env = extendFamInstEnvList (tcg_fam_inst_env gbl) 
                                                       home_fam_insts,
-             tcg_hpc          = hpc_info
-           }) $ do {
-
-       ; traceRn (text "rn1" <+> ppr (imp_dep_mods imports))
-               -- Fail if there are any errors so far
-               -- The error printing (if needed) takes advantage 
-               -- of the tcg_env we have now set
---     ; traceIf (text "rdr_env: " <+> ppr rdr_env)
-       ; failIfErrsM
-
-               -- Load any orphan-module and family instance-module
-               -- interfaces, so that their rules and instance decls will be
-               -- found.
-       ; loadModuleInterfaces (ptext (sLit "Loading orphan modules")) 
+              tcg_hpc          = hpc_info
+            }) $ do {
+
+        ; traceRn (text "rn1" <+> ppr (imp_dep_mods imports))
+                -- Fail if there are any errors so far
+                -- The error printing (if needed) takes advantage 
+                -- of the tcg_env we have now set
+--      ; traceIf (text "rdr_env: " <+> ppr rdr_env)
+        ; failIfErrsM
+
+                -- Load any orphan-module and family instance-module
+                -- interfaces, so that their rules and instance decls will be
+                -- found.
+        ; loadModuleInterfaces (ptext (sLit "Loading orphan modules")) 
                                (imp_orphs imports)
 
                 -- Check type-family consistency
-       ; traceRn (text "rn1: checking family instance consistency")
-       ; let { dir_imp_mods = moduleEnvKeys
-                            . imp_mods 
-                            $ imports }
-       ; checkFamInstConsistency (imp_finsts imports) dir_imp_mods ;
+        ; traceRn (text "rn1: checking family instance consistency")
+        ; let { dir_imp_mods = moduleEnvKeys
+                             . imp_mods 
+                             $ imports }
+        ; checkFamInstConsistency (imp_finsts imports) dir_imp_mods ;
 
-       ; getGblEnv } }
+        ; getGblEnv } }
 \end{code}
 
 
 %************************************************************************
-%*                                                                     *
-       Type-checking external-core modules
-%*                                                                     *
+%*                                                                      *
+        Type-checking external-core modules
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
 tcRnExtCore :: HscEnv 
-           -> HsExtCore RdrName
-           -> IO (Messages, Maybe ModGuts)
-       -- Nothing => some error occurred 
+            -> HsExtCore RdrName
+            -> IO (Messages, Maybe ModGuts)
+        -- Nothing => some error occurred 
 
 tcRnExtCore hsc_env (HsExtCore this_mod decls src_binds)
-       -- The decls are IfaceDecls; all names are original names
+        -- The decls are IfaceDecls; all names are original names
  = do { showPass (hsc_dflags hsc_env) "Renamer/typechecker" ;
 
    initTc hsc_env ExtCoreFile False this_mod $ do {
@@ -338,35 +331,35 @@ tcRnExtCore hsc_env (HsExtCore this_mod decls src_binds)
    -- The empty list is for extra dependencies coming from .hs-boot files
    -- See Note [Extra dependencies from .hs-boot files] in RnSource
 
-       -- Dump trace of renaming part
+        -- Dump trace of renaming part
    rnDump (ppr rn_decls) ;
 
-       -- Typecheck them all together so that
-       -- any mutually recursive types are done right
-       -- Just discard the auxiliary bindings; they are generated 
-       -- only for Haskell source code, and should already be in Core
+        -- Typecheck them all together so that
+        -- any mutually recursive types are done right
+        -- Just discard the auxiliary bindings; they are generated 
+        -- only for Haskell source code, and should already be in Core
    tcg_env   <- tcTyAndClassDecls emptyModDetails rn_decls ;
    dep_files <- liftIO $ readIORef (tcg_dependent_files tcg_env) ;
 
    setGblEnv tcg_env $ do {
-       -- Make the new type env available to stuff slurped from interface files
+        -- Make the new type env available to stuff slurped from interface files
    
-       -- Now the core bindings
+        -- Now the core bindings
    core_binds <- initIfaceExtCore (tcExtCoreBindings src_binds) ;
 
 
-       -- Wrap up
+        -- Wrap up
    let {
-       bndrs      = bindersOfBinds core_binds ;
-       my_exports = map (Avail . idName) bndrs ;
-               -- ToDo: export the data types also?
+        bndrs      = bindersOfBinds core_binds ;
+        my_exports = map (Avail . idName) bndrs ;
+                -- ToDo: export the data types also?
 
         mod_guts = ModGuts {    mg_module    = this_mod,
-                                mg_boot             = False,
+                                mg_boot      = False,
                                 mg_used_names = emptyNameSet, -- ToDo: compute usage
                                 mg_used_th   = False,
                                 mg_dir_imps  = emptyModuleEnv, -- ??
-                                mg_deps      = noDependencies, -- ??
+                                mg_deps      = noDependencies,  -- ??
                                 mg_exports   = my_exports,
                                 mg_tcs       = tcg_tcs tcg_env,
                                 mg_insts     = tcg_insts tcg_env,
@@ -402,43 +395,43 @@ mkFakeGroup decls -- Rather clumsy; lots of unused fields
 
 
 %************************************************************************
-%*                                                                     *
-       Type-checking the top level of a module
-%*                                                                     *
+%*                                                                      *
+        Type-checking the top level of a module
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
 tcRnSrcDecls :: ModDetails -> [LHsDecl RdrName] -> TcM TcGblEnv
-       -- Returns the variables free in the decls
-       -- Reason: solely to report unused imports and bindings
+        -- Returns the variables free in the decls
+        -- Reason: solely to report unused imports and bindings
 tcRnSrcDecls boot_iface decls
- = do {        -- Do all the declarations
-       ((tcg_env, tcl_env), lie) <- captureConstraints $ tc_rn_src_decls boot_iface decls ;
+ = do {         -- Do all the declarations
+        ((tcg_env, tcl_env), lie) <- captureConstraints $ tc_rn_src_decls boot_iface decls ;
       ; traceTc "Tc8" empty ;
       ; setEnvs (tcg_env, tcl_env) $ 
    do { 
 
-            --         Finish simplifying class constraints
-            -- 
-            -- simplifyTop deals with constant or ambiguous InstIds.  
-            -- How could there be ambiguous ones?  They can only arise if a
-            -- top-level decl falls under the monomorphism restriction
-            -- and no subsequent decl instantiates its type.
-            --
-            -- We do this after checkMain, so that we use the type info 
-            -- that checkMain adds
-            -- 
-            -- We do it with both global and local env in scope:
-            --  * the global env exposes the instances to simplifyTop
-            --  * the local env exposes the local Ids to simplifyTop, 
-            --    so that we get better error messages (monomorphism restriction)
-       new_ev_binds <- {-# SCC "simplifyTop" #-}
+             --         Finish simplifying class constraints
+             -- 
+             -- simplifyTop deals with constant or ambiguous InstIds.  
+             -- How could there be ambiguous ones?  They can only arise if a
+             -- top-level decl falls under the monomorphism restriction
+             -- and no subsequent decl instantiates its type.
+             --
+             -- We do this after checkMain, so that we use the type info 
+             -- that checkMain adds
+             -- 
+             -- We do it with both global and local env in scope:
+             --  * the global env exposes the instances to simplifyTop
+             --  * the local env exposes the local Ids to simplifyTop, 
+             --    so that we get better error messages (monomorphism restriction)
+        new_ev_binds <- {-# SCC "simplifyTop" #-}
                         simplifyTop lie ;
         traceTc "Tc9" empty ;
 
-       failIfErrsM ;   -- Don't zonk if there have been errors
-                       -- It's a waste of time; and we may get debug warnings
-                       -- about strangely-typed TyCons!
+        failIfErrsM ;   -- Don't zonk if there have been errors
+                        -- It's a waste of time; and we may get debug warnings
+                        -- about strangely-typed TyCons!
 
         -- Zonk the final code.  This must be done last.
         -- Even simplifyTop may do some unification.
@@ -476,53 +469,53 @@ tc_rn_src_decls :: ModDetails
 tc_rn_src_decls boot_details ds
  = {-# SCC "tc_rn_src_decls" #-}
    do { (first_group, group_tail) <- findSplice ds  ;
-               -- If ds is [] we get ([], Nothing)
+                -- If ds is [] we get ([], Nothing)
         
         -- The extra_deps are needed while renaming type and class declarations 
         -- See Note [Extra dependencies from .hs-boot files] in RnSource
-       let { extra_deps = map tyConName (typeEnvTyCons (md_types boot_details)) } ;
-       -- Deal with decls up to, but not including, the first splice
-       (tcg_env, rn_decls) <- rnTopSrcDecls extra_deps first_group ;
-               -- rnTopSrcDecls fails if there are any errors
+        let { extra_deps = map tyConName (typeEnvTyCons (md_types boot_details)) } ;
+        -- Deal with decls up to, but not including, the first splice
+        (tcg_env, rn_decls) <- rnTopSrcDecls extra_deps first_group ;
+                -- rnTopSrcDecls fails if there are any errors
         
-       (tcg_env, tcl_env) <- setGblEnv tcg_env $ 
-                             tcTopSrcDecls boot_details rn_decls ;
+        (tcg_env, tcl_env) <- setGblEnv tcg_env $ 
+                              tcTopSrcDecls boot_details rn_decls ;
 
-       -- If there is no splice, we're nearly done
-       setEnvs (tcg_env, tcl_env) $ 
-       case group_tail of {
-          Nothing -> do { tcg_env <- checkMain ;       -- Check for `main'
-                          return (tcg_env, tcl_env) 
-                     } ;
+        -- If there is no splice, we're nearly done
+        setEnvs (tcg_env, tcl_env) $ 
+        case group_tail of {
+           Nothing -> do { tcg_env <- checkMain ;       -- Check for `main'
+                           return (tcg_env, tcl_env) 
+                      } ;
 
 #ifndef GHCI
-       -- There shouldn't be a splice
-          Just (SpliceDecl {}, _) -> do {
-       failWithTc (text "Can't do a top-level splice; need a bootstrapped compiler")
+        -- There shouldn't be a splice
+           Just (SpliceDecl {}, _) -> do {
+        failWithTc (text "Can't do a top-level splice; need a bootstrapped compiler")
 #else
-       -- If there's a splice, we must carry on
-          Just (SpliceDecl splice_expr _, rest_ds) -> do {
+        -- If there's a splice, we must carry on
+           Just (SpliceDecl splice_expr _, rest_ds) -> do {
 
-       -- Rename the splice expression, and get its supporting decls
-       (rn_splice_expr, splice_fvs) <- checkNoErrs (rnLExpr splice_expr) ;
-               -- checkNoErrs: don't typecheck if renaming failed
-       rnDump (ppr rn_splice_expr) ;
+        -- Rename the splice expression, and get its supporting decls
+        (rn_splice_expr, splice_fvs) <- checkNoErrs (rnLExpr splice_expr) ;
+                -- checkNoErrs: don't typecheck if renaming failed
+        rnDump (ppr rn_splice_expr) ;
 
-       -- Execute the splice
-       spliced_decls <- tcSpliceDecls rn_splice_expr ;
+        -- Execute the splice
+        spliced_decls <- tcSpliceDecls rn_splice_expr ;
 
-       -- Glue them on the front of the remaining decls and loop
-       setGblEnv (tcg_env `addTcgDUs` usesOnly splice_fvs) $
-       tc_rn_src_decls boot_details (spliced_decls ++ rest_ds)
+        -- Glue them on the front of the remaining decls and loop
+        setGblEnv (tcg_env `addTcgDUs` usesOnly splice_fvs) $
+        tc_rn_src_decls boot_details (spliced_decls ++ rest_ds)
 #endif /* GHCI */
     } } }
 \end{code}
 
 %************************************************************************
-%*                                                                     *
-       Compiling hs-boot source files, and
-       comparing the hi-boot interface with the real thing
-%*                                                                     *
+%*                                                                      *
+        Compiling hs-boot source files, and
+        comparing the hi-boot interface with the real thing
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -530,63 +523,63 @@ tcRnHsBootDecls :: [LHsDecl RdrName] -> TcM TcGblEnv
 tcRnHsBootDecls decls
    = do { (first_group, group_tail) <- findSplice decls
 
-               -- Rename the declarations
+                -- Rename the declarations
         ; (tcg_env, HsGroup { 
-                  hs_tyclds = tycl_decls, 
-                  hs_instds = inst_decls,
-                  hs_derivds = deriv_decls,
-                  hs_fords  = for_decls,
-                  hs_defds  = def_decls,  
-                  hs_ruleds = rule_decls, 
-                  hs_vects  = vect_decls, 
-                  hs_annds  = _,
-                  hs_valds  = val_binds }) <- rnTopSrcDecls [] first_group
+                   hs_tyclds = tycl_decls, 
+                   hs_instds = inst_decls,
+                   hs_derivds = deriv_decls,
+                   hs_fords  = for_decls,
+                   hs_defds  = def_decls,  
+                   hs_ruleds = rule_decls, 
+                   hs_vects  = vect_decls, 
+                   hs_annds  = _,
+                   hs_valds  = val_binds }) <- rnTopSrcDecls [] first_group
         -- The empty list is for extra dependencies coming from .hs-boot files
         -- See Note [Extra dependencies from .hs-boot files] in RnSource
-       ; (gbl_env, lie) <- captureConstraints $ setGblEnv tcg_env $ do {
-
-
-               -- Check for illegal declarations
-       ; case group_tail of
-            Just (SpliceDecl d _, _) -> badBootDecl "splice" d
-            Nothing                  -> return ()
-       ; mapM_ (badBootDecl "foreign") for_decls
-       ; mapM_ (badBootDecl "default") def_decls
-       ; mapM_ (badBootDecl "rule")    rule_decls
-       ; mapM_ (badBootDecl "vect")    vect_decls
-
-               -- Typecheck type/class decls
-       ; traceTc "Tc2" empty
-       ; tcg_env <- tcTyAndClassDecls emptyModDetails tycl_decls
-       ; setGblEnv tcg_env    $ do {
-
-               -- Typecheck instance decls
-               -- Family instance declarations are rejected here
-       ; traceTc "Tc3" empty
-       ; (tcg_env, inst_infos, _deriv_binds) 
+        ; (gbl_env, lie) <- captureConstraints $ setGblEnv tcg_env $ do {
+
+
+                -- Check for illegal declarations
+        ; case group_tail of
+             Just (SpliceDecl d _, _) -> badBootDecl "splice" d
+             Nothing                  -> return ()
+        ; mapM_ (badBootDecl "foreign") for_decls
+        ; mapM_ (badBootDecl "default") def_decls
+        ; mapM_ (badBootDecl "rule")    rule_decls
+        ; mapM_ (badBootDecl "vect")    vect_decls
+
+                -- Typecheck type/class decls
+        ; traceTc "Tc2" empty
+        ; tcg_env <- tcTyAndClassDecls emptyModDetails tycl_decls
+        ; setGblEnv tcg_env    $ do {
+
+                -- Typecheck instance decls
+                -- Family instance declarations are rejected here
+        ; traceTc "Tc3" empty
+        ; (tcg_env, inst_infos, _deriv_binds) 
             <- tcInstDecls1 (concat tycl_decls) inst_decls deriv_decls
 
-       ; setGblEnv tcg_env     $ do {
-
-               -- Typecheck value declarations
-       ; traceTc "Tc5" empty 
-       ; val_ids <- tcHsBootSigs val_binds
-
-               -- Wrap up
-               -- No simplification or zonking to do
-       ; traceTc "Tc7a" empty
-       ; gbl_env <- getGblEnv 
-       
-               -- Make the final type-env
-               -- Include the dfun_ids so that their type sigs
-               -- are written into the interface file. 
-       ; let { type_env0 = tcg_type_env gbl_env
-             ; type_env1 = extendTypeEnvWithIds type_env0 val_ids
-             ; type_env2 = extendTypeEnvWithIds type_env1 dfun_ids 
-             ; dfun_ids = map iDFunId inst_infos
-             }
-
-       ; setGlobalTypeEnv gbl_env type_env2
+        ; setGblEnv tcg_env     $ do {
+
+                -- Typecheck value declarations
+        ; traceTc "Tc5" empty 
+        ; val_ids <- tcHsBootSigs val_binds
+
+                -- Wrap up
+                -- No simplification or zonking to do
+        ; traceTc "Tc7a" empty
+        ; gbl_env <- getGblEnv 
+        
+                -- Make the final type-env
+                -- Include the dfun_ids so that their type sigs
+                -- are written into the interface file. 
+        ; let { type_env0 = tcg_type_env gbl_env
+              ; type_env1 = extendTypeEnvWithIds type_env0 val_ids
+              ; type_env2 = extendTypeEnvWithIds type_env1 dfun_ids 
+              ; dfun_ids = map iDFunId inst_infos
+              }
+
+        ; setGlobalTypeEnv gbl_env type_env2
    }}}
    ; traceTc "boot" (ppr lie); return gbl_env }
 
@@ -607,34 +600,34 @@ checkHiBootIface :: TcGblEnv -> ModDetails -> TcM TcGblEnv
 -- of boot_names is empty.
 --
 -- The bindings we return give bindings for the dfuns defined in the
--- hs-boot file, such as       $fbEqT = $fEqT
+-- hs-boot file, such as        $fbEqT = $fEqT
 
 checkHiBootIface
-       tcg_env@(TcGblEnv { tcg_src = hs_src, tcg_binds = binds,
-                           tcg_insts = local_insts, 
-                           tcg_type_env = local_type_env, tcg_exports = local_exports })
-       (ModDetails { md_insts = boot_insts, md_fam_insts = boot_fam_insts,
-                     md_types = boot_type_env, md_exports = boot_exports })
-  | isHsBoot hs_src    -- Current module is already a hs-boot file!
-  = return tcg_env     
+        tcg_env@(TcGblEnv { tcg_src = hs_src, tcg_binds = binds,
+                            tcg_insts = local_insts, 
+                            tcg_type_env = local_type_env, tcg_exports = local_exports })
+        (ModDetails { md_insts = boot_insts, md_fam_insts = boot_fam_insts,
+                      md_types = boot_type_env, md_exports = boot_exports })
+  | isHsBoot hs_src     -- Current module is already a hs-boot file!
+  = return tcg_env      
 
   | otherwise
-  = do { traceTc "checkHiBootIface" $ vcat
+  = do  { traceTc "checkHiBootIface" $ vcat
              [ ppr boot_type_env, ppr boot_insts, ppr boot_exports]
 
-               -- Check the exports of the boot module, one by one
-       ; mapM_ check_export boot_exports
+                -- Check the exports of the boot module, one by one
+        ; mapM_ check_export boot_exports
 
-               -- Check for no family instances
-       ; unless (null boot_fam_insts) $
-           panic ("TcRnDriver.checkHiBootIface: Cannot handle family " ++
-                  "instances in boot files yet...")
+                -- Check for no family instances
+        ; unless (null boot_fam_insts) $
+            panic ("TcRnDriver.checkHiBootIface: Cannot handle family " ++
+                   "instances in boot files yet...")
             -- FIXME: Why?  The actual comparison is not hard, but what would
-            --       be the equivalent to the dfun bindings returned for class
-            --       instances?  We can't easily equate tycons...
+            --        be the equivalent to the dfun bindings returned for class
+            --        instances?  We can't easily equate tycons...
 
-               -- Check instance declarations
-       ; mb_dfun_prs <- mapM check_inst boot_insts
+                -- Check instance declarations
+        ; mb_dfun_prs <- mapM check_inst boot_insts
         ; let dfun_prs   = catMaybes mb_dfun_prs
               boot_dfuns = map fst dfun_prs
               dfun_binds = listToBag [ mkVarBind boot_dfun (nlHsVar dfun)
@@ -643,29 +636,29 @@ checkHiBootIface
               tcg_env'   = tcg_env { tcg_binds = binds `unionBags` dfun_binds }
 
         ; failIfErrsM
-       ; setGlobalTypeEnv tcg_env' type_env' }
-            -- Update the global type env *including* the knot-tied one
+        ; setGlobalTypeEnv tcg_env' type_env' }
+             -- Update the global type env *including* the knot-tied one
              -- so that if the source module reads in an interface unfolding
              -- mentioning one of the dfuns from the boot module, then it
              -- can "see" that boot dfun.   See Trac #4003
   where
-    check_export boot_avail    -- boot_avail is exported by the boot iface
-      | name `elem` dfun_names = return ()     
-      | isWiredInName name     = return ()     -- No checking for wired-in names.  In particular,
-                                               -- 'error' is handled by a rather gross hack
-                                               -- (see comments in GHC.Err.hs-boot)
+    check_export boot_avail     -- boot_avail is exported by the boot iface
+      | name `elem` dfun_names = return ()      
+      | isWiredInName name     = return ()      -- No checking for wired-in names.  In particular,
+                                                -- 'error' is handled by a rather gross hack
+                                                -- (see comments in GHC.Err.hs-boot)
 
-       -- Check that the actual module exports the same thing
+        -- Check that the actual module exports the same thing
       | not (null missing_names)
       = addErrAt (nameSrcSpan (head missing_names)) 
                  (missingBootThing (head missing_names) "exported by")
 
-       -- If the boot module does not *define* the thing, we are done
-       -- (it simply re-exports it, and names match, so nothing further to do)
+        -- If the boot module does not *define* the thing, we are done
+        -- (it simply re-exports it, and names match, so nothing further to do)
       | isNothing mb_boot_thing = return ()
 
-       -- Check that the actual module also defines the thing, and 
-       -- then compare the definitions
+        -- Check that the actual module also defines the thing, and 
+        -- then compare the definitions
       | Just real_thing <- lookupTypeEnv local_type_env name,
         Just boot_thing <- mb_boot_thing
       = when (not (checkBootDecl boot_thing real_thing))
@@ -678,33 +671,33 @@ checkHiBootIface
       | otherwise
       = addErrTc (missingBootThing name "defined in")
       where
-       name          = availName boot_avail
-       mb_boot_thing = lookupTypeEnv boot_type_env name
-       missing_names = case lookupNameEnv local_export_env name of
-                         Nothing    -> [name]
-                         Just avail -> availNames boot_avail `minusList` availNames avail
-                
+        name          = availName boot_avail
+        mb_boot_thing = lookupTypeEnv boot_type_env name
+        missing_names = case lookupNameEnv local_export_env name of
+                          Nothing    -> [name]
+                          Just avail -> availNames boot_avail `minusList` availNames avail
+                 
     dfun_names = map getName boot_insts
 
     local_export_env :: NameEnv AvailInfo
     local_export_env = availsToNameEnv local_exports
 
     check_inst :: ClsInst -> TcM (Maybe (Id, Id))
-       -- Returns a pair of the boot dfun in terms of the equivalent real dfun
+        -- Returns a pair of the boot dfun in terms of the equivalent real dfun
     check_inst boot_inst
-       = case [dfun | inst <- local_insts, 
-                      let dfun = instanceDFunId inst,
-                      idType dfun `eqType` boot_inst_ty ] of
-           [] -> do { traceTc "check_inst" (vcat [ text "local_insts" <+> vcat (map (ppr . idType . instanceDFunId) local_insts)
+        = case [dfun | inst <- local_insts, 
+                       let dfun = instanceDFunId inst,
+                       idType dfun `eqType` boot_inst_ty ] of
+            [] -> do { traceTc "check_inst" (vcat [ text "local_insts" <+> vcat (map (ppr . idType . instanceDFunId) local_insts)
                                                   , text "boot_inst"   <+> ppr boot_inst
                                                   , text "boot_inst_ty" <+> ppr boot_inst_ty
                                                   ]) 
                      ; addErrTc (instMisMatch boot_inst); return Nothing }
-           (dfun:_) -> return (Just (local_boot_dfun, dfun))
-       where
-         boot_dfun = instanceDFunId boot_inst
-         boot_inst_ty = idType boot_dfun
-         local_boot_dfun = Id.mkExportedLocalId (idName boot_dfun) boot_inst_ty
+            (dfun:_) -> return (Just (local_boot_dfun, dfun))
+        where
+          boot_dfun = instanceDFunId boot_inst
+          boot_inst_ty = idType boot_dfun
+          local_boot_dfun = Id.mkExportedLocalId (idName boot_dfun) boot_inst_ty
 
 
 -- This has to compare the TyThing from the .hi-boot file to the TyThing
@@ -732,7 +725,7 @@ checkBootDecl _ _ = False -- probably shouldn't happen
 checkBootTyCon :: TyCon -> TyCon -> Bool
 checkBootTyCon tc1 tc2
   | not (eqKind (tyConKind tc1) (tyConKind tc2))
-  = False      -- First off, check the kind
+  = False       -- First off, check the kind
 
   | Just c1 <- tyConClass_maybe tc1
   , Just c2 <- tyConClass_maybe tc2
@@ -810,7 +803,7 @@ checkBootTyCon tc1 tc2
         env0 = mkRnEnv2 emptyInScopeSet
 
         eqAlgRhs (AbstractTyCon dis1) rhs2 
-          | dis1      = isDistinctAlgRhs rhs2  --Check compatibility
+          | dis1      = isDistinctAlgRhs rhs2   --Check compatibility
           | otherwise = True
         eqAlgRhs DataFamilyTyCon{} DataFamilyTyCon{} = True
         eqAlgRhs tc1@DataTyCon{} tc2@DataTyCon{} =
@@ -830,13 +823,13 @@ checkBootTyCon tc1 tc2
 missingBootThing :: Name -> String -> SDoc
 missingBootThing name what
   = ppr name <+> ptext (sLit "is exported by the hs-boot file, but not") 
-             <+> text what <+> ptext (sLit "the module")
+              <+> text what <+> ptext (sLit "the module")
 
 bootMisMatch :: TyThing -> IfaceDecl -> IfaceDecl -> SDoc
 bootMisMatch thing boot_decl real_decl
   = vcat [ppr thing <+> ptext (sLit "has conflicting definitions in the module and its hs-boot file"),
-         ptext (sLit "Main module:") <+> ppr real_decl,
-         ptext (sLit "Boot file:  ") <+> ppr boot_decl]
+          ptext (sLit "Main module:") <+> ppr real_decl,
+          ptext (sLit "Boot file:  ") <+> ppr boot_decl]
 
 instMisMatch :: ClsInst -> SDoc
 instMisMatch inst
@@ -846,9 +839,9 @@ instMisMatch inst
 
 
 %************************************************************************
-%*                                                                     *
-       Type-checking the top level of a module
-%*                                                                     *
+%*                                                                      *
+        Type-checking the top level of a module
+%*                                                                      *
 %************************************************************************
 
 tcRnGroup takes a bunch of top-level source-code declarations, and
@@ -869,68 +862,68 @@ rnTopSrcDecls :: [Name] -> HsGroup RdrName -> TcM (TcGblEnv, HsGroup Name)
 rnTopSrcDecls extra_deps group
  = do { -- Rename the source decls
         traceTc "rn12" empty ;
-       (tcg_env, rn_decls) <- checkNoErrs $ rnSrcDecls extra_deps group ;
+        (tcg_env, rn_decls) <- checkNoErrs $ rnSrcDecls extra_deps group ;
         traceTc "rn13" empty ;
 
         -- save the renamed syntax, if we want it
-       let { tcg_env'
-               | Just grp <- tcg_rn_decls tcg_env
-                 = tcg_env{ tcg_rn_decls = Just (appendGroups grp rn_decls) }
-               | otherwise
-                  = tcg_env };
+        let { tcg_env'
+                | Just grp <- tcg_rn_decls tcg_env
+                  = tcg_env{ tcg_rn_decls = Just (appendGroups grp rn_decls) }
+                | otherwise
+                   = tcg_env };
 
-               -- Dump trace of renaming part
-       rnDump (ppr rn_decls) ;
+                -- Dump trace of renaming part
+        rnDump (ppr rn_decls) ;
 
-       return (tcg_env', rn_decls)
+        return (tcg_env', rn_decls)
    }
 
 ------------------------------------------------
 tcTopSrcDecls :: ModDetails -> HsGroup Name -> TcM (TcGblEnv, TcLclEnv)
 tcTopSrcDecls boot_details 
-       (HsGroup { hs_tyclds = tycl_decls, 
-                  hs_instds = inst_decls,
+        (HsGroup { hs_tyclds = tycl_decls, 
+                   hs_instds = inst_decls,
                    hs_derivds = deriv_decls,
-                  hs_fords  = foreign_decls,
-                  hs_defds  = default_decls,
-                  hs_annds  = annotation_decls,
-                  hs_ruleds = rule_decls,
-                  hs_vects  = vect_decls,
-                  hs_valds  = val_binds })
- = do {                -- Type-check the type and class decls, and all imported decls
-               -- The latter come in via tycl_decls
+                   hs_fords  = foreign_decls,
+                   hs_defds  = default_decls,
+                   hs_annds  = annotation_decls,
+                   hs_ruleds = rule_decls,
+                   hs_vects  = vect_decls,
+                   hs_valds  = val_binds })
+ = do {         -- Type-check the type and class decls, and all imported decls
+                -- The latter come in via tycl_decls
         traceTc "Tc2" empty ;
 
-       tcg_env <- tcTyAndClassDecls boot_details tycl_decls ;
-       setGblEnv tcg_env       $ do {
+        tcg_env <- tcTyAndClassDecls boot_details tycl_decls ;
+        setGblEnv tcg_env       $ do {
 
-               -- Source-language instances, including derivings,
-               -- and import the supporting declarations
+                -- Source-language instances, including derivings,
+                -- and import the supporting declarations
         traceTc "Tc3" empty ;
-       (tcg_env, inst_infos, deriv_binds) 
+        (tcg_env, inst_infos, deriv_binds) 
             <- tcInstDecls1 (concat tycl_decls) inst_decls deriv_decls;
-       setGblEnv tcg_env       $ do {
+        setGblEnv tcg_env       $ do {
 
-               -- Foreign import declarations next. 
+                -- Foreign import declarations next. 
         traceTc "Tc4" empty ;
-       (fi_ids, fi_decls) <- tcForeignImports foreign_decls ;
-       tcExtendGlobalValEnv fi_ids     $ do {
+        (fi_ids, fi_decls) <- tcForeignImports foreign_decls ;
+        tcExtendGlobalValEnv fi_ids     $ do {
 
-               -- Default declarations
+                -- Default declarations
         traceTc "Tc4a" empty ;
-       default_tys <- tcDefaults default_decls ;
-       updGblEnv (\gbl -> gbl { tcg_default = default_tys }) $ do {
-       
-               -- Now GHC-generated derived bindings, generics, and selectors
-               -- Do not generate warnings from compiler-generated code;
-               -- hence the use of discardWarnings
-       tc_envs <- discardWarnings (tcTopBinds deriv_binds) ;
+        default_tys <- tcDefaults default_decls ;
+        updGblEnv (\gbl -> gbl { tcg_default = default_tys }) $ do {
+        
+                -- Now GHC-generated derived bindings, generics, and selectors
+                -- Do not generate warnings from compiler-generated code;
+                -- hence the use of discardWarnings
+        tc_envs <- discardWarnings (tcTopBinds deriv_binds) ;
         setEnvs tc_envs $ do {
 
-               -- Value declarations next
+                -- Value declarations next
         traceTc "Tc5" empty ;
-       tc_envs@(tcg_env, tcl_env) <- tcTopBinds val_binds;
-        setEnvs tc_envs $ do { -- Environment doesn't change now
+        tc_envs@(tcg_env, tcl_env) <- tcTopBinds val_binds;
+        setEnvs tc_envs $ do {  -- Environment doesn't change now
 
                 -- Second pass over class and instance declarations, 
                 -- now using the kind-checked decls
@@ -952,8 +945,8 @@ tcTopSrcDecls boot_details
 
                 -- Wrap up
         traceTc "Tc7a" empty ;
-       let { all_binds = inst_binds     `unionBags`
-                         foe_binds
+        let { all_binds = inst_binds     `unionBags`
+                          foe_binds
 
             ; sig_names = mkNameSet (collectHsValBinders val_binds) 
                           `minusNameSet` getTypeSigNames val_binds
@@ -973,9 +966,9 @@ tcTopSrcDecls boot_details
 
 
 %************************************************************************
-%*                                                                     *
-       Checking for 'main'
-%*                                                                     *
+%*                                                                      *
+        Checking for 'main'
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -983,8 +976,8 @@ checkMain :: TcM TcGblEnv
 -- If we are in module Main, check that 'main' is defined.
 checkMain 
   = do { tcg_env   <- getGblEnv ;
-        dflags    <- getDynFlags ;
-        check_main dflags tcg_env
+         dflags    <- getDynFlags ;
+         check_main dflags tcg_env
     }
 
 check_main :: DynFlags -> TcGblEnv -> TcM TcGblEnv
@@ -994,59 +987,59 @@ check_main dflags tcg_env
    return tcg_env
 
  | otherwise
- = do  { mb_main <- lookupGlobalOccRn_maybe main_fn
-               -- Check that 'main' is in scope
-               -- It might be imported from another module!
-       ; case mb_main of {
-            Nothing -> do { traceTc "checkMain fail" (ppr main_mod <+> ppr main_fn)
-                          ; complain_no_main   
-                          ; return tcg_env } ;
-            Just main_name -> do
-
-       { traceTc "checkMain found" (ppr main_mod <+> ppr main_fn)
-       ; let loc = srcLocSpan (getSrcLoc main_name)
-       ; ioTyCon <- tcLookupTyCon ioTyConName
+ = do   { mb_main <- lookupGlobalOccRn_maybe main_fn
+                -- Check that 'main' is in scope
+                -- It might be imported from another module!
+        ; case mb_main of {
+             Nothing -> do { traceTc "checkMain fail" (ppr main_mod <+> ppr main_fn)
+                           ; complain_no_main   
+                           ; return tcg_env } ;
+             Just main_name -> do
+
+        { traceTc "checkMain found" (ppr main_mod <+> ppr main_fn)
+        ; let loc = srcLocSpan (getSrcLoc main_name)
+        ; ioTyCon <- tcLookupTyCon ioTyConName
         ; res_ty <- newFlexiTyVarTy liftedTypeKind
-       ; main_expr
-               <- addErrCtxt mainCtxt    $
-                  tcMonoExpr (L loc (HsVar main_name)) (mkTyConApp ioTyCon [res_ty])
-
-               -- See Note [Root-main Id]
-               -- Construct the binding
-               --      :Main.main :: IO res_ty = runMainIO res_ty main 
-       ; run_main_id <- tcLookupId runMainIOName
-       ; let { root_main_name =  mkExternalName rootMainKey rOOT_MAIN 
-                                  (mkVarOccFS (fsLit "main")) 
-                                  (getSrcSpan main_name)
-             ; root_main_id = Id.mkExportedLocalId root_main_name 
-                                                   (mkTyConApp ioTyCon [res_ty])
-             ; co  = mkWpTyApps [res_ty]
-             ; rhs = nlHsApp (mkLHsWrap co (nlHsVar run_main_id)) main_expr
-             ; main_bind = mkVarBind root_main_id rhs }
-
-       ; return (tcg_env { tcg_main  = Just main_name,
+        ; main_expr
+                <- addErrCtxt mainCtxt    $
+                   tcMonoExpr (L loc (HsVar main_name)) (mkTyConApp ioTyCon [res_ty])
+
+                -- See Note [Root-main Id]
+                -- Construct the binding
+                --      :Main.main :: IO res_ty = runMainIO res_ty main 
+        ; run_main_id <- tcLookupId runMainIOName
+        ; let { root_main_name =  mkExternalName rootMainKey rOOT_MAIN 
+                                   (mkVarOccFS (fsLit "main")) 
+                                   (getSrcSpan main_name)
+              ; root_main_id = Id.mkExportedLocalId root_main_name 
+                                                    (mkTyConApp ioTyCon [res_ty])
+              ; co  = mkWpTyApps [res_ty]
+              ; rhs = nlHsApp (mkLHsWrap co (nlHsVar run_main_id)) main_expr
+              ; main_bind = mkVarBind root_main_id rhs }
+
+        ; return (tcg_env { tcg_main  = Just main_name,
                             tcg_binds = tcg_binds tcg_env
-                                       `snocBag` main_bind,
-                           tcg_dus   = tcg_dus tcg_env
-                                       `plusDU` usesOnly (unitFV main_name)
-                       -- Record the use of 'main', so that we don't 
-                       -- complain about it being defined but not used
-                })
+                                        `snocBag` main_bind,
+                            tcg_dus   = tcg_dus tcg_env
+                                        `plusDU` usesOnly (unitFV main_name)
+                        -- Record the use of 'main', so that we don't 
+                        -- complain about it being defined but not used
+                 })
     }}}
   where
-    mod         = tcg_mod tcg_env
+    mod          = tcg_mod tcg_env
     main_mod     = mainModIs dflags
     main_fn      = getMainFun dflags
 
     complain_no_main | ghcLink dflags == LinkInMemory = return ()
-                    | otherwise = failWithTc noMainMsg
-       -- In interactive mode, don't worry about the absence of 'main'
-       -- In other modes, fail altogether, so that we don't go on
-       -- and complain a second time when processing the export list.
+                     | otherwise = failWithTc noMainMsg
+        -- In interactive mode, don't worry about the absence of 'main'
+        -- In other modes, fail altogether, so that we don't go on
+        -- and complain a second time when processing the export list.
 
     mainCtxt  = ptext (sLit "When checking the type of the") <+> pp_main_fn
     noMainMsg = ptext (sLit "The") <+> pp_main_fn
-               <+> ptext (sLit "is not defined in module") <+> quotes (ppr main_mod)
+                <+> ptext (sLit "is not defined in module") <+> quotes (ppr main_mod)
     pp_main_fn = ppMainFn main_fn
 
 ppMainFn :: RdrName -> SDoc
@@ -1055,7 +1048,7 @@ ppMainFn main_fn
   = ptext (sLit "function") <+> quotes (ppr main_fn)
   | otherwise
   = ptext (sLit "main function") <+> quotes (ppr main_fn)
-              
+               
 -- | Get the unqualified name of the function to use as the \"main\" for the main module.
 -- Either returns the default name or the one configured on the command line with -main-is
 getMainFun :: DynFlags -> RdrName
@@ -1089,9 +1082,9 @@ get two defns for 'main' in the interface file!
 
 
 %*********************************************************
-%*                                                      *
-               GHCi stuff
-%*                                                      *
+%*                                                       *
+                GHCi stuff
+%*                                                       *
 %*********************************************************
 
 \begin{code}
@@ -1171,15 +1164,15 @@ setInteractiveContext hsc_env icxt thing_inside
 \begin{code}
 #ifdef GHCI
 tcRnStmt :: HscEnv
-        -> InteractiveContext
-        -> LStmt RdrName
-        -> IO (Messages, Maybe ([Id], LHsExpr Id))
-               -- The returned [Id] is the list of new Ids bound by
+         -> InteractiveContext
+         -> LStmt RdrName
+         -> IO (Messages, Maybe ([Id], LHsExpr Id))
+                -- The returned [Id] is the list of new Ids bound by
                 -- this statement.  It can be used to extend the
                 -- InteractiveContext via extendInteractiveContext.
-               --
-               -- The returned TypecheckedHsExpr is of type IO [ () ],
-               -- a list of the bound values, coerced to ().
+                --
+                -- The returned TypecheckedHsExpr is of type IO [ () ],
+                -- a list of the bound values, coerced to ().
 
 tcRnStmt hsc_env ictxt rdr_stmt
   = initTcPrintErrors hsc_env iNTERACTIVE $ 
@@ -1197,8 +1190,8 @@ tcRnStmt hsc_env ictxt rdr_stmt
     zonked_expr <- zonkTopLExpr tc_expr ;
     zonked_ids  <- zonkTopBndrs bound_ids ;
     
-       -- None of the Ids should be of unboxed type, because we
-       -- cast them all to HValues in the end!
+        -- None of the Ids should be of unboxed type, because we
+        -- cast them all to HValues in the end!
     mapM_ bad_unboxed (filter (isUnLiftedType . idType) zonked_ids) ;
 
     traceTc "tcs 1" empty ;
@@ -1210,12 +1203,12 @@ tcRnStmt hsc_env ictxt rdr_stmt
    they are inaccessible but might, I suppose, cause a space leak if we leave them there.
    However, with Template Haskell they aren't necessarily inaccessible.  Consider this
    GHCi session
-        Prelude> let f n = n * 2 :: Int
-        Prelude> fName <- runQ [| f |]
-        Prelude> $(return $ AppE fName (LitE (IntegerL 7)))
-        14
-        Prelude> let f n = n * 3 :: Int
-        Prelude> $(return $ AppE fName (LitE (IntegerL 7)))
+         Prelude> let f n = n * 2 :: Int
+         Prelude> fName <- runQ [| f |]
+         Prelude> $(return $ AppE fName (LitE (IntegerL 7)))
+         14
+         Prelude> let f n = n * 3 :: Int
+         Prelude> $(return $ AppE fName (LitE (IntegerL 7)))
    In the last line we use 'fName', which resolves to the *first* 'f'
    in scope. If we delete it from the type env, GHCi crashes because
    it doesn't expect that.
@@ -1225,22 +1218,22 @@ tcRnStmt hsc_env ictxt rdr_stmt
 -------------------------------------------------- -}
 
     dumpOptTcRn Opt_D_dump_tc 
-       (vcat [text "Bound Ids" <+> pprWithCommas ppr global_ids,
-              text "Typechecked expr" <+> ppr zonked_expr]) ;
+        (vcat [text "Bound Ids" <+> pprWithCommas ppr global_ids,
+               text "Typechecked expr" <+> ppr zonked_expr]) ;
 
     return (global_ids, zonked_expr)
     }
   where
     bad_unboxed id = addErr (sep [ptext (sLit "GHCi can't bind a variable of unlifted type:"),
-                                 nest 2 (ppr id <+> dcolon <+> ppr (idType id))])
+                                  nest 2 (ppr id <+> dcolon <+> ppr (idType id))])
 \end{code}
 
 Note [Interactively-bound Ids in GHCi]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The Ids bound by previous Stmts in GHCi are currently
-       a) GlobalIds
+        a) GlobalIds
         b) with an Internal Name (not External)
-       c) and a tidied type
+        c) and a tidied type
 
  (a) They must be GlobalIds (not LocalIds) otherwise when we come to
      compile an expression using these ids later, the byte code
@@ -1253,29 +1246,29 @@ The Ids bound by previous Stmts in GHCi are currently
  (c) Their types are tidied.  This is important, because :info may ask
      to look at them, and :info expects the things it looks up to have
      tidy types
-       
+        
 
 --------------------------------------------------------------------------
-               Typechecking Stmts in GHCi
+                Typechecking Stmts in GHCi
 
 Here is the grand plan, implemented in tcUserStmt
 
-       What you type                   The IO [HValue] that hscStmt returns
-       -------------                   ------------------------------------
-       let pat = expr          ==>     let pat = expr in return [coerce HVal x, coerce HVal y, ...]
-                                       bindings: [x,y,...]
+        What you type                   The IO [HValue] that hscStmt returns
+        -------------                   ------------------------------------
+        let pat = expr          ==>     let pat = expr in return [coerce HVal x, coerce HVal y, ...]
+                                        bindings: [x,y,...]
 
-       pat <- expr             ==>     expr >>= \ pat -> return [coerce HVal x, coerce HVal y, ...]
-                                       bindings: [x,y,...]
+        pat <- expr             ==>     expr >>= \ pat -> return [coerce HVal x, coerce HVal y, ...]
+                                        bindings: [x,y,...]
 
-       expr (of IO type)       ==>     expr >>= \ it -> return [coerce HVal it]
-         [NB: result not printed]      bindings: [it]
-         
-       expr (of non-IO type,   ==>     let it = expr in print it >> return [coerce HVal it]
-         result showable)              bindings: [it]
+        expr (of IO type)       ==>     expr >>= \ it -> return [coerce HVal it]
+          [NB: result not printed]      bindings: [it]
+          
+        expr (of non-IO type,   ==>     let it = expr in print it >> return [coerce HVal it]
+          result showable)              bindings: [it]
 
-       expr (of non-IO type, 
-         result not showable)  ==>     error
+        expr (of non-IO type, 
+          result not showable)  ==>     error
 
 
 \begin{code}
@@ -1292,59 +1285,59 @@ runPlans (p:ps) = tryTcLIE_ (runPlans ps) p
 
 --------------------
 mkPlan :: LStmt Name -> TcM PlanResult
-mkPlan (L loc (ExprStmt expr _ _ _))   -- An expression typed at the prompt 
-  = do { uniq <- newUnique             -- is treated very specially
+mkPlan (L loc (ExprStmt expr _ _ _))    -- An expression typed at the prompt 
+  = do  { uniq <- newUnique             -- is treated very specially
         ; let fresh_it  = itName uniq loc
-             the_bind  = L loc $ mkTopFunBind (L loc fresh_it) matches
-             matches   = [mkMatch [] expr emptyLocalBinds]
-             let_stmt  = L loc $ LetStmt $ HsValBinds $
+              the_bind  = L loc $ mkTopFunBind (L loc fresh_it) matches
+              matches   = [mkMatch [] expr emptyLocalBinds]
+              let_stmt  = L loc $ LetStmt $ HsValBinds $
                           ValBindsOut [(NonRecursive,unitBag the_bind)] []
               bind_stmt = L loc $ BindStmt (L loc (VarPat fresh_it)) expr
-                                          (HsVar bindIOName) noSyntaxExpr 
-             print_it  = L loc $ ExprStmt (nlHsApp (nlHsVar printName) (nlHsVar fresh_it))
-                                          (HsVar thenIOName) noSyntaxExpr placeHolderType
-
-       -- The plans are:
-       --      [it <- e; print it]     but not if it::()
-       --      [it <- e]               
-       --      [let it = e; print it]  
-       ; runPlans [    -- Plan A
-                   do { stuff@([it_id], _) <- tcGhciStmts [bind_stmt, print_it]
-                      ; it_ty <- zonkTcType (idType it_id)
-                      ; when (isUnitTy it_ty) failM
-                      ; return stuff },
-
-                       -- Plan B; a naked bind statment
-                   tcGhciStmts [bind_stmt],    
-
-                       -- Plan C; check that the let-binding is typeable all by itself.
-                       -- If not, fail; if so, try to print it.
-                       -- The two-step process avoids getting two errors: one from
-                       -- the expression itself, and one from the 'print it' part
-                       -- This two-step story is very clunky, alas
-                   do { _ <- checkNoErrs (tcGhciStmts [let_stmt]) 
-                               --- checkNoErrs defeats the error recovery of let-bindings
-                      ; tcGhciStmts [let_stmt, print_it] }
-         ]}
+                                           (HsVar bindIOName) noSyntaxExpr 
+              print_it  = L loc $ ExprStmt (nlHsApp (nlHsVar printName) (nlHsVar fresh_it))
+                                           (HsVar thenIOName) noSyntaxExpr placeHolderType
+
+        -- The plans are:
+        --      [it <- e; print it]     but not if it::()
+        --      [it <- e]               
+        --      [let it = e; print it]  
+        ; runPlans [    -- Plan A
+                    do { stuff@([it_id], _) <- tcGhciStmts [bind_stmt, print_it]
+                       ; it_ty <- zonkTcType (idType it_id)
+                       ; when (isUnitTy it_ty) failM
+                       ; return stuff },
+
+                        -- Plan B; a naked bind statment
+                    tcGhciStmts [bind_stmt],    
+
+                        -- Plan C; check that the let-binding is typeable all by itself.
+                        -- If not, fail; if so, try to print it.
+                        -- The two-step process avoids getting two errors: one from
+                        -- the expression itself, and one from the 'print it' part
+                        -- This two-step story is very clunky, alas
+                    do { _ <- checkNoErrs (tcGhciStmts [let_stmt]) 
+                                --- checkNoErrs defeats the error recovery of let-bindings
+                       ; tcGhciStmts [let_stmt, print_it] }
+          ]}
 
 mkPlan stmt@(L loc (BindStmt {}))
-  | [v] <- collectLStmtBinders stmt            -- One binder, for a bind stmt 
-  = do { let print_v  = L loc $ ExprStmt (nlHsApp (nlHsVar printName) (nlHsVar v))
-                                         (HsVar thenIOName) noSyntaxExpr placeHolderType
-
-       ; print_bind_result <- doptM Opt_PrintBindResult
-       ; let print_plan = do
-                 { stuff@([v_id], _) <- tcGhciStmts [stmt, print_v]
-                 ; v_ty <- zonkTcType (idType v_id)
-                 ; when (isUnitTy v_ty || not (isTauTy v_ty)) failM
-                 ; return stuff }
-
-       -- The plans are:
-       --      [stmt; print v]         but not if v::()
-       --      [stmt]
-       ; runPlans ((if print_bind_result then [print_plan] else []) ++
-                   [tcGhciStmts [stmt]])
-       }
+  | [v] <- collectLStmtBinders stmt             -- One binder, for a bind stmt 
+  = do  { let print_v  = L loc $ ExprStmt (nlHsApp (nlHsVar printName) (nlHsVar v))
+                                          (HsVar thenIOName) noSyntaxExpr placeHolderType
+
+        ; print_bind_result <- doptM Opt_PrintBindResult
+        ; let print_plan = do
+                  { stuff@([v_id], _) <- tcGhciStmts [stmt, print_v]
+                  ; v_ty <- zonkTcType (idType v_id)
+                  ; when (isUnitTy v_ty || not (isTauTy v_ty)) failM
+                  ; return stuff }
+
+        -- The plans are:
+        --      [stmt; print v]         but not if v::()
+        --      [stmt]
+        ; runPlans ((if print_bind_result then [print_plan] else []) ++
+                    [tcGhciStmts [stmt]])
+        }
 
 mkPlan stmt
   = tcGhciStmts [stmt]
@@ -1353,47 +1346,47 @@ mkPlan stmt
 tcGhciStmts :: [LStmt Name] -> TcM PlanResult
 tcGhciStmts stmts
  = do { ioTyCon <- tcLookupTyCon ioTyConName ;
-       ret_id  <- tcLookupId returnIOName ;            -- return @ IO
-       let {
-           ret_ty    = mkListTy unitTy ;
-           io_ret_ty = mkTyConApp ioTyCon [ret_ty] ;
-           tc_io_stmts stmts = tcStmtsAndThen GhciStmt tcDoStmt stmts io_ret_ty ;
-           names = collectLStmtsBinders stmts ;
-        } ;
-
-       -- OK, we're ready to typecheck the stmts
-       traceTc "TcRnDriver.tcGhciStmts: tc stmts" empty ;
-       ((tc_stmts, ids), lie) <- captureConstraints $ 
+        ret_id  <- tcLookupId returnIOName ;            -- return @ IO
+        let {
+            ret_ty    = mkListTy unitTy ;
+            io_ret_ty = mkTyConApp ioTyCon [ret_ty] ;
+            tc_io_stmts stmts = tcStmtsAndThen GhciStmt tcDoStmt stmts io_ret_ty ;
+            names = collectLStmtsBinders stmts ;
+         } ;
+
+        -- OK, we're ready to typecheck the stmts
+        traceTc "TcRnDriver.tcGhciStmts: tc stmts" empty ;
+        ((tc_stmts, ids), lie) <- captureConstraints $ 
                                   tc_io_stmts stmts  $ \ _ ->
-                                 mapM tcLookupId names  ;
-                       -- Look up the names right in the middle,
-                       -- where they will all be in scope
+                                  mapM tcLookupId names  ;
+                        -- Look up the names right in the middle,
+                        -- where they will all be in scope
 
-       -- Simplify the context
-       traceTc "TcRnDriver.tcGhciStmts: simplify ctxt" empty ;
-       const_binds <- checkNoErrs (simplifyInteractive lie) ;
-               -- checkNoErrs ensures that the plan fails if context redn fails
+        -- Simplify the context
+        traceTc "TcRnDriver.tcGhciStmts: simplify ctxt" empty ;
+        const_binds <- checkNoErrs (simplifyInteractive lie) ;
+                -- checkNoErrs ensures that the plan fails if context redn fails
 
-       traceTc "TcRnDriver.tcGhciStmts: done" empty ;
+        traceTc "TcRnDriver.tcGhciStmts: done" empty ;
         let {   -- mk_return builds the expression
-               --      returnIO @ [()] [coerce () x, ..,  coerce () z]
-               --
-               -- Despite the inconvenience of building the type applications etc,
-               -- this *has* to be done in type-annotated post-typecheck form
-               -- because we are going to return a list of *polymorphic* values
-               -- coerced to type (). If we built a *source* stmt
-               --      return [coerce x, ..., coerce z]
-               -- then the type checker would instantiate x..z, and we wouldn't
-               -- get their *polymorphic* values.  (And we'd get ambiguity errs
-               -- if they were overloaded, since they aren't applied to anything.)
-           ret_expr = nlHsApp (nlHsTyApp ret_id [ret_ty]) 
-                      (noLoc $ ExplicitList unitTy (map mk_item ids)) ;
-           mk_item id = nlHsApp (nlHsTyApp unsafeCoerceId [idType id, unitTy])
-                                (nlHsVar id) ;
-           stmts = tc_stmts ++ [noLoc (mkLastStmt ret_expr)]
+                --      returnIO @ [()] [coerce () x, ..,  coerce () z]
+                --
+                -- Despite the inconvenience of building the type applications etc,
+                -- this *has* to be done in type-annotated post-typecheck form
+                -- because we are going to return a list of *polymorphic* values
+                -- coerced to type (). If we built a *source* stmt
+                --      return [coerce x, ..., coerce z]
+                -- then the type checker would instantiate x..z, and we wouldn't
+                -- get their *polymorphic* values.  (And we'd get ambiguity errs
+                -- if they were overloaded, since they aren't applied to anything.)
+            ret_expr = nlHsApp (nlHsTyApp ret_id [ret_ty]) 
+                       (noLoc $ ExplicitList unitTy (map mk_item ids)) ;
+            mk_item id = nlHsApp (nlHsTyApp unsafeCoerceId [idType id, unitTy])
+                                 (nlHsVar id) ;
+            stmts = tc_stmts ++ [noLoc (mkLastStmt ret_expr)]
         } ;
-       return (ids, mkHsDictLet (EvBinds const_binds) $
-                    noLoc (HsDo GhciStmt stmts io_ret_ty))
+        return (ids, mkHsDictLet (EvBinds const_binds) $
+                     noLoc (HsDo GhciStmt stmts io_ret_ty))
     }
 \end{code}
 
@@ -1403,8 +1396,8 @@ tcRnExpr just finds the type of an expression
 \begin{code}
 tcRnExpr :: HscEnv
          -> InteractiveContext
-        -> LHsExpr RdrName
-        -> IO (Messages, Maybe Type)
+         -> LHsExpr RdrName
+         -> IO (Messages, Maybe Type)
 tcRnExpr hsc_env ictxt rdr_expr
   = initTcPrintErrors hsc_env iNTERACTIVE $
     setInteractiveContext hsc_env ictxt $ do {
@@ -1412,11 +1405,11 @@ tcRnExpr hsc_env ictxt rdr_expr
     (rn_expr, _fvs) <- rnLExpr rdr_expr ;
     failIfErrsM ;
 
-       -- Now typecheck the expression; 
-       -- it might have a rank-2 type (e.g. :t runST)
+        -- Now typecheck the expression; 
+        -- it might have a rank-2 type (e.g. :t runST)
     uniq <- newUnique ;
     let { fresh_it  = itName uniq (getLoc rdr_expr) } ;
-    ((_tc_expr, res_ty), lie)  <- captureConstraints (tcInferRho rn_expr) ;
+    ((_tc_expr, res_ty), lie)   <- captureConstraints (tcInferRho rn_expr) ;
     ((qtvs, dicts, _, _), lie_top) <- captureConstraints $ 
                                       {-# SCC "simplifyInfer" #-}
                                       simplifyInfer True {- Free vars are closed -}
@@ -1431,8 +1424,8 @@ tcRnExpr hsc_env ictxt rdr_expr
 
 --------------------------
 tcRnImportDecls :: HscEnv
-               -> [LImportDecl RdrName]
-               -> IO (Messages, Maybe GlobalRdrEnv)
+                -> [LImportDecl RdrName]
+                -> IO (Messages, Maybe GlobalRdrEnv)
 tcRnImportDecls hsc_env import_decls
  =  initTcPrintErrors hsc_env iNTERACTIVE $ 
     do { gbl_env <- tcRnImports hsc_env iNTERACTIVE import_decls
@@ -1443,10 +1436,10 @@ tcRnType just finds the kind of a type
 
 \begin{code}
 tcRnType :: HscEnv
-        -> InteractiveContext
-        -> Bool        -- Normalise the returned type
-        -> LHsType RdrName
-        -> IO (Messages, Maybe (Type, Kind))
+         -> InteractiveContext
+         -> Bool        -- Normalise the returned type
+         -> LHsType RdrName
+         -> IO (Messages, Maybe (Type, Kind))
 tcRnType hsc_env ictxt normalise rdr_type
   = initTcPrintErrors hsc_env iNTERACTIVE $ 
     setInteractiveContext hsc_env ictxt $ do {
@@ -1454,15 +1447,15 @@ tcRnType hsc_env ictxt normalise rdr_type
     rn_type <- rnLHsType GHCiCtx rdr_type ;
     failIfErrsM ;
 
-       -- Now kind-check the type
-       -- It can have any rank or kind
+        -- Now kind-check the type
+        -- It can have any rank or kind
     ty <- tcHsSigType GhciCtxt rn_type ;
 
     ty' <- if normalise 
            then do { fam_envs <- tcGetFamInstEnvs 
                    ; return (snd (normaliseType fam_envs ty)) }
-                  -- normaliseType returns a coercion
-                  -- which we discard
+                   -- normaliseType returns a coercion
+                   -- which we discard
            else return ty ;
             
     return (ty', typeKind ty)
@@ -1475,8 +1468,8 @@ tcRnDeclsi exists to allow class, data, and other declarations in GHCi.
 \begin{code}
 tcRnDeclsi :: HscEnv 
            -> InteractiveContext
-          -> [LHsDecl RdrName]
-          -> IO (Messages, Maybe TcGblEnv)
+           -> [LHsDecl RdrName]
+           -> IO (Messages, Maybe TcGblEnv)
 
 tcRnDeclsi hsc_env ictxt local_decls =
     initTcPrintErrors hsc_env iNTERACTIVE $
@@ -1520,9 +1513,9 @@ tcRnDeclsi hsc_env ictxt local_decls =
 
 
 %************************************************************************
-%*                                                                     *
-       More GHCi stuff, to do with browsing and getting info
-%*                                                                     *
+%*                                                                      *
+        More GHCi stuff, to do with browsing and getting info
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -1564,9 +1557,9 @@ lookup_rdr_name rdr_name = do
                 -- No lookup succeeded, so
                 -- pick the first error message and report it
                 -- ToDo: If one of the errors is "could be Foo.X or Baz.X",
-                --      while the other is "X is not in scope", 
-                --      we definitely want the former; but we might pick the latter
-      else     mapM_ addMessages warns_s
+                --       while the other is "X is not in scope", 
+                --       we definitely want the former; but we might pick the latter
+      else      mapM_ addMessages warns_s
                 -- Add deprecation warnings
     return good_names
 
@@ -1612,10 +1605,10 @@ tcRnGetInfo' hsc_env name
   = let ictxt = hsc_IC hsc_env in
     setInteractiveContext hsc_env ictxt $ do
 
-       -- Load the interface for all unqualified types and classes
-       -- That way we will find all the instance declarations
-       -- (Packages have not orphan modules, and we assume that
-       --  in the home package all relevant modules are loaded.)
+        -- Load the interface for all unqualified types and classes
+        -- That way we will find all the instance declarations
+        -- (Packages have not orphan modules, and we assume that
+        --  in the home package all relevant modules are loaded.)
     loadUnqualIfaces hsc_env ictxt
 
     thing  <- tcRnLookupName' name
@@ -1631,16 +1624,16 @@ lookupInsts (ATyCon tc)
 
   | otherwise
   = do  { (pkg_ie, home_ie) <- tcGetInstEnvs
-               -- Load all instances for all classes that are
-               -- in the type environment (which are all the ones
-               -- we've seen in any interface file so far)
-       ; return [ ispec        -- Search all
-                | ispec <- instEnvElts home_ie ++ instEnvElts pkg_ie
-                , let dfun = instanceDFunId ispec
-                , relevant dfun ] } 
+                -- Load all instances for all classes that are
+                -- in the type environment (which are all the ones
+                -- we've seen in any interface file so far)
+        ; return [ ispec        -- Search all
+                 | ispec <- instEnvElts home_ie ++ instEnvElts pkg_ie
+                 , let dfun = instanceDFunId ispec
+                 , relevant dfun ] } 
   where
     relevant df = tc_name `elemNameSet` orphNamesOfDFunHead (idType df)
-    tc_name     = tyConName tc           
+    tc_name     = tyConName tc            
 
 lookupInsts _ = return []
 
@@ -1656,18 +1649,18 @@ loadUnqualIfaces hsc_env ictxt
 
     unqual_mods = filter ((/= this_pkg) . modulePackageId)
                   [ nameModule name
-                 | gre <- globalRdrEnvElts (ic_rn_gbl_env ictxt),
-                   let name = gre_name gre,
+                  | gre <- globalRdrEnvElts (ic_rn_gbl_env ictxt),
+                    let name = gre_name gre,
                     not (isInternalName name),
-                   isTcOcc (nameOccName name),  -- Types and classes only
-                   unQualOK gre ]               -- In scope unqualified
+                    isTcOcc (nameOccName name),  -- Types and classes only
+                    unQualOK gre ]               -- In scope unqualified
     doc = ptext (sLit "Need interface for module whose export(s) are in scope unqualified")
 \end{code}
 
 %************************************************************************
-%*                                                                     *
-               Degugging output
-%*                                                                     *
+%*                                                                      *
+                Degugging output
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -1679,27 +1672,27 @@ tcDump :: TcGblEnv -> TcRn ()
 tcDump env
  = do { dflags <- getDynFlags ;
 
-       -- Dump short output if -ddump-types or -ddump-tc
-       when (dopt Opt_D_dump_types dflags || dopt Opt_D_dump_tc dflags)
-            (dumpTcRn short_dump) ;
+        -- Dump short output if -ddump-types or -ddump-tc
+        when (dopt Opt_D_dump_types dflags || dopt Opt_D_dump_tc dflags)
+             (dumpTcRn short_dump) ;
 
-       -- Dump bindings if -ddump-tc
-       dumpOptTcRn Opt_D_dump_tc (mkDumpDoc "Typechecker" full_dump)
+        -- Dump bindings if -ddump-tc
+        dumpOptTcRn Opt_D_dump_tc (mkDumpDoc "Typechecker" full_dump)
    }
   where
     short_dump = pprTcGblEnv env
     full_dump  = pprLHsBinds (tcg_binds env)
-       -- NB: foreign x-d's have undefined's in their types; 
-       --     hence can't show the tc_fords
+        -- NB: foreign x-d's have undefined's in their types; 
+        --     hence can't show the tc_fords
 
 tcCoreDump :: ModGuts -> TcM ()
 tcCoreDump mod_guts
  = do { dflags <- getDynFlags ;
-       when (dopt Opt_D_dump_types dflags || dopt Opt_D_dump_tc dflags)
-            (dumpTcRn (pprModGuts mod_guts)) ;
+        when (dopt Opt_D_dump_types dflags || dopt Opt_D_dump_tc dflags)
+             (dumpTcRn (pprModGuts mod_guts)) ;
 
-       -- Dump bindings if -ddump-tc
-       dumpOptTcRn Opt_D_dump_tc (mkDumpDoc "Typechecker" full_dump) }
+        -- Dump bindings if -ddump-tc
+        dumpOptTcRn Opt_D_dump_tc (mkDumpDoc "Typechecker" full_dump) }
   where
     full_dump = pprCoreBindings (mg_binds mod_guts)
 
@@ -1712,27 +1705,27 @@ pprTcGblEnv (TcGblEnv { tcg_type_env  = type_env,
                         tcg_vects     = vects,
                         tcg_imports   = imports })
   = vcat [ ppr_types insts type_env
-        , ppr_tycons fam_insts type_env
+         , ppr_tycons fam_insts type_env
          , ppr_insts insts
          , ppr_fam_insts fam_insts
          , vcat (map ppr rules)
          , vcat (map ppr vects)
          , ptext (sLit "Dependent modules:") <+> 
                 ppr (sortBy cmp_mp $ eltsUFM (imp_dep_mods imports))
-        , ptext (sLit "Dependent packages:") <+> 
-               ppr (sortBy stablePackageIdCmp $ imp_dep_pkgs imports)]
-  where                -- The two uses of sortBy are just to reduce unnecessary
-               -- wobbling in testsuite output
+         , ptext (sLit "Dependent packages:") <+> 
+                ppr (sortBy stablePackageIdCmp $ imp_dep_pkgs imports)]
+  where         -- The two uses of sortBy are just to reduce unnecessary
+                -- wobbling in testsuite output
     cmp_mp (mod_name1, is_boot1) (mod_name2, is_boot2)
-       = (mod_name1 `stableModuleNameCmp` mod_name2)
-                 `thenCmp`     
-         (is_boot1 `compare` is_boot2)
+        = (mod_name1 `stableModuleNameCmp` mod_name2)
+                  `thenCmp`     
+          (is_boot1 `compare` is_boot2)
 
 pprModGuts :: ModGuts -> SDoc
 pprModGuts (ModGuts { mg_tcs = tcs
                     , mg_rules = rules })
   = vcat [ ppr_types [] (mkTypeEnv (map ATyCon tcs)),
-          ppr_rules rules ]
+           ppr_rules rules ]
 
 ppr_types :: [ClsInst] -> TypeEnv -> SDoc
 ppr_types insts type_env
@@ -1741,13 +1734,13 @@ ppr_types insts type_env
     dfun_ids = map instanceDFunId insts
     ids = [id | id <- typeEnvIds type_env, want_sig id]
     want_sig id | opt_PprStyle_Debug = True
-               | otherwise          = isLocalId id && 
-                                      isExternalName (idName id) && 
-                                      not (id `elem` dfun_ids)
-       -- isLocalId ignores data constructors, records selectors etc.
-       -- The isExternalName ignores local dictionary and method bindings
-       -- that the type checker has invented.  Top-level user-defined things 
-       -- have External names.
+                | otherwise          = isLocalId id && 
+                                       isExternalName (idName id) && 
+                                       not (id `elem` dfun_ids)
+        -- isLocalId ignores data constructors, records selectors etc.
+        -- The isExternalName ignores local dictionary and method bindings
+        -- that the type checker has invented.  Top-level user-defined things 
+        -- have External names.
 
 ppr_tycons :: [FamInst] -> TypeEnv -> SDoc
 ppr_tycons fam_insts type_env
@@ -1759,9 +1752,9 @@ ppr_tycons fam_insts type_env
     fi_tycons = famInstsRepTyCons fam_insts
     tycons = [tycon | tycon <- typeEnvTyCons type_env, want_tycon tycon]
     want_tycon tycon | opt_PprStyle_Debug = True
-                    | otherwise          = not (isImplicitTyCon tycon) &&
-                                           isExternalName (tyConName tycon) &&
-                                           not (tycon `elem` fi_tycons)
+                     | otherwise          = not (isImplicitTyCon tycon) &&
+                                            isExternalName (tyConName tycon) &&
+                                            not (tycon `elem` fi_tycons)
 
 ppr_insts :: [ClsInst] -> SDoc
 ppr_insts []     = empty
@@ -1774,7 +1767,7 @@ ppr_fam_insts fam_insts =
 
 ppr_sigs :: [Var] -> SDoc
 ppr_sigs ids
-       -- Print type signatures; sort by OccName 
+        -- Print type signatures; sort by OccName 
   = vcat (map ppr_sig (sortLe le_sig ids))
   where
     le_sig id1 id2 = getOccName id1 <= getOccName id2
@@ -1782,7 +1775,7 @@ ppr_sigs ids
 
 ppr_tydecls :: [TyCon] -> SDoc
 ppr_tydecls tycons
-       -- Print type constructor info; sort by OccName 
+        -- Print type constructor info; sort by OccName 
   = vcat (map ppr_tycon (sortLe le_sig tycons))
   where
     le_sig tycon1 tycon2 = getOccName tycon1 <= getOccName tycon2
@@ -1791,6 +1784,6 @@ ppr_tydecls tycons
 ppr_rules :: [CoreRule] -> SDoc
 ppr_rules [] = empty
 ppr_rules rs = vcat [ptext (sLit "{-# RULES"),
-                     nest 2 (pprRules rs),
-                     ptext (sLit "#-}")]
+                      nest 2 (pprRules rs),
+                      ptext (sLit "#-}")]
 \end{code}