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,
  15         mkImportInfo, 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                           emptyModuleEnv, extendModuleEnv, lookupModuleEnv, lookupModuleEnvByName,
  51                           extendModuleEnv_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_env ->
 175     loadDeprecs mod                               (pi_deprecs iface)    `thenRn` \ deprec_env ->
 176     foldlRn (loadInstDecl mod)  (iInsts ifaces)   (pi_insts iface)      `thenRn` \ new_insts ->
 177     loadExports                                   (pi_exports iface)    `thenRn` \ (export_vers, avails) ->
 178     let
 179         version = VersionInfo { vers_module  = pi_vers iface,
 180                                 vers_exports = export_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, IsLoaded))]
 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 :: (Version, [ExportItem]) -> RnM d (Version, Avails)
 251 loadExports (vers, items)
 252   = getModuleRn                                 `thenRn` \ this_mod ->
 253     mapRn (loadExport this_mod) items           `thenRn` \ avails_s ->
 254     returnRn (vers, 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 decls
 365   = mapRn (loadFixDecl mod_name) decls  `thenRn` \ to_add ->
 366     returnRn (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
 435 -----------------------------------------------------
 436 --      Loading Deprecations
 437 -----------------------------------------------------
 438
 439 loadDeprecs :: Module -> [RdrNameDeprecation] -> RnM d Deprecations
 440 loadDeprecs m []                                       = returnRn NoDeprecs
 441 loadDeprecs m [Deprecation (IEModuleContents _) txt _] = returnRn (DeprecAll txt)
 442 loadDeprecs m deprecs                                  = setModuleRn m          $
 443                                                          foldlRn loadDeprec emptyNameEnv deprecs        `thenRn` \ env ->
 444                                                          returnRn (DeprecSome env)
 445 loadDeprec deprec_env (Deprecation ie txt _)
 446   = mapRn lookupOrigName (ieNames ie)           `thenRn` \ names ->
 447     traceRn (text "Loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
 448     returnRn (extendNameEnvList deprec_env (zip names (repeat txt)))
 449 \end{code}
 450
 451
 452 %*********************************************************
 453 %*                                                      *
 454 \subsection{Getting in a declaration}
 455 %*                                                      *
 456 %*********************************************************
 457
 458 \begin{code}
 459 importDecl :: Name -> RnMG ImportDeclResult
 460
 461 data ImportDeclResult
 462   = AlreadySlurped
 463   | WiredIn
 464   | Deferred
 465   | HereItIs (Module, RdrNameHsDecl)
 466
 467 importDecl name
 468   =     -- Check if it was loaded before beginning this module
 469     checkAlreadyAvailable name          `thenRn` \ done ->
 470     if done then
 471         returnRn AlreadySlurped
 472     else
 473
 474         -- Check if we slurped it in while compiling this module
 475     getIfacesRn                         `thenRn` \ ifaces ->
 476     if name `elemNameSet` iSlurp ifaces then
 477         returnRn AlreadySlurped
 478     else
 479
 480         -- Don't slurp in decls from this module's own interface file
 481         -- (Indeed, this shouldn't happen.)
 482     if isLocallyDefined name then
 483         addWarnRn (importDeclWarn name) `thenRn_`
 484         returnRn AlreadySlurped
 485     else
 486
 487         -- When we find a wired-in name we must load its home
 488         -- module so that we find any instance decls lurking therein
 489     if name `elemNameEnv` wiredInThingEnv then
 490         loadHomeInterface doc name      `thenRn_`
 491         returnRn WiredIn
 492
 493     else getNonWiredInDecl name
 494   where
 495     doc = ptext SLIT("need home module for wired in thing") <+> ppr name
 496
 497 getNonWiredInDecl :: Name -> RnMG ImportDeclResult
 498 getNonWiredInDecl needed_name
 499   = traceRn doc_str                             `thenRn_`
 500     loadHomeInterface doc_str needed_name       `thenRn` \ ifaces ->
 501     case lookupNameEnv (iDecls ifaces) needed_name of
 502
 503 {-              OMIT DEFERRED STUFF FOR NOW, TILL GHCI WORKS
 504       Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _ _)))
 505         -- This case deals with deferred import of algebraic data types
 506
 507         |  not opt_NoPruneTyDecls
 508
 509         && (opt_IgnoreIfacePragmas || ncons > 1)
 510                 -- We only defer if imported interface pragmas are ingored
 511                 -- or if it's not a product type.
 512                 -- Sole reason: The wrapper for a strict function may need to look
 513                 -- inside its arg, and hence need to see its arg type's constructors.
 514
 515         && not (getUnique tycon_name `elem` cCallishTyKeys)
 516                 -- Never defer ccall types; we have to unbox them,
 517                 -- and importing them does no harm
 518
 519
 520         ->      -- OK, so we're importing a deferrable data type
 521             if needed_name == tycon_name
 522                 -- The needed_name is the TyCon of a data type decl
 523                 -- Record that it's slurped, put it in the deferred set
 524                 -- and don't return a declaration at all
 525                 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
 526                                                               `addOneToNameSet` tycon_name})
 527                                          version (AvailTC needed_name [needed_name]))   `thenRn_`
 528                 returnRn Deferred
 529
 530             else
 531                 -- The needed name is a constructor of a data type decl,
 532                 -- getting a constructor, so remove the TyCon from the deferred set
 533                 -- (if it's there) and return the full declaration
 534                 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces
 535                                                                `delFromNameSet` tycon_name})
 536                                     version avail)      `thenRn_`
 537                 returnRn (HereItIs decl)
 538         where
 539            tycon_name = availName avail
 540 -}
 541
 542       Just (avail,_,decl)
 543         -> setIfacesRn (recordSlurp ifaces avail)       `thenRn_`
 544            returnRn (HereItIs decl)
 545
 546       Nothing
 547         -> addErrRn (getDeclErr needed_name)    `thenRn_`
 548            returnRn AlreadySlurped
 549   where
 550      doc_str = ptext SLIT("need decl for") <+> ppr needed_name
 551
 552 {-              OMIT FOR NOW
 553 getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
 554 getDeferredDecls
 555   = getIfacesRn         `thenRn` \ ifaces ->
 556     let
 557         decls_map           = iDecls ifaces
 558         deferred_names      = nameSetToList (iDeferred ifaces)
 559         get_abstract_decl n = case lookupNameEnv decls_map n of
 560                                  Just (_, _, _, decl) -> decl
 561     in
 562     traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))])     `thenRn_`
 563     returnRn (map get_abstract_decl deferred_names)
 564 -}
 565 \end{code}
 566
 567 @getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
 568 It behaves exactly as if the wired in decl were actually in an interface file.
 569 Specifically,
 570 \begin{itemize}
 571 \item   if the wired-in name is a data type constructor or a data constructor,
 572         it brings in the type constructor and all the data constructors; and
 573         marks as ``occurrences'' any free vars of the data con.
 574
 575 \item   similarly for synonum type constructor
 576
 577 \item   if the wired-in name is another wired-in Id, it marks as ``occurrences''
 578         the free vars of the Id's type.
 579
 580 \item   it loads the interface file for the wired-in thing for the
 581         sole purpose of making sure that its instance declarations are available
 582 \end{itemize}
 583 All this is necessary so that we know all types that are ``in play'', so
 584 that we know just what instances to bring into scope.
 585
 586
 587
 588
 589 %*********************************************************
 590 %*                                                      *
 591 \subsection{Getting what a module exports}
 592 %*                                                      *
 593 %*********************************************************
 594
 595 @getInterfaceExports@ is called only for directly-imported modules.
 596
 597 \begin{code}
 598 getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
 599 getInterfaceExports mod_name from
 600   = getHomeIfaceTableRn                 `thenRn` \ hit ->
 601     case lookupModuleEnvByName hit mod_name of {
 602         Just mi -> returnRn (mi_module mi, mi_exports mi) ;
 603         Nothing  ->
 604
 605     loadInterface doc_str mod_name from `thenRn` \ ifaces ->
 606     case lookupModuleEnvByName (iPIT ifaces) mod_name of
 607         Just mi -> returnRn (mi_module mi, mi_exports mi) ;
 608                 -- loadInterface always puts something in the map
 609                 -- even if it's a fake
 610         Nothing -> pprPanic "getInterfaceExports" (ppr mod_name)
 611     }
 612     where
 613       doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
 614 \end{code}
 615
 616
 617 %*********************************************************
 618 %*                                                      *
 619 \subsection{Instance declarations are handled specially}
 620 %*                                                      *
 621 %*********************************************************
 622
 623 \begin{code}
 624 getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
 625 getImportedInstDecls gates
 626   =     -- First, load any orphan-instance modules that aren't aready loaded
 627         -- Orphan-instance modules are recorded in the module dependecnies
 628     getIfacesRn                                         `thenRn` \ ifaces ->
 629     let
 630         orphan_mods =
 631           [mod | (mod, (True, _, False)) <- fmToList (iImpModInfo ifaces)]
 632     in
 633     loadOrphanModules orphan_mods                       `thenRn_`
 634
 635         -- Now we're ready to grab the instance declarations
 636         -- Find the un-gated ones and return them,
 637         -- removing them from the bag kept in Ifaces
 638     getIfacesRn                                         `thenRn` \ ifaces ->
 639     let
 640         (decls, new_insts) = selectGated gates (iInsts ifaces)
 641     in
 642     setIfacesRn (ifaces { iInsts = new_insts })         `thenRn_`
 643
 644     traceRn (sep [text "getImportedInstDecls:",
 645                   nest 4 (fsep (map ppr gate_list)),
 646                   text "Slurped" <+> int (length decls) <+> text "instance declarations",
 647                   nest 4 (vcat (map ppr_brief_inst_decl decls))])       `thenRn_`
 648     returnRn decls
 649   where
 650     gate_list      = nameSetToList gates
 651
 652 ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
 653   = case inst_ty of
 654         HsForAllTy _ _ tau -> ppr tau
 655         other              -> ppr inst_ty
 656
 657 getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
 658 getImportedRules
 659   | opt_IgnoreIfacePragmas = returnRn []
 660   | otherwise
 661   = getIfacesRn         `thenRn` \ ifaces ->
 662     let
 663         gates              = iSlurp ifaces      -- Anything at all that's been slurped
 664         rules              = iRules ifaces
 665         (decls, new_rules) = selectGated gates rules
 666     in
 667     if null decls then
 668         returnRn []
 669     else
 670     setIfacesRn (ifaces { iRules = new_rules })              `thenRn_`
 671     traceRn (sep [text "getImportedRules:",
 672                   text "Slurped" <+> int (length decls) <+> text "rules"])   `thenRn_`
 673     returnRn decls
 674
 675 selectGated gates decl_bag
 676         -- Select only those decls whose gates are *all* in 'gates'
 677 #ifdef DEBUG
 678   | opt_NoPruneDecls    -- Just to try the effect of not gating at all
 679   = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag)       -- Grab them all
 680
 681   | otherwise
 682 #endif
 683   = foldrBag select ([], emptyBag) decl_bag
 684   where
 685     select (reqd, decl) (yes, no)
 686         | isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
 687         | otherwise                                  = (yes,      (reqd,decl) `consBag` no)
 688
 689 lookupFixityRn :: Name -> RnMS Fixity
 690 lookupFixityRn name
 691   | isLocallyDefined name
 692   = getFixityEnv                        `thenRn` \ local_fix_env ->
 693     returnRn (lookupLocalFixity local_fix_env name)
 694
 695   | otherwise   -- Imported
 696       -- For imported names, we have to get their fixities by doing a loadHomeInterface,
 697       -- and consulting the Ifaces that comes back from that, because the interface
 698       -- file for the Name might not have been loaded yet.  Why not?  Suppose you import module A,
 699       -- which exports a function 'f', which is defined in module B.  Then B isn't loaded
 700       -- right away (after all, it's possible that nothing from B will be used).
 701       -- When we come across a use of 'f', we need to know its fixity, and it's then,
 702       -- and only then, that we load B.hi.  That is what's happening here.
 703   = getHomeIfaceTableRn                 `thenRn` \ hst ->
 704     case lookupFixityEnv hst name of {
 705         Just fixity -> returnRn fixity ;
 706         Nothing     ->
 707
 708     loadHomeInterface doc name          `thenRn` \ ifaces ->
 709     returnRn (lookupFixityEnv (iPIT ifaces) name `orElse` defaultFixity)
 710     }
 711   where
 712     doc = ptext SLIT("Checking fixity for") <+> ppr name
 713 \end{code}
 714
 715
 716 %*********************************************************
 717 %*                                                      *
 718 \subsection{Keeping track of what we've slurped, and version numbers}
 719 %*                                                      *
 720 %*********************************************************
 721
 722 getImportVersions figures out what the ``usage information'' for this
 723 moudule is; that is, what it must record in its interface file as the
 724 things it uses.  It records:
 725
 726 \begin{itemize}
 727 \item   (a) anything reachable from its body code
 728 \item   (b) any module exported with a @module Foo@
 729 \item   (c) anything reachable from an exported item
 730 \end{itemize}
 731
 732 Why (b)?  Because if @Foo@ changes then this module's export list
 733 will change, so we must recompile this module at least as far as
 734 making a new interface file --- but in practice that means complete
 735 recompilation.
 736
 737 Why (c)?  Consider this:
 738 \begin{verbatim}
 739         module A( f, g ) where  |       module B( f ) where
 740           import B( f )         |         f = h 3
 741           g = ...               |         h = ...
 742 \end{verbatim}
 743
 744 Here, @B.f@ isn't used in A.  Should we nevertheless record @B.f@ in
 745 @A@'s usages?  Our idea is that we aren't going to touch A.hi if it is
 746 *identical* to what it was before.  If anything about @B.f@ changes
 747 than anyone who imports @A@ should be recompiled in case they use
 748 @B.f@ (they'll get an early exit if they don't).  So, if anything
 749 about @B.f@ changes we'd better make sure that something in A.hi
 750 changes, and the convenient way to do that is to record the version
 751 number @B.f@ in A.hi in the usage list.  If B.f changes that'll force a
 752 complete recompiation of A, which is overkill but it's the only way to
 753 write a new, slightly different, A.hi.
 754
 755 But the example is tricker.  Even if @B.f@ doesn't change at all,
 756 @B.h@ may do so, and this change may not be reflected in @f@'s version
 757 number.  But with -O, a module that imports A must be recompiled if
 758 @B.h@ changes!  So A must record a dependency on @B.h@.  So we treat
 759 the occurrence of @B.f@ in the export list *just as if* it were in the
 760 code of A, and thereby haul in all the stuff reachable from it.
 761
 762 [NB: If B was compiled with -O, but A isn't, we should really *still*
 763 haul in all the unfoldings for B, in case the module that imports A *is*
 764 compiled with -O.  I think this is the case.]
 765
 766 Even if B is used at all we get a usage line for B
 767         import B <n> :: ... ;
 768 in A.hi, to record the fact that A does import B.  This is used to decide
 769 to look to look for B.hi rather than B.hi-boot when compiling a module that
 770 imports A.  This line says that A imports B, but uses nothing in it.
 771 So we'll get an early bale-out when compiling A if B's version changes.
 772
 773 \begin{code}
 774 mkImportInfo :: ModuleName                      -- Name of this module
 775              -> [ImportDecl n]                  -- The import decls
 776              -> RnMG [ImportVersion Name]
 777
 778 mkImportInfo this_mod imports
 779   = getIfacesRn                                 `thenRn` \ ifaces ->
 780     getHomeIfaceTableRn                         `thenRn` \ hit ->
 781     let
 782         import_all_mods :: [ModuleName]
 783                 -- Modules where we imported all the names
 784                 -- (apart from hiding some, perhaps)
 785         import_all_mods = nub [ m | ImportDecl m _ _ _ imp_list _ <- imports,
 786                                     import_all imp_list ]
 787
 788         import_all (Just (False, _)) = False    -- Imports are specified explicitly
 789         import_all other             = True     -- Everything is imported
 790
 791         mod_map   = iImpModInfo ifaces
 792         imp_names = iVSlurp     ifaces
 793         pit       = iPIT        ifaces
 794
 795         -- mv_map groups together all the things imported from a particular module.
 796         mv_map :: ModuleEnv [Name]
 797         mv_map = foldr add_mv emptyModuleEnv imp_names
 798
 799         add_mv name mv_map = addItem mv_map (nameModule name) name
 800
 801         -- Build the result list by adding info for each module.
 802         -- For (a) a library module, we don't record it at all unless it contains orphans
 803         --         (We must never lose track of orphans.)
 804         --
 805         --     (b) a source-imported module, don't record the dependency at all
 806         --
 807         -- (b) may seem a bit strange.  The idea is that the usages in a .hi file records
 808         -- *all* the module's dependencies other than the loop-breakers.  We use
 809         -- this info in findAndReadInterface to decide whether to look for a .hi file or
 810         -- a .hi-boot file.
 811         --
 812         -- This means we won't track version changes, or orphans, from .hi-boot files.
 813         -- The former is potentially rather bad news.  It could be fixed by recording
 814         -- whether something is a boot file along with the usage info for it, but
 815         -- I can't be bothered just now.
 816
 817         mk_imp_info mod_name (has_orphans, is_boot, opened) so_far
 818            | mod_name == this_mod       -- Check if M appears in the set of modules 'below' M
 819                                         -- This seems like a convenient place to check
 820            = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+>
 821                                 ptext SLIT("imports itself (perhaps indirectly)") )
 822              so_far
 823
 824            | not opened                 -- We didn't even open the interface
 825            =            -- This happens when a module, Foo, that we explicitly imported has
 826                         -- 'import Baz' in its interface file, recording that Baz is below
 827                         -- Foo in the module dependency hierarchy.  We want to propagate this
 828                         -- information.  The Nothing says that we didn't even open the interface
 829                         -- file but we must still propagate the dependency info.
 830                         -- The module in question must be a local module (in the same package)
 831              go_for_it NothingAtAll
 832
 833
 834            | is_lib_module && not has_orphans
 835            = so_far
 836
 837            | is_lib_module                      -- Record the module version only
 838            = go_for_it (Everything module_vers)
 839
 840            | otherwise
 841            = go_for_it whats_imported
 842
 843              where
 844                 go_for_it exports = (mod_name, has_orphans, is_boot, exports) : so_far
 845                 mod_iface         = lookupIface hit pit mod_name
 846                 mod               = mi_module mod_iface
 847                 is_lib_module     = not (isModuleInThisPackage mod)
 848                 version_info      = mi_version mod_iface
 849                 version_env       = vers_decls version_info
 850                 module_vers       = vers_module version_info
 851
 852                 whats_imported = Specifically module_vers
 853                                               export_vers import_items
 854                                               (vers_rules version_info)
 855
 856                 import_items = [(n,v) | n <- lookupWithDefaultModuleEnv mv_map [] mod,
 857                                         let v = lookupNameEnv version_env n `orElse`
 858                                                 pprPanic "mk_whats_imported" (ppr n)
 859                                ]
 860                 export_vers | moduleName mod `elem` import_all_mods
 861                             = Just (vers_exports version_info)
 862                             | otherwise
 863                             = Nothing
 864
 865         import_info = foldFM mk_imp_info [] mod_map
 866     in
 867     traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map)))    `thenRn_`
 868     returnRn import_info
 869
 870
 871 addItem :: ModuleEnv [a] -> Module -> a -> ModuleEnv [a]
 872 addItem fm mod x = extendModuleEnv_C add_item fm mod [x]
 873                  where
 874                    add_item xs _ = x:xs
 875 \end{code}
 876
 877 \begin{code}
 878 getSlurped
 879   = getIfacesRn         `thenRn` \ ifaces ->
 880     returnRn (iSlurp ifaces)
 881
 882 recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
 883             avail
 884   = let
 885         new_slurped_names = addAvailToNameSet slurped_names avail
 886         new_imp_names     = availName avail : imp_names
 887     in
 888     ifaces { iSlurp  = new_slurped_names, iVSlurp = new_imp_names }
 889
 890 recordLocalSlurps local_avails
 891   = getIfacesRn         `thenRn` \ ifaces ->
 892     let
 893         new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
 894     in
 895     setIfacesRn (ifaces { iSlurp  = new_slurped_names })
 896 \end{code}
 897
 898
 899 %*********************************************************
 900 %*                                                      *
 901 \subsection{Getting binders out of a declaration}
 902 %*                                                      *
 903 %*********************************************************
 904
 905 @getDeclBinders@ returns the names for a @RdrNameHsDecl@.
 906 It's used for both source code (from @availsFromDecl@) and interface files
 907 (from @loadDecl@).
 908
 909 It doesn't deal with source-code specific things: @ValD@, @DefD@.  They
 910 are handled by the sourc-code specific stuff in @RnNames@.
 911
 912 \begin{code}
 913 getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name)     -- New-name function
 914                 -> RdrNameHsDecl
 915                 -> RnM d (Maybe AvailInfo)
 916
 917 getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc _ _))
 918   = new_name tycon src_loc                      `thenRn` \ tycon_name ->
 919     getConFieldNames new_name condecls          `thenRn` \ sub_names ->
 920     returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
 921         -- The "nub" is because getConFieldNames can legitimately return duplicates,
 922         -- when a record declaration has the same field in multiple constructors
 923
 924 getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
 925   = new_name tycon src_loc              `thenRn` \ tycon_name ->
 926     returnRn (Just (AvailTC tycon_name [tycon_name]))
 927
 928 getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ src_loc))
 929   = new_name cname src_loc                      `thenRn` \ class_name ->
 930
 931         -- Record the names for the class ops
 932     let
 933         -- just want class-op sigs
 934         op_sigs = filter isClassOpSig sigs
 935     in
 936     mapRn (getClassOpNames new_name) op_sigs    `thenRn` \ sub_names ->
 937
 938     returnRn (Just (AvailTC class_name (class_name : sub_names)))
 939
 940 getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
 941   = new_name var src_loc                        `thenRn` \ var_name ->
 942     returnRn (Just (Avail var_name))
 943
 944 getDeclBinders new_name (FixD _)    = returnRn Nothing
 945 getDeclBinders new_name (DeprecD _) = returnRn Nothing
 946
 947     -- foreign declarations
 948 getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
 949   | binds_haskell_name kind dyn
 950   = new_name nm loc                 `thenRn` \ name ->
 951     returnRn (Just (Avail name))
 952
 953   | otherwise           -- a foreign export
 954   = lookupOrigName nm `thenRn_`
 955     returnRn Nothing
 956
 957 getDeclBinders new_name (DefD _)  = returnRn Nothing
 958 getDeclBinders new_name (InstD _) = returnRn Nothing
 959 getDeclBinders new_name (RuleD _) = returnRn Nothing
 960
 961 binds_haskell_name (FoImport _) _   = True
 962 binds_haskell_name FoLabel      _   = True
 963 binds_haskell_name FoExport  ext_nm = isDynamicExtName ext_nm
 964
 965 ----------------
 966 getConFieldNames new_name (ConDecl con _ _ _ (RecCon fielddecls) src_loc : rest)
 967   = mapRn (\n -> new_name n src_loc) (con:fields)       `thenRn` \ cfs ->
 968     getConFieldNames new_name rest                      `thenRn` \ ns  ->
 969     returnRn (cfs ++ ns)
 970   where
 971     fields = concat (map fst fielddecls)
 972
 973 getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
 974   = new_name con src_loc                `thenRn` \ n ->
 975     getConFieldNames new_name rest      `thenRn` \ ns ->
 976     returnRn (n : ns)
 977
 978 getConFieldNames new_name [] = returnRn []
 979
 980 getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
 981 \end{code}
 982
 983 @getDeclSysBinders@ gets the implicit binders introduced by a decl.
 984 A the moment that's just the tycon and datacon that come with a class decl.
 985 They aren't returned by @getDeclBinders@ because they aren't in scope;
 986 but they {\em should} be put into the @DeclsMap@ of this module.
 987
 988 Note that this excludes the default-method names of a class decl,
 989 and the dict fun of an instance decl, because both of these have
 990 bindings of their own elsewhere.
 991
 992 \begin{code}
 993 getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ names
 994                                    src_loc))
 995   = sequenceRn [new_name n src_loc | n <- names]
 996
 997 getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _ _ _))
 998   = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
 999
1000 getDeclSysBinders new_name other_decl
1001   = returnRn []
1002 \end{code}
1003
1004 %*********************************************************
1005 %*                                                      *
1006 \subsection{Reading an interface file}
1007 %*                                                      *
1008 %*********************************************************
1009
1010 \begin{code}
1011 findAndReadIface :: SDoc -> ModuleName
1012                  -> IsBootInterface     -- True  <=> Look for a .hi-boot file
1013                                         -- False <=> Look for .hi file
1014                  -> RnM d (Either Message (Module, ParsedIface))
1015         -- Nothing <=> file not found, or unreadable, or illegible
1016         -- Just x  <=> successfully found and parsed
1017
1018 findAndReadIface doc_str mod_name hi_boot_file
1019   = traceRn trace_msg                   `thenRn_`
1020       -- we keep two maps for interface files,
1021       -- one for 'normal' ones, the other for .hi-boot files,
1022       -- hence the need to signal which kind we're interested.
1023
1024     getFinderRn                         `thenRn` \ finder ->
1025     ioToRnM (finder mod_name)           `thenRn` \ maybe_found ->
1026
1027     case maybe_found of
1028       Right (Just (mod,locn))
1029         | hi_boot_file -> readIface mod (hi_file locn ++ "-hi-boot")
1030         | otherwise    -> readIface mod (hi_file locn)
1031
1032         -- Can't find it
1033       other   -> traceRn (ptext SLIT("...not found"))   `thenRn_`
1034                  returnRn (Left (noIfaceErr mod_name hi_boot_file))
1035
1036   where
1037     trace_msg = sep [hsep [ptext SLIT("Reading"),
1038                            if hi_boot_file then ptext SLIT("[boot]") else empty,
1039                            ptext SLIT("interface for"),
1040                            ppr mod_name <> semi],
1041                      nest 4 (ptext SLIT("reason:") <+> doc_str)]
1042 \end{code}
1043
1044 @readIface@ tries just the one file.
1045
1046 \begin{code}
1047 readIface :: Module -> String -> RnM d (Either Message (Module, ParsedIface))
1048         -- Nothing <=> file not found, or unreadable, or illegible
1049         -- Just x  <=> successfully found and parsed
1050 readIface wanted_mod file_path
1051   = traceRn (ptext SLIT("...reading from") <+> text file_path)  `thenRn_`
1052     ioToRnM (hGetStringBuffer False file_path)                   `thenRn` \ read_result ->
1053     case read_result of
1054         Right contents    ->
1055              case parseIface contents
1056                         PState{ bol = 0#, atbol = 1#,
1057                                 context = [],
1058                                 glasgow_exts = 1#,
1059                                 loc = mkSrcLoc (mkFastString file_path) 1 } of
1060                   POk _  (PIface iface) ->
1061                       warnCheckRn (wanted_mod == read_mod)
1062                                   (hiModuleNameMismatchWarn wanted_mod read_mod) `thenRn_`
1063                       returnRn (Right (wanted_mod, iface))
1064                     where
1065                       read_mod = pi_mod iface
1066
1067                   PFailed err   -> bale_out err
1068                   parse_result  -> bale_out empty
1069                         -- This last case can happen if the interface file is (say) empty
1070                         -- in which case the parser thinks it looks like an IdInfo or
1071                         -- something like that.  Just an artefact of the fact that the
1072                         -- parser is used for several purposes at once.
1073
1074         Left io_err -> bale_out (text (show io_err))
1075   where
1076     bale_out err = returnRn (Left (badIfaceFile file_path err))
1077 \end{code}
1078
1079 %*********************************************************
1080 %*                                                       *
1081 \subsection{Errors}
1082 %*                                                       *
1083 %*********************************************************
1084
1085 \begin{code}
1086 noIfaceErr mod_name boot_file
1087   = ptext SLIT("Could not find interface file for") <+> quotes (ppr mod_name)
1088         -- We used to print the search path, but we can't do that
1089         -- now, becuase it's hidden inside the finder.
1090         -- Maybe the finder should expose more functions.
1091
1092 badIfaceFile file err
1093   = vcat [ptext SLIT("Bad interface file:") <+> text file,
1094           nest 4 err]
1095
1096 getDeclErr name
1097   = vcat [ptext SLIT("Failed to find interface decl for") <+> quotes (ppr name),
1098           ptext SLIT("from module") <+> quotes (ppr (nameModule name))
1099          ]
1100
1101 importDeclWarn name
1102   = sep [ptext SLIT(
1103     "Compiler tried to import decl from interface file with same name as module."),
1104          ptext SLIT(
1105     "(possible cause: module name clashes with interface file already in scope.)")
1106         ] $$
1107     hsep [ptext SLIT("name:"), quotes (ppr name)]
1108
1109 warnRedundantSourceImport mod_name
1110   = ptext SLIT("Unnecessary {- SOURCE -} in the import of module")
1111           <+> quotes (ppr mod_name)
1112
1113 hiModuleNameMismatchWarn :: Module -> Module  -> Message
1114 hiModuleNameMismatchWarn requested_mod read_mod =
1115     hsep [ ptext SLIT("Something is amiss; requested module name")
1116          , ppr (moduleName requested_mod)
1117          , ptext SLIT("differs from name found in the interface file")
1118          , ppr read_mod
1119          ]
1120
1121 \end{code}