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