[project @ 2003-10-13 10:43:02 by simonpj]

[ghc-hetmet.git] / ghc / compiler / iface / TcIface.lhs

diff --git a/ghc/compiler/iface/TcIface.lhs b/ghc/compiler/iface/TcIface.lhs
index 5fc5399..dce075c 100644 (file)
--- a/ghc/compiler/iface/TcIface.lhs
+++ b/ghc/compiler/iface/TcIface.lhs
@@ -27,7 +27,7 @@ import TypeRep                ( Type(..), PredType(..) )
 import TyCon           ( TyCon, tyConName )
 import HscTypes                ( ExternalPackageState(..), PackageInstEnv, PackageRuleBase,
                          HscEnv, TyThing(..), implicitTyThings, typeEnvIds,
-                         ModIface(..), ModDetails(..), InstPool, 
+                         ModIface(..), ModDetails(..), InstPool, ModGuts,
                          TypeEnv, mkTypeEnv, extendTypeEnvList, lookupTypeEnv,
                          DeclPool, RulePool, Pool(..), Gated, addRuleToPool )
 import InstEnv         ( extendInstEnv )
@@ -492,25 +492,33 @@ are in the type environment.  However, remember that typechecking a Rule may
 (as a side effect) augment the type envt, and so we may need to iterate the process.
 
 \begin{code}
-loadImportedRules :: HscEnv -> IO PackageRuleBase
-loadImportedRules hsc_env
-  = initIfaceIO hsc_env $ do 
+loadImportedRules :: HscEnv -> ModGuts -> IO PackageRuleBase
+loadImportedRules hsc_env guts
+  = initIfaceRules hsc_env guts $ do 
        { -- Get new rules
          if_rules <- updateEps (\ eps ->
                let { (new_pool, if_rules) = selectRules (eps_rules eps) (eps_PTE eps) }
                in (eps { eps_rules = new_pool }, if_rules) )
 
+       ; traceIf (ptext SLIT("Importing rules:") <+> vcat (map ppr if_rules))
+
        ; let tc_rule (mod, rule) = initIfaceLcl mod (tcIfaceRule rule)
        ; core_rules <- mapM tc_rule if_rules
 
        -- Debug print
-       ; traceIf (ptext SLIT("Importing rules:") <+> pprIdRules core_rules)
+       ; traceIf (ptext SLIT("Imported rules:") <+> pprIdRules core_rules)
        
        -- Update the rule base and return it
        ; updateEps (\ eps -> 
            let { new_rule_base = extendRuleBaseList (eps_rule_base eps) core_rules }
            in (eps { eps_rule_base = new_rule_base }, new_rule_base)
-         ) }
+         ) 
+
+       -- Strictly speaking, at this point we should go round again, since
+       -- typechecking one set of rules may bring in new things which enable
+       -- some more rules to come in.  But we call loadImportedRules several
+       -- times anyway, so I'm going to be lazy and ignore this.
+    }
 
 
 selectRules :: RulePool -> TypeEnv -> (RulePool, [(ModuleName, IfaceRule)])