ghc/compiler/rename/RnIfaces.lhs

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