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