X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fmain%2FHscTypes.lhs;h=5fd475cffbad46fc929997225126ff07fcd3f421;hb=3721dd37a707d2aacb5cac814410a78096e28a2c;hp=ed882397d7e4c31ceb9ad4fa74e6a7293606903f;hpb=92cdc09e48d3410182581f5bd687d1ee7cbe476b;p=ghc-hetmet.git diff --git a/ghc/compiler/main/HscTypes.lhs b/ghc/compiler/main/HscTypes.lhs index ed88239..5fd475c 100644 --- a/ghc/compiler/main/HscTypes.lhs +++ b/ghc/compiler/main/HscTypes.lhs @@ -1,143 +1,189 @@ -% + % (c) The University of Glasgow, 2000 % \section[HscTypes]{Types for the per-module compiler} \begin{code} module HscTypes ( + HscEnv(..), hscEPS, GhciMode(..), - ModuleLocation(..), showModMsg, + ModDetails(..), + ModGuts(..), ModImports(..), ForeignStubs(..), + + HomePackageTable, HomeModInfo(..), emptyHomePackageTable, - ModDetails(..), ModIface(..), - HomeSymbolTable, emptySymbolTable, - PackageTypeEnv, - HomeIfaceTable, PackageIfaceTable, emptyIfaceTable, - lookupIface, lookupIfaceByModName, + ExternalPackageState(..), + PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable, + lookupIface, lookupIfaceByModName, moduleNameToModule, emptyModIface, - InteractiveContext(..), + InteractiveContext(..), emptyInteractiveContext, + icPrintUnqual, unQualInScope, - IfaceDecls, mkIfaceDecls, dcl_tycl, dcl_rules, dcl_insts, + ModIface(..), mkIfaceDepCache, mkIfaceVerCache, mkIfaceFixCache, + emptyIfaceDepCache, - VersionInfo(..), initialVersionInfo, lookupVersion, + Deprecs(..), IfaceDeprecs, - TyThing(..), isTyClThing, implicitTyThingIds, + FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv, + implicitTyThings, isImplicitTyThing, + + TyThing(..), tyThingClass, tyThingTyCon, tyThingDataCon, tyThingId, TypeEnv, lookupType, mkTypeEnv, emptyTypeEnv, - extendTypeEnvList, extendTypeEnvWithIds, + extendTypeEnvList, extendTypeEnvWithIds, lookupTypeEnv, typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds, - ImportedModuleInfo, WhetherHasOrphans, ImportVersion, WhatsImported(..), - PersistentRenamerState(..), IsBootInterface, DeclsMap, - IfaceInsts, IfaceRules, GatedDecl, GatedDecls, GateFn, IsExported, - NameSupply(..), OrigNameCache, OrigIParamCache, - Avails, AvailEnv, emptyAvailEnv, + WhetherHasOrphans, IsBootInterface, Usage(..), + Dependencies(..), noDependencies, + Pool(..), emptyPool, DeclPool, InstPool, + Gated, + RulePool, RulePoolContents, addRuleToPool, + NameCache(..), OrigNameCache, OrigIParamCache, + Avails, availsToNameSet, availName, availNames, GenAvailInfo(..), AvailInfo, RdrAvailInfo, - PersistentCompilerState(..), + IfaceExport, - Deprecations(..), lookupDeprec, + Deprecations, DeprecTxt, lookupDeprec, plusDeprecs, - InstEnv, ClsInstEnv, DFunId, + InstEnv, DFunId, PackageInstEnv, PackageRuleBase, - GlobalRdrEnv, GlobalRdrElt(..), pprGlobalRdrEnv, - LocalRdrEnv, extendLocalRdrEnv, - - - -- Provenance - Provenance(..), ImportReason(..), - pprNameProvenance, hasBetterProv - + -- Linker stuff + Linkable(..), isObjectLinkable, + Unlinked(..), CompiledByteCode, + isObject, nameOfObject, isInterpretable, byteCodeOfObject ) where #include "HsVersions.h" -import RdrName ( RdrName, RdrNameEnv, addListToRdrEnv, emptyRdrEnv, - mkRdrUnqual, rdrEnvToList ) -import Name ( Name, NamedThing, getName, nameOccName, nameModule, nameSrcLoc ) +#ifdef GHCI +import ByteCodeAsm ( CompiledByteCode ) +#endif + +import RdrName ( GlobalRdrEnv, emptyGlobalRdrEnv, + LocalRdrEnv, emptyLocalRdrEnv, + GlobalRdrElt(..), unQualOK ) +import Name ( Name, NamedThing, getName, nameOccName, nameModule ) import NameEnv -import OccName ( OccName ) -import Module ( Module, ModuleName, ModuleEnv, - lookupModuleEnv, lookupModuleEnvByName, - emptyModuleEnv, moduleUserString - ) -import InstEnv ( InstEnv, ClsInstEnv, DFunId ) +import NameSet +import OccName ( OccName, OccEnv, lookupOccEnv, mkOccEnv, emptyOccEnv, + extendOccEnv, foldOccEnv ) +import Module +import InstEnv ( InstEnv, DFunId ) import Rules ( RuleBase ) import CoreSyn ( CoreBind ) -import Id ( Id ) -import Class ( Class, classSelIds ) -import TyCon ( TyCon, isNewTyCon, tyConGenIds, tyConSelIds, tyConDataConsIfAvailable ) -import DataCon ( dataConId, dataConWrapId ) +import Id ( Id, isImplicitId ) +import Type ( TyThing(..) ) -import BasicTypes ( Version, initialVersion, Fixity, IPName ) +import Class ( Class, classSelIds, classTyCon ) +import TyCon ( TyCon, isClassTyCon, tyConSelIds, tyConDataCons ) +import DataCon ( dataConImplicitIds ) +import Packages ( PackageName ) +import CmdLineOpts ( DynFlags ) -import HsSyn ( DeprecTxt, tyClDeclName, ifaceRuleDeclName ) -import RdrHsSyn ( RdrNameInstDecl, RdrNameRuleDecl, RdrNameTyClDecl ) -import RnHsSyn ( RenamedTyClDecl, RenamedRuleDecl, RenamedInstDecl ) +import BasicTypes ( Version, initialVersion, IPName, + Fixity, defaultFixity, DeprecTxt ) -import CoreSyn ( IdCoreRule ) +import IfaceSyn ( IfaceInst, IfaceRule, IfaceDecl(ifName) ) import FiniteMap ( FiniteMap ) -import Bag ( Bag ) -import Maybes ( seqMaybe, orElse ) +import CoreSyn ( IdCoreRule ) +import PrelNames ( isBuiltInSyntaxName ) +import Maybes ( orElse ) import Outputable -import SrcLoc ( SrcLoc, isGoodSrcLoc ) -import Util ( thenCmp, sortLt, unJust ) +import SrcLoc ( SrcSpan ) import UniqSupply ( UniqSupply ) +import Maybe ( fromJust ) +import FastString ( FastString ) + +import DATA_IOREF ( IORef, readIORef ) +import Time ( ClockTime ) \end{code} + %************************************************************************ %* * -\subsection{Which mode we're in +\subsection{Compilation environment} %* * %************************************************************************ +The HscEnv gives the environment in which to compile a chunk of code. + \begin{code} -data GhciMode = Batch | Interactive | OneShot - deriving Eq +data HscEnv + = HscEnv { hsc_mode :: GhciMode, + hsc_dflags :: DynFlags, + + hsc_HPT :: HomePackageTable, + -- The home package table describes already-compiled + -- home-packge modules, *excluding* the module we + -- are compiling right now. + -- (In one-shot mode the current module is the only + -- home-package module, so hsc_HPT is empty. All other + -- modules count as "external-package" modules.) + -- hsc_HPT is not mutable because we only demand-load + -- external packages; the home package is eagerly + -- loaded by the compilation manager. + + -- The next two are side-effected by compiling + -- to reflect sucking in interface files + hsc_EPS :: IORef ExternalPackageState, + hsc_NC :: IORef NameCache } + +hscEPS :: HscEnv -> IO ExternalPackageState +hscEPS hsc_env = readIORef (hsc_EPS hsc_env) \end{code} +The GhciMode is self-explanatory: -%************************************************************************ -%* * -\subsection{Module locations} -%* * -%************************************************************************ +\begin{code} +data GhciMode = Batch | Interactive | OneShot + deriving Eq +\end{code} \begin{code} -data ModuleLocation - = ModuleLocation { - ml_hs_file :: Maybe FilePath, - ml_hspp_file :: Maybe FilePath, -- path of preprocessed source - ml_hi_file :: FilePath, - ml_obj_file :: Maybe FilePath - } - deriving Show - -instance Outputable ModuleLocation where - ppr = text . show - --- Probably doesn't really belong here, but used in HscMain and InteractiveUI. - -showModMsg :: Bool -> Module -> ModuleLocation -> String -showModMsg use_object mod location = - mod_str ++ replicate (max 0 (16 - length mod_str)) ' ' - ++" ( " ++ unJust "showModMsg" (ml_hs_file location) ++ ", " - ++ (if use_object - then unJust "showModMsg" (ml_obj_file location) - else "interpreted") - ++ " )" - where mod_str = moduleUserString mod +type HomePackageTable = ModuleEnv HomeModInfo -- Domain = modules in the home package +type PackageIfaceTable = ModuleEnv ModIface -- Domain = modules in the imported packages + +emptyHomePackageTable = emptyModuleEnv +emptyPackageIfaceTable = emptyModuleEnv + +data HomeModInfo + = HomeModInfo { hm_iface :: ModIface, + hm_globals :: Maybe GlobalRdrEnv, -- Its top level environment + -- Nothing <-> compiled module + hm_details :: ModDetails, + hm_linkable :: Linkable } \end{code} -For a module in another package, the hs_file and obj_file -components of ModuleLocation are undefined. +Simple lookups in the symbol table. + +\begin{code} +lookupIface :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface +-- We often have two IfaceTables, and want to do a lookup +lookupIface hpt pit mod + = case lookupModuleEnv hpt mod of + Just mod_info -> Just (hm_iface mod_info) + Nothing -> lookupModuleEnv pit mod -The locations specified by a ModuleLocation may or may not -correspond to actual files yet: for example, even if the object -file doesn't exist, the ModuleLocation still contains the path to -where the object file will reside if/when it is created. +lookupIfaceByModName :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Maybe ModIface +-- We often have two IfaceTables, and want to do a lookup +lookupIfaceByModName hpt pit mod + = case lookupModuleEnvByName hpt mod of + Just mod_info -> Just (hm_iface mod_info) + Nothing -> lookupModuleEnvByName pit mod +\end{code} + +\begin{code} +-- Use instead of Finder.findModule if possible: this way doesn't +-- require filesystem operations, and it is guaranteed not to fail +-- when the IfaceTables are properly populated (i.e. after the renamer). +moduleNameToModule :: HomePackageTable -> PackageIfaceTable -> ModuleName -> Module +moduleNameToModule hpt pit mod + = mi_module (fromJust (lookupIfaceByModName hpt pit mod)) +\end{code} %************************************************************************ @@ -158,143 +204,165 @@ the declarations into a single indexed map in the @PersistentRenamerState@. \begin{code} data ModIface = ModIface { - mi_module :: !Module, -- Complete with package info - mi_version :: !VersionInfo, -- Module version number + mi_package :: !PackageName, -- Which package the module comes from + mi_module :: !Module, + mi_mod_vers :: !Version, -- Module version: changes when anything changes - mi_orphan :: WhetherHasOrphans, -- Whether this module has orphans - -- NOT STRICT! we fill this field with _|_ sometimes + mi_orphan :: !WhetherHasOrphans, -- Whether this module has orphans + mi_boot :: !IsBootInterface, -- Read from an hi-boot file? - mi_boot :: !IsBootInterface, -- read from an hi-boot file? + mi_deps :: Dependencies, + -- This is consulted for directly-imported modules, + -- but not for anything else (hence lazy) - mi_usages :: ![ImportVersion Name], -- Usages; kept sorted so that it's easy to decide -- whether to write a new iface file (changing usages -- doesn't affect the version of this module) - - mi_exports :: ![(ModuleName,Avails)], - -- What it exports Kept sorted by (mod,occ), to make - -- version comparisons easier - - mi_globals :: !(Maybe GlobalRdrEnv), - -- Its top level environment or Nothing if we read this - -- interface from a file. - - mi_fixities :: !(NameEnv Fixity), -- Fixities - mi_deprecs :: !Deprecations, -- Deprecations - - mi_decls :: IfaceDecls -- The RnDecls form of ModDetails - -- NOT STRICT! we fill this field with _|_ sometimes + mi_usages :: [Usage], + -- NOT STRICT! we read this field lazily from the interface file + -- It is *only* consulted by the recompilation checker + + -- Exports + -- Kept sorted by (mod,occ), to make version comparisons easier + mi_exports :: ![IfaceExport], + mi_exp_vers :: !Version, -- Version number of export list + + -- Fixities + mi_fixities :: [(OccName,Fixity)], + -- NOT STRICT! we read this field lazily from the interface file + + -- Deprecations + mi_deprecs :: Deprecs [(OccName,DeprecTxt)], + -- NOT STRICT! we read this field lazily from the interface file + + -- Type, class and variable declarations + -- The version of an Id changes if its fixity or deprecations change + -- (as well as its type of course) + -- Ditto data constructors, class operations, except that + -- the version of the parent class/tycon changes + mi_decls :: [(Version,IfaceDecl)], -- Sorted + + -- Instance declarations and rules + mi_insts :: [IfaceInst], -- Sorted + mi_rules :: [IfaceRule], -- Sorted + mi_rule_vers :: !Version, -- Version number for rules and instances combined + + -- Cached environments for easy lookup + -- These are computed (lazily) from other fields + -- and are not put into the interface file + mi_dep_fn :: Name -> Maybe DeprecTxt, -- Cached lookup for mi_deprecs + mi_fix_fn :: OccName -> Fixity, -- Cached lookup for mi_fixities + mi_ver_fn :: OccName -> Maybe Version -- Cached lookup for mi_decls + -- The Nothing in mi_ver_fn means that the thing + -- isn't in decls. It's useful to know that when + -- seeing if we are up to date wrt the old interface } -data IfaceDecls = IfaceDecls { dcl_tycl :: [RenamedTyClDecl], -- Sorted - dcl_rules :: [RenamedRuleDecl], -- Sorted - dcl_insts :: [RenamedInstDecl] } -- Unsorted - -mkIfaceDecls :: [RenamedTyClDecl] -> [RenamedRuleDecl] -> [RenamedInstDecl] -> IfaceDecls -mkIfaceDecls tycls rules insts - = IfaceDecls { dcl_tycl = sortLt lt_tycl tycls, - dcl_rules = sortLt lt_rule rules, - dcl_insts = insts } - where - d1 `lt_tycl` d2 = tyClDeclName d1 < tyClDeclName d2 - r1 `lt_rule` r2 = ifaceRuleDeclName r1 < ifaceRuleDeclName r2 - - --- typechecker should only look at this, not ModIface -- Should be able to construct ModDetails from mi_decls in ModIface data ModDetails = ModDetails { -- The next three fields are created by the typechecker md_types :: !TypeEnv, md_insts :: ![DFunId], -- Dfun-ids for the instances in this module - md_rules :: ![IdCoreRule], -- Domain may include Ids from other modules - md_binds :: ![CoreBind] + md_rules :: ![IdCoreRule] -- Domain may include Ids from other modules } --- The ModDetails takes on several slightly different forms: --- --- After typecheck + desugar --- md_types Contains TyCons, Classes, and implicit Ids --- md_insts All instances from this module (incl derived ones) --- md_rules All rules from this module --- md_binds Desugared bindings +-- A ModGuts is carried through the compiler, accumulating stuff as it goes +-- There is only one ModGuts at any time, the one for the module +-- being compiled right now. Once it is compiled, a ModIface and +-- ModDetails are extracted and the ModGuts is dicarded. + +data ModGuts + = ModGuts { + mg_module :: !Module, + mg_exports :: !NameSet, -- What it exports + mg_deps :: !Dependencies, -- What is below it, directly or otherwise + mg_dir_imps :: ![Module], -- Directly-imported modules; used to + -- generate initialisation code + mg_usages :: ![Usage], -- Version info for what it needed + + mg_rdr_env :: !GlobalRdrEnv, -- Top-level lexical environment + mg_fix_env :: !FixityEnv, -- Fixity env, for things declared in this module + mg_deprecs :: !Deprecations, -- Deprecations declared in the module + + mg_types :: !TypeEnv, + mg_insts :: ![DFunId], -- Instances + mg_rules :: ![IdCoreRule], -- Rules from this module + mg_binds :: ![CoreBind], -- Bindings for this module + mg_foreign :: !ForeignStubs + } + +-- The ModGuts takes on several slightly different forms: -- --- After simplification --- md_types Same as after typecheck --- md_insts Ditto --- md_rules Orphan rules only (local ones now attached to binds) --- md_binds With rules attached +-- After simplification, the following fields change slightly: +-- mg_rules Orphan rules only (local ones now attached to binds) +-- mg_binds With rules attached -- --- After CoreTidy --- md_types Now contains Ids as well, replete with final IdInfo +-- After CoreTidy, the following fields change slightly: +-- mg_types Now contains Ids as well, replete with final IdInfo -- The Ids are only the ones that are visible from -- importing modules. Without -O that means only -- exported Ids, but with -O importing modules may -- see ids mentioned in unfoldings of exported Ids -- --- md_insts Same DFunIds as before, but with final IdInfo, +-- mg_insts Same DFunIds as before, but with final IdInfo, -- and the unique might have changed; remember that -- CoreTidy links up the uniques of old and new versions -- --- md_rules All rules for exported things, substituted with final Ids --- --- md_binds Tidied +-- mg_rules All rules for exported things, substituted with final Ids -- --- Passed back to compilation manager --- Just as after CoreTidy, but with md_binds nuked +-- mg_binds Tidied + + + +data ModImports + = ModImports { + imp_direct :: ![(Module,Bool)], -- Explicitly-imported modules + -- Boolean is true if we imported the whole + -- module (apart, perhaps, from hiding some) + imp_pkg_mods :: !ModuleSet, -- Non-home-package modules on which we depend, + -- directly or indirectly + imp_home_names :: !NameSet -- Home package things on which we depend, + -- directly or indirectly + } + +data ForeignStubs = NoStubs + | ForeignStubs + SDoc -- Header file prototypes for + -- "foreign exported" functions + SDoc -- C stubs to use when calling + -- "foreign exported" functions + [FastString] -- Headers that need to be included + -- into C code generated for this module + [Id] -- Foreign-exported binders + -- we have to generate code to register these \end{code} \begin{code} -emptyModIface :: Module -> ModIface -emptyModIface mod - = ModIface { mi_module = mod, - mi_version = initialVersionInfo, - mi_usages = [], +emptyModIface :: PackageName -> ModuleName -> ModIface +emptyModIface pkg mod + = ModIface { mi_package = pkg, + mi_module = mkModule pkg mod, + mi_mod_vers = initialVersion, mi_orphan = False, mi_boot = False, + mi_deps = noDependencies, + mi_usages = [], mi_exports = [], - mi_fixities = emptyNameEnv, - mi_globals = Nothing, + mi_exp_vers = initialVersion, + mi_fixities = [], mi_deprecs = NoDeprecs, - mi_decls = panic "emptyModIface: decls" + mi_insts = [], + mi_rules = [], + mi_decls = [], + mi_rule_vers = initialVersion, + mi_dep_fn = emptyIfaceDepCache, + mi_fix_fn = emptyIfaceFixCache, + mi_ver_fn = emptyIfaceVerCache } \end{code} -Symbol tables map modules to ModDetails: - -\begin{code} -type SymbolTable = ModuleEnv ModDetails -type IfaceTable = ModuleEnv ModIface - -type HomeIfaceTable = IfaceTable -type PackageIfaceTable = IfaceTable - -type HomeSymbolTable = SymbolTable -- Domain = modules in the home package - -emptySymbolTable :: SymbolTable -emptySymbolTable = emptyModuleEnv - -emptyIfaceTable :: IfaceTable -emptyIfaceTable = emptyModuleEnv -\end{code} - -Simple lookups in the symbol table. - -\begin{code} -lookupIface :: HomeIfaceTable -> PackageIfaceTable -> Name -> Maybe ModIface --- We often have two IfaceTables, and want to do a lookup -lookupIface hit pit name - = lookupModuleEnv hit mod `seqMaybe` lookupModuleEnv pit mod - where - mod = nameModule name - -lookupIfaceByModName :: HomeIfaceTable -> PackageIfaceTable -> ModuleName -> Maybe ModIface --- We often have two IfaceTables, and want to do a lookup -lookupIfaceByModName hit pit mod - = lookupModuleEnvByName hit mod `seqMaybe` lookupModuleEnvByName pit mod -\end{code} - %************************************************************************ %* * @@ -305,108 +373,154 @@ lookupIfaceByModName hit pit mod \begin{code} data InteractiveContext = InteractiveContext { - ic_toplev_scope :: [Module], -- Include the "top-level" scope of + ic_toplev_scope :: [String], -- Include the "top-level" scope of -- these modules - ic_exports :: [Module], -- Include just the exports of these + ic_exports :: [String], -- Include just the exports of these -- modules ic_rn_gbl_env :: GlobalRdrEnv, -- The cached GlobalRdrEnv, built from -- ic_toplev_scope and ic_exports - ic_print_unqual :: PrintUnqualified, - -- cached PrintUnqualified, as above - ic_rn_local_env :: LocalRdrEnv, -- Lexical context for variables bound -- during interaction ic_type_env :: TypeEnv -- Ditto for types } + +emptyInteractiveContext + = InteractiveContext { ic_toplev_scope = [], + ic_exports = [], + ic_rn_gbl_env = emptyGlobalRdrEnv, + ic_rn_local_env = emptyLocalRdrEnv, + ic_type_env = emptyTypeEnv } + +icPrintUnqual :: InteractiveContext -> PrintUnqualified +icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt) +\end{code} + +@unQualInScope@ returns a function that takes a @Name@ and tells whether +its unqualified name is in scope. This is put as a boolean flag in +the @Name@'s provenance to guide whether or not to print the name qualified +in error messages. + +\begin{code} +unQualInScope :: GlobalRdrEnv -> Name -> Bool +-- True if 'f' is in scope, and has only one binding, +-- and the thing it is bound to is the name we are looking for +-- (i.e. false if A.f and B.f are both in scope as unqualified 'f') +-- +-- Also checks for built-in syntax, which is always 'in scope' +-- +-- This fn is only efficient if the shared +-- partial application is used a lot. +unQualInScope env + = \n -> n `elemNameSet` unqual_names || isBuiltInSyntaxName n + where + unqual_names :: NameSet + unqual_names = foldOccEnv add emptyNameSet env + add [gre] unquals | unQualOK gre = addOneToNameSet unquals (gre_name gre) + add _ unquals = unquals \end{code} %************************************************************************ %* * -\subsection{Type environment stuff} + TyThing %* * %************************************************************************ \begin{code} -data TyThing = AnId Id - | ATyCon TyCon - | AClass Class +isImplicitTyThing :: TyThing -> Bool +isImplicitTyThing (ADataCon dc) = True +isImplicitTyThing (AnId id) = isImplicitId id +isImplicitTyThing (ATyCon tc) = isClassTyCon tc +isImplicitTyThing other = False + +implicitTyThings :: TyThing -> [TyThing] +implicitTyThings (AnId id) = [] + + -- For type constructors, add the data cons (and their extras), + -- and the selectors and generic-programming Ids too + -- + -- Newtypes don't have a worker Id, so don't generate that? +implicitTyThings (ATyCon tc) = map AnId (tyConSelIds tc) ++ + concatMap (extras_plus . ADataCon) (tyConDataCons tc) + + -- For classes, add the class TyCon too (and its extras) + -- and the class selector Ids +implicitTyThings (AClass cl) = map AnId (classSelIds cl) ++ + extras_plus (ATyCon (classTyCon cl)) + + + -- For data cons add the worker and wrapper (if any) +implicitTyThings (ADataCon dc) = map AnId (dataConImplicitIds dc) + +extras_plus thing = thing : implicitTyThings thing -isTyClThing :: TyThing -> Bool -isTyClThing (ATyCon _) = True -isTyClThing (AClass _) = True -isTyClThing (AnId _) = False - -instance NamedThing TyThing where - getName (AnId id) = getName id - getName (ATyCon tc) = getName tc - getName (AClass cl) = getName cl +extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv +extendTypeEnvWithIds env ids + = extendNameEnvList env [(getName id, AnId id) | id <- ids] +\end{code} -instance Outputable TyThing where - ppr (AnId id) = ptext SLIT("AnId") <+> ppr id - ppr (ATyCon tc) = ptext SLIT("ATyCon") <+> ppr tc - ppr (AClass cl) = ptext SLIT("AClass") <+> ppr cl +%************************************************************************ +%* * + TypeEnv +%* * +%************************************************************************ +\begin{code} +type TypeEnv = NameEnv TyThing +emptyTypeEnv :: TypeEnv typeEnvElts :: TypeEnv -> [TyThing] typeEnvClasses :: TypeEnv -> [Class] typeEnvTyCons :: TypeEnv -> [TyCon] typeEnvIds :: TypeEnv -> [Id] +lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing +emptyTypeEnv = emptyNameEnv typeEnvElts env = nameEnvElts env typeEnvClasses env = [cl | AClass cl <- typeEnvElts env] typeEnvTyCons env = [tc | ATyCon tc <- typeEnvElts env] typeEnvIds env = [id | AnId id <- typeEnvElts env] -implicitTyThingIds :: [TyThing] -> [Id] --- Add the implicit data cons and selectors etc -implicitTyThingIds things - = concat (map go things) - where - go (AnId f) = [] - go (AClass cl) = classSelIds cl - go (ATyCon tc) = tyConGenIds tc ++ - tyConSelIds tc ++ - [ n | dc <- tyConDataConsIfAvailable tc, - n <- implicitConIds tc dc] - -- Synonyms return empty list of constructors and selectors - - implicitConIds tc dc -- Newtypes have a constructor wrapper, - -- but no worker - | isNewTyCon tc = [dataConWrapId dc] - | otherwise = [dataConId dc, dataConWrapId dc] -\end{code} - - -\begin{code} -type TypeEnv = NameEnv TyThing - -emptyTypeEnv = emptyNameEnv - mkTypeEnv :: [TyThing] -> TypeEnv mkTypeEnv things = extendTypeEnvList emptyTypeEnv things +lookupTypeEnv = lookupNameEnv + extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv +-- Extend the type environment extendTypeEnvList env things - = extendNameEnvList env [(getName thing, thing) | thing <- things] - -extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv -extendTypeEnvWithIds env ids - = extendNameEnvList env [(getName id, AnId id) | id <- ids] + = foldl extend env things + where + extend env thing = extendNameEnv env (getName thing) thing \end{code} \begin{code} -lookupType :: HomeSymbolTable -> PackageTypeEnv -> Name -> Maybe TyThing -lookupType hst pte name - = case lookupModuleEnv hst (nameModule name) of - Just details -> lookupNameEnv (md_types details) name +lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing +lookupType hpt pte name + = case lookupModuleEnv hpt (nameModule name) of + Just details -> lookupNameEnv (md_types (hm_details details)) name Nothing -> lookupNameEnv pte name \end{code} + +\begin{code} +tyThingTyCon (ATyCon tc) = tc +tyThingTyCon other = pprPanic "tyThingTyCon" (ppr other) + +tyThingClass (AClass cls) = cls +tyThingClass other = pprPanic "tyThingClass" (ppr other) + +tyThingDataCon (ADataCon dc) = dc +tyThingDataCon other = pprPanic "tyThingDataCon" (ppr other) + +tyThingId (AnId id) = id +tyThingId other = pprPanic "tyThingId" (ppr other) +\end{code} + %************************************************************************ %* * \subsection{Auxiliary types} @@ -417,35 +531,33 @@ These types are defined here because they are mentioned in ModDetails, but they are mostly elaborated elsewhere \begin{code} -data VersionInfo - = VersionInfo { - vers_module :: Version, -- Changes when anything changes - vers_exports :: Version, -- Changes when export list changes - vers_rules :: Version, -- Changes when any rule changes - vers_decls :: NameEnv Version - -- Versions for "big" names only (not data constructors, class ops) - -- The version of an Id changes if its fixity changes - -- Ditto data constructors, class operations, except that the version of - -- the parent class/tycon changes - -- - -- If a name isn't in the map, it means 'initialVersion' - } +mkIfaceVerCache :: [(Version,IfaceDecl)] -> OccName -> Maybe Version +mkIfaceVerCache pairs + = \occ -> lookupOccEnv env occ + where + env = foldl add emptyOccEnv pairs + add env (v,d) = extendOccEnv env (ifName d) v + +emptyIfaceVerCache :: OccName -> Maybe Version +emptyIfaceVerCache occ = Nothing -initialVersionInfo :: VersionInfo -initialVersionInfo = VersionInfo { vers_module = initialVersion, - vers_exports = initialVersion, - vers_rules = initialVersion, - vers_decls = emptyNameEnv - } +------------------ Deprecations ------------------------- +data Deprecs a + = NoDeprecs + | DeprecAll DeprecTxt -- Whole module deprecated + | DeprecSome a -- Some specific things deprecated + deriving( Eq ) -lookupVersion :: NameEnv Version -> Name -> Version -lookupVersion env name = lookupNameEnv env name `orElse` initialVersion +type IfaceDeprecs = Deprecs [(OccName,DeprecTxt)] +type Deprecations = Deprecs (NameEnv (OccName,DeprecTxt)) -data Deprecations = NoDeprecs - | DeprecAll DeprecTxt -- Whole module deprecated - | DeprecSome (NameEnv (Name,DeprecTxt)) -- Some things deprecated - -- Just "big" names - -- We keep the Name in the range, so we can print them out +mkIfaceDepCache:: IfaceDeprecs -> Name -> Maybe DeprecTxt +mkIfaceDepCache NoDeprecs = \n -> Nothing +mkIfaceDepCache (DeprecAll t) = \n -> Just t +mkIfaceDepCache (DeprecSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName + +emptyIfaceDepCache :: Name -> Maybe DeprecTxt +emptyIfaceDepCache n = Nothing lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt lookupDeprec NoDeprecs name = Nothing @@ -454,12 +566,12 @@ lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of Just (_, txt) -> Just txt Nothing -> Nothing -instance Eq Deprecations where - -- Used when checking whether we need write a new interface - NoDeprecs == NoDeprecs = True - (DeprecAll t1) == (DeprecAll t2) = t1 == t2 - (DeprecSome e1) == (DeprecSome e2) = nameEnvElts e1 == nameEnvElts e2 - d1 == d2 = False +plusDeprecs :: Deprecations -> Deprecations -> Deprecations +plusDeprecs d NoDeprecs = d +plusDeprecs NoDeprecs d = d +plusDeprecs d (DeprecAll t) = DeprecAll t +plusDeprecs (DeprecAll t) d = DeprecAll t +plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2) \end{code} @@ -477,11 +589,21 @@ data GenAvailInfo name = Avail name -- An ordinary identifier deriving( Eq ) -- Equality used when deciding if the interface has changed -type AvailEnv = NameEnv AvailInfo -- Maps a Name to the AvailInfo that contains it +type IfaceExport = (ModuleName, [GenAvailInfo OccName]) + +availsToNameSet :: [AvailInfo] -> NameSet +availsToNameSet avails = foldl add emptyNameSet avails + where + add set avail = addListToNameSet set (availNames avail) + +availName :: GenAvailInfo name -> name +availName (Avail n) = n +availName (AvailTC n _) = n + +availNames :: GenAvailInfo name -> [name] +availNames (Avail n) = [n] +availNames (AvailTC n ns) = ns -emptyAvailEnv :: AvailEnv -emptyAvailEnv = emptyNameEnv - instance Outputable n => Outputable (GenAvailInfo n) where ppr = pprAvail @@ -493,10 +615,38 @@ pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of pprAvail (Avail n) = ppr n \end{code} +\begin{code} +mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity +mkIfaceFixCache pairs + = \n -> lookupOccEnv env n `orElse` defaultFixity + where + env = mkOccEnv pairs + +emptyIfaceFixCache :: OccName -> Fixity +emptyIfaceFixCache n = defaultFixity + +-- This fixity environment is for source code only +type FixityEnv = NameEnv FixItem + +-- We keep the OccName in the range so that we can generate an interface from it +data FixItem = FixItem OccName Fixity SrcSpan + +instance Outputable FixItem where + ppr (FixItem occ fix loc) = ppr fix <+> ppr occ <+> parens (ppr loc) + +emptyFixityEnv :: FixityEnv +emptyFixityEnv = emptyNameEnv + +lookupFixity :: FixityEnv -> Name -> Fixity +lookupFixity env n = case lookupNameEnv env n of + Just (FixItem _ fix _) -> fix + Nothing -> defaultFixity +\end{code} + %************************************************************************ %* * -\subsection{ModIface} +\subsection{WhatsImported} %* * %************************************************************************ @@ -508,107 +658,92 @@ type WhetherHasOrphans = Bool -- * a transformation rule in a module other than the one defining -- the function in the head of the rule. -type IsBootInterface = Bool - -type ImportVersion name = (ModuleName, WhetherHasOrphans, IsBootInterface, WhatsImported name) +type IsBootInterface = Bool -data WhatsImported name = NothingAtAll -- The module is below us in the - -- hierarchy, but we import nothing - - | Everything Version -- Used for modules from other packages; - -- we record only the module's version number - - | Specifically - Version -- Module version - (Maybe Version) -- Export-list version, if we depend on it - [(name,Version)] -- List guaranteed non-empty - Version -- Rules version - - deriving( Eq ) - -- 'Specifically' doesn't let you say "I imported f but none of the rules in +-- Dependency info about modules and packages below this one +-- in the import hierarchy. See TcRnTypes.ImportAvails for details. +-- +-- Invariant: the dependencies of a module M never includes M +data Dependencies + = Deps { dep_mods :: [(ModuleName,IsBootInterface)], -- Home-package module dependencies + dep_pkgs :: [PackageName], -- External package dependencies + dep_orphs :: [ModuleName] } -- Orphan modules (whether home or external pkg) + +noDependencies :: Dependencies +noDependencies = Deps [] [] [] + +data Usage + = Usage { usg_name :: ModuleName, -- Name of the module + usg_mod :: Version, -- Module version + usg_entities :: [(OccName,Version)], -- Sorted by occurrence name + usg_exports :: Maybe Version, -- Export-list version, if we depend on it + usg_rules :: Version -- Orphan-rules version (for non-orphan + -- modules this will always be initialVersion) + } deriving( Eq ) + -- This type doesn't let you say "I imported f but none of the rules in -- the module". If you use anything in the module you get its rule version -- So if the rules change, you'll recompile, even if you don't use them. -- This is easy to implement, and it's safer: you might not have used the rules last -- time round, but if someone has added a new rule you might need it this time -- The export list field is (Just v) if we depend on the export list: - -- we imported the module without saying exactly what we imported + -- i.e. we imported the module without saying exactly what we imported -- We need to recompile if the module exports changes, because we might -- now have a name clash in the importing module. - -type IsExported = Name -> Bool -- True for names that are exported from this module \end{code} %************************************************************************ %* * -\subsection{The persistent compiler state} + The External Package State %* * %************************************************************************ -The @PersistentCompilerState@ persists across successive calls to the -compiler. - - * A ModIface for each non-home-package module - - * An accumulated TypeEnv from all the modules in imported packages - - * An accumulated InstEnv from all the modules in imported packages - The point is that we don't want to keep recreating it whenever - we compile a new module. The InstEnv component of pcPST is empty. - (This means we might "see" instances that we shouldn't "really" see; - but the Haskell Report is vague on what is meant to be visible, - so we just take the easy road here.) - - * Ditto for rules - - * The persistent renamer state - -\begin{code} -data PersistentCompilerState - = PCS { - pcs_PIT :: !PackageIfaceTable, -- Domain = non-home-package modules - -- the mi_decls component is empty - - pcs_PTE :: !PackageTypeEnv, -- Domain = non-home-package modules - -- except that the InstEnv components is empty - - pcs_insts :: !PackageInstEnv, -- The total InstEnv accumulated from all - -- the non-home-package modules - - pcs_rules :: !PackageRuleBase, -- Ditto RuleEnv - - pcs_PRS :: !PersistentRenamerState - } -\end{code} - - -The persistent renamer state contains: - - * A name supply, which deals with allocating unique names to - (Module,OccName) original names, - - * A "holding pen" for declarations that have been read out of - interface files but not yet sucked in, renamed, and typechecked - \begin{code} type PackageTypeEnv = TypeEnv type PackageRuleBase = RuleBase type PackageInstEnv = InstEnv -data PersistentRenamerState - = PRS { prsOrig :: !NameSupply, - prsImpMods :: !ImportedModuleInfo, - - -- Holding pens for stuff that has been read in - -- but not yet slurped into the renamer - prsDecls :: !DeclsMap, - prsInsts :: !IfaceInsts, - prsRules :: !IfaceRules - } +data ExternalPackageState + = EPS { + eps_PIT :: !PackageIfaceTable, + -- The ModuleIFaces for modules in external packages + -- whose interfaces we have opened + -- The declarations in these interface files are held in + -- eps_decls, eps_insts, eps_rules (below), not in the + -- mi_decls fields of the iPIT. + -- What _is_ in the iPIT is: + -- * The Module + -- * Version info + -- * Its exports + -- * Fixities + -- * Deprecations + + eps_PTE :: !PackageTypeEnv, -- Domain = external-package modules + + eps_inst_env :: !PackageInstEnv, -- The total InstEnv accumulated from + -- all the external-package modules + eps_rule_base :: !PackageRuleBase, -- Ditto RuleEnv + + + -- Holding pens for stuff that has been read in from file, + -- but not yet slurped into the renamer + eps_decls :: !DeclPool, + -- A single, global map of Names to unslurped decls + -- Decls move from here to eps_PTE + + eps_insts :: !InstPool, + -- The as-yet un-slurped instance decls + -- Decls move from here to eps_inst_env + -- Each instance is 'gated' by the names that must be + -- available before this instance decl is needed. + + eps_rules :: !RulePool + -- The as-yet un-slurped rules + } \end{code} -The NameSupply makes sure that there is just one Unique assigned for +The NameCache makes sure that there is just one Unique assigned for each original name; i.e. (module-name, occ-name) pair. The Name is always stored as a Global, and has the SrcLoc of its binding location. Actually that's not quite right. When we first encounter the original @@ -621,8 +756,8 @@ encounter the occurrence, we may not know the details of the module, so we just store junk. Then when we find the binding site, we fix it up. \begin{code} -data NameSupply - = NameSupply { nsUniqs :: UniqSupply, +data NameCache + = NameCache { nsUniqs :: UniqSupply, -- Supply of uniques nsNames :: OrigNameCache, -- Ensures that one original name gets one unique @@ -630,36 +765,42 @@ data NameSupply -- Ensures that one implicit parameter name gets one unique } -type OrigNameCache = FiniteMap (ModuleName,OccName) Name -type OrigIParamCache = FiniteMap (IPName RdrName) (IPName Name) +type OrigNameCache = ModuleEnv (OccEnv Name) +type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name) \end{code} -@ImportedModuleInfo@ contains info ONLY about modules that have not yet -been loaded into the iPIT. These modules are mentioned in interfaces we've -already read, so we know a tiny bit about them, but we havn't yet looked -at the interface file for the module itself. It needs to persist across -invocations of the renamer, at least from Rename.checkOldIface to Rename.renameSource. -And there's no harm in it persisting across multiple compilations. - \begin{code} -type ImportedModuleInfo = FiniteMap ModuleName (WhetherHasOrphans, IsBootInterface) -\end{code} - -A DeclsMap contains a binding for each Name in the declaration -including the constructors of a type decl etc. The Bool is True just -for the 'main' Name. - -\begin{code} -type DeclsMap = (NameEnv (AvailInfo, Bool, (Module, RdrNameTyClDecl)), Int) - -- The Int says how many have been sucked in - -type IfaceInsts = GatedDecls RdrNameInstDecl -type IfaceRules = GatedDecls RdrNameRuleDecl - -type GatedDecls d = (Bag (GatedDecl d), Int) -- The Int says how many have been sucked in -type GatedDecl d = (GateFn, (Module, d)) -type GateFn = (Name -> Bool) -> Bool -- Returns True <=> gate is open - -- The (Name -> Bool) fn returns True for visible Names +data Pool p = Pool p -- The pool itself + Int -- Number of decls slurped into the map + Int -- Number of decls slurped out of the map + +emptyPool p = Pool p 0 0 + +instance Outputable p => Outputable (Pool p) where + ppr (Pool p n_in n_out) -- Debug printing only + = vcat [ptext SLIT("Pool") <+> int n_in <+> int n_out, + nest 2 (ppr p)] + +type DeclPool = Pool (NameEnv IfaceDecl) -- Keyed by the "main thing" of the decl + +------------------------- +type Gated d = ([Name], (ModuleName, d)) -- The [Name] 'gate' the declaration + -- ModuleName records which iface file this + -- decl came from + +type RulePool = Pool RulePoolContents +type RulePoolContents = [Gated IfaceRule] + +addRuleToPool :: RulePoolContents + -> (ModuleName, IfaceRule) + -> [Name] -- Free vars of rule; always non-empty + -> RulePoolContents +addRuleToPool rules rule fvs = (fvs,rule) : rules + +------------------------- +type InstPool = Pool (NameEnv [Gated IfaceInst]) + -- The key of the Pool is the Class + -- The Names are the TyCons in the instance head -- For example, suppose this is in an interface file -- instance C T where ... -- We want to slurp this decl if both C and T are "visible" in @@ -669,103 +810,64 @@ type GateFn = (Name -> Bool) -> Bool -- Returns True <=> gate is open %************************************************************************ %* * -\subsection{Provenance and export info} +\subsection{Linkable stuff} %* * %************************************************************************ -A LocalRdrEnv is used for local bindings (let, where, lambda, case) +This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs +stuff is the *dynamic* linker, and isn't present in a stage-1 compiler \begin{code} -type LocalRdrEnv = RdrNameEnv Name - -extendLocalRdrEnv :: LocalRdrEnv -> [Name] -> LocalRdrEnv -extendLocalRdrEnv env names - = addListToRdrEnv env [(mkRdrUnqual (nameOccName n), n) | n <- names] +data Linkable = LM { + linkableTime :: ClockTime, -- Time at which this linkable was built + -- (i.e. when the bytecodes were produced, + -- or the mod date on the files) + linkableModName :: ModuleName, -- Should be Module, but see below + linkableUnlinked :: [Unlinked] + } + +isObjectLinkable :: Linkable -> Bool +isObjectLinkable l = all isObject (linkableUnlinked l) + +instance Outputable Linkable where + ppr (LM when_made mod unlinkeds) + = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod) + $$ nest 3 (ppr unlinkeds) + +------------------------------------------- +data Unlinked + = DotO FilePath + | DotA FilePath + | DotDLL FilePath + | BCOs CompiledByteCode + +#ifndef GHCI +data CompiledByteCode = NoByteCode +#endif + +instance Outputable Unlinked where + ppr (DotO path) = text "DotO" <+> text path + ppr (DotA path) = text "DotA" <+> text path + ppr (DotDLL path) = text "DotDLL" <+> text path +#ifdef GHCI + ppr (BCOs bcos) = text "BCOs" <+> ppr bcos +#else + ppr (BCOs bcos) = text "No byte code" +#endif + +isObject (DotO _) = True +isObject (DotA _) = True +isObject (DotDLL _) = True +isObject _ = False + +isInterpretable = not . isObject + +nameOfObject (DotO fn) = fn +nameOfObject (DotA fn) = fn +nameOfObject (DotDLL fn) = fn + +byteCodeOfObject (BCOs bc) = bc \end{code} -The GlobalRdrEnv gives maps RdrNames to Names. There is a separate -one for each module, corresponding to that module's top-level scope. -\begin{code} -type GlobalRdrEnv = RdrNameEnv [GlobalRdrElt] - -- The list is because there may be name clashes - -- These only get reported on lookup, not on construction -data GlobalRdrElt = GRE Name Provenance (Maybe DeprecTxt) - -- The Maybe DeprecTxt tells whether this name is deprecated - -pprGlobalRdrEnv env - = vcat (map pp (rdrEnvToList env)) - where - pp (rn, nps) = ppr rn <> colon <+> - vcat [ppr n <+> pprNameProvenance n p | (GRE n p _) <- nps] -\end{code} - -The "provenance" of something says how it came to be in scope. - -\begin{code} -data Provenance - = LocalDef -- Defined locally - - | NonLocalDef -- Defined non-locally - ImportReason - --- Just used for grouping error messages (in RnEnv.warnUnusedBinds) -instance Eq Provenance where - p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False - -instance Eq ImportReason where - p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False - -instance Ord Provenance where - compare LocalDef LocalDef = EQ - compare LocalDef (NonLocalDef _) = LT - compare (NonLocalDef _) LocalDef = GT - - compare (NonLocalDef reason1) (NonLocalDef reason2) - = compare reason1 reason2 - -instance Ord ImportReason where - compare ImplicitImport ImplicitImport = EQ - compare ImplicitImport (UserImport _ _ _) = LT - compare (UserImport _ _ _) ImplicitImport = GT - compare (UserImport m1 loc1 _) (UserImport m2 loc2 _) - = (m1 `compare` m2) `thenCmp` (loc1 `compare` loc2) - - -data ImportReason - = UserImport Module SrcLoc Bool -- Imported from module M on line L - -- Note the M may well not be the defining module - -- for this thing! - -- The Bool is true iff the thing was named *explicitly* in the import spec, - -- rather than being imported as part of a group; e.g. - -- import B - -- import C( T(..) ) - -- Here, everything imported by B, and the constructors of T - -- are not named explicitly; only T is named explicitly. - -- This info is used when warning of unused names. - - | ImplicitImport -- Imported implicitly for some other reason -\end{code} - -\begin{code} -hasBetterProv :: Provenance -> Provenance -> Bool --- Choose --- a local thing over an imported thing --- a user-imported thing over a non-user-imported thing --- an explicitly-imported thing over an implicitly imported thing -hasBetterProv LocalDef _ = True -hasBetterProv (NonLocalDef (UserImport _ _ _ )) (NonLocalDef ImplicitImport) = True -hasBetterProv _ _ = False - -pprNameProvenance :: Name -> Provenance -> SDoc -pprNameProvenance name LocalDef = ptext SLIT("defined at") <+> ppr (nameSrcLoc name) -pprNameProvenance name (NonLocalDef why) = sep [ppr_reason why, - nest 2 (ppr_defn (nameSrcLoc name))] - -ppr_reason ImplicitImport = ptext SLIT("implicitly imported") -ppr_reason (UserImport mod loc _) = ptext SLIT("imported from") <+> ppr mod <+> ptext SLIT("at") <+> ppr loc - -ppr_defn loc | isGoodSrcLoc loc = parens (ptext SLIT("at") <+> ppr loc) - | otherwise = empty -\end{code}