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