ghc/compiler/main/HscTypes.lhs

   1 %
   2 % (c) The University of Glasgow, 2000
   3 %
   4 \section[HscTypes]{Types for the per-module compiler}
   5
   6 \begin{code}
   7 module HscTypes (
   8         HscEnv(..),
   9         GhciMode(..),
  10
  11         ModDetails(..), ModIface(..),
  12         ModGuts(..), ModImports(..), ForeignStubs(..),
  13         ParsedIface(..), IfaceDeprecs,
  14
  15         HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
  16
  17         ExternalPackageState(..),
  18         PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
  19         lookupIface, lookupIfaceByModName, moduleNameToModule,
  20         emptyModIface,
  21
  22         InteractiveContext(..), emptyInteractiveContext, icPrintUnqual,
  23
  24         IfaceDecls, mkIfaceDecls, dcl_tycl, dcl_rules, dcl_insts,
  25
  26         VersionInfo(..), initialVersionInfo, lookupVersion,
  27         FixityEnv, lookupFixity, collectFixities, emptyFixityEnv,
  28
  29         TyThing(..), isTyClThing, implicitTyThingIds,
  30
  31         TypeEnv, lookupType, mkTypeEnv, emptyTypeEnv,
  32         extendTypeEnvList, extendTypeEnvWithIds,
  33         typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
  34
  35         ImportedModuleInfo, WhetherHasOrphans, ImportVersion, WhatsImported(..),
  36         IsBootInterface, DeclsMap,
  37         IfaceInsts, IfaceRules, GatedDecl, GatedDecls, GateFn,
  38         NameCache(..), OrigNameCache, OrigIParamCache,
  39         Avails, availsToNameSet, availName, availNames,
  40         GenAvailInfo(..), AvailInfo, RdrAvailInfo,
  41         ExportItem, RdrExportItem,
  42
  43         PersistentCompilerState(..),
  44
  45         Deprecations(..), lookupDeprec, plusDeprecs,
  46
  47         InstEnv, ClsInstEnv, DFunId,
  48         PackageInstEnv, PackageRuleBase,
  49
  50         GlobalRdrEnv, GlobalRdrElt(..), emptyGlobalRdrEnv, pprGlobalRdrEnv,
  51         LocalRdrEnv, extendLocalRdrEnv, isLocalGRE, unQualInScope,
  52
  53         -- Linker stuff
  54         Linkable(..), isObjectLinkable,
  55         Unlinked(..), CompiledByteCode,
  56         isObject, nameOfObject, isInterpretable, byteCodeOfObject,
  57
  58         -- Provenance
  59         Provenance(..), ImportReason(..),
  60         pprNameProvenance, hasBetterProv
  61
  62     ) where
  63
  64 #include "HsVersions.h"
  65
  66 #ifdef GHCI
  67 import ByteCodeAsm      ( CompiledByteCode )
  68 #endif
  69
  70 import RdrName          ( RdrName, mkRdrUnqual,
  71                           RdrNameEnv, addListToRdrEnv, foldRdrEnv, isUnqual,
  72                           rdrEnvToList, emptyRdrEnv )
  73 import Name             ( Name, NamedThing, getName, nameOccName, nameModule, nameSrcLoc )
  74 import NameEnv
  75 import NameSet
  76 import OccName          ( OccName )
  77 import Module
  78 import InstEnv          ( InstEnv, ClsInstEnv, DFunId )
  79 import Rules            ( RuleBase )
  80 import CoreSyn          ( CoreBind )
  81 import Id               ( Id )
  82 import Class            ( Class, classSelIds )
  83 import TyCon            ( TyCon, isNewTyCon, tyConGenIds, tyConSelIds, tyConDataCons_maybe )
  84 import Type             ( TyThing(..), isTyClThing )
  85 import DataCon          ( dataConWorkId, dataConWrapId )
  86 import Packages         ( PackageName, preludePackage )
  87 import CmdLineOpts      ( DynFlags )
  88
  89 import BasicTypes       ( Version, initialVersion, IPName,
  90                           Fixity, FixitySig(..), defaultFixity )
  91
  92 import HsSyn            ( DeprecTxt, TyClDecl, InstDecl, RuleDecl,
  93                           tyClDeclName, ifaceRuleDeclName, tyClDeclNames )
  94 import RnHsSyn          ( RenamedTyClDecl, RenamedRuleDecl, RenamedInstDecl )
  95
  96 import CoreSyn          ( IdCoreRule )
  97 import PrelNames        ( isBuiltInSyntaxName )
  98
  99 import FiniteMap
 100 import Bag              ( Bag )
 101 import Maybes           ( orElse )
 102 import Outputable
 103 import SrcLoc           ( SrcLoc, isGoodSrcLoc )
 104 import Util             ( thenCmp, sortLt )
 105 import UniqSupply       ( UniqSupply )
 106 import Maybe            ( fromJust )
 107 import FastString       ( FastString )
 108
 109 import Time             ( ClockTime )
 110 \end{code}
 111
 112
 113 %************************************************************************
 114 %*                                                                      *
 115 \subsection{Compilation environment}
 116 %*                                                                      *
 117 %************************************************************************
 118
 119 The HscEnv gives the environment in which to compile a chunk of code.
 120
 121 \begin{code}
 122 data HscEnv = HscEnv { hsc_mode   :: GhciMode,
 123                        hsc_dflags :: DynFlags,
 124                        hsc_HPT    :: HomePackageTable }
 125 \end{code}
 126
 127 The GhciMode is self-explanatory:
 128
 129 \begin{code}
 130 data GhciMode = Batch | Interactive | OneShot
 131               deriving Eq
 132 \end{code}
 133
 134 \begin{code}
 135 type HomePackageTable  = ModuleEnv HomeModInfo  -- Domain = modules in the home package
 136 type PackageIfaceTable = ModuleEnv ModIface     -- Domain = modules in the imported packages
 137
 138 emptyHomePackageTable  = emptyModuleEnv
 139 emptyPackageIfaceTable = emptyModuleEnv
 140
 141 data HomeModInfo = HomeModInfo { hm_iface    :: ModIface,
 142                                  hm_details  :: ModDetails,
 143                                  hm_linkable :: Linkable }
 144 \end{code}
 145
 146 Simple lookups in the symbol table.
 147
 148 \begin{code}
 149 lookupIface :: HomePackageTable -> PackageIfaceTable -> Name -> Maybe ModIface
 150 -- We often have two IfaceTables, and want to do a lookup
 151 lookupIface hpt pit name
 152   = case lookupModuleEnv hpt mod of
 153         Just mod_info -> Just (hm_iface mod_info)
 154         Nothing       -> lookupModuleEnv pit mod
 155   where
 156     mod = nameModule name
 157
 158 lookupIfaceByModName :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Maybe ModIface
 159 -- We often have two IfaceTables, and want to do a lookup
 160 lookupIfaceByModName hpt pit mod
 161   = case lookupModuleEnvByName hpt mod of
 162         Just mod_info -> Just (hm_iface mod_info)
 163         Nothing       -> lookupModuleEnvByName pit mod
 164 \end{code}
 165
 166 \begin{code}
 167 -- Use instead of Finder.findModule if possible: this way doesn't
 168 -- require filesystem operations, and it is guaranteed not to fail
 169 -- when the IfaceTables are properly populated (i.e. after the renamer).
 170 moduleNameToModule :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Module
 171 moduleNameToModule hpt pit mod
 172    = mi_module (fromJust (lookupIfaceByModName hpt pit mod))
 173 \end{code}
 174
 175
 176 %************************************************************************
 177 %*                                                                      *
 178 \subsection{Symbol tables and Module details}
 179 %*                                                                      *
 180 %************************************************************************
 181
 182 A @ModIface@ plus a @ModDetails@ summarises everything we know
 183 about a compiled module.  The @ModIface@ is the stuff *before* linking,
 184 and can be written out to an interface file.  (The @ModDetails@ is after
 185 linking; it is the "linked" form of the mi_decls field.)
 186
 187 When we *read* an interface file, we also construct a @ModIface@ from it,
 188 except that the mi_decls part is empty; when reading we consolidate
 189 the declarations into a single indexed map in the @PersistentRenamerState@.
 190
 191 \begin{code}
 192 data ModIface
 193    = ModIface {
 194         mi_module   :: !Module,
 195         mi_package  :: !PackageName,        -- Which package the module comes from
 196         mi_version  :: !VersionInfo,        -- Module version number
 197         mi_orphan   :: !WhetherHasOrphans,  -- Whether this module has orphans
 198         mi_boot     :: !IsBootInterface,    -- Read from an hi-boot file?
 199
 200         mi_usages   :: [ImportVersion Name],
 201                 -- Usages; kept sorted so that it's easy to decide
 202                 -- whether to write a new iface file (changing usages
 203                 -- doesn't affect the version of this module)
 204                 -- NOT STRICT!  we read this field lazily from the interface file
 205
 206         mi_exports  :: ![ExportItem],
 207                 -- What it exports Kept sorted by (mod,occ), to make
 208                 -- version comparisons easier
 209
 210         mi_globals  :: !(Maybe GlobalRdrEnv),
 211                 -- Its top level environment or Nothing if we read this
 212                 -- interface from an interface file.  (We need the source
 213                 -- file to figure out the top-level environment.)
 214
 215         mi_fixities :: !FixityEnv,          -- Fixities
 216         mi_deprecs  :: Deprecations,        -- Deprecations
 217                 -- NOT STRICT!  we read this field lazilly from the interface file
 218
 219         mi_decls    :: IfaceDecls           -- The RnDecls form of ModDetails
 220                 -- NOT STRICT!  we fill this field with _|_ sometimes
 221      }
 222
 223 -- Should be able to construct ModDetails from mi_decls in ModIface
 224 data ModDetails
 225    = ModDetails {
 226         -- The next three fields are created by the typechecker
 227         md_types    :: !TypeEnv,
 228         md_insts    :: ![DFunId],       -- Dfun-ids for the instances in this module
 229         md_rules    :: ![IdCoreRule]    -- Domain may include Ids from other modules
 230      }
 231
 232
 233
 234 -- A ModGuts is carried through the compiler, accumulating stuff as it goes
 235 -- There is only one ModGuts at any time, the one for the module
 236 -- being compiled right now.  Once it is compiled, a ModIface and
 237 -- ModDetails are extracted and the ModGuts is dicarded.
 238
 239 data ModGuts
 240   = ModGuts {
 241         mg_module   :: !Module,
 242         mg_exports  :: !Avails,                 -- What it exports
 243         mg_usages   :: ![ImportVersion Name],   -- What it imports, directly or otherwise
 244                                                 -- ...exactly as in ModIface
 245         mg_dir_imps :: ![Module],               -- Directly imported modules
 246
 247         mg_rdr_env  :: !GlobalRdrEnv,   -- Top-level lexical environment
 248         mg_fix_env  :: !FixityEnv,      -- Fixity env, for things declared in this module
 249         mg_deprecs  :: !Deprecations,   -- Deprecations declared in the module
 250
 251         mg_types    :: !TypeEnv,
 252         mg_insts    :: ![DFunId],       -- Instances
 253         mg_rules    :: ![IdCoreRule],   -- Rules from this module
 254         mg_binds    :: ![CoreBind],     -- Bindings for this module
 255         mg_foreign  :: !ForeignStubs
 256     }
 257
 258 -- The ModGuts takes on several slightly different forms:
 259 --
 260 -- After simplification, the following fields change slightly:
 261 --      mg_rules        Orphan rules only (local ones now attached to binds)
 262 --      mg_binds        With rules attached
 263 --
 264 -- After CoreTidy, the following fields change slightly:
 265 --      mg_types        Now contains Ids as well, replete with final IdInfo
 266 --                         The Ids are only the ones that are visible from
 267 --                         importing modules.  Without -O that means only
 268 --                         exported Ids, but with -O importing modules may
 269 --                         see ids mentioned in unfoldings of exported Ids
 270 --
 271 --      mg_insts        Same DFunIds as before, but with final IdInfo,
 272 --                         and the unique might have changed; remember that
 273 --                         CoreTidy links up the uniques of old and new versions
 274 --
 275 --      mg_rules        All rules for exported things, substituted with final Ids
 276 --
 277 --      mg_binds        Tidied
 278
 279
 280
 281 data ModImports
 282   = ModImports {
 283         imp_direct     :: ![(Module,Bool)],     -- Explicitly-imported modules
 284                                                 -- Boolean is true if we imported the whole
 285                                                 --      module (apart, perhaps, from hiding some)
 286         imp_pkg_mods   :: !ModuleSet,           -- Non-home-package modules on which we depend,
 287                                                 --      directly or indirectly
 288         imp_home_names :: !NameSet              -- Home package things on which we depend,
 289                                                 --      directly or indirectly
 290     }
 291
 292 data ForeignStubs = NoStubs
 293                   | ForeignStubs
 294                         SDoc            -- Header file prototypes for
 295                                         --      "foreign exported" functions
 296                         SDoc            -- C stubs to use when calling
 297                                         --      "foreign exported" functions
 298                         [FastString]    -- Headers that need to be included
 299                                         --      into C code generated for this module
 300                         [Id]            -- Foreign-exported binders
 301                                         --      we have to generate code to register these
 302
 303
 304 data IfaceDecls = IfaceDecls { dcl_tycl  :: [RenamedTyClDecl],  -- Sorted
 305                                dcl_rules :: [RenamedRuleDecl],  -- Sorted
 306                                dcl_insts :: [RenamedInstDecl] } -- Unsorted
 307
 308 mkIfaceDecls :: [RenamedTyClDecl] -> [RenamedRuleDecl] -> [RenamedInstDecl] -> IfaceDecls
 309 mkIfaceDecls tycls rules insts
 310   = IfaceDecls { dcl_tycl  = sortLt lt_tycl tycls,
 311                  dcl_rules = sortLt lt_rule rules,
 312                  dcl_insts = insts }
 313   where
 314     d1 `lt_tycl` d2 = tyClDeclName      d1 < tyClDeclName      d2
 315     r1 `lt_rule` r2 = ifaceRuleDeclName r1 < ifaceRuleDeclName r2
 316 \end{code}
 317
 318 \begin{code}
 319 emptyModIface :: Module -> ModIface
 320 emptyModIface mod
 321   = ModIface { mi_module   = mod,
 322                mi_package  = preludePackage, -- XXX fully bogus
 323                mi_version  = initialVersionInfo,
 324                mi_usages   = [],
 325                mi_orphan   = False,
 326                mi_boot     = False,
 327                mi_exports  = [],
 328                mi_fixities = emptyNameEnv,
 329                mi_globals  = Nothing,
 330                mi_deprecs  = NoDeprecs,
 331                mi_decls    = panic "emptyModIface: decls"
 332     }
 333 \end{code}
 334
 335
 336 %************************************************************************
 337 %*                                                                      *
 338                 Parsed interface files
 339 %*                                                                      *
 340 %************************************************************************
 341
 342 A ParsedIface is exactly as read from an interface file.
 343
 344 \begin{code}
 345 type IfaceDeprecs = Maybe (Either DeprecTxt [(RdrName,DeprecTxt)])
 346         -- Nothing        => NoDeprecs
 347         -- Just (Left t)  => DeprecAll
 348         -- Just (Right p) => DeprecSome
 349
 350 data ParsedIface
 351   = ParsedIface {
 352       pi_mod       :: ModuleName,
 353       pi_pkg       :: PackageName,
 354       pi_vers      :: Version,                          -- Module version number
 355       pi_orphan    :: WhetherHasOrphans,                -- Whether this module has orphans
 356       pi_usages    :: [ImportVersion OccName],          -- Usages
 357       pi_exports   :: (Version, [RdrExportItem]),       -- Exports
 358       pi_decls     :: [(Version, TyClDecl RdrName)],    -- Local definitions
 359       pi_fixity    :: [FixitySig RdrName],              -- Local fixity declarations,
 360       pi_insts     :: [InstDecl RdrName],               -- Local instance declarations
 361       pi_rules     :: (Version, [RuleDecl RdrName]),    -- Rules, with their version
 362       pi_deprecs   :: IfaceDeprecs                      -- Deprecations
 363     }
 364 \end{code}
 365
 366
 367 %************************************************************************
 368 %*                                                                      *
 369 \subsection{The interactive context}
 370 %*                                                                      *
 371 %************************************************************************
 372
 373 \begin{code}
 374 data InteractiveContext
 375   = InteractiveContext {
 376         ic_toplev_scope :: [Module],    -- Include the "top-level" scope of
 377                                         -- these modules
 378
 379         ic_exports :: [Module],         -- Include just the exports of these
 380                                         -- modules
 381
 382         ic_rn_gbl_env :: GlobalRdrEnv,  -- The cached GlobalRdrEnv, built from
 383                                         -- ic_toplev_scope and ic_exports
 384
 385         ic_rn_local_env :: LocalRdrEnv, -- Lexical context for variables bound
 386                                         -- during interaction
 387
 388         ic_type_env :: TypeEnv          -- Ditto for types
 389     }
 390
 391 emptyInteractiveContext
 392   = InteractiveContext { ic_toplev_scope = [],
 393                          ic_exports = [],
 394                          ic_rn_gbl_env = emptyRdrEnv,
 395                          ic_rn_local_env = emptyRdrEnv,
 396                          ic_type_env = emptyTypeEnv }
 397
 398 icPrintUnqual :: InteractiveContext -> PrintUnqualified
 399 icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt)
 400 \end{code}
 401
 402
 403 %************************************************************************
 404 %*                                                                      *
 405 \subsection{Type environment stuff}
 406 %*                                                                      *
 407 %************************************************************************
 408
 409 \begin{code}
 410 typeEnvElts    :: TypeEnv -> [TyThing]
 411 typeEnvClasses :: TypeEnv -> [Class]
 412 typeEnvTyCons  :: TypeEnv -> [TyCon]
 413 typeEnvIds     :: TypeEnv -> [Id]
 414
 415 typeEnvElts    env = nameEnvElts env
 416 typeEnvClasses env = [cl | AClass cl <- typeEnvElts env]
 417 typeEnvTyCons  env = [tc | ATyCon tc <- typeEnvElts env]
 418 typeEnvIds     env = [id | AnId id   <- typeEnvElts env]
 419
 420 implicitTyThingIds :: [TyThing] -> [Id]
 421 -- Add the implicit data cons and selectors etc
 422 implicitTyThingIds things
 423   = concat (map go things)
 424   where
 425     go (AnId f)    = []
 426     go (AClass cl) = classSelIds cl
 427     go (ATyCon tc) = tyConGenIds tc ++
 428                      tyConSelIds tc ++
 429                      [ n | dc <- tyConDataCons_maybe tc `orElse` [],
 430                            n  <- implicitConIds tc dc]
 431                 -- Synonyms return empty list of constructors and selectors
 432
 433     implicitConIds tc dc        -- Newtypes have a constructor wrapper,
 434                                 -- but no worker
 435         | isNewTyCon tc = [dataConWrapId dc]
 436         | otherwise     = [dataConWorkId dc, dataConWrapId dc]
 437 \end{code}
 438
 439
 440 \begin{code}
 441 type TypeEnv = NameEnv TyThing
 442
 443 emptyTypeEnv = emptyNameEnv
 444
 445 mkTypeEnv :: [TyThing] -> TypeEnv
 446 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
 447
 448 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
 449 extendTypeEnvList env things
 450   = extendNameEnvList env [(getName thing, thing) | thing <- things]
 451
 452 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
 453 extendTypeEnvWithIds env ids
 454   = extendNameEnvList env [(getName id, AnId id) | id <- ids]
 455 \end{code}
 456
 457 \begin{code}
 458 lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
 459 lookupType hpt pte name
 460   = case lookupModuleEnv hpt (nameModule name) of
 461         Just details -> lookupNameEnv (md_types (hm_details details)) name
 462         Nothing      -> lookupNameEnv pte name
 463 \end{code}
 464
 465 %************************************************************************
 466 %*                                                                      *
 467 \subsection{Auxiliary types}
 468 %*                                                                      *
 469 %************************************************************************
 470
 471 These types are defined here because they are mentioned in ModDetails,
 472 but they are mostly elaborated elsewhere
 473
 474 \begin{code}
 475 data VersionInfo
 476   = VersionInfo {
 477         vers_module  :: Version,        -- Changes when anything changes
 478         vers_exports :: Version,        -- Changes when export list changes
 479         vers_rules   :: Version,        -- Changes when any rule changes
 480         vers_decls   :: NameEnv Version
 481                 -- Versions for "big" names only (not data constructors, class ops)
 482                 -- The version of an Id changes if its fixity changes
 483                 -- Ditto data constructors, class operations, except that the version of
 484                 -- the parent class/tycon changes
 485                 --
 486                 -- If a name isn't in the map, it means 'initialVersion'
 487     }
 488
 489 initialVersionInfo :: VersionInfo
 490 initialVersionInfo = VersionInfo { vers_module  = initialVersion,
 491                                    vers_exports = initialVersion,
 492                                    vers_rules   = initialVersion,
 493                                    vers_decls   = emptyNameEnv
 494                         }
 495
 496 lookupVersion :: NameEnv Version -> Name -> Version
 497 lookupVersion env name = lookupNameEnv env name `orElse` initialVersion
 498
 499 data Deprecations = NoDeprecs
 500                   | DeprecAll DeprecTxt                         -- Whole module deprecated
 501                   | DeprecSome (NameEnv (Name,DeprecTxt))       -- Some things deprecated
 502                                                                 -- Just "big" names
 503                 -- We keep the Name in the range, so we can print them out
 504
 505 lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt
 506 lookupDeprec NoDeprecs        name = Nothing
 507 lookupDeprec (DeprecAll  txt) name = Just txt
 508 lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of
 509                                             Just (_, txt) -> Just txt
 510                                             Nothing       -> Nothing
 511
 512 plusDeprecs :: Deprecations -> Deprecations -> Deprecations
 513 plusDeprecs d NoDeprecs = d
 514 plusDeprecs NoDeprecs d = d
 515 plusDeprecs d (DeprecAll t) = DeprecAll t
 516 plusDeprecs (DeprecAll t) d = DeprecAll t
 517 plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
 518
 519 instance Eq Deprecations where
 520   -- Used when checking whether we need write a new interface
 521   NoDeprecs       == NoDeprecs       = True
 522   (DeprecAll t1)  == (DeprecAll t2)  = t1 == t2
 523   (DeprecSome e1) == (DeprecSome e2) = nameEnvElts e1 == nameEnvElts e2
 524   d1              == d2              = False
 525 \end{code}
 526
 527
 528 \begin{code}
 529 type Avails       = [AvailInfo]
 530 type AvailInfo    = GenAvailInfo Name
 531 type RdrAvailInfo = GenAvailInfo OccName
 532
 533 data GenAvailInfo name  = Avail name     -- An ordinary identifier
 534                         | AvailTC name   -- The name of the type or class
 535                                   [name] -- The available pieces of type/class.
 536                                          -- NB: If the type or class is itself
 537                                          -- to be in scope, it must be in this list.
 538                                          -- Thus, typically: AvailTC Eq [Eq, ==, /=]
 539                         deriving( Eq )
 540                         -- Equality used when deciding if the interface has changed
 541
 542 type RdrExportItem = (ModuleName, [RdrAvailInfo])
 543 type ExportItem    = (ModuleName, [AvailInfo])
 544
 545 availsToNameSet :: [AvailInfo] -> NameSet
 546 availsToNameSet avails = foldl add emptyNameSet avails
 547                        where
 548                          add set avail = addListToNameSet set (availNames avail)
 549
 550 availName :: GenAvailInfo name -> name
 551 availName (Avail n)     = n
 552 availName (AvailTC n _) = n
 553
 554 availNames :: GenAvailInfo name -> [name]
 555 availNames (Avail n)      = [n]
 556 availNames (AvailTC n ns) = ns
 557
 558 instance Outputable n => Outputable (GenAvailInfo n) where
 559    ppr = pprAvail
 560
 561 pprAvail :: Outputable n => GenAvailInfo n -> SDoc
 562 pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of
 563                                         []  -> empty
 564                                         ns' -> braces (hsep (punctuate comma (map ppr ns')))
 565
 566 pprAvail (Avail n) = ppr n
 567 \end{code}
 568
 569 \begin{code}
 570 type FixityEnv = NameEnv (FixitySig Name)
 571         -- We keep the whole fixity sig so that we
 572         -- can report line-number info when there is a duplicate
 573         -- fixity declaration
 574
 575 emptyFixityEnv :: FixityEnv
 576 emptyFixityEnv = emptyNameEnv
 577
 578 lookupFixity :: FixityEnv -> Name -> Fixity
 579 lookupFixity env n = case lookupNameEnv env n of
 580                         Just (FixitySig _ fix _) -> fix
 581                         Nothing                  -> defaultFixity
 582
 583 collectFixities :: FixityEnv -> [TyClDecl Name] -> [FixitySig Name]
 584 -- Collect fixities for the specified declarations
 585 collectFixities env decls
 586   = [ fix
 587     | d <- decls, (n,_) <- tyClDeclNames d,
 588       Just fix <- [lookupNameEnv env n]
 589     ]
 590 \end{code}
 591
 592
 593 %************************************************************************
 594 %*                                                                      *
 595 \subsection{WhatsImported}
 596 %*                                                                      *
 597 %************************************************************************
 598
 599 \begin{code}
 600 type WhetherHasOrphans   = Bool
 601         -- An "orphan" is
 602         --      * an instance decl in a module other than the defn module for
 603         --              one of the tycons or classes in the instance head
 604         --      * a transformation rule in a module other than the one defining
 605         --              the function in the head of the rule.
 606
 607 type IsBootInterface     = Bool
 608
 609 type ImportVersion name  = (ModuleName, WhetherHasOrphans, IsBootInterface, WhatsImported name)
 610
 611 data WhatsImported name  = NothingAtAll                 -- The module is below us in the
 612                                                         -- hierarchy, but we import nothing
 613                                                         -- Used for orphan modules, so they appear
 614                                                         -- in the usage list
 615
 616                          | Everything Version           -- Used for modules from other packages;
 617                                                         -- we record only the module's version number
 618
 619                          | Specifically
 620                                 Version                 -- Module version
 621                                 (Maybe Version)         -- Export-list version, if we depend on it
 622                                 [(name,Version)]        -- List guaranteed non-empty
 623                                 Version                 -- Rules version
 624
 625                          deriving( Eq )
 626         -- 'Specifically' doesn't let you say "I imported f but none of the rules in
 627         -- the module". If you use anything in the module you get its rule version
 628         -- So if the rules change, you'll recompile, even if you don't use them.
 629         -- This is easy to implement, and it's safer: you might not have used the rules last
 630         -- time round, but if someone has added a new rule you might need it this time
 631
 632         -- The export list field is (Just v) if we depend on the export list:
 633         --      we imported the module without saying exactly what we imported
 634         -- We need to recompile if the module exports changes, because we might
 635         -- now have a name clash in the importing module.
 636 \end{code}
 637
 638
 639 %************************************************************************
 640 %*                                                                      *
 641 \subsection{The persistent compiler state}
 642 %*                                                                      *
 643 %************************************************************************
 644
 645 The @PersistentCompilerState@ persists across successive calls to the
 646 compiler.
 647
 648 \begin{code}
 649 data PersistentCompilerState
 650    = PCS {
 651         pcs_nc  :: !NameCache,
 652         pcs_EPS :: !ExternalPackageState
 653      }
 654 \end{code}
 655
 656
 657 \begin{code}
 658 type PackageTypeEnv  = TypeEnv
 659 type PackageRuleBase = RuleBase
 660 type PackageInstEnv  = InstEnv
 661
 662 data ExternalPackageState
 663   = EPS {
 664         eps_PIT :: !PackageIfaceTable,
 665                 -- The ModuleIFaces for modules in external packages
 666                 -- whose interfaces we have opened
 667                 -- The declarations in these interface files are held in
 668                 -- eps_decls, eps_insts, eps_rules (below), not in the
 669                 -- mi_decls fields of the iPIT.
 670                 -- What _is_ in the iPIT is:
 671                 --      * The Module
 672                 --      * Version info
 673                 --      * Its exports
 674                 --      * Fixities
 675                 --      * Deprecations
 676
 677         eps_imp_mods :: !ImportedModuleInfo,
 678                 -- Modules that we know something about, because they are mentioned
 679                 -- in interface files, BUT which we have not loaded yet.
 680                 -- No module is both in here and in the PIT
 681
 682         eps_PTE :: !PackageTypeEnv,             -- Domain = external-package modules
 683
 684         eps_inst_env :: !PackageInstEnv,        -- The total InstEnv accumulated from
 685                                                 --   all the external-package modules
 686         eps_rule_base :: !PackageRuleBase,      -- Ditto RuleEnv
 687
 688
 689         -- Holding pens for stuff that has been read in from file,
 690         -- but not yet slurped into the renamer
 691         eps_decls      :: !DeclsMap,
 692                 -- A single, global map of Names to unslurped decls
 693         eps_insts      :: !IfaceInsts,
 694                 -- The as-yet un-slurped instance decls; this bag is depleted when we
 695                 -- slurp an instance decl so that we don't slurp the same one twice.
 696                 -- Each is 'gated' by the names that must be available before
 697                 -- this instance decl is needed.
 698         eps_rules      :: !IfaceRules,
 699                 -- Similar to instance decls, only for rules
 700
 701         eps_inst_gates :: !NameSet      -- Gates for instance decls
 702                 -- The instance gates must accumulate across
 703                 -- all invocations of the renamer;
 704                 -- see "the gating story" in RnIfaces.lhs
 705                 -- These names should all be from other packages;
 706                 -- for the home package we have all the instance
 707                 -- declarations anyhow
 708   }
 709 \end{code}
 710
 711 The NameCache makes sure that there is just one Unique assigned for
 712 each original name; i.e. (module-name, occ-name) pair.  The Name is
 713 always stored as a Global, and has the SrcLoc of its binding location.
 714 Actually that's not quite right.  When we first encounter the original
 715 name, we might not be at its binding site (e.g. we are reading an
 716 interface file); so we give it 'noSrcLoc' then.  Later, when we find
 717 its binding site, we fix it up.
 718
 719 Exactly the same is true of the Module stored in the Name.  When we first
 720 encounter the occurrence, we may not know the details of the module, so
 721 we just store junk.  Then when we find the binding site, we fix it up.
 722
 723 \begin{code}
 724 data NameCache
 725  = NameCache {  nsUniqs :: UniqSupply,
 726                 -- Supply of uniques
 727                 nsNames :: OrigNameCache,
 728                 -- Ensures that one original name gets one unique
 729                 nsIPs   :: OrigIParamCache
 730                 -- Ensures that one implicit parameter name gets one unique
 731    }
 732
 733 type OrigNameCache   = FiniteMap (ModuleName,OccName) Name
 734 type OrigIParamCache = FiniteMap (IPName RdrName) (IPName Name)
 735 \end{code}
 736
 737 @ImportedModuleInfo@ contains info ONLY about modules that have not yet
 738 been loaded into the iPIT.  These modules are mentioned in interfaces we've
 739 already read, so we know a tiny bit about them, but we havn't yet looked
 740 at the interface file for the module itself.  It needs to persist across
 741 invocations of the renamer, at least from Rename.checkOldIface to Rename.renameSource.
 742 And there's no harm in it persisting across multiple compilations.
 743
 744 \begin{code}
 745 type ImportedModuleInfo
 746     = FiniteMap ModuleName (WhetherHasOrphans, IsBootInterface)
 747 \end{code}
 748
 749 A DeclsMap contains a binding for each Name in the declaration
 750 including the constructors of a type decl etc.  The Bool is True just
 751 for the 'main' Name.
 752
 753 \begin{code}
 754 type DeclsMap = (NameEnv (AvailInfo, Bool, (Module, TyClDecl RdrName)), Int)
 755                                                 -- The Int says how many have been sucked in
 756
 757 type IfaceInsts = GatedDecls (InstDecl RdrName)
 758 type IfaceRules = GatedDecls (RuleDecl RdrName)
 759
 760 type GatedDecls d = (Bag (GatedDecl d), Int)    -- The Int says how many have been sucked in
 761 type GatedDecl  d = (GateFn, (Module, d))
 762 type GateFn       = (Name -> Bool) -> Bool      -- Returns True <=> gate is open
 763                                                 -- The (Name -> Bool) fn returns True for visible Names
 764         -- For example, suppose this is in an interface file
 765         --      instance C T where ...
 766         -- We want to slurp this decl if both C and T are "visible" in
 767         -- the importing module.  See "The gating story" in RnIfaces for details.
 768 \end{code}
 769
 770
 771 %************************************************************************
 772 %*                                                                      *
 773 \subsection{Linkable stuff}
 774 %*                                                                      *
 775 %************************************************************************
 776
 777 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
 778 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
 779
 780 \begin{code}
 781 data Linkable = LM {
 782   linkableTime     :: ClockTime,        -- Time at which this linkable was built
 783                                         -- (i.e. when the bytecodes were produced,
 784                                         --       or the mod date on the files)
 785   linkableModName  :: ModuleName,       -- Should be Module, but see below
 786   linkableUnlinked :: [Unlinked]
 787  }
 788
 789 isObjectLinkable :: Linkable -> Bool
 790 isObjectLinkable l = all isObject (linkableUnlinked l)
 791
 792 instance Outputable Linkable where
 793    ppr (LM when_made mod unlinkeds)
 794       = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
 795         $$ nest 3 (ppr unlinkeds)
 796
 797 -------------------------------------------
 798 data Unlinked
 799    = DotO FilePath
 800    | DotA FilePath
 801    | DotDLL FilePath
 802    | BCOs CompiledByteCode
 803
 804 #ifndef GHCI
 805 data CompiledByteCode = NoByteCode
 806 #endif
 807
 808 instance Outputable Unlinked where
 809    ppr (DotO path)   = text "DotO" <+> text path
 810    ppr (DotA path)   = text "DotA" <+> text path
 811    ppr (DotDLL path) = text "DotDLL" <+> text path
 812 #ifdef GHCI
 813    ppr (BCOs bcos)   = text "BCOs" <+> ppr bcos
 814 #else
 815    ppr (BCOs bcos)   = text "No byte code"
 816 #endif
 817
 818 isObject (DotO _)   = True
 819 isObject (DotA _)   = True
 820 isObject (DotDLL _) = True
 821 isObject _          = False
 822
 823 isInterpretable = not . isObject
 824
 825 nameOfObject (DotO fn)   = fn
 826 nameOfObject (DotA fn)   = fn
 827 nameOfObject (DotDLL fn) = fn
 828
 829 byteCodeOfObject (BCOs bc) = bc
 830 \end{code}
 831
 832
 833 %************************************************************************
 834 %*                                                                      *
 835 \subsection{Provenance and export info}
 836 %*                                                                      *
 837 %************************************************************************
 838
 839 A LocalRdrEnv is used for local bindings (let, where, lambda, case)
 840 Also used in
 841
 842 \begin{code}
 843 type LocalRdrEnv = RdrNameEnv Name
 844
 845 extendLocalRdrEnv :: LocalRdrEnv -> [Name] -> LocalRdrEnv
 846 extendLocalRdrEnv env names
 847   = addListToRdrEnv env [(mkRdrUnqual (nameOccName n), n) | n <- names]
 848 \end{code}
 849
 850 The GlobalRdrEnv gives maps RdrNames to Names.  There is a separate
 851 one for each module, corresponding to that module's top-level scope.
 852
 853 \begin{code}
 854 type GlobalRdrEnv = RdrNameEnv [GlobalRdrElt]
 855         -- The list is because there may be name clashes
 856         -- These only get reported on lookup, not on construction
 857
 858 emptyGlobalRdrEnv = emptyRdrEnv
 859
 860 data GlobalRdrElt
 861   = GRE { gre_name   :: Name,
 862           gre_parent :: Name,   -- Name of the "parent" structure
 863                                 --      * the tycon of a data con
 864                                 --      * the class of a class op
 865                                 -- For others it's just the same as gre_name
 866           gre_prov   :: Provenance,             -- Why it's in scope
 867           gre_deprec :: Maybe DeprecTxt         -- Whether this name is deprecated
 868     }
 869
 870 instance Outputable GlobalRdrElt where
 871   ppr gre = ppr (gre_name gre) <+>
 872             parens (hsep [text "parent:" <+> ppr (gre_parent gre) <> comma,
 873                           pprNameProvenance gre])
 874 pprGlobalRdrEnv env
 875   = vcat (map pp (rdrEnvToList env))
 876   where
 877     pp (rn, gres) = ppr rn <> colon <+>
 878                     vcat [ ppr (gre_name gre) <+> pprNameProvenance gre
 879                          | gre <- gres]
 880
 881 isLocalGRE :: GlobalRdrElt -> Bool
 882 isLocalGRE (GRE {gre_prov = LocalDef}) = True
 883 isLocalGRE other                       = False
 884 \end{code}
 885
 886 @unQualInScope@ returns a function that takes a @Name@ and tells whether
 887 its unqualified name is in scope.  This is put as a boolean flag in
 888 the @Name@'s provenance to guide whether or not to print the name qualified
 889 in error messages.
 890
 891 \begin{code}
 892 unQualInScope :: GlobalRdrEnv -> Name -> Bool
 893 -- True if 'f' is in scope, and has only one binding,
 894 -- and the thing it is bound to is the name we are looking for
 895 -- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
 896 --
 897 -- Also checks for built-in syntax, which is always 'in scope'
 898 --
 899 -- This fn is only efficient if the shared
 900 -- partial application is used a lot.
 901 unQualInScope env
 902   = \n -> n `elemNameSet` unqual_names || isBuiltInSyntaxName n
 903   where
 904     unqual_names :: NameSet
 905     unqual_names = foldRdrEnv add emptyNameSet env
 906     add rdr_name [gre] unquals | isUnqual rdr_name = addOneToNameSet unquals (gre_name gre)
 907     add _        _     unquals                     = unquals
 908 \end{code}
 909
 910 The "provenance" of something says how it came to be in scope.
 911
 912 \begin{code}
 913 data Provenance
 914   = LocalDef                    -- Defined locally
 915
 916   | NonLocalDef                 -- Defined non-locally
 917         ImportReason
 918
 919 -- Just used for grouping error messages (in RnEnv.warnUnusedBinds)
 920 instance Eq Provenance where
 921   p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
 922
 923 instance Eq ImportReason where
 924   p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
 925
 926 instance Ord Provenance where
 927    compare LocalDef LocalDef = EQ
 928    compare LocalDef (NonLocalDef _) = LT
 929    compare (NonLocalDef _) LocalDef = GT
 930
 931    compare (NonLocalDef reason1) (NonLocalDef reason2)
 932       = compare reason1 reason2
 933
 934 instance Ord ImportReason where
 935    compare ImplicitImport ImplicitImport = EQ
 936    compare ImplicitImport (UserImport _ _ _) = LT
 937    compare (UserImport _ _ _) ImplicitImport = GT
 938    compare (UserImport m1 loc1 _) (UserImport m2 loc2 _)
 939       = (m1 `compare` m2) `thenCmp` (loc1 `compare` loc2)
 940
 941
 942 data ImportReason
 943   = UserImport Module SrcLoc Bool       -- Imported from module M on line L
 944                                         -- Note the M may well not be the defining module
 945                                         -- for this thing!
 946         -- The Bool is true iff the thing was named *explicitly* in the import spec,
 947         -- rather than being imported as part of a group; e.g.
 948         --      import B
 949         --      import C( T(..) )
 950         -- Here, everything imported by B, and the constructors of T
 951         -- are not named explicitly; only T is named explicitly.
 952         -- This info is used when warning of unused names.
 953
 954   | ImplicitImport                      -- Imported implicitly for some other reason
 955 \end{code}
 956
 957 \begin{code}
 958 hasBetterProv :: Provenance -> Provenance -> Bool
 959 -- Choose
 960 --      a local thing                 over an   imported thing
 961 --      a user-imported thing         over a    non-user-imported thing
 962 --      an explicitly-imported thing  over an   implicitly imported thing
 963 hasBetterProv LocalDef                            _                            = True
 964 hasBetterProv (NonLocalDef (UserImport _ _ _   )) (NonLocalDef ImplicitImport) = True
 965 hasBetterProv _                                   _                            = False
 966
 967 pprNameProvenance :: GlobalRdrElt -> SDoc
 968 pprNameProvenance (GRE {gre_name = name, gre_prov = prov})
 969   = case prov of
 970         LocalDef        -> ptext SLIT("defined at") <+> ppr (nameSrcLoc name)
 971         NonLocalDef why ->  sep [ppr_reason why,
 972                                  nest 2 (ppr_defn (nameSrcLoc name))]
 973
 974 ppr_reason ImplicitImport         = ptext SLIT("implicitly imported")
 975 ppr_reason (UserImport mod loc _) = ptext SLIT("imported from") <+> ppr mod <+> ptext SLIT("at") <+> ppr loc
 976
 977 ppr_defn loc | isGoodSrcLoc loc = parens (ptext SLIT("at") <+> ppr loc)
 978              | otherwise        = empty
 979 \end{code}