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