compiler/main/HscTypes.lhs

   1 %
   2 % (c) The University of Glasgow, 2006
   3 %
   4 \section[HscTypes]{Types for the per-module compiler}
   5
   6 \begin{code}
   7 module HscTypes (
   8         -- * Sessions and compilation state
   9         Session(..), HscEnv(..), hscEPS,
  10         FinderCache, FindResult(..), ModLocationCache,
  11         Target(..), TargetId(..), pprTarget, pprTargetId,
  12         ModuleGraph, emptyMG,
  13
  14         ModDetails(..), emptyModDetails,
  15         ModGuts(..), CgGuts(..), ModImports(..), ForeignStubs(..),
  16
  17         ModSummary(..), showModMsg, isBootSummary,
  18         msHsFilePath, msHiFilePath, msObjFilePath,
  19
  20         HscSource(..), isHsBoot, hscSourceString,       -- Re-exported from DriverPhases
  21
  22         HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
  23         hptInstances, hptRules,
  24
  25         ExternalPackageState(..), EpsStats(..), addEpsInStats,
  26         PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
  27         lookupIfaceByModule, emptyModIface,
  28
  29         InteractiveContext(..), emptyInteractiveContext,
  30         icPrintUnqual, mkPrintUnqualified,
  31
  32         ModIface(..), mkIfaceDepCache, mkIfaceVerCache, mkIfaceFixCache,
  33         emptyIfaceDepCache,
  34
  35         Deprecs(..), IfaceDeprecs,
  36
  37         FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,
  38
  39         implicitTyThings, isImplicitTyThing,
  40
  41         TyThing(..), tyThingClass, tyThingTyCon, tyThingDataCon, tyThingId,
  42         TypeEnv, lookupType, mkTypeEnv, emptyTypeEnv,
  43         extendTypeEnv, extendTypeEnvList, extendTypeEnvWithIds, lookupTypeEnv,
  44         typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
  45         typeEnvDataCons,
  46
  47         WhetherHasOrphans, IsBootInterface, Usage(..),
  48         Dependencies(..), noDependencies,
  49         NameCache(..), OrigNameCache, OrigIParamCache,
  50         Avails, availsToNameSet, availsToNameEnv, availName, availNames,
  51         GenAvailInfo(..), AvailInfo, RdrAvailInfo,
  52         IfaceExport,
  53
  54         Deprecations, DeprecTxt, plusDeprecs,
  55
  56         PackageInstEnv, PackageRuleBase,
  57
  58         -- Linker stuff
  59         Linkable(..), isObjectLinkable,
  60         Unlinked(..), CompiledByteCode,
  61         isObject, nameOfObject, isInterpretable, byteCodeOfObject,
  62         HpcInfo, noHpcInfo,
  63
  64         -- Breakpoints
  65         ModBreaks (..), BreakIndex, emptyModBreaks
  66     ) where
  67
  68 #include "HsVersions.h"
  69
  70 #ifdef GHCI
  71 import ByteCodeAsm      ( CompiledByteCode )
  72 #endif
  73
  74 import RdrName          ( GlobalRdrEnv, emptyGlobalRdrEnv,
  75                           LocalRdrEnv, emptyLocalRdrEnv, GlobalRdrElt(..),
  76                           unQualOK, ImpDeclSpec(..), Provenance(..),
  77                           ImportSpec(..), lookupGlobalRdrEnv )
  78 import Name             ( Name, NamedThing, getName, nameOccName, nameModule )
  79 import NameEnv
  80 import NameSet
  81 import OccName          ( OccName, OccEnv, lookupOccEnv, mkOccEnv, emptyOccEnv,
  82                           extendOccEnv )
  83 import Module
  84 import InstEnv          ( InstEnv, Instance )
  85 import FamInstEnv       ( FamInstEnv, FamInst )
  86 import Rules            ( RuleBase )
  87 import CoreSyn          ( CoreBind )
  88 import VarSet
  89 import Id               ( Id, isImplicitId )
  90 import Type             ( TyThing(..) )
  91
  92 import Class            ( Class, classSelIds, classATs, classTyCon )
  93 import TyCon
  94 import DataCon          ( DataCon, dataConImplicitIds )
  95 import PrelNames        ( gHC_PRIM )
  96 import Packages         ( PackageId )
  97 import DynFlags         ( DynFlags(..), DynFlag(..), isOneShot, HscTarget (..) )
  98 import DriverPhases     ( HscSource(..), isHsBoot, hscSourceString, Phase )
  99 import BasicTypes       ( Version, initialVersion, IPName,
 100                           Fixity, defaultFixity, DeprecTxt )
 101 import IfaceSyn
 102 import FiniteMap        ( FiniteMap )
 103 import CoreSyn          ( CoreRule )
 104 import Maybes           ( orElse, expectJust, catMaybes, seqMaybe )
 105 import Outputable
 106 import BreakArray
 107 import SrcLoc           ( SrcSpan, Located )
 108 import UniqFM           ( lookupUFM, eltsUFM, emptyUFM )
 109 import UniqSupply       ( UniqSupply )
 110 import FastString       ( FastString )
 111
 112 import StringBuffer     ( StringBuffer )
 113
 114 import System.Time      ( ClockTime )
 115 import Data.IORef       ( IORef, readIORef )
 116 import Data.Array       ( Array, array )
 117 \end{code}
 118
 119
 120 %************************************************************************
 121 %*                                                                      *
 122 \subsection{Compilation environment}
 123 %*                                                                      *
 124 %************************************************************************
 125
 126
 127 \begin{code}
 128 -- | The Session is a handle to the complete state of a compilation
 129 -- session.  A compilation session consists of a set of modules
 130 -- constituting the current program or library, the context for
 131 -- interactive evaluation, and various caches.
 132 newtype Session = Session (IORef HscEnv)
 133 \end{code}
 134
 135 HscEnv is like Session, except that some of the fields are immutable.
 136 An HscEnv is used to compile a single module from plain Haskell source
 137 code (after preprocessing) to either C, assembly or C--.  Things like
 138 the module graph don't change during a single compilation.
 139
 140 Historical note: "hsc" used to be the name of the compiler binary,
 141 when there was a separate driver and compiler.  To compile a single
 142 module, the driver would invoke hsc on the source code... so nowadays
 143 we think of hsc as the layer of the compiler that deals with compiling
 144 a single module.
 145
 146 \begin{code}
 147 data HscEnv
 148   = HscEnv {
 149         hsc_dflags :: DynFlags,
 150                 -- The dynamic flag settings
 151
 152         hsc_targets :: [Target],
 153                 -- The targets (or roots) of the current session
 154
 155         hsc_mod_graph :: ModuleGraph,
 156                 -- The module graph of the current session
 157
 158         hsc_IC :: InteractiveContext,
 159                 -- The context for evaluating interactive statements
 160
 161         hsc_HPT    :: HomePackageTable,
 162                 -- The home package table describes already-compiled
 163                 -- home-packge modules, *excluding* the module we
 164                 -- are compiling right now.
 165                 -- (In one-shot mode the current module is the only
 166                 --  home-package module, so hsc_HPT is empty.  All other
 167                 --  modules count as "external-package" modules.
 168                 --  However, even in GHCi mode, hi-boot interfaces are
 169                 --  demand-loadeded into the external-package table.)
 170                 --
 171                 -- hsc_HPT is not mutable because we only demand-load
 172                 -- external packages; the home package is eagerly
 173                 -- loaded, module by module, by the compilation manager.
 174                 --
 175                 -- The HPT may contain modules compiled earlier by --make
 176                 -- but not actually below the current module in the dependency
 177                 -- graph.  (This changes a previous invariant: changed Jan 05.)
 178
 179         hsc_EPS :: {-# UNPACK #-} !(IORef ExternalPackageState),
 180         hsc_NC  :: {-# UNPACK #-} !(IORef NameCache),
 181                 -- These are side-effected by compiling to reflect
 182                 -- sucking in interface files.  They cache the state of
 183                 -- external interface files, in effect.
 184
 185         hsc_FC   :: {-# UNPACK #-} !(IORef FinderCache),
 186         hsc_MLC  :: {-# UNPACK #-} !(IORef ModLocationCache),
 187                 -- The finder's cache.  This caches the location of modules,
 188                 -- so we don't have to search the filesystem multiple times.
 189
 190         hsc_global_rdr_env :: GlobalRdrEnv,
 191         hsc_global_type_env :: TypeEnv
 192  }
 193
 194 hscEPS :: HscEnv -> IO ExternalPackageState
 195 hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
 196
 197 -- | A compilation target.
 198 --
 199 -- A target may be supplied with the actual text of the
 200 -- module.  If so, use this instead of the file contents (this
 201 -- is for use in an IDE where the file hasn't been saved by
 202 -- the user yet).
 203 data Target = Target TargetId (Maybe (StringBuffer,ClockTime))
 204
 205 data TargetId
 206   = TargetModule ModuleName
 207         -- ^ A module name: search for the file
 208   | TargetFile FilePath (Maybe Phase)
 209         -- ^ A filename: preprocess & parse it to find the module name.
 210         -- If specified, the Phase indicates how to compile this file
 211         -- (which phase to start from).  Nothing indicates the starting phase
 212         -- should be determined from the suffix of the filename.
 213   deriving Eq
 214
 215 pprTarget :: Target -> SDoc
 216 pprTarget (Target id _) = pprTargetId id
 217
 218 instance Outputable Target where
 219     ppr = pprTarget
 220
 221 pprTargetId (TargetModule m) = ppr m
 222 pprTargetId (TargetFile f _) = text f
 223
 224 instance Outputable TargetId where
 225     ppr = pprTargetId
 226
 227 type HomePackageTable  = ModuleNameEnv HomeModInfo
 228         -- Domain = modules in the home package
 229         -- "home" package name cached here for convenience
 230 type PackageIfaceTable = ModuleEnv ModIface
 231         -- Domain = modules in the imported packages
 232
 233 emptyHomePackageTable  = emptyUFM
 234 emptyPackageIfaceTable = emptyModuleEnv
 235
 236 data HomeModInfo
 237   = HomeModInfo { hm_iface    :: !ModIface,
 238                   hm_details  :: !ModDetails,
 239                   hm_linkable :: !(Maybe Linkable) }
 240                 -- hm_linkable might be Nothing if:
 241                 --   a) this is an .hs-boot module
 242                 --   b) temporarily during compilation if we pruned away
 243                 --      the old linkable because it was out of date.
 244                 -- after a complete compilation (GHC.load), all hm_linkable
 245                 -- fields in the HPT will be Just.
 246                 --
 247                 -- When re-linking a module (hscNoRecomp), we construct
 248                 -- the HomModInfo by building a new ModDetails from the
 249                 -- old ModIface (only).
 250
 251 -- | Find the 'ModIface' for a 'Module'
 252 lookupIfaceByModule
 253         :: DynFlags
 254         -> HomePackageTable
 255         -> PackageIfaceTable
 256         -> Module
 257         -> Maybe ModIface
 258 lookupIfaceByModule dflags hpt pit mod
 259   | modulePackageId mod == thisPackage dflags
 260   =     -- The module comes from the home package, so look first
 261         -- in the HPT.  If it's not from the home package it's wrong to look
 262         -- in the HPT, because the HPT is indexed by *ModuleName* not Module
 263     fmap hm_iface (lookupUFM hpt (moduleName mod))
 264     `seqMaybe` lookupModuleEnv pit mod
 265
 266   | otherwise = lookupModuleEnv pit mod         -- Look in PIT only
 267
 268 -- If the module does come from the home package, why do we look in the PIT as well?
 269 -- (a) In OneShot mode, even home-package modules accumulate in the PIT
 270 -- (b) Even in Batch (--make) mode, there is *one* case where a home-package
 271 --     module is in the PIT, namely GHC.Prim when compiling the base package.
 272 -- We could eliminate (b) if we wanted, by making GHC.Prim belong to a packake
 273 -- of its own, but it doesn't seem worth the bother.
 274 \end{code}
 275
 276
 277 \begin{code}
 278 hptInstances :: HscEnv -> (ModuleName -> Bool) -> [Instance]
 279 -- Find all the instance declarations that are in modules imported
 280 -- by this one, directly or indirectly, and are in the Home Package Table
 281 -- This ensures that we don't see instances from modules --make compiled
 282 -- before this one, but which are not below this one
 283 hptInstances hsc_env want_this_module
 284   = [ ispec
 285     | mod_info <- eltsUFM (hsc_HPT hsc_env)
 286     , want_this_module (moduleName (mi_module (hm_iface mod_info)))
 287     , ispec <- md_insts (hm_details mod_info) ]
 288
 289 hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]
 290 -- Get rules from modules "below" this one (in the dependency sense)
 291 -- C.f Inst.hptInstances
 292 hptRules hsc_env deps
 293   | isOneShot (ghcMode (hsc_dflags hsc_env)) = []
 294   | otherwise
 295   = let
 296         hpt = hsc_HPT hsc_env
 297     in
 298     [ rule
 299     |   -- Find each non-hi-boot module below me
 300       (mod, False) <- deps
 301
 302         -- unsavoury: when compiling the base package with --make, we
 303         -- sometimes try to look up RULES for GHC.Prim.  GHC.Prim won't
 304         -- be in the HPT, because we never compile it; it's in the EPT
 305         -- instead.  ToDo: clean up, and remove this slightly bogus
 306         -- filter:
 307     , mod /= moduleName gHC_PRIM
 308
 309         -- Look it up in the HPT
 310     , let rules = case lookupUFM hpt mod of
 311                     Just info -> md_rules (hm_details info)
 312                     Nothing -> pprTrace "WARNING in hptRules" msg []
 313           msg = vcat [ptext SLIT("missing module") <+> ppr mod,
 314                       ptext SLIT("Probable cause: out-of-date interface files")]
 315                         -- This really shouldn't happen, but see Trac #962
 316
 317         -- And get its dfuns
 318     , rule <- rules ]
 319 \end{code}
 320
 321 %************************************************************************
 322 %*                                                                      *
 323 \subsection{The Finder cache}
 324 %*                                                                      *
 325 %************************************************************************
 326
 327 \begin{code}
 328 -- | The 'FinderCache' maps home module names to the result of
 329 -- searching for that module.  It records the results of searching for
 330 -- modules along the search path.  On @:load@, we flush the entire
 331 -- contents of this cache.
 332 --
 333 -- Although the @FinderCache@ range is 'FindResult' for convenience ,
 334 -- in fact it will only ever contain 'Found' or 'NotFound' entries.
 335 --
 336 type FinderCache = ModuleNameEnv FindResult
 337
 338 -- | The result of searching for an imported module.
 339 data FindResult
 340   = Found ModLocation Module
 341         -- the module was found
 342   | NoPackage PackageId
 343         -- the requested package was not found
 344   | FoundMultiple [PackageId]
 345         -- *error*: both in multiple packages
 346   | PackageHidden PackageId
 347         -- for an explicit source import: the package containing the module is
 348         -- not exposed.
 349   | ModuleHidden  PackageId
 350         -- for an explicit source import: the package containing the module is
 351         -- exposed, but the module itself is hidden.
 352   | NotFound [FilePath] (Maybe PackageId)
 353         -- the module was not found, the specified places were searched
 354   | NotFoundInPackage PackageId
 355         -- the module was not found in this package
 356
 357 -- | Cache that remembers where we found a particular module.  Contains both
 358 -- home modules and package modules.  On @:load@, only home modules are
 359 -- purged from this cache.
 360 type ModLocationCache = ModuleEnv ModLocation
 361 \end{code}
 362
 363 %************************************************************************
 364 %*                                                                      *
 365 \subsection{Symbol tables and Module details}
 366 %*                                                                      *
 367 %************************************************************************
 368
 369 A @ModIface@ plus a @ModDetails@ summarises everything we know
 370 about a compiled module.  The @ModIface@ is the stuff *before* linking,
 371 and can be written out to an interface file.  (The @ModDetails@ is after
 372 linking; it is the "linked" form of the mi_decls field.)
 373
 374 When we *read* an interface file, we also construct a @ModIface@ from it,
 375 except that the mi_decls part is empty; when reading we consolidate
 376 the declarations into a single indexed map in the @PersistentRenamerState@.
 377
 378 \begin{code}
 379 data ModIface
 380    = ModIface {
 381         mi_module   :: !Module,
 382         mi_mod_vers :: !Version,            -- Module version: changes when anything changes
 383
 384         mi_orphan   :: !WhetherHasOrphans,  -- Whether this module has orphans
 385         mi_finsts   :: !WhetherHasFamInst,  -- Whether module has family insts
 386         mi_boot     :: !IsBootInterface,    -- Read from an hi-boot file?
 387
 388         mi_deps     :: Dependencies,
 389                 -- This is consulted for directly-imported modules,
 390                 -- but not for anything else (hence lazy)
 391
 392                 -- Usages; kept sorted so that it's easy to decide
 393                 -- whether to write a new iface file (changing usages
 394                 -- doesn't affect the version of this module)
 395         mi_usages   :: [Usage],
 396                 -- NOT STRICT!  we read this field lazily from the interface file
 397                 -- It is *only* consulted by the recompilation checker
 398
 399                 -- Exports
 400                 -- Kept sorted by (mod,occ), to make version comparisons easier
 401         mi_exports  :: ![IfaceExport],
 402         mi_exp_vers :: !Version,        -- Version number of export list
 403
 404                 -- Fixities
 405         mi_fixities :: [(OccName,Fixity)],
 406                 -- NOT STRICT!  we read this field lazily from the interface file
 407
 408                 -- Deprecations
 409         mi_deprecs  :: IfaceDeprecs,
 410                 -- NOT STRICT!  we read this field lazily from the interface file
 411
 412                 -- Type, class and variable declarations
 413                 -- The version of an Id changes if its fixity or deprecations change
 414                 --      (as well as its type of course)
 415                 -- Ditto data constructors, class operations, except that
 416                 -- the version of the parent class/tycon changes
 417         mi_decls :: [(Version,IfaceDecl)],      -- Sorted
 418
 419         mi_globals  :: !(Maybe GlobalRdrEnv),
 420                 -- Binds all the things defined at the top level in
 421                 -- the *original source* code for this module. which
 422                 -- is NOT the same as mi_exports, nor mi_decls (which
 423                 -- may contains declarations for things not actually
 424                 -- defined by the user).  Used for GHCi and for inspecting
 425                 -- the contents of modules via the GHC API only.
 426                 --
 427                 -- (We need the source file to figure out the
 428                 -- top-level environment, if we didn't compile this module
 429                 -- from source then this field contains Nothing).
 430                 --
 431                 -- Strictly speaking this field should live in the
 432                 -- HomeModInfo, but that leads to more plumbing.
 433
 434                 -- Instance declarations and rules
 435         mi_insts     :: [IfaceInst],                    -- Sorted
 436         mi_fam_insts :: [IfaceFamInst],                 -- Sorted
 437         mi_rules     :: [IfaceRule],                    -- Sorted
 438         mi_rule_vers :: !Version,       -- Version number for rules and
 439                                         -- instances (for classes and families)
 440                                         -- combined
 441
 442                 -- Cached environments for easy lookup
 443                 -- These are computed (lazily) from other fields
 444                 -- and are not put into the interface file
 445         mi_dep_fn  :: Name -> Maybe DeprecTxt,  -- Cached lookup for mi_deprecs
 446         mi_fix_fn  :: OccName -> Fixity,        -- Cached lookup for mi_fixities
 447         mi_ver_fn  :: OccName -> Maybe (OccName, Version)
 448                         -- Cached lookup for mi_decls
 449                         -- The Nothing in mi_ver_fn means that the thing
 450                         -- isn't in decls. It's useful to know that when
 451                         -- seeing if we are up to date wrt the old interface
 452                         -- The 'OccName' is the parent of the name, if it has one.
 453      }
 454
 455 -- Should be able to construct ModDetails from mi_decls in ModIface
 456 data ModDetails
 457    = ModDetails {
 458         -- The next two fields are created by the typechecker
 459         md_exports   :: [AvailInfo],
 460         md_types     :: !TypeEnv,
 461         md_insts     :: ![Instance],    -- Dfun-ids for the instances in this module
 462         md_fam_insts :: ![FamInst],
 463         md_rules     :: ![CoreRule],    -- Domain may include Ids from other modules
 464         md_modBreaks :: !ModBreaks  -- breakpoint information for this module
 465      }
 466
 467 emptyModDetails = ModDetails { md_types = emptyTypeEnv,
 468                                md_exports = [],
 469                                md_insts     = [],
 470                                md_rules     = [],
 471                                md_fam_insts = [],
 472                                md_modBreaks = emptyModBreaks }
 473
 474 -- A ModGuts is carried through the compiler, accumulating stuff as it goes
 475 -- There is only one ModGuts at any time, the one for the module
 476 -- being compiled right now.  Once it is compiled, a ModIface and
 477 -- ModDetails are extracted and the ModGuts is dicarded.
 478
 479 data ModGuts
 480   = ModGuts {
 481         mg_module    :: !Module,
 482         mg_boot      :: IsBootInterface, -- Whether it's an hs-boot module
 483         mg_exports   :: ![AvailInfo],    -- What it exports
 484         mg_deps      :: !Dependencies,   -- What is below it, directly or
 485                                          --   otherwise
 486         mg_dir_imps  :: ![Module],       -- Directly-imported modules; used to
 487                                          --     generate initialisation code
 488         mg_usages    :: ![Usage],        -- Version info for what it needed
 489
 490         mg_rdr_env   :: !GlobalRdrEnv,   -- Top-level lexical environment
 491         mg_fix_env   :: !FixityEnv,      -- Fixity env, for things declared in
 492                                          --   this module
 493
 494         mg_fam_inst_env :: FamInstEnv,   -- Type-family instance enviroment
 495                                          -- for *home-package* modules (including
 496                                          -- this one).  c.f. tcg_fam_inst_env
 497
 498         mg_types     :: !TypeEnv,
 499         mg_insts     :: ![Instance],     -- Instances
 500         mg_fam_insts :: ![FamInst],      -- Instances
 501         mg_rules     :: ![CoreRule],     -- Rules from this module
 502         mg_binds     :: ![CoreBind],     -- Bindings for this module
 503         mg_foreign   :: !ForeignStubs,
 504         mg_deprecs   :: !Deprecations,   -- Deprecations declared in the module
 505         mg_hpc_info  :: !HpcInfo,        -- info about coverage tick boxes
 506         mg_modBreaks :: !ModBreaks
 507     }
 508
 509 -- The ModGuts takes on several slightly different forms:
 510 --
 511 -- After simplification, the following fields change slightly:
 512 --      mg_rules        Orphan rules only (local ones now attached to binds)
 513 --      mg_binds        With rules attached
 514
 515
 516 ---------------------------------------------------------
 517 -- The Tidy pass forks the information about this module:
 518 --      * one lot goes to interface file generation (ModIface)
 519 --        and later compilations (ModDetails)
 520 --      * the other lot goes to code generation (CgGuts)
 521 data CgGuts
 522   = CgGuts {
 523         cg_module   :: !Module,
 524
 525         cg_tycons   :: [TyCon],
 526                 -- Algebraic data types (including ones that started
 527                 -- life as classes); generate constructors and info
 528                 -- tables Includes newtypes, just for the benefit of
 529                 -- External Core
 530
 531         cg_binds    :: [CoreBind],
 532                 -- The tidied main bindings, including
 533                 -- previously-implicit bindings for record and class
 534                 -- selectors, and data construtor wrappers.  But *not*
 535                 -- data constructor workers; reason: we we regard them
 536                 -- as part of the code-gen of tycons
 537
 538         cg_dir_imps :: ![Module],
 539                 -- Directly-imported modules; used to generate
 540                 -- initialisation code
 541
 542         cg_foreign  :: !ForeignStubs,
 543         cg_dep_pkgs :: ![PackageId],    -- Used to generate #includes for C code gen
 544         cg_hpc_info :: !HpcInfo         -- info about coverage tick boxes
 545     }
 546
 547 -----------------------------------
 548 data ModImports
 549   = ModImports {
 550         imp_direct     :: ![(Module,Bool)],     -- Explicitly-imported modules
 551                                                 -- Boolean is true if we imported the whole
 552                                                 --      module (apart, perhaps, from hiding some)
 553         imp_pkg_mods   :: !ModuleSet,           -- Non-home-package modules on which we depend,
 554                                                 --      directly or indirectly
 555         imp_home_names :: !NameSet              -- Home package things on which we depend,
 556                                                 --      directly or indirectly
 557     }
 558
 559 -----------------------------------
 560 data ForeignStubs = NoStubs
 561                   | ForeignStubs
 562                         SDoc            -- Header file prototypes for
 563                                         --      "foreign exported" functions
 564                         SDoc            -- C stubs to use when calling
 565                                         --      "foreign exported" functions
 566                         [FastString]    -- Headers that need to be included
 567                                         --      into C code generated for this module
 568                         [Id]            -- Foreign-exported binders
 569                                         --      we have to generate code to register these
 570
 571 \end{code}
 572
 573 \begin{code}
 574 emptyModIface :: Module -> ModIface
 575 emptyModIface mod
 576   = ModIface { mi_module   = mod,
 577                mi_mod_vers = initialVersion,
 578                mi_orphan   = False,
 579                mi_finsts   = False,
 580                mi_boot     = False,
 581                mi_deps     = noDependencies,
 582                mi_usages   = [],
 583                mi_exports  = [],
 584                mi_exp_vers = initialVersion,
 585                mi_fixities = [],
 586                mi_deprecs  = NoDeprecs,
 587                mi_insts     = [],
 588                mi_fam_insts = [],
 589                mi_rules     = [],
 590                mi_decls     = [],
 591                mi_globals   = Nothing,
 592                mi_rule_vers = initialVersion,
 593                mi_dep_fn = emptyIfaceDepCache,
 594                mi_fix_fn = emptyIfaceFixCache,
 595                mi_ver_fn = emptyIfaceVerCache
 596     }
 597 \end{code}
 598
 599
 600 %************************************************************************
 601 %*                                                                      *
 602 \subsection{The interactive context}
 603 %*                                                                      *
 604 %************************************************************************
 605
 606 \begin{code}
 607 data InteractiveContext
 608   = InteractiveContext {
 609         ic_toplev_scope :: [Module],    -- Include the "top-level" scope of
 610                                         -- these modules
 611
 612         ic_exports :: [Module],         -- Include just the exports of these
 613                                         -- modules
 614
 615         ic_rn_gbl_env :: GlobalRdrEnv,  -- The cached GlobalRdrEnv, built from
 616                                         -- ic_toplev_scope and ic_exports
 617
 618         ic_type_env :: TypeEnv,         -- Type env for names bound during
 619                                         -- interaction.  NB. the names from
 620                                         -- these Ids are used to populate
 621                                         -- the LocalRdrEnv used during
 622                                         -- typechecking of a statement, so
 623                                         -- there should be no duplicate
 624                                         -- names in here.
 625
 626         ic_tyvars :: TyVarSet           -- skolem type variables free in
 627                                         -- ic_type_env.  These arise at
 628                                         -- breakpoints in a polymorphic
 629                                         -- context, where we have only partial
 630                                         -- type information.
 631     }
 632
 633 emptyInteractiveContext
 634   = InteractiveContext { ic_toplev_scope = [],
 635                          ic_exports = [],
 636                          ic_rn_gbl_env = emptyGlobalRdrEnv,
 637                          ic_type_env = emptyTypeEnv,
 638                          ic_tyvars = emptyVarSet }
 639
 640 icPrintUnqual :: InteractiveContext -> PrintUnqualified
 641 icPrintUnqual ictxt = mkPrintUnqualified (ic_rn_gbl_env ictxt)
 642 \end{code}
 643
 644 %************************************************************************
 645 %*                                                                      *
 646         Building a PrintUnqualified
 647 %*                                                                      *
 648 %************************************************************************
 649
 650 \begin{code}
 651 mkPrintUnqualified :: GlobalRdrEnv -> PrintUnqualified
 652 mkPrintUnqualified env = (qual_name, qual_mod)
 653   where
 654   qual_name mod occ
 655         | null gres = Just (moduleName mod)
 656                 -- it isn't in scope at all, this probably shouldn't happen,
 657                 -- but we'll qualify it by the original module anyway.
 658         | any unQualOK gres = Nothing
 659         | (Imported is : _) <- map gre_prov gres, (idecl : _) <- is
 660           = Just (is_as (is_decl idecl))
 661         | otherwise = panic "mkPrintUnqualified"
 662       where
 663         gres  = [ gre | gre <- lookupGlobalRdrEnv env occ,
 664                         nameModule (gre_name gre) == mod ]
 665
 666   qual_mod mod = Nothing       -- For now...
 667 \end{code}
 668
 669
 670 %************************************************************************
 671 %*                                                                      *
 672                 TyThing
 673 %*                                                                      *
 674 %************************************************************************
 675
 676 \begin{code}
 677 implicitTyThings :: TyThing -> [TyThing]
 678 -- If you change this, make sure you change LoadIface.ifaceDeclSubBndrs in sync
 679
 680 implicitTyThings (AnId id)   = []
 681
 682         -- For type constructors, add the data cons (and their extras),
 683         -- and the selectors and generic-programming Ids too
 684         --
 685         -- Newtypes don't have a worker Id, so don't generate that?
 686 implicitTyThings (ATyCon tc) = implicitCoTyCon tc ++
 687                                map AnId (tyConSelIds tc) ++
 688                                concatMap (extras_plus . ADataCon)
 689                                          (tyConDataCons tc)
 690
 691         -- For classes, add the class selector Ids, and assoicated TyCons
 692         -- and the class TyCon too (and its extras)
 693 implicitTyThings (AClass cl)
 694   = map AnId (classSelIds cl) ++
 695     map ATyCon (classATs cl) ++
 696         -- No extras_plus for the classATs, because they
 697         -- are only the family decls; they have no implicit things
 698     extras_plus (ATyCon (classTyCon cl))
 699
 700         -- For data cons add the worker and wrapper (if any)
 701 implicitTyThings (ADataCon dc) = map AnId (dataConImplicitIds dc)
 702
 703 -- | returns 'True' if there should be no interface-file declaration
 704 -- for this thing on its own: either it is built-in, or it is part
 705 -- of some other declaration, or it is generated implicitly by some
 706 -- other declaration.
 707 isImplicitTyThing :: TyThing -> Bool
 708 isImplicitTyThing (ADataCon _)  = True
 709 isImplicitTyThing (AnId     id) = isImplicitId id
 710 isImplicitTyThing (AClass   _)  = False
 711 isImplicitTyThing (ATyCon   tc) = isImplicitTyCon tc
 712
 713         -- For newtypes and indexed data types, add the implicit coercion tycon
 714 implicitCoTyCon tc
 715   = map ATyCon . catMaybes $ [newTyConCo_maybe tc,
 716                               tyConFamilyCoercion_maybe tc]
 717
 718 extras_plus thing = thing : implicitTyThings thing
 719
 720 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
 721 extendTypeEnvWithIds env ids
 722   = extendNameEnvList env [(getName id, AnId id) | id <- ids]
 723 \end{code}
 724
 725 %************************************************************************
 726 %*                                                                      *
 727                 TypeEnv
 728 %*                                                                      *
 729 %************************************************************************
 730
 731 \begin{code}
 732 type TypeEnv = NameEnv TyThing
 733
 734 emptyTypeEnv    :: TypeEnv
 735 typeEnvElts     :: TypeEnv -> [TyThing]
 736 typeEnvClasses  :: TypeEnv -> [Class]
 737 typeEnvTyCons   :: TypeEnv -> [TyCon]
 738 typeEnvIds      :: TypeEnv -> [Id]
 739 typeEnvDataCons :: TypeEnv -> [DataCon]
 740 lookupTypeEnv   :: TypeEnv -> Name -> Maybe TyThing
 741
 742 emptyTypeEnv        = emptyNameEnv
 743 typeEnvElts     env = nameEnvElts env
 744 typeEnvClasses  env = [cl | AClass cl   <- typeEnvElts env]
 745 typeEnvTyCons   env = [tc | ATyCon tc   <- typeEnvElts env]
 746 typeEnvIds      env = [id | AnId id     <- typeEnvElts env]
 747 typeEnvDataCons env = [dc | ADataCon dc <- typeEnvElts env]
 748
 749 mkTypeEnv :: [TyThing] -> TypeEnv
 750 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
 751
 752 lookupTypeEnv = lookupNameEnv
 753
 754 -- Extend the type environment
 755 extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
 756 extendTypeEnv env thing = extendNameEnv env (getName thing) thing
 757
 758 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
 759 extendTypeEnvList env things = foldl extendTypeEnv env things
 760 \end{code}
 761
 762 \begin{code}
 763 lookupType :: DynFlags
 764            -> HomePackageTable
 765            -> PackageTypeEnv
 766            -> Name
 767            -> Maybe TyThing
 768
 769 lookupType dflags hpt pte name
 770   -- in one-shot, we don't use the HPT
 771   | not (isOneShot (ghcMode dflags)) && modulePackageId mod == this_pkg
 772   = do hm <- lookupUFM hpt (moduleName mod) -- Maybe monad
 773        lookupNameEnv (md_types (hm_details hm)) name
 774   | otherwise
 775   = lookupNameEnv pte name
 776   where mod = nameModule name
 777         this_pkg = thisPackage dflags
 778 \end{code}
 779
 780 \begin{code}
 781 tyThingTyCon (ATyCon tc) = tc
 782 tyThingTyCon other       = pprPanic "tyThingTyCon" (ppr other)
 783
 784 tyThingClass (AClass cls) = cls
 785 tyThingClass other        = pprPanic "tyThingClass" (ppr other)
 786
 787 tyThingDataCon (ADataCon dc) = dc
 788 tyThingDataCon other         = pprPanic "tyThingDataCon" (ppr other)
 789
 790 tyThingId (AnId id) = id
 791 tyThingId other     = pprPanic "tyThingId" (ppr other)
 792 \end{code}
 793
 794 %************************************************************************
 795 %*                                                                      *
 796 \subsection{Auxiliary types}
 797 %*                                                                      *
 798 %************************************************************************
 799
 800 These types are defined here because they are mentioned in ModDetails,
 801 but they are mostly elaborated elsewhere
 802
 803 \begin{code}
 804 mkIfaceVerCache :: [(Version,IfaceDecl)]
 805                 -> (OccName -> Maybe (OccName, Version))
 806 mkIfaceVerCache pairs
 807   = \occ -> lookupOccEnv env occ
 808   where
 809     env = foldr add_decl emptyOccEnv pairs
 810     add_decl (v,d) env0 = foldr add_imp env1 (ifaceDeclSubBndrs d)
 811       where
 812           decl_name = ifName d
 813           env1 = extendOccEnv env0 decl_name (decl_name, v)
 814           add_imp bndr env = extendOccEnv env bndr (decl_name, v)
 815
 816 emptyIfaceVerCache :: OccName -> Maybe (OccName, Version)
 817 emptyIfaceVerCache occ = Nothing
 818
 819 ------------------ Deprecations -------------------------
 820 data Deprecs a
 821   = NoDeprecs
 822   | DeprecAll DeprecTxt -- Whole module deprecated
 823   | DeprecSome a        -- Some specific things deprecated
 824   deriving( Eq )
 825
 826 type IfaceDeprecs = Deprecs [(OccName,DeprecTxt)]
 827 type Deprecations = Deprecs (NameEnv (OccName,DeprecTxt))
 828         -- Keep the OccName so we can flatten the NameEnv to
 829         -- get an IfaceDeprecs from a Deprecations
 830         -- Only an OccName is needed, because a deprecation always
 831         -- applies to things defined in the module in which the
 832         -- deprecation appears.
 833
 834 mkIfaceDepCache:: IfaceDeprecs -> Name -> Maybe DeprecTxt
 835 mkIfaceDepCache NoDeprecs         = \n -> Nothing
 836 mkIfaceDepCache (DeprecAll t)     = \n -> Just t
 837 mkIfaceDepCache (DeprecSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
 838
 839 emptyIfaceDepCache :: Name -> Maybe DeprecTxt
 840 emptyIfaceDepCache n = Nothing
 841
 842 plusDeprecs :: Deprecations -> Deprecations -> Deprecations
 843 plusDeprecs d NoDeprecs = d
 844 plusDeprecs NoDeprecs d = d
 845 plusDeprecs d (DeprecAll t) = DeprecAll t
 846 plusDeprecs (DeprecAll t) d = DeprecAll t
 847 plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
 848 \end{code}
 849
 850
 851 \begin{code}
 852 type Avails       = [AvailInfo]
 853 type AvailInfo    = GenAvailInfo Name
 854 type RdrAvailInfo = GenAvailInfo OccName
 855
 856 data GenAvailInfo name  = Avail name     -- An ordinary identifier
 857                         | AvailTC name   -- The name of the type or class
 858                                   [name] -- The available pieces of type/class.
 859                                          -- NB: If the type or class is itself
 860                                          -- to be in scope, it must be in this list.
 861                                          -- Thus, typically: AvailTC Eq [Eq, ==, /=]
 862                         deriving( Eq )
 863                         -- Equality used when deciding if the interface has changed
 864
 865 type IfaceExport = (Module, [GenAvailInfo OccName])
 866
 867 availsToNameSet :: [AvailInfo] -> NameSet
 868 availsToNameSet avails = foldr add emptyNameSet avails
 869       where add avail set = addListToNameSet set (availNames avail)
 870
 871 availsToNameEnv :: [AvailInfo] -> NameEnv AvailInfo
 872 availsToNameEnv avails = foldr add emptyNameEnv avails
 873      where add avail env = extendNameEnvList env
 874                                 (zip (availNames avail) (repeat avail))
 875
 876 availName :: GenAvailInfo name -> name
 877 availName (Avail n)     = n
 878 availName (AvailTC n _) = n
 879
 880 availNames :: GenAvailInfo name -> [name]
 881 availNames (Avail n)      = [n]
 882 availNames (AvailTC n ns) = ns
 883
 884 instance Outputable n => Outputable (GenAvailInfo n) where
 885    ppr = pprAvail
 886
 887 pprAvail :: Outputable n => GenAvailInfo n -> SDoc
 888 pprAvail (Avail n)      = ppr n
 889 pprAvail (AvailTC n ns) = ppr n <> braces (hsep (punctuate comma (map ppr ns)))
 890 \end{code}
 891
 892 \begin{code}
 893 mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
 894 mkIfaceFixCache pairs
 895   = \n -> lookupOccEnv env n `orElse` defaultFixity
 896   where
 897    env = mkOccEnv pairs
 898
 899 emptyIfaceFixCache :: OccName -> Fixity
 900 emptyIfaceFixCache n = defaultFixity
 901
 902 -- This fixity environment is for source code only
 903 type FixityEnv = NameEnv FixItem
 904
 905 -- We keep the OccName in the range so that we can generate an interface from it
 906 data FixItem = FixItem OccName Fixity SrcSpan
 907
 908 instance Outputable FixItem where
 909   ppr (FixItem occ fix loc) = ppr fix <+> ppr occ <+> parens (ppr loc)
 910
 911 emptyFixityEnv :: FixityEnv
 912 emptyFixityEnv = emptyNameEnv
 913
 914 lookupFixity :: FixityEnv -> Name -> Fixity
 915 lookupFixity env n = case lookupNameEnv env n of
 916                         Just (FixItem _ fix _) -> fix
 917                         Nothing                -> defaultFixity
 918 \end{code}
 919
 920
 921 %************************************************************************
 922 %*                                                                      *
 923 \subsection{WhatsImported}
 924 %*                                                                      *
 925 %************************************************************************
 926
 927 \begin{code}
 928 type WhetherHasOrphans   = Bool
 929         -- An "orphan" is
 930         --      * an instance decl in a module other than the defn module for
 931         --              one of the tycons or classes in the instance head
 932         --      * a transformation rule in a module other than the one defining
 933         --              the function in the head of the rule.
 934
 935 type WhetherHasFamInst = Bool        -- This module defines family instances?
 936
 937 type IsBootInterface = Bool
 938
 939 -- Dependency info about modules and packages below this one
 940 -- in the import hierarchy.  See TcRnTypes.ImportAvails for details.
 941 -- The orphan modules in `dep_orphs' do *not* include family instance orphans,
 942 -- as they are anyway included in `dep_finsts'.
 943 --
 944 -- Invariant: the dependencies of a module M never includes M
 945 -- Invariant: the lists are unordered, with no duplicates
 946 data Dependencies
 947   = Deps { dep_mods   :: [(ModuleName,      -- Home-package module dependencies
 948                            IsBootInterface)]
 949          , dep_pkgs   :: [PackageId]        -- External package dependencies
 950          , dep_orphs  :: [Module]           -- Orphan modules (whether home or
 951                                             -- external pkg)
 952          , dep_finsts :: [Module]           -- Modules that contain family
 953                                             -- instances (whether home or
 954                                             -- external pkg)
 955          }
 956   deriving( Eq )
 957         -- Equality used only for old/new comparison in MkIface.addVersionInfo
 958
 959 noDependencies :: Dependencies
 960 noDependencies = Deps [] [] [] []
 961
 962 data Usage
 963   = Usage { usg_name     :: ModuleName,                 -- Name of the module
 964             usg_mod      :: Version,                    -- Module version
 965             usg_entities :: [(OccName,Version)],        -- Sorted by occurrence name
 966                 -- NB. usages are for parent names only, eg. tycon but not constructors.
 967             usg_exports  :: Maybe Version,              -- Export-list version, if we depend on it
 968             usg_rules    :: Version                     -- Orphan-rules version (for non-orphan
 969                                                         -- modules this will always be initialVersion)
 970     }       deriving( Eq )
 971         -- This type doesn't let you say "I imported f but none of the rules in
 972         -- the module". If you use anything in the module you get its rule version
 973         -- So if the rules change, you'll recompile, even if you don't use them.
 974         -- This is easy to implement, and it's safer: you might not have used the rules last
 975         -- time round, but if someone has added a new rule you might need it this time
 976
 977         -- The export list field is (Just v) if we depend on the export list:
 978         --      i.e. we imported the module directly, whether or not we
 979         --           enumerated the things we imported, or just imported everything
 980         -- We need to recompile if M's exports change, because
 981         -- if the import was    import M,       we might now have a name clash in the
 982         --                                      importing module.
 983         -- if the import was    import M(x)     M might no longer export x
 984         -- The only way we don't depend on the export list is if we have
 985         --                      import M()
 986         -- And of course, for modules that aren't imported directly we don't
 987         -- depend on their export lists
 988 \end{code}
 989
 990
 991 %************************************************************************
 992 %*                                                                      *
 993                 The External Package State
 994 %*                                                                      *
 995 %************************************************************************
 996
 997 \begin{code}
 998 type PackageTypeEnv    = TypeEnv
 999 type PackageRuleBase   = RuleBase
1000 type PackageInstEnv    = InstEnv
1001 type PackageFamInstEnv = FamInstEnv
1002
1003 data ExternalPackageState
1004   = EPS {
1005         eps_is_boot :: !(ModuleNameEnv (ModuleName, IsBootInterface)),
1006                 -- In OneShot mode (only), home-package modules
1007                 -- accumulate in the external package state, and are
1008                 -- sucked in lazily.  For these home-pkg modules
1009                 -- (only) we need to record which are boot modules.
1010                 -- We set this field after loading all the
1011                 -- explicitly-imported interfaces, but before doing
1012                 -- anything else
1013                 --
1014                 -- The ModuleName part is not necessary, but it's useful for
1015                 -- debug prints, and it's convenient because this field comes
1016                 -- direct from TcRnTypes.ImportAvails.imp_dep_mods
1017
1018         eps_PIT :: !PackageIfaceTable,
1019                 -- The ModuleIFaces for modules in external packages
1020                 -- whose interfaces we have opened
1021                 -- The declarations in these interface files are held in
1022                 -- eps_decls, eps_inst_env, eps_fam_inst_env, eps_rules
1023                 -- (below), not in the mi_decls fields of the iPIT.
1024                 -- What _is_ in the iPIT is:
1025                 --      * The Module
1026                 --      * Version info
1027                 --      * Its exports
1028                 --      * Fixities
1029                 --      * Deprecations
1030
1031         eps_PTE :: !PackageTypeEnv,        -- Domain = external-package modules
1032
1033         eps_inst_env     :: !PackageInstEnv,   -- The total InstEnv accumulated
1034                                                -- from all the external-package
1035                                                -- modules
1036         eps_fam_inst_env :: !PackageFamInstEnv,-- Ditto FamInstEnv
1037         eps_rule_base    :: !PackageRuleBase,  -- Ditto RuleEnv
1038
1039         eps_mod_fam_inst_env :: !(ModuleEnv FamInstEnv), -- identifies family
1040                                                        -- instances of each mod
1041
1042         eps_stats :: !EpsStats
1043   }
1044
1045 -- "In" means read from iface files
1046 -- "Out" means actually sucked in and type-checked
1047 data EpsStats = EpsStats { n_ifaces_in
1048                          , n_decls_in, n_decls_out
1049                          , n_rules_in, n_rules_out
1050                          , n_insts_in, n_insts_out :: !Int }
1051
1052 addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
1053 -- Add stats for one newly-read interface
1054 addEpsInStats stats n_decls n_insts n_rules
1055   = stats { n_ifaces_in = n_ifaces_in stats + 1
1056           , n_decls_in  = n_decls_in stats + n_decls
1057           , n_insts_in  = n_insts_in stats + n_insts
1058           , n_rules_in  = n_rules_in stats + n_rules }
1059 \end{code}
1060
1061 The NameCache makes sure that there is just one Unique assigned for
1062 each original name; i.e. (module-name, occ-name) pair.  The Name is
1063 always stored as a Global, and has the SrcLoc of its binding location.
1064 Actually that's not quite right.  When we first encounter the original
1065 name, we might not be at its binding site (e.g. we are reading an
1066 interface file); so we give it 'noSrcLoc' then.  Later, when we find
1067 its binding site, we fix it up.
1068
1069 \begin{code}
1070 data NameCache
1071  = NameCache {  nsUniqs :: UniqSupply,
1072                 -- Supply of uniques
1073                 nsNames :: OrigNameCache,
1074                 -- Ensures that one original name gets one unique
1075                 nsIPs   :: OrigIParamCache
1076                 -- Ensures that one implicit parameter name gets one unique
1077    }
1078
1079 type OrigNameCache   = ModuleEnv (OccEnv Name)
1080 type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name)
1081 \end{code}
1082
1083
1084
1085 %************************************************************************
1086 %*                                                                      *
1087                 The module graph and ModSummary type
1088         A ModSummary is a node in the compilation manager's
1089         dependency graph, and it's also passed to hscMain
1090 %*                                                                      *
1091 %************************************************************************
1092
1093 A ModuleGraph contains all the nodes from the home package (only).
1094 There will be a node for each source module, plus a node for each hi-boot
1095 module.
1096
1097 \begin{code}
1098 type ModuleGraph = [ModSummary]  -- The module graph,
1099                                  -- NOT NECESSARILY IN TOPOLOGICAL ORDER
1100
1101 emptyMG :: ModuleGraph
1102 emptyMG = []
1103
1104 -- The nodes of the module graph are
1105 --      EITHER a regular Haskell source module
1106 --      OR     a hi-boot source module
1107
1108 data ModSummary
1109    = ModSummary {
1110         ms_mod       :: Module,                 -- Identity of the module
1111         ms_hsc_src   :: HscSource,              -- Source is Haskell, hs-boot, external core
1112         ms_location  :: ModLocation,            -- Location
1113         ms_hs_date   :: ClockTime,              -- Timestamp of source file
1114         ms_obj_date  :: Maybe ClockTime,        -- Timestamp of object, maybe
1115         ms_srcimps   :: [Located ModuleName],   -- Source imports
1116         ms_imps      :: [Located ModuleName],   -- Non-source imports
1117         ms_hspp_file :: FilePath,               -- Filename of preprocessed source.
1118         ms_hspp_opts :: DynFlags,               -- Cached flags from OPTIONS, INCLUDE
1119                                                 -- and LANGUAGE pragmas.
1120         ms_hspp_buf  :: Maybe StringBuffer      -- The actual preprocessed source, maybe.
1121      }
1122
1123 -- The ModLocation contains both the original source filename and the
1124 -- filename of the cleaned-up source file after all preprocessing has been
1125 -- done.  The point is that the summariser will have to cpp/unlit/whatever
1126 -- all files anyway, and there's no point in doing this twice -- just
1127 -- park the result in a temp file, put the name of it in the location,
1128 -- and let @compile@ read from that file on the way back up.
1129
1130 -- The ModLocation is stable over successive up-sweeps in GHCi, wheres
1131 -- the ms_hs_date and imports can, of course, change
1132
1133 msHsFilePath, msHiFilePath, msObjFilePath :: ModSummary -> FilePath
1134 msHsFilePath  ms = expectJust "msHsFilePath" (ml_hs_file  (ms_location ms))
1135 msHiFilePath  ms = ml_hi_file  (ms_location ms)
1136 msObjFilePath ms = ml_obj_file (ms_location ms)
1137
1138 isBootSummary :: ModSummary -> Bool
1139 isBootSummary ms = isHsBoot (ms_hsc_src ms)
1140
1141 instance Outputable ModSummary where
1142    ppr ms
1143       = sep [text "ModSummary {",
1144              nest 3 (sep [text "ms_hs_date = " <> text (show (ms_hs_date ms)),
1145                           text "ms_mod =" <+> ppr (ms_mod ms)
1146                                 <> text (hscSourceString (ms_hsc_src ms)) <> comma,
1147                           text "ms_imps =" <+> ppr (ms_imps ms),
1148                           text "ms_srcimps =" <+> ppr (ms_srcimps ms)]),
1149              char '}'
1150             ]
1151
1152 showModMsg :: HscTarget -> Bool -> ModSummary -> String
1153 showModMsg target recomp mod_summary
1154   = showSDoc (hsep [text (mod_str ++ replicate (max 0 (16 - length mod_str)) ' '),
1155                     char '(', text (msHsFilePath mod_summary) <> comma,
1156                     case target of
1157                       HscInterpreted | recomp
1158                                  -> text "interpreted"
1159                       HscNothing -> text "nothing"
1160                       _other     -> text (msObjFilePath mod_summary),
1161                     char ')'])
1162  where
1163     mod     = moduleName (ms_mod mod_summary)
1164     mod_str = showSDoc (ppr mod) ++ hscSourceString (ms_hsc_src mod_summary)
1165 \end{code}
1166
1167
1168 %************************************************************************
1169 %*                                                                      *
1170 \subsection{Hpc Support}
1171 %*                                                                      *
1172 %************************************************************************
1173
1174 \begin{code}
1175 type HpcInfo = Int             -- just the number of ticks in a module
1176
1177 noHpcInfo :: HpcInfo
1178 noHpcInfo = 0                  -- default = 0
1179 \end{code}
1180
1181 %************************************************************************
1182 %*                                                                      *
1183 \subsection{Linkable stuff}
1184 %*                                                                      *
1185 %************************************************************************
1186
1187 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
1188 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
1189
1190 \begin{code}
1191 data Linkable = LM {
1192   linkableTime     :: ClockTime,        -- Time at which this linkable was built
1193                                         -- (i.e. when the bytecodes were produced,
1194                                         --       or the mod date on the files)
1195   linkableModule   :: Module,           -- Should be Module, but see below
1196   linkableUnlinked :: [Unlinked]
1197  }
1198
1199 isObjectLinkable :: Linkable -> Bool
1200 isObjectLinkable l = not (null unlinked) && all isObject unlinked
1201   where unlinked = linkableUnlinked l
1202         -- A linkable with no Unlinked's is treated as a BCO.  We can
1203         -- generate a linkable with no Unlinked's as a result of
1204         -- compiling a module in HscNothing mode, and this choice
1205         -- happens to work well with checkStability in module GHC.
1206
1207 instance Outputable Linkable where
1208    ppr (LM when_made mod unlinkeds)
1209       = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
1210         $$ nest 3 (ppr unlinkeds)
1211
1212 -------------------------------------------
1213 data Unlinked
1214    = DotO FilePath
1215    | DotA FilePath
1216    | DotDLL FilePath
1217    | BCOs CompiledByteCode
1218
1219 #ifndef GHCI
1220 data CompiledByteCode = NoByteCode
1221 #endif
1222
1223 instance Outputable Unlinked where
1224    ppr (DotO path)   = text "DotO" <+> text path
1225    ppr (DotA path)   = text "DotA" <+> text path
1226    ppr (DotDLL path) = text "DotDLL" <+> text path
1227 #ifdef GHCI
1228    ppr (BCOs bcos)   = text "BCOs" <+> ppr bcos
1229 #else
1230    ppr (BCOs bcos)   = text "No byte code"
1231 #endif
1232
1233 isObject (DotO _)   = True
1234 isObject (DotA _)   = True
1235 isObject (DotDLL _) = True
1236 isObject _          = False
1237
1238 isInterpretable = not . isObject
1239
1240 nameOfObject (DotO fn)   = fn
1241 nameOfObject (DotA fn)   = fn
1242 nameOfObject (DotDLL fn) = fn
1243 nameOfObject other       = pprPanic "nameOfObject" (ppr other)
1244
1245 byteCodeOfObject (BCOs bc) = bc
1246 byteCodeOfObject other     = pprPanic "byteCodeOfObject" (ppr other)
1247 \end{code}
1248
1249 %************************************************************************
1250 %*                                                                      *
1251 \subsection{Breakpoint Support}
1252 %*                                                                      *
1253 %************************************************************************
1254
1255 \begin{code}
1256 type BreakIndex = Int
1257
1258 -- | all the information about the breakpoints for a given module
1259 data ModBreaks
1260    = ModBreaks
1261    { modBreaks_flags :: BreakArray
1262         -- The array of flags, one per breakpoint,
1263         -- indicating which breakpoints are enabled.
1264    , modBreaks_locs :: !(Array BreakIndex SrcSpan)
1265         -- An array giving the source span of each breakpoint.
1266    , modBreaks_vars :: !(Array BreakIndex [OccName])
1267         -- An array giving the names of the free variables at each breakpoint.
1268    }
1269
1270 emptyModBreaks :: ModBreaks
1271 emptyModBreaks = ModBreaks
1272    { modBreaks_flags = error "ModBreaks.modBreaks_array not initialised"
1273          -- Todo: can we avoid this?
1274    , modBreaks_locs = array (0,-1) []
1275    , modBreaks_vars = array (0,-1) []
1276    }
1277 \end{code}