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