ghc/compiler/rename/RnIfaces.lhs

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