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