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