ghc/compiler/rename/RnIfaces.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[RnIfaces]{Cacheing and Renaming of Interfaces}
   5
   6 \begin{code}
   7 module RnIfaces
   8        (
   9         findAndReadIface,
  10
  11         getInterfaceExports,
  12         getImportedInstDecls, getImportedRules,
  13         lookupFixityRn, loadHomeInterface,
  14         importDecl, ImportDeclResult(..), recordLocalSlurps,
  15         mkImportInfo, getSlurped,
  16
  17         getDeclBinders, getDeclSysBinders,
  18         removeContext           -- removeContext probably belongs somewhere else
  19        )
  20 where
  21
  22 #include "HsVersions.h"
  23
  24 import CmdLineOpts      ( opt_NoPruneDecls, opt_NoPruneTyDecls, opt_IgnoreIfacePragmas )
  25 import HscTypes
  26 import HsSyn            ( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..),
  27                           HsType(..), ConDecl(..),
  28                           ForeignDecl(..), ForKind(..), isDynamicExtName,
  29                           FixitySig(..), RuleDecl(..),
  30                           tyClDeclNames
  31                         )
  32 import HsImpExp         ( ImportDecl(..) )
  33 import BasicTypes       ( Version, defaultFixity )
  34 import RdrHsSyn         ( RdrNameHsDecl, RdrNameInstDecl, RdrNameRuleDecl,
  35                           extractHsTyRdrNames
  36                         )
  37 import RnEnv
  38 import RnMonad
  39 import ParseIface       ( parseIface, IfaceStuff(..) )
  40
  41 import Name             ( Name {-instance NamedThing-}, nameOccName,
  42                           nameModule, isLocallyDefined,
  43                           NamedThing(..),
  44                           mkNameEnv, elemNameEnv, extendNameEnv
  45                          )
  46 import Module           ( Module, ModuleEnv,
  47                           moduleName, isModuleInThisPackage,
  48                           ModuleName, WhereFrom(..),
  49                           emptyModuleEnv, extendModuleEnv, lookupModuleEnvByName,
  50                           extendModuleEnv_C, lookupWithDefaultModuleEnv
  51                         )
  52 import RdrName          ( RdrName, rdrNameOcc )
  53 import NameSet
  54 import SrcLoc           ( mkSrcLoc, SrcLoc )
  55 import PrelInfo         ( wiredInThingEnv )
  56 import Maybes           ( maybeToBool, orElse )
  57 import StringBuffer     ( hGetStringBuffer )
  58 import FastString       ( mkFastString )
  59 import ErrUtils         ( Message )
  60 import Lex
  61 import FiniteMap
  62 import Outputable
  63 import Bag
  64
  65 import List             ( nub )
  66 \end{code}
  67
  68
  69 %*********************************************************
  70 %*                                                      *
  71 \subsection{Loading a new interface file}
  72 %*                                                      *
  73 %*********************************************************
  74
  75 \begin{code}
  76 loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
  77 loadHomeInterface doc_str name
  78   = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
  79
  80 loadOrphanModules :: [ModuleName] -> RnM d ()
  81 loadOrphanModules mods
  82   | null mods = returnRn ()
  83   | otherwise = traceRn (text "Loading orphan modules:" <+>
  84                          fsep (map ppr mods))                   `thenRn_`
  85                 mapRn_ load mods                                `thenRn_`
  86                 returnRn ()
  87   where
  88     load mod   = loadInterface (mk_doc mod) mod ImportBySystem
  89     mk_doc mod = ppr mod <+> ptext SLIT("is a orphan-instance module")
  90
  91
  92 loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
  93 loadInterface doc mod from
  94   = tryLoadInterface doc mod from       `thenRn` \ (ifaces, maybe_err) ->
  95     case maybe_err of
  96         Nothing  -> returnRn ifaces
  97         Just err -> failWithRn ifaces err
  98
  99 tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Ifaces, Maybe Message)
 100         -- Returns (Just err) if an error happened
 101         -- Guarantees to return with iImpModInfo m --> (... Just cts)
 102         -- (If the load fails, we plug in a vanilla placeholder
 103 tryLoadInterface doc_str mod_name from
 104  = getIfacesRn                  `thenRn` \ ifaces ->
 105    let
 106         mod_map  = iImpModInfo ifaces
 107         mod_info = lookupFM mod_map mod_name
 108
 109         hi_boot_file
 110           = case (from, mod_info) of
 111                 (ImportByUser,       _)                -> False         -- Not hi-boot
 112                 (ImportByUserSource, _)                -> True          -- hi-boot
 113                 (ImportBySystem, Just (_, is_boot, _)) -> is_boot       --
 114                 (ImportBySystem, Nothing)              -> False
 115                         -- We're importing a module we know absolutely
 116                         -- nothing about, so we assume it's from
 117                         -- another package, where we aren't doing
 118                         -- dependency tracking. So it won't be a hi-boot file.
 119
 120         redundant_source_import
 121           = case (from, mod_info) of
 122                 (ImportByUserSource, Just (_,False,_)) -> True
 123                 other                                  -> False
 124    in
 125         -- CHECK WHETHER WE HAVE IT ALREADY
 126    case mod_info of {
 127         Just (_, _, True)
 128                 ->      -- We're read it already so don't re-read it
 129                     returnRn (ifaces, Nothing) ;
 130
 131         _ ->
 132
 133         -- Issue a warning for a redundant {- SOURCE -} import
 134         -- NB that we arrange to read all the ordinary imports before
 135         -- any of the {- SOURCE -} imports
 136    warnCheckRn  (not redundant_source_import)
 137                 (warnRedundantSourceImport mod_name)    `thenRn_`
 138
 139         -- READ THE MODULE IN
 140    findAndReadIface doc_str mod_name hi_boot_file   `thenRn` \ read_result ->
 141    case read_result of {
 142         Left err ->     -- Not found, so add an empty export env to the Ifaces map
 143                         -- so that we don't look again
 144            let
 145                 new_mod_map = addToFM mod_map mod_name (False, False, True)
 146                 new_ifaces  = ifaces { iImpModInfo = new_mod_map }
 147            in
 148            setIfacesRn new_ifaces               `thenRn_`
 149            returnRn (new_ifaces, Just err) ;
 150
 151         -- Found and parsed!
 152         Right (mod, iface) ->
 153
 154         -- LOAD IT INTO Ifaces
 155
 156         -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
 157         ---    names is done correctly (notably, whether this is an .hi file or .hi-boot file).
 158         --     If we do loadExport first the wrong info gets into the cache (unless we
 159         --      explicitly tag each export which seems a bit of a bore)
 160
 161
 162         -- Sanity check.  If we're system-importing a module we know nothing at all
 163         -- about, it should be from a different package to this one
 164     WARN( not (maybeToBool mod_info) &&
 165           case from of { ImportBySystem -> True; other -> False } &&
 166           isModuleInThisPackage mod,
 167           ppr mod )
 168
 169     loadDecls mod               (iDecls ifaces)   (pi_decls iface)      `thenRn` \ (decls_vers, new_decls) ->
 170     loadRules mod               (iRules ifaces)   (pi_rules iface)      `thenRn` \ (rule_vers, new_rules) ->
 171     loadFixDecls mod_name                         (pi_fixity iface)     `thenRn` \ fix_env ->
 172     loadDeprecs mod                               (pi_deprecs iface)    `thenRn` \ deprec_env ->
 173     foldlRn (loadInstDecl mod)  (iInsts ifaces)   (pi_insts iface)      `thenRn` \ new_insts ->
 174     loadExports                                   (pi_exports iface)    `thenRn` \ (export_vers, avails) ->
 175     let
 176         version = VersionInfo { vers_module  = pi_vers iface,
 177                                 vers_exports = export_vers,
 178                                 vers_rules = rule_vers,
 179                                 vers_decls = decls_vers }
 180
 181         -- For an explicit user import, add to mod_map info about
 182         -- the things the imported module depends on, extracted
 183         -- from its usage info.
 184         mod_map1 = case from of
 185                         ImportByUser -> addModDeps mod (pi_usages iface) mod_map
 186                         other        -> mod_map
 187         mod_map2 = addToFM mod_map1 mod_name (has_orphans, hi_boot_file, True)
 188
 189         -- Now add info about this module to the PIT
 190         has_orphans = pi_orphan iface
 191         new_pit   = extendModuleEnv (iPIT ifaces) mod mod_iface
 192         mod_iface = ModIface { mi_module = mod, mi_version = version,
 193                                mi_exports = avails, mi_orphan = has_orphans,
 194                                mi_fixities = fix_env, mi_deprecs = deprec_env,
 195                                mi_usages  = [], -- Will be filled in later
 196                                mi_decls   = panic "No mi_decls in PIT",
 197                                mi_globals = panic "No mi_globals in PIT"
 198                     }
 199
 200         new_ifaces = ifaces { iPIT        = new_pit,
 201                               iDecls      = new_decls,
 202                               iInsts      = new_insts,
 203                               iRules      = new_rules,
 204                               iImpModInfo = mod_map2  }
 205     in
 206     setIfacesRn new_ifaces              `thenRn_`
 207     returnRn (new_ifaces, Nothing)
 208     }}
 209
 210 -----------------------------------------------------
 211 --      Adding module dependencies from the
 212 --      import decls in the interface file
 213 -----------------------------------------------------
 214
 215 addModDeps :: Module -> [ImportVersion a]
 216            -> ImportedModuleInfo -> ImportedModuleInfo
 217 -- (addModDeps M ivs deps)
 218 -- We are importing module M, and M.hi contains 'import' decls given by ivs
 219 addModDeps mod new_deps mod_deps
 220   = foldr add mod_deps filtered_new_deps
 221   where
 222         -- Don't record dependencies when importing a module from another package
 223         -- Except for its descendents which contain orphans,
 224         -- and in that case, forget about the boot indicator
 225     filtered_new_deps :: [(ModuleName, (WhetherHasOrphans, IsBootInterface, IsLoaded))]
 226     filtered_new_deps
 227         | isModuleInThisPackage mod
 228                             = [ (imp_mod, (has_orphans, is_boot, False))
 229                               | (imp_mod, has_orphans, is_boot, _) <- new_deps
 230                               ]
 231         | otherwise         = [ (imp_mod, (True, False, False))
 232                               | (imp_mod, has_orphans, _, _) <- new_deps,
 233                                 has_orphans
 234                               ]
 235     add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
 236
 237     combine old@(_, old_is_boot, old_is_loaded) new
 238         | old_is_loaded || not old_is_boot = old        -- Keep the old info if it's already loaded
 239                                                         -- or if it's a non-boot pending load
 240         | otherwise                         = new       -- Otherwise pick new info
 241
 242
 243 -----------------------------------------------------
 244 --      Loading the export list
 245 -----------------------------------------------------
 246
 247 loadExports :: (Version, [ExportItem]) -> RnM d (Version, Avails)
 248 loadExports (vers, items)
 249   = getModuleRn                                 `thenRn` \ this_mod ->
 250     mapRn (loadExport this_mod) items           `thenRn` \ avails_s ->
 251     returnRn (vers, concat avails_s)
 252
 253
 254 loadExport :: Module -> ExportItem -> RnM d [AvailInfo]
 255 loadExport this_mod (mod, entities)
 256   | mod == moduleName this_mod = returnRn []
 257         -- If the module exports anything defined in this module, just ignore it.
 258         -- Reason: otherwise it looks as if there are two local definition sites
 259         -- for the thing, and an error gets reported.  Easiest thing is just to
 260         -- filter them out up front. This situation only arises if a module
 261         -- imports itself, or another module that imported it.  (Necessarily,
 262         -- this invoves a loop.)  Consequence: if you say
 263         --      module A where
 264         --         import B( AType )
 265         --         type AType = ...
 266         --
 267         --      module B( AType ) where
 268         --         import {-# SOURCE #-} A( AType )
 269         --
 270         -- then you'll get a 'B does not export AType' message.  A bit bogus
 271         -- but it's a bogus thing to do!
 272
 273   | otherwise
 274   = mapRn (load_entity mod) entities
 275   where
 276     new_name mod occ = newGlobalName mod occ
 277
 278     load_entity mod (Avail occ)
 279       = new_name mod occ        `thenRn` \ name ->
 280         returnRn (Avail name)
 281     load_entity mod (AvailTC occ occs)
 282       = new_name mod occ              `thenRn` \ name ->
 283         mapRn (new_name mod) occs     `thenRn` \ names ->
 284         returnRn (AvailTC name names)
 285
 286
 287 -----------------------------------------------------
 288 --      Loading type/class/value decls
 289 -----------------------------------------------------
 290
 291 loadDecls :: Module
 292           -> DeclsMap
 293           -> [(Version, RdrNameHsDecl)]
 294           -> RnM d (NameEnv Version, DeclsMap)
 295 loadDecls mod decls_map decls
 296   = foldlRn (loadDecl mod) (emptyNameEnv, decls_map) decls
 297
 298 loadDecl :: Module
 299          -> (NameEnv Version, DeclsMap)
 300          -> (Version, RdrNameHsDecl)
 301          -> RnM d (NameEnv Version, DeclsMap)
 302 loadDecl mod (version_map, decls_map) (version, decl)
 303   = getDeclBinders new_name decl        `thenRn` \ maybe_avail ->
 304     case maybe_avail of {
 305         Nothing    -> returnRn (version_map, decls_map);        -- No bindings
 306         Just avail ->
 307
 308     getDeclSysBinders new_name decl     `thenRn` \ sys_bndrs ->
 309     let
 310         full_avail    = addSysAvails avail sys_bndrs
 311                 -- Add the sys-binders to avail.  When we import the decl,
 312                 -- it's full_avail that will get added to the 'already-slurped' set (iSlurp)
 313                 -- If we miss out sys-binders, we'll read the decl multiple times!
 314
 315         main_name     = availName avail
 316         new_decls_map = foldl add_decl decls_map
 317                                        [ (name, (full_avail, name==main_name, (mod, decl')))
 318                                        | name <- availNames full_avail]
 319         add_decl decls_map (name, stuff)
 320           = WARN( name `elemNameEnv` decls_map, ppr name )
 321             extendNameEnv decls_map name stuff
 322
 323         new_version_map = extendNameEnv version_map main_name version
 324     in
 325     returnRn (new_version_map, new_decls_map)
 326     }
 327   where
 328         -- newTopBinder puts into the cache the binder with the
 329         -- module information set correctly.  When the decl is later renamed,
 330         -- the binding site will thereby get the correct module.
 331         -- There maybe occurrences that don't have the correct Module, but
 332         -- by the typechecker will propagate the binding definition to all
 333         -- the occurrences, so that doesn't matter
 334     new_name rdr_name loc = newTopBinder mod rdr_name loc
 335
 336     {-
 337       If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
 338       we toss away unfolding information.
 339
 340       Also, if the signature is loaded from a module we're importing from source,
 341       we do the same. This is to avoid situations when compiling a pair of mutually
 342       recursive modules, peering at unfolding info in the interface file of the other,
 343       e.g., you compile A, it looks at B's interface file and may as a result change
 344       its interface file. Hence, B is recompiled, maybe changing its interface file,
 345       which will the unfolding info used in A to become invalid. Simple way out is to
 346       just ignore unfolding info.
 347
 348       [Jan 99: I junked the second test above.  If we're importing from an hi-boot
 349        file there isn't going to *be* any pragma info.  Maybe the above comment
 350        dates from a time where we picked up a .hi file first if it existed?]
 351     -}
 352     decl' = case decl of
 353                SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
 354                          ->  SigD (IfaceSig name tp [] loc)
 355                other     -> decl
 356
 357 -----------------------------------------------------
 358 --      Loading fixity decls
 359 -----------------------------------------------------
 360
 361 loadFixDecls mod_name decls
 362   = mapRn (loadFixDecl mod_name) decls  `thenRn` \ to_add ->
 363     returnRn (mkNameEnv to_add)
 364
 365 loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
 366   = newGlobalName mod_name (rdrNameOcc rdr_name)        `thenRn` \ name ->
 367     returnRn (name, fixity)
 368
 369
 370 -----------------------------------------------------
 371 --      Loading instance decls
 372 -----------------------------------------------------
 373
 374 loadInstDecl :: Module
 375              -> IfaceInsts
 376              -> RdrNameInstDecl
 377              -> RnM d IfaceInsts
 378 loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
 379   =
 380         -- Find out what type constructors and classes are "gates" for the
 381         -- instance declaration.  If all these "gates" are slurped in then
 382         -- we should slurp the instance decl too.
 383         --
 384         -- We *don't* want to count names in the context part as gates, though.
 385         -- For example:
 386         --              instance Foo a => Baz (T a) where ...
 387         --
 388         -- Here the gates are Baz and T, but *not* Foo.
 389     let
 390         munged_inst_ty = removeContext inst_ty
 391         free_names     = extractHsTyRdrNames munged_inst_ty
 392     in
 393     setModuleRn mod $
 394     mapRn lookupOrigName free_names     `thenRn` \ gate_names ->
 395     returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)
 396
 397
 398 -- In interface files, the instance decls now look like
 399 --      forall a. Foo a -> Baz (T a)
 400 -- so we have to strip off function argument types as well
 401 -- as the bit before the '=>' (which is always empty in interface files)
 402 removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
 403 removeContext ty                      = removeFuns ty
 404
 405 removeFuns (HsFunTy _ ty) = removeFuns ty
 406 removeFuns ty               = ty
 407
 408
 409 -----------------------------------------------------
 410 --      Loading Rules
 411 -----------------------------------------------------
 412
 413 loadRules :: Module -> IfaceRules
 414           -> (Version, [RdrNameRuleDecl])
 415           -> RnM d (Version, IfaceRules)
 416 loadRules mod rule_bag (version, rules)
 417   | null rules || opt_IgnoreIfacePragmas
 418   = returnRn (version, rule_bag)
 419   | otherwise
 420   = setModuleRn mod                     $
 421     mapRn (loadRule mod) rules          `thenRn` \ new_rules ->
 422     returnRn (version, rule_bag `unionBags` listToBag new_rules)
 423
 424 loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
 425 -- "Gate" the rule simply by whether the rule variable is
 426 -- needed.  We can refine this later.
 427 loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
 428   = lookupOrigName var          `thenRn` \ var_name ->
 429     returnRn (unitNameSet var_name, (mod, RuleD decl))
 430
 431
 432 -----------------------------------------------------
 433 --      Loading Deprecations
 434 -----------------------------------------------------
 435
 436 loadDeprecs :: Module -> IfaceDeprecs -> RnM d Deprecations
 437 loadDeprecs m Nothing                                  = returnRn NoDeprecs
 438 loadDeprecs m (Just (Left txt)) = returnRn (DeprecAll txt)
 439 loadDeprecs m (Just (Right prs)) = setModuleRn m                                $
 440                                    foldlRn loadDeprec emptyNameEnv prs  `thenRn` \ env ->
 441                                    returnRn (DeprecSome env)
 442 loadDeprec deprec_env (n, txt)
 443   = lookupOrigName n            `thenRn` \ name ->
 444     traceRn (text "Loaded deprecation(s) for" <+> ppr name <> colon <+> ppr txt) `thenRn_`
 445     returnRn (extendNameEnv deprec_env name txt)
 446 \end{code}
 447
 448
 449 %*********************************************************
 450 %*                                                      *
 451 \subsection{Getting in a declaration}
 452 %*                                                      *
 453 %*********************************************************
 454
 455 \begin{code}
 456 importDecl :: Name -> RnMG ImportDeclResult
 457
 458 data ImportDeclResult
 459   = AlreadySlurped
 460   | WiredIn
 461   | Deferred
 462   | HereItIs (Module, RdrNameHsDecl)
 463
 464 importDecl name
 465   =     -- Check if it was loaded before beginning this module
 466     checkAlreadyAvailable name          `thenRn` \ done ->
 467     if done then
 468         returnRn AlreadySlurped
 469     else
 470
 471         -- Check if we slurped it in while compiling this module
 472     getIfacesRn                         `thenRn` \ ifaces ->
 473     if name `elemNameSet` iSlurp ifaces then
 474         returnRn AlreadySlurped
 475     else
 476
 477         -- Don't slurp in decls from this module's own interface file
 478         -- (Indeed, this shouldn't happen.)
 479     if isLocallyDefined name then
 480         addWarnRn (importDeclWarn name) `thenRn_`
 481         returnRn AlreadySlurped
 482     else
 483
 484         -- When we find a wired-in name we must load its home
 485         -- module so that we find any instance decls lurking therein
 486     if name `elemNameEnv` wiredInThingEnv then
 487         loadHomeInterface doc name      `thenRn_`
 488         returnRn WiredIn
 489
 490     else getNonWiredInDecl name
 491   where
 492     doc = ptext SLIT("need home module for wired in thing") <+> ppr name
 493
 494 getNonWiredInDecl :: Name -> RnMG ImportDeclResult
 495 getNonWiredInDecl needed_name
 496   = traceRn doc_str                             `thenRn_`
 497     loadHomeInterface doc_str needed_name       `thenRn` \ ifaces ->
 498     case lookupNameEnv (iDecls ifaces) needed_name of
 499
 500 {-              OMIT DEFERRED STUFF FOR NOW, TILL GHCI WORKS
 501       Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _)))
 502         -- This case deals with deferred import of algebraic data types
 503
 504         |  not opt_NoPruneTyDecls
 505
 506         && (opt_IgnoreIfacePragmas || ncons > 1)
 507                 -- We only defer if imported interface pragmas are ingored
 508                 -- or if it's not a product type.
 509                 -- Sole reason: The wrapper for a strict function may need to look
 510                 -- inside its arg, and hence need to see its arg type's constructors.
 511
 512         && not (getUnique tycon_name `elem` cCallishTyKeys)
 513                 -- Never defer ccall types; we have to unbox them,
 514                 -- and importing them does no harm
 515
 516
 517         ->      -- OK, so we're importing a deferrable data type
 518             if needed_name == tycon_name
 519                 -- The needed_name is the TyCon of a data type decl
 520                 -- Record that it's slurped, put it in the deferred set
 521                 -- and don't return a declaration at all
 522                 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
 523                                                               `addOneToNameSet` tycon_name})
 524                                          version (AvailTC needed_name [needed_name]))   `thenRn_`
 525                 returnRn Deferred
 526
 527             else
 528                 -- The needed name is a constructor of a data type decl,
 529                 -- getting a constructor, so remove the TyCon from the deferred set
 530                 -- (if it's there) and return the full declaration
 531                 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
 532                                                                `delFromNameSet` tycon_name})
 533                                     version avail)      `thenRn_`
 534                 returnRn (HereItIs decl)
 535         where
 536            tycon_name = availName avail
 537 -}
 538
 539       Just (avail,_,decl)
 540         -> setIfacesRn (recordSlurp ifaces avail)       `thenRn_`
 541            returnRn (HereItIs decl)
 542
 543       Nothing
 544         -> addErrRn (getDeclErr needed_name)    `thenRn_`
 545            returnRn AlreadySlurped
 546   where
 547      doc_str = ptext SLIT("need decl for") <+> ppr needed_name
 548
 549 {-              OMIT FOR NOW
 550 getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
 551 getDeferredDecls
 552   = getIfacesRn         `thenRn` \ ifaces ->
 553     let
 554         decls_map           = iDecls ifaces
 555         deferred_names      = nameSetToList (iDeferred ifaces)
 556         get_abstract_decl n = case lookupNameEnv decls_map n of
 557                                  Just (_, _, _, decl) -> decl
 558     in
 559     traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))])     `thenRn_`
 560     returnRn (map get_abstract_decl deferred_names)
 561 -}
 562 \end{code}
 563
 564 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
 565 It behaves exactly as if the wired in decl were actually in an interface file.
 566 Specifically,
 567 \begin{itemize}
 568 \item   if the wired-in name is a data type constructor or a data constructor,
 569         it brings in the type constructor and all the data constructors; and
 570         marks as ``occurrences'' any free vars of the data con.
 571
 572 \item   similarly for synonum type constructor
 573
 574 \item   if the wired-in name is another wired-in Id, it marks as ``occurrences''
 575         the free vars of the Id's type.
 576
 577 \item   it loads the interface file for the wired-in thing for the
 578         sole purpose of making sure that its instance declarations are available
 579 \end{itemize}
 580 All this is necessary so that we know all types that are ``in play'', so
 581 that we know just what instances to bring into scope.
 582
 583
 584
 585
 586 %*********************************************************
 587 %*                                                      *
 588 \subsection{Getting what a module exports}
 589 %*                                                      *
 590 %*********************************************************
 591
 592 @getInterfaceExports@ is called only for directly-imported modules.
 593
 594 \begin{code}
 595 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
 596 getInterfaceExports mod_name from
 597   = getHomeIfaceTableRn                 `thenRn` \ hit ->
 598     case lookupModuleEnvByName hit mod_name of {
 599         Just mi -> returnRn (mi_module mi, mi_exports mi) ;
 600         Nothing  ->
 601
 602     loadInterface doc_str mod_name from `thenRn` \ ifaces ->
 603     case lookupModuleEnvByName (iPIT ifaces) mod_name of
 604         Just mi -> returnRn (mi_module mi, mi_exports mi) ;
 605                 -- loadInterface always puts something in the map
 606                 -- even if it's a fake
 607         Nothing -> pprPanic "getInterfaceExports" (ppr mod_name)
 608     }
 609     where
 610       doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
 611 \end{code}
 612
 613
 614 %*********************************************************
 615 %*                                                      *
 616 \subsection{Instance declarations are handled specially}
 617 %*                                                      *
 618 %*********************************************************
 619
 620 \begin{code}
 621 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
 622 getImportedInstDecls gates
 623   =     -- First, load any orphan-instance modules that aren't aready loaded
 624         -- Orphan-instance modules are recorded in the module dependecnies
 625     getIfacesRn                                         `thenRn` \ ifaces ->
 626     let
 627         orphan_mods =
 628           [mod | (mod, (True, _, False)) <- fmToList (iImpModInfo ifaces)]
 629     in
 630     loadOrphanModules orphan_mods                       `thenRn_`
 631
 632         -- Now we're ready to grab the instance declarations
 633         -- Find the un-gated ones and return them,
 634         -- removing them from the bag kept in Ifaces
 635     getIfacesRn                                         `thenRn` \ ifaces ->
 636     let
 637         (decls, new_insts) = selectGated gates (iInsts ifaces)
 638     in
 639     setIfacesRn (ifaces { iInsts = new_insts })         `thenRn_`
 640
 641     traceRn (sep [text "getImportedInstDecls:",
 642                   nest 4 (fsep (map ppr gate_list)),
 643                   text "Slurped" <+> int (length decls) <+> text "instance declarations",
 644                   nest 4 (vcat (map ppr_brief_inst_decl decls))])       `thenRn_`
 645     returnRn decls
 646   where
 647     gate_list      = nameSetToList gates
 648
 649 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
 650   = case inst_ty of
 651         HsForAllTy _ _ tau -> ppr tau
 652         other              -> ppr inst_ty
 653
 654 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
 655 getImportedRules
 656   | opt_IgnoreIfacePragmas = returnRn []
 657   | otherwise
 658   = getIfacesRn         `thenRn` \ ifaces ->
 659     let
 660         gates              = iSlurp ifaces      -- Anything at all that's been slurped
 661         rules              = iRules ifaces
 662         (decls, new_rules) = selectGated gates rules
 663     in
 664     if null decls then
 665         returnRn []
 666     else
 667     setIfacesRn (ifaces { iRules = new_rules })              `thenRn_`
 668     traceRn (sep [text "getImportedRules:",
 669                   text "Slurped" <+> int (length decls) <+> text "rules"])   `thenRn_`
 670     returnRn decls
 671
 672 selectGated gates decl_bag
 673         -- Select only those decls whose gates are *all* in 'gates'
 674 #ifdef DEBUG
 675   | opt_NoPruneDecls    -- Just to try the effect of not gating at all
 676   = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag)       -- Grab them all
 677
 678   | otherwise
 679 #endif
 680   = foldrBag select ([], emptyBag) decl_bag
 681   where
 682     select (reqd, decl) (yes, no)
 683         | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
 684         | otherwise                                  = (yes,      (reqd,decl) `consBag` no)
 685
 686 lookupFixityRn :: Name -> RnMS Fixity
 687 lookupFixityRn name
 688   | isLocallyDefined name
 689   = getFixityEnv                        `thenRn` \ local_fix_env ->
 690     returnRn (lookupLocalFixity local_fix_env name)
 691
 692   | otherwise   -- Imported
 693       -- For imported names, we have to get their fixities by doing a loadHomeInterface,
 694       -- and consulting the Ifaces that comes back from that, because the interface
 695       -- file for the Name might not have been loaded yet.  Why not?  Suppose you import module A,
 696       -- which exports a function 'f', which is defined in module B.  Then B isn't loaded
 697       -- right away (after all, it's possible that nothing from B will be used).
 698       -- When we come across a use of 'f', we need to know its fixity, and it's then,
 699       -- and only then, that we load B.hi.  That is what's happening here.
 700   = getHomeIfaceTableRn                 `thenRn` \ hst ->
 701     case lookupFixityEnv hst name of {
 702         Just fixity -> returnRn fixity ;
 703         Nothing     ->
 704
 705     loadHomeInterface doc name          `thenRn` \ ifaces ->
 706     returnRn (lookupFixityEnv (iPIT ifaces) name `orElse` defaultFixity)
 707     }
 708   where
 709     doc = ptext SLIT("Checking fixity for") <+> ppr name
 710 \end{code}
 711
 712
 713 %*********************************************************
 714 %*                                                      *
 715 \subsection{Keeping track of what we've slurped, and version numbers}
 716 %*                                                      *
 717 %*********************************************************
 718
 719 getImportVersions figures out what the ``usage information'' for this
 720 moudule is; that is, what it must record in its interface file as the
 721 things it uses.  It records:
 722
 723 \begin{itemize}
 724 \item   (a) anything reachable from its body code
 725 \item   (b) any module exported with a @module Foo@
 726 \item   (c) anything reachable from an exported item
 727 \end{itemize}
 728
 729 Why (b)?  Because if @Foo@ changes then this module's export list
 730 will change, so we must recompile this module at least as far as
 731 making a new interface file --- but in practice that means complete
 732 recompilation.
 733
 734 Why (c)?  Consider this:
 735 \begin{verbatim}
 736         module A( f, g ) where  |       module B( f ) where
 737           import B( f )         |         f = h 3
 738           g = ...               |         h = ...
 739 \end{verbatim}
 740
 741 Here, @B.f@ isn't used in A.  Should we nevertheless record @B.f@ in
 742 @A@'s usages?  Our idea is that we aren't going to touch A.hi if it is
 743 *identical* to what it was before.  If anything about @B.f@ changes
 744 than anyone who imports @A@ should be recompiled in case they use
 745 @B.f@ (they'll get an early exit if they don't).  So, if anything
 746 about @B.f@ changes we'd better make sure that something in A.hi
 747 changes, and the convenient way to do that is to record the version
 748 number @B.f@ in A.hi in the usage list.  If B.f changes that'll force a
 749 complete recompiation of A, which is overkill but it's the only way to
 750 write a new, slightly different, A.hi.
 751
 752 But the example is tricker.  Even if @B.f@ doesn't change at all,
 753 @B.h@ may do so, and this change may not be reflected in @f@'s version
 754 number.  But with -O, a module that imports A must be recompiled if
 755 @B.h@ changes!  So A must record a dependency on @B.h@.  So we treat
 756 the occurrence of @B.f@ in the export list *just as if* it were in the
 757 code of A, and thereby haul in all the stuff reachable from it.
 758
 759 [NB: If B was compiled with -O, but A isn't, we should really *still*
 760 haul in all the unfoldings for B, in case the module that imports A *is*
 761 compiled with -O.  I think this is the case.]
 762
 763 Even if B is used at all we get a usage line for B
 764         import B <n> :: ... ;
 765 in A.hi, to record the fact that A does import B.  This is used to decide
 766 to look to look for B.hi rather than B.hi-boot when compiling a module that
 767 imports A.  This line says that A imports B, but uses nothing in it.
 768 So we'll get an early bale-out when compiling A if B's version changes.
 769
 770 \begin{code}
 771 mkImportInfo :: ModuleName                      -- Name of this module
 772              -> [ImportDecl n]                  -- The import decls
 773              -> RnMG [ImportVersion Name]
 774
 775 mkImportInfo this_mod imports
 776   = getIfacesRn                                 `thenRn` \ ifaces ->
 777     getHomeIfaceTableRn                         `thenRn` \ hit ->
 778     let
 779         import_all_mods :: [ModuleName]
 780                 -- Modules where we imported all the names
 781                 -- (apart from hiding some, perhaps)
 782         import_all_mods = nub [ m | ImportDecl m _ _ _ imp_list _ <- imports,
 783                                     import_all imp_list ]
 784
 785         import_all (Just (False, _)) = False    -- Imports are specified explicitly
 786         import_all other             = True     -- Everything is imported
 787
 788         mod_map   = iImpModInfo ifaces
 789         imp_names = iVSlurp     ifaces
 790         pit       = iPIT        ifaces
 791
 792         -- mv_map groups together all the things imported from a particular module.
 793         mv_map :: ModuleEnv [Name]
 794         mv_map = foldr add_mv emptyModuleEnv imp_names
 795
 796         add_mv name mv_map = addItem mv_map (nameModule name) name
 797
 798         -- Build the result list by adding info for each module.
 799         -- For (a) a library module, we don't record it at all unless it contains orphans
 800         --         (We must never lose track of orphans.)
 801         --
 802         --     (b) a source-imported module, don't record the dependency at all
 803         --
 804         -- (b) may seem a bit strange.  The idea is that the usages in a .hi file records
 805         -- *all* the module's dependencies other than the loop-breakers.  We use
 806         -- this info in findAndReadInterface to decide whether to look for a .hi file or
 807         -- a .hi-boot file.
 808         --
 809         -- This means we won't track version changes, or orphans, from .hi-boot files.
 810         -- The former is potentially rather bad news.  It could be fixed by recording
 811         -- whether something is a boot file along with the usage info for it, but
 812         -- I can't be bothered just now.
 813
 814         mk_imp_info mod_name (has_orphans, is_boot, opened) so_far
 815            | mod_name == this_mod       -- Check if M appears in the set of modules 'below' M
 816                                         -- This seems like a convenient place to check
 817            = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
 818                                 ptext SLIT("imports itself (perhaps indirectly)") )
 819              so_far
 820
 821            | not opened                 -- We didn't even open the interface
 822            =            -- This happens when a module, Foo, that we explicitly imported has
 823                         -- 'import Baz' in its interface file, recording that Baz is below
 824                         -- Foo in the module dependency hierarchy.  We want to propagate this
 825                         -- information.  The Nothing says that we didn't even open the interface
 826                         -- file but we must still propagate the dependency info.
 827                         -- The module in question must be a local module (in the same package)
 828              go_for_it NothingAtAll
 829
 830
 831            | is_lib_module && not has_orphans
 832            = so_far
 833
 834            | is_lib_module                      -- Record the module version only
 835            = go_for_it (Everything module_vers)
 836
 837            | otherwise
 838            = go_for_it whats_imported
 839
 840              where
 841                 go_for_it exports = (mod_name, has_orphans, is_boot, exports) : so_far
 842                 mod_iface         = lookupIface hit pit mod_name
 843                 mod               = mi_module mod_iface
 844                 is_lib_module     = not (isModuleInThisPackage mod)
 845                 version_info      = mi_version mod_iface
 846                 version_env       = vers_decls version_info
 847                 module_vers       = vers_module version_info
 848
 849                 whats_imported = Specifically module_vers
 850                                               export_vers import_items
 851                                               (vers_rules version_info)
 852
 853                 import_items = [(n,v) | n <- lookupWithDefaultModuleEnv mv_map [] mod,
 854                                         let v = lookupNameEnv version_env n `orElse`
 855                                                 pprPanic "mk_whats_imported" (ppr n)
 856                                ]
 857                 export_vers | moduleName mod `elem` import_all_mods
 858                             = Just (vers_exports version_info)
 859                             | otherwise
 860                             = Nothing
 861
 862         import_info = foldFM mk_imp_info [] mod_map
 863     in
 864     traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map)))    `thenRn_`
 865     returnRn import_info
 866
 867
 868 addItem :: ModuleEnv [a] -> Module -> a -> ModuleEnv [a]
 869 addItem fm mod x = extendModuleEnv_C add_item fm mod [x]
 870                  where
 871                    add_item xs _ = x:xs
 872 \end{code}
 873
 874 \begin{code}
 875 getSlurped
 876   = getIfacesRn         `thenRn` \ ifaces ->
 877     returnRn (iSlurp ifaces)
 878
 879 recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
 880             avail
 881   = let
 882         new_slurped_names = addAvailToNameSet slurped_names avail
 883         new_imp_names     = availName avail : imp_names
 884     in
 885     ifaces { iSlurp  = new_slurped_names, iVSlurp = new_imp_names }
 886
 887 recordLocalSlurps local_avails
 888   = getIfacesRn         `thenRn` \ ifaces ->
 889     let
 890         new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
 891     in
 892     setIfacesRn (ifaces { iSlurp  = new_slurped_names })
 893 \end{code}
 894
 895
 896 %*********************************************************
 897 %*                                                      *
 898 \subsection{Getting binders out of a declaration}
 899 %*                                                      *
 900 %*********************************************************
 901
 902 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
 903 It's used for both source code (from @availsFromDecl@) and interface files
 904 (from @loadDecl@).
 905
 906 It doesn't deal with source-code specific things: @ValD@, @DefD@.  They
 907 are handled by the sourc-code specific stuff in @RnNames@.
 908
 909 \begin{code}
 910 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name)     -- New-name function
 911                 -> RdrNameHsDecl
 912                 -> RnM d (Maybe AvailInfo)
 913
 914 getDeclBinders new_name (TyClD tycl_decl)
 915   = mapRn do_one (tyClDeclNames tycl_decl)      `thenRn` \ (main_name:sub_names) ->
 916     returnRn (Just (AvailTC main_name (main_name : sub_names)))
 917   where
 918     do_one (name,loc) = new_name name loc
 919
 920 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
 921   = new_name var src_loc                        `thenRn` \ var_name ->
 922     returnRn (Just (Avail var_name))
 923
 924     -- foreign declarations
 925 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
 926   | binds_haskell_name kind dyn
 927   = new_name nm loc                 `thenRn` \ name ->
 928     returnRn (Just (Avail name))
 929
 930   | otherwise           -- a foreign export
 931   = lookupOrigName nm `thenRn_`
 932     returnRn Nothing
 933
 934 getDeclBinders new_name (FixD _)    = returnRn Nothing
 935 getDeclBinders new_name (DeprecD _) = returnRn Nothing
 936 getDeclBinders new_name (DefD _)    = returnRn Nothing
 937 getDeclBinders new_name (InstD _)   = returnRn Nothing
 938 getDeclBinders new_name (RuleD _)   = returnRn Nothing
 939
 940 binds_haskell_name (FoImport _) _   = True
 941 binds_haskell_name FoLabel      _   = True
 942 binds_haskell_name FoExport  ext_nm = isDynamicExtName ext_nm
 943 \end{code}
 944
 945 @getDeclSysBinders@ gets the implicit binders introduced by a decl.
 946 A the moment that's just the tycon and datacon that come with a class decl.
 947 They aren't returned by @getDeclBinders@ because they aren't in scope;
 948 but they {\em should} be put into the @DeclsMap@ of this module.
 949
 950 Note that this excludes the default-method names of a class decl,
 951 and the dict fun of an instance decl, because both of these have
 952 bindings of their own elsewhere.
 953
 954 \begin{code}
 955 getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ names src_loc))
 956   = sequenceRn [new_name n src_loc | n <- names]
 957
 958 getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _ _))
 959   = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
 960
 961 getDeclSysBinders new_name other_decl
 962   = returnRn []
 963 \end{code}
 964
 965 %*********************************************************
 966 %*                                                      *
 967 \subsection{Reading an interface file}
 968 %*                                                      *
 969 %*********************************************************
 970
 971 \begin{code}
 972 findAndReadIface :: SDoc -> ModuleName
 973                  -> IsBootInterface     -- True  <=> Look for a .hi-boot file
 974                                         -- False <=> Look for .hi file
 975                  -> RnM d (Either Message (Module, ParsedIface))
 976         -- Nothing <=> file not found, or unreadable, or illegible
 977         -- Just x  <=> successfully found and parsed
 978
 979 findAndReadIface doc_str mod_name hi_boot_file
 980   = traceRn trace_msg                   `thenRn_`
 981       -- we keep two maps for interface files,
 982       -- one for 'normal' ones, the other for .hi-boot files,
 983       -- hence the need to signal which kind we're interested.
 984
 985     getFinderRn                         `thenRn` \ finder ->
 986     ioToRnM (finder mod_name)           `thenRn` \ maybe_found ->
 987
 988     case maybe_found of
 989       Right (Just (mod,locn))
 990         | hi_boot_file -> readIface mod (hi_file locn ++ "-hi-boot")
 991         | otherwise    -> readIface mod (hi_file locn)
 992
 993         -- Can't find it
 994       other   -> traceRn (ptext SLIT("...not found"))   `thenRn_`
 995                  returnRn (Left (noIfaceErr mod_name hi_boot_file))
 996
 997   where
 998     trace_msg = sep [hsep [ptext SLIT("Reading"),
 999                            if hi_boot_file then ptext SLIT("[boot]") else empty,
1000                            ptext SLIT("interface for"),
1001                            ppr mod_name <> semi],
1002                      nest 4 (ptext SLIT("reason:") <+> doc_str)]
1003 \end{code}
1004
1005 @readIface@ tries just the one file.
1006
1007 \begin{code}
1008 readIface :: Module -> String -> RnM d (Either Message (Module, ParsedIface))
1009         -- Nothing <=> file not found, or unreadable, or illegible
1010         -- Just x  <=> successfully found and parsed
1011 readIface wanted_mod file_path
1012   = traceRn (ptext SLIT("...reading from") <+> text file_path)  `thenRn_`
1013     ioToRnM (hGetStringBuffer False file_path)                   `thenRn` \ read_result ->
1014     case read_result of
1015         Right contents    ->
1016              case parseIface contents
1017                         PState{ bol = 0#, atbol = 1#,
1018                                 context = [],
1019                                 glasgow_exts = 1#,
1020                                 loc = mkSrcLoc (mkFastString file_path) 1 } of
1021                   POk _  (PIface iface) ->
1022                       warnCheckRn (wanted_mod == read_mod)
1023                                   (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
1024                       returnRn (Right (wanted_mod, iface))
1025                     where
1026                       read_mod = pi_mod iface
1027
1028                   PFailed err   -> bale_out err
1029                   parse_result  -> bale_out empty
1030                         -- This last case can happen if the interface file is (say) empty
1031                         -- in which case the parser thinks it looks like an IdInfo or
1032                         -- something like that.  Just an artefact of the fact that the
1033                         -- parser is used for several purposes at once.
1034
1035         Left io_err -> bale_out (text (show io_err))
1036   where
1037     bale_out err = returnRn (Left (badIfaceFile file_path err))
1038 \end{code}
1039
1040 %*********************************************************
1041 %*                                                       *
1042 \subsection{Errors}
1043 %*                                                       *
1044 %*********************************************************
1045
1046 \begin{code}
1047 noIfaceErr mod_name boot_file
1048   = ptext SLIT("Could not find interface file for") <+> quotes (ppr mod_name)
1049         -- We used to print the search path, but we can't do that
1050         -- now, becuase it's hidden inside the finder.
1051         -- Maybe the finder should expose more functions.
1052
1053 badIfaceFile file err
1054   = vcat [ptext SLIT("Bad interface file:") <+> text file,
1055           nest 4 err]
1056
1057 getDeclErr name
1058   = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
1059           ptext SLIT("from module") <+> quotes (ppr (nameModule name))
1060          ]
1061
1062 importDeclWarn name
1063   = sep [ptext SLIT(
1064     "Compiler tried to import decl from interface file with same name as module."),
1065          ptext SLIT(
1066     "(possible cause: module name clashes with interface file already in scope.)")
1067         ] $$
1068     hsep [ptext SLIT("name:"), quotes (ppr name)]
1069
1070 warnRedundantSourceImport mod_name
1071   = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
1072           <+> quotes (ppr mod_name)
1073
1074 hiModuleNameMismatchWarn :: Module -> Module  -> Message
1075 hiModuleNameMismatchWarn requested_mod read_mod =
1076     hsep [ ptext SLIT("Something is amiss; requested module name")
1077          , ppr (moduleName requested_mod)
1078          , ptext SLIT("differs from name found in the interface file")
1079          , ppr read_mod
1080          ]
1081
1082 \end{code}