Module reexports, fixing #8407.
[ghc.git] / 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 {-# LANGUAGE CPP, DeriveDataTypeable, ScopedTypeVariables #-}
8
9 -- | Types for the per-module compiler
10 module HscTypes (
11         -- * compilation state
12         HscEnv(..), hscEPS,
13         FinderCache, FindResult(..), ModLocationCache,
14         Target(..), TargetId(..), pprTarget, pprTargetId,
15         ModuleGraph, emptyMG,
16         HscStatus(..),
17
18         -- * Hsc monad
19         Hsc(..), runHsc, runInteractiveHsc,
20
21         -- * Information about modules
22         ModDetails(..), emptyModDetails,
23         ModGuts(..), CgGuts(..), ForeignStubs(..), appendStubC,
24         ImportedMods, ImportedModsVal,
25
26         ModSummary(..), ms_imps, ms_mod_name, showModMsg, isBootSummary,
27         msHsFilePath, msHiFilePath, msObjFilePath,
28         SourceModified(..),
29
30         -- * Information about the module being compiled
31         HscSource(..), isHsBoot, hscSourceString,       -- Re-exported from DriverPhases
32
33         -- * State relating to modules in this package
34         HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
35         hptInstances, hptRules, hptVectInfo, pprHPT,
36         hptObjs,
37
38         -- * State relating to known packages
39         ExternalPackageState(..), EpsStats(..), addEpsInStats,
40         PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
41         lookupIfaceByModule, emptyModIface,
42
43         PackageInstEnv, PackageFamInstEnv, PackageRuleBase,
44
45         mkSOName, mkHsSOName, soExt,
46
47         -- * Annotations
48         prepareAnnotations,
49
50         -- * Interactive context
51         InteractiveContext(..), emptyInteractiveContext,
52         icPrintUnqual, icInScopeTTs, icExtendGblRdrEnv,
53         extendInteractiveContext, substInteractiveContext,
54         setInteractivePrintName, icInteractiveModule,
55         InteractiveImport(..), setInteractivePackage,
56         mkPrintUnqualified, pprModulePrefix,
57
58         -- * Interfaces
59         ModIface(..), mkIfaceWarnCache, mkIfaceHashCache, mkIfaceFixCache,
60         emptyIfaceWarnCache, 
61
62         -- * Fixity
63         FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,
64
65         -- * TyThings and type environments
66         TyThing(..),  tyThingAvailInfo,
67         tyThingTyCon, tyThingDataCon,
68         tyThingId, tyThingCoAxiom, tyThingParent_maybe, tyThingsTyVars,
69         implicitTyThings, implicitTyConThings, implicitClassThings,
70         isImplicitTyThing,
71
72         TypeEnv, lookupType, lookupTypeHscEnv, mkTypeEnv, emptyTypeEnv,
73         typeEnvFromEntities, mkTypeEnvWithImplicits,
74         extendTypeEnv, extendTypeEnvList,
75         extendTypeEnvWithIds, 
76         lookupTypeEnv,
77         typeEnvElts, typeEnvTyCons, typeEnvIds, typeEnvPatSyns,
78         typeEnvDataCons, typeEnvCoAxioms, typeEnvClasses,
79
80         -- * MonadThings
81         MonadThings(..),
82
83         -- * Information on imports and exports
84         WhetherHasOrphans, IsBootInterface, Usage(..),
85         Dependencies(..), noDependencies,
86         NameCache(..), OrigNameCache,
87         IfaceExport,
88
89         -- * Warnings
90         Warnings(..), WarningTxt(..), plusWarns,
91
92         -- * Linker stuff
93         Linkable(..), isObjectLinkable, linkableObjs,
94         Unlinked(..), CompiledByteCode,
95         isObject, nameOfObject, isInterpretable, byteCodeOfObject,
96
97         -- * Program coverage
98         HpcInfo(..), emptyHpcInfo, isHpcUsed, AnyHpcUsage,
99
100         -- * Breakpoints
101         ModBreaks (..), BreakIndex, emptyModBreaks,
102
103         -- * Vectorisation information
104         VectInfo(..), IfaceVectInfo(..), noVectInfo, plusVectInfo,
105         noIfaceVectInfo, isNoIfaceVectInfo,
106
107         -- * Safe Haskell information
108         IfaceTrustInfo, getSafeMode, setSafeMode, noIfaceTrustInfo,
109         trustInfoToNum, numToTrustInfo, IsSafeImport,
110
111         -- * result of the parser
112         HsParsedModule(..),
113
114         -- * Compilation errors and warnings
115         SourceError, GhcApiError, mkSrcErr, srcErrorMessages, mkApiErr,
116         throwOneError, handleSourceError,
117         handleFlagWarnings, printOrThrowWarnings,
118     ) where
119
120 #include "HsVersions.h"
121
122 #ifdef GHCI
123 import ByteCodeAsm      ( CompiledByteCode )
124 import InteractiveEvalTypes ( Resume )
125 #endif
126
127 import HsSyn
128 import RdrName
129 import Avail
130 import Module
131 import InstEnv          ( InstEnv, ClsInst )
132 import FamInstEnv
133 import Rules            ( RuleBase )
134 import CoreSyn          ( CoreProgram )
135 import Name
136 import NameEnv
137 import NameSet
138 import VarEnv
139 import VarSet
140 import Var
141 import Id
142 import IdInfo           ( IdDetails(..) )
143 import Type
144
145 import Annotations      ( Annotation, AnnEnv, mkAnnEnv, plusAnnEnv )
146 import Class
147 import TyCon
148 import CoAxiom
149 import ConLike
150 import DataCon
151 import PatSyn
152 import PrelNames        ( gHC_PRIM, ioTyConName, printName, mkInteractiveModule )
153 import Packages hiding  ( Version(..) )
154 import DynFlags
155 import DriverPhases     ( Phase, HscSource(..), isHsBoot, hscSourceString )
156 import BasicTypes
157 import IfaceSyn
158 import CoreSyn          ( CoreRule, CoreVect )
159 import Maybes
160 import Outputable
161 import BreakArray
162 import SrcLoc
163 -- import Unique
164 import UniqFM
165 import UniqSupply
166 import FastString
167 import StringBuffer     ( StringBuffer )
168 import Fingerprint
169 import MonadUtils
170 import Bag
171 import Binary
172 import ErrUtils
173 import Platform
174 import Util
175
176 import Control.Monad    ( guard, liftM, when, ap )
177 import Data.Array       ( Array, array )
178 import Data.IORef
179 import Data.Time
180 import Data.Word
181 import Data.Typeable    ( Typeable )
182 import Exception
183 import System.FilePath
184
185 -- -----------------------------------------------------------------------------
186 -- Compilation state
187 -- -----------------------------------------------------------------------------
188
189 -- | Status of a compilation to hard-code
190 data HscStatus
191     = HscNotGeneratingCode
192     | HscUpToDate
193     | HscUpdateBoot
194     | HscRecomp CgGuts ModSummary
195
196 -- -----------------------------------------------------------------------------
197 -- The Hsc monad: Passing an environment and warning state
198
199 newtype Hsc a = Hsc (HscEnv -> WarningMessages -> IO (a, WarningMessages))
200
201 instance Functor Hsc where
202     fmap = liftM
203
204 instance Applicative Hsc where
205     pure = return
206     (<*>) = ap
207
208 instance Monad Hsc where
209     return a    = Hsc $ \_ w -> return (a, w)
210     Hsc m >>= k = Hsc $ \e w -> do (a, w1) <- m e w
211                                    case k a of
212                                        Hsc k' -> k' e w1
213
214 instance MonadIO Hsc where
215     liftIO io = Hsc $ \_ w -> do a <- io; return (a, w)
216
217 instance HasDynFlags Hsc where
218     getDynFlags = Hsc $ \e w -> return (hsc_dflags e, w)
219
220 runHsc :: HscEnv -> Hsc a -> IO a
221 runHsc hsc_env (Hsc hsc) = do
222     (a, w) <- hsc hsc_env emptyBag
223     printOrThrowWarnings (hsc_dflags hsc_env) w
224     return a
225
226 runInteractiveHsc :: HscEnv -> Hsc a -> IO a
227 -- A variant of runHsc that switches in the DynFlags from the
228 -- InteractiveContext before running the Hsc computation.
229 runInteractiveHsc hsc_env
230   = runHsc (hsc_env { hsc_dflags = interactive_dflags })
231   where
232     interactive_dflags = ic_dflags (hsc_IC hsc_env)
233
234 -- -----------------------------------------------------------------------------
235 -- Source Errors
236
237 -- When the compiler (HscMain) discovers errors, it throws an
238 -- exception in the IO monad.
239
240 mkSrcErr :: ErrorMessages -> SourceError
241 mkSrcErr = SourceError
242
243 srcErrorMessages :: SourceError -> ErrorMessages
244 srcErrorMessages (SourceError msgs) = msgs
245
246 mkApiErr :: DynFlags -> SDoc -> GhcApiError
247 mkApiErr dflags msg = GhcApiError (showSDoc dflags msg)
248
249 throwOneError :: MonadIO m => ErrMsg -> m ab
250 throwOneError err = liftIO $ throwIO $ mkSrcErr $ unitBag err
251
252 -- | A source error is an error that is caused by one or more errors in the
253 -- source code.  A 'SourceError' is thrown by many functions in the
254 -- compilation pipeline.  Inside GHC these errors are merely printed via
255 -- 'log_action', but API clients may treat them differently, for example,
256 -- insert them into a list box.  If you want the default behaviour, use the
257 -- idiom:
258 --
259 -- > handleSourceError printExceptionAndWarnings $ do
260 -- >   ... api calls that may fail ...
261 --
262 -- The 'SourceError's error messages can be accessed via 'srcErrorMessages'.
263 -- This list may be empty if the compiler failed due to @-Werror@
264 -- ('Opt_WarnIsError').
265 --
266 -- See 'printExceptionAndWarnings' for more information on what to take care
267 -- of when writing a custom error handler.
268 newtype SourceError = SourceError ErrorMessages
269   deriving Typeable
270
271 instance Show SourceError where
272   show (SourceError msgs) = unlines . map show . bagToList $ msgs
273
274 instance Exception SourceError
275
276 -- | Perform the given action and call the exception handler if the action
277 -- throws a 'SourceError'.  See 'SourceError' for more information.
278 handleSourceError :: (ExceptionMonad m) =>
279                      (SourceError -> m a) -- ^ exception handler
280                   -> m a -- ^ action to perform
281                   -> m a
282 handleSourceError handler act =
283   gcatch act (\(e :: SourceError) -> handler e)
284
285 -- | An error thrown if the GHC API is used in an incorrect fashion.
286 newtype GhcApiError = GhcApiError String
287   deriving Typeable
288
289 instance Show GhcApiError where
290   show (GhcApiError msg) = msg
291
292 instance Exception GhcApiError
293
294 -- | Given a bag of warnings, turn them into an exception if
295 -- -Werror is enabled, or print them out otherwise.
296 printOrThrowWarnings :: DynFlags -> Bag WarnMsg -> IO ()
297 printOrThrowWarnings dflags warns
298   | gopt Opt_WarnIsError dflags
299   = when (not (isEmptyBag warns)) $ do
300       throwIO $ mkSrcErr $ warns `snocBag` warnIsErrorMsg dflags
301   | otherwise
302   = printBagOfErrors dflags warns
303
304 handleFlagWarnings :: DynFlags -> [Located String] -> IO ()
305 handleFlagWarnings dflags warns
306  = when (wopt Opt_WarnDeprecatedFlags dflags) $ do
307         -- It would be nicer if warns :: [Located MsgDoc], but that
308         -- has circular import problems.
309       let bag = listToBag [ mkPlainWarnMsg dflags loc (text warn)
310                           | L loc warn <- warns ]
311
312       printOrThrowWarnings dflags bag
313 \end{code}
314
315 %************************************************************************
316 %*                                                                      *
317 \subsection{HscEnv}
318 %*                                                                      *
319 %************************************************************************
320
321 \begin{code}
322
323 -- | Hscenv is like 'Session', except that some of the fields are immutable.
324 -- An HscEnv is used to compile a single module from plain Haskell source
325 -- code (after preprocessing) to either C, assembly or C--.  Things like
326 -- the module graph don't change during a single compilation.
327 --
328 -- Historical note: \"hsc\" used to be the name of the compiler binary,
329 -- when there was a separate driver and compiler.  To compile a single
330 -- module, the driver would invoke hsc on the source code... so nowadays
331 -- we think of hsc as the layer of the compiler that deals with compiling
332 -- a single module.
333 data HscEnv
334   = HscEnv {
335         hsc_dflags :: DynFlags,
336                 -- ^ The dynamic flag settings
337
338         hsc_targets :: [Target],
339                 -- ^ The targets (or roots) of the current session
340
341         hsc_mod_graph :: ModuleGraph,
342                 -- ^ The module graph of the current session
343
344         hsc_IC :: InteractiveContext,
345                 -- ^ The context for evaluating interactive statements
346
347         hsc_HPT    :: HomePackageTable,
348                 -- ^ The home package table describes already-compiled
349                 -- home-package modules, /excluding/ the module we
350                 -- are compiling right now.
351                 -- (In one-shot mode the current module is the only
352                 -- home-package module, so hsc_HPT is empty.  All other
353                 -- modules count as \"external-package\" modules.
354                 -- However, even in GHCi mode, hi-boot interfaces are
355                 -- demand-loaded into the external-package table.)
356                 --
357                 -- 'hsc_HPT' is not mutable because we only demand-load
358                 -- external packages; the home package is eagerly
359                 -- loaded, module by module, by the compilation manager.
360                 --
361                 -- The HPT may contain modules compiled earlier by @--make@
362                 -- but not actually below the current module in the dependency
363                 -- graph.
364                 --
365                 -- (This changes a previous invariant: changed Jan 05.)
366
367         hsc_EPS :: {-# UNPACK #-} !(IORef ExternalPackageState),
368                 -- ^ Information about the currently loaded external packages.
369                 -- This is mutable because packages will be demand-loaded during
370                 -- a compilation run as required.
371
372         hsc_NC  :: {-# UNPACK #-} !(IORef NameCache),
373                 -- ^ As with 'hsc_EPS', this is side-effected by compiling to
374                 -- reflect sucking in interface files.  They cache the state of
375                 -- external interface files, in effect.
376
377         hsc_FC   :: {-# UNPACK #-} !(IORef FinderCache),
378                 -- ^ The cached result of performing finding in the file system
379         hsc_MLC  :: {-# UNPACK #-} !(IORef ModLocationCache),
380                 -- ^ This caches the location of modules, so we don't have to
381                 -- search the filesystem multiple times. See also 'hsc_FC'.
382
383         hsc_type_env_var :: Maybe (Module, IORef TypeEnv)
384                 -- ^ Used for one-shot compilation only, to initialise
385                 -- the 'IfGblEnv'. See 'TcRnTypes.tcg_type_env_var' for
386                 -- 'TcRunTypes.TcGblEnv'
387  }
388
389 instance ContainsDynFlags HscEnv where
390     extractDynFlags env = hsc_dflags env
391     replaceDynFlags env dflags = env {hsc_dflags = dflags}
392
393 -- | Retrieve the ExternalPackageState cache.
394 hscEPS :: HscEnv -> IO ExternalPackageState
395 hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
396
397 -- | A compilation target.
398 --
399 -- A target may be supplied with the actual text of the
400 -- module.  If so, use this instead of the file contents (this
401 -- is for use in an IDE where the file hasn't been saved by
402 -- the user yet).
403 data Target
404   = Target {
405       targetId           :: TargetId, -- ^ module or filename
406       targetAllowObjCode :: Bool,     -- ^ object code allowed?
407       targetContents     :: Maybe (StringBuffer,UTCTime)
408                                         -- ^ in-memory text buffer?
409     }
410
411 data TargetId
412   = TargetModule ModuleName
413         -- ^ A module name: search for the file
414   | TargetFile FilePath (Maybe Phase)
415         -- ^ A filename: preprocess & parse it to find the module name.
416         -- If specified, the Phase indicates how to compile this file
417         -- (which phase to start from).  Nothing indicates the starting phase
418         -- should be determined from the suffix of the filename.
419   deriving Eq
420
421 pprTarget :: Target -> SDoc
422 pprTarget (Target id obj _) =
423     (if obj then char '*' else empty) <> pprTargetId id
424
425 instance Outputable Target where
426     ppr = pprTarget
427
428 pprTargetId :: TargetId -> SDoc
429 pprTargetId (TargetModule m) = ppr m
430 pprTargetId (TargetFile f _) = text f
431
432 instance Outputable TargetId where
433     ppr = pprTargetId
434 \end{code}
435
436 %************************************************************************
437 %*                                                                      *
438 \subsection{Package and Module Tables}
439 %*                                                                      *
440 %************************************************************************
441
442 \begin{code}
443 -- | Helps us find information about modules in the home package
444 type HomePackageTable  = ModuleNameEnv HomeModInfo
445         -- Domain = modules in the home package that have been fully compiled
446         -- "home" package name cached here for convenience
447
448 -- | Helps us find information about modules in the imported packages
449 type PackageIfaceTable = ModuleEnv ModIface
450         -- Domain = modules in the imported packages
451
452 -- | Constructs an empty HomePackageTable
453 emptyHomePackageTable :: HomePackageTable
454 emptyHomePackageTable  = emptyUFM
455
456 -- | Constructs an empty PackageIfaceTable
457 emptyPackageIfaceTable :: PackageIfaceTable
458 emptyPackageIfaceTable = emptyModuleEnv
459
460 pprHPT :: HomePackageTable -> SDoc
461 -- A bit aribitrary for now
462 pprHPT hpt
463   = vcat [ hang (ppr (mi_module (hm_iface hm)))
464               2 (ppr (md_types (hm_details hm)))
465          | hm <- eltsUFM hpt ]
466
467 lookupHptByModule :: HomePackageTable -> Module -> Maybe HomeModInfo
468 -- The HPT is indexed by ModuleName, not Module,
469 -- we must check for a hit on the right Module
470 lookupHptByModule hpt mod
471   = case lookupUFM hpt (moduleName mod) of
472       Just hm | mi_module (hm_iface hm) == mod -> Just hm
473       _otherwise                               -> Nothing
474
475 -- | Information about modules in the package being compiled
476 data HomeModInfo
477   = HomeModInfo {
478       hm_iface    :: !ModIface,
479         -- ^ The basic loaded interface file: every loaded module has one of
480         -- these, even if it is imported from another package
481       hm_details  :: !ModDetails,
482         -- ^ Extra information that has been created from the 'ModIface' for
483         -- the module, typically during typechecking
484       hm_linkable :: !(Maybe Linkable)
485         -- ^ The actual artifact we would like to link to access things in
486         -- this module.
487         --
488         -- 'hm_linkable' might be Nothing:
489         --
490         --   1. If this is an .hs-boot module
491         --
492         --   2. Temporarily during compilation if we pruned away
493         --      the old linkable because it was out of date.
494         --
495         -- After a complete compilation ('GHC.load'), all 'hm_linkable' fields
496         -- in the 'HomePackageTable' will be @Just@.
497         --
498         -- When re-linking a module ('HscMain.HscNoRecomp'), we construct the
499         -- 'HomeModInfo' by building a new 'ModDetails' from the old
500         -- 'ModIface' (only).
501     }
502
503 -- | Find the 'ModIface' for a 'Module', searching in both the loaded home
504 -- and external package module information
505 lookupIfaceByModule
506         :: DynFlags
507         -> HomePackageTable
508         -> PackageIfaceTable
509         -> Module
510         -> Maybe ModIface
511 lookupIfaceByModule _dflags hpt pit mod
512   = case lookupHptByModule hpt mod of
513        Just hm -> Just (hm_iface hm)
514        Nothing -> lookupModuleEnv pit mod
515
516 -- If the module does come from the home package, why do we look in the PIT as well?
517 -- (a) In OneShot mode, even home-package modules accumulate in the PIT
518 -- (b) Even in Batch (--make) mode, there is *one* case where a home-package
519 --     module is in the PIT, namely GHC.Prim when compiling the base package.
520 -- We could eliminate (b) if we wanted, by making GHC.Prim belong to a package
521 -- of its own, but it doesn't seem worth the bother.
522
523
524 -- | Find all the instance declarations (of classes and families) from
525 -- the Home Package Table filtered by the provided predicate function.
526 -- Used in @tcRnImports@, to select the instances that are in the
527 -- transitive closure of imports from the currently compiled module.
528 hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])
529 hptInstances hsc_env want_this_module
530   = let (insts, famInsts) = unzip $ flip hptAllThings hsc_env $ \mod_info -> do
531                 guard (want_this_module (moduleName (mi_module (hm_iface mod_info))))
532                 let details = hm_details mod_info
533                 return (md_insts details, md_fam_insts details)
534     in (concat insts, concat famInsts)
535
536 -- | Get the combined VectInfo of all modules in the home package table. In
537 -- contrast to instances and rules, we don't care whether the modules are
538 -- "below" us in the dependency sense. The VectInfo of those modules not "below"
539 -- us does not affect the compilation of the current module.
540 hptVectInfo :: HscEnv -> VectInfo
541 hptVectInfo = concatVectInfo . hptAllThings ((: []) . md_vect_info . hm_details)
542
543 -- | Get rules from modules "below" this one (in the dependency sense)
544 hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]
545 hptRules = hptSomeThingsBelowUs (md_rules . hm_details) False
546
547
548 -- | Get annotations from modules "below" this one (in the dependency sense)
549 hptAnns :: HscEnv -> Maybe [(ModuleName, IsBootInterface)] -> [Annotation]
550 hptAnns hsc_env (Just deps) = hptSomeThingsBelowUs (md_anns . hm_details) False hsc_env deps
551 hptAnns hsc_env Nothing = hptAllThings (md_anns . hm_details) hsc_env
552
553 hptAllThings :: (HomeModInfo -> [a]) -> HscEnv -> [a]
554 hptAllThings extract hsc_env = concatMap extract (eltsUFM (hsc_HPT hsc_env))
555
556 -- | Get things from modules "below" this one (in the dependency sense)
557 -- C.f Inst.hptInstances
558 hptSomeThingsBelowUs :: (HomeModInfo -> [a]) -> Bool -> HscEnv -> [(ModuleName, IsBootInterface)] -> [a]
559 hptSomeThingsBelowUs extract include_hi_boot hsc_env deps
560   | isOneShot (ghcMode (hsc_dflags hsc_env)) = []
561
562   | otherwise
563   = let hpt = hsc_HPT hsc_env
564     in
565     [ thing
566     |   -- Find each non-hi-boot module below me
567       (mod, is_boot_mod) <- deps
568     , include_hi_boot || not is_boot_mod
569
570         -- unsavoury: when compiling the base package with --make, we
571         -- sometimes try to look up RULES etc for GHC.Prim. GHC.Prim won't
572         -- be in the HPT, because we never compile it; it's in the EPT
573         -- instead. ToDo: clean up, and remove this slightly bogus filter:
574     , mod /= moduleName gHC_PRIM
575
576         -- Look it up in the HPT
577     , let things = case lookupUFM hpt mod of
578                     Just info -> extract info
579                     Nothing -> pprTrace "WARNING in hptSomeThingsBelowUs" msg []
580           msg = vcat [ptext (sLit "missing module") <+> ppr mod,
581                       ptext (sLit "Probable cause: out-of-date interface files")]
582                         -- This really shouldn't happen, but see Trac #962
583
584         -- And get its dfuns
585     , thing <- things ]
586
587 hptObjs :: HomePackageTable -> [FilePath]
588 hptObjs hpt = concat (map (maybe [] linkableObjs . hm_linkable) (eltsUFM hpt))
589 \end{code}
590
591 %************************************************************************
592 %*                                                                      *
593 \subsection{Dealing with Annotations}
594 %*                                                                      *
595 %************************************************************************
596
597 \begin{code}
598 -- | Deal with gathering annotations in from all possible places
599 --   and combining them into a single 'AnnEnv'
600 prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv
601 prepareAnnotations hsc_env mb_guts = do
602     eps <- hscEPS hsc_env
603     let -- Extract annotations from the module being compiled if supplied one
604         mb_this_module_anns = fmap (mkAnnEnv . mg_anns) mb_guts
605         -- Extract dependencies of the module if we are supplied one,
606         -- otherwise load annotations from all home package table
607         -- entries regardless of dependency ordering.
608         home_pkg_anns  = (mkAnnEnv . hptAnns hsc_env) $ fmap (dep_mods . mg_deps) mb_guts
609         other_pkg_anns = eps_ann_env eps
610         ann_env        = foldl1' plusAnnEnv $ catMaybes [mb_this_module_anns,
611                                                          Just home_pkg_anns,
612                                                          Just other_pkg_anns]
613     return ann_env
614 \end{code}
615
616 %************************************************************************
617 %*                                                                      *
618 \subsection{The Finder cache}
619 %*                                                                      *
620 %************************************************************************
621
622 \begin{code}
623 -- | The 'FinderCache' maps home module names to the result of
624 -- searching for that module. It records the results of searching for
625 -- modules along the search path. On @:load@, we flush the entire
626 -- contents of this cache.
627 --
628 -- Although the @FinderCache@ range is 'FindResult' for convenience,
629 -- in fact it will only ever contain 'Found' or 'NotFound' entries.
630 --
631 type FinderCache = ModuleNameEnv FindResult
632
633 -- | The result of searching for an imported module.
634 data FindResult
635   = Found ModLocation Module
636         -- ^ The module was found
637   | NoPackage PackageKey
638         -- ^ The requested package was not found
639   | FoundMultiple [PackageKey]
640         -- ^ _Error_: both in multiple packages
641
642         -- | Not found
643   | NotFound
644       { fr_paths       :: [FilePath]       -- Places where I looked
645
646       , fr_pkg         :: Maybe PackageKey  -- Just p => module is in this package's
647                                            --           manifest, but couldn't find
648                                            --           the .hi file
649
650       , fr_mods_hidden :: [PackageKey]      -- Module is in these packages,
651                                            --   but the *module* is hidden
652
653       , fr_pkgs_hidden :: [PackageKey]      -- Module is in these packages,
654                                            --   but the *package* is hidden
655
656       , fr_suggestions :: [Module]         -- Possible mis-spelled modules
657       }
658
659 -- | Cache that remembers where we found a particular module.  Contains both
660 -- home modules and package modules.  On @:load@, only home modules are
661 -- purged from this cache.
662 type ModLocationCache = ModuleEnv ModLocation
663 \end{code}
664
665 %************************************************************************
666 %*                                                                      *
667 \subsection{Symbol tables and Module details}
668 %*                                                                      *
669 %************************************************************************
670
671 \begin{code}
672 -- | A 'ModIface' plus a 'ModDetails' summarises everything we know
673 -- about a compiled module.  The 'ModIface' is the stuff *before* linking,
674 -- and can be written out to an interface file. The 'ModDetails is after
675 -- linking and can be completely recovered from just the 'ModIface'.
676 --
677 -- When we read an interface file, we also construct a 'ModIface' from it,
678 -- except that we explicitly make the 'mi_decls' and a few other fields empty;
679 -- as when reading we consolidate the declarations etc. into a number of indexed
680 -- maps and environments in the 'ExternalPackageState'.
681 data ModIface
682   = ModIface {
683         mi_module     :: !Module,             -- ^ Name of the module we are for
684         mi_iface_hash :: !Fingerprint,        -- ^ Hash of the whole interface
685         mi_mod_hash   :: !Fingerprint,        -- ^ Hash of the ABI only
686         mi_flag_hash  :: !Fingerprint,        -- ^ Hash of the important flags
687                                               -- used when compiling this module
688
689         mi_orphan     :: !WhetherHasOrphans,  -- ^ Whether this module has orphans
690         mi_finsts     :: !WhetherHasFamInst,  -- ^ Whether this module has family instances
691         mi_boot       :: !IsBootInterface,    -- ^ Read from an hi-boot file?
692
693         mi_deps     :: Dependencies,
694                 -- ^ The dependencies of the module.  This is
695                 -- consulted for directly-imported modules, but not
696                 -- for anything else (hence lazy)
697
698         mi_usages   :: [Usage],
699                 -- ^ Usages; kept sorted so that it's easy to decide
700                 -- whether to write a new iface file (changing usages
701                 -- doesn't affect the hash of this module)
702                 -- NOT STRICT!  we read this field lazily from the interface file
703                 -- It is *only* consulted by the recompilation checker
704
705         mi_exports  :: ![IfaceExport],
706                 -- ^ Exports
707                 -- Kept sorted by (mod,occ), to make version comparisons easier
708                 -- Records the modules that are the declaration points for things
709                 -- exported by this module, and the 'OccName's of those things
710
711         mi_exp_hash :: !Fingerprint,
712                 -- ^ Hash of export list
713
714         mi_used_th  :: !Bool,
715                 -- ^ Module required TH splices when it was compiled.
716                 -- This disables recompilation avoidance (see #481).
717
718         mi_fixities :: [(OccName,Fixity)],
719                 -- ^ Fixities
720                 -- NOT STRICT!  we read this field lazily from the interface file
721
722         mi_warns    :: Warnings,
723                 -- ^ Warnings
724                 -- NOT STRICT!  we read this field lazily from the interface file
725
726         mi_anns     :: [IfaceAnnotation],
727                 -- ^ Annotations
728                 -- NOT STRICT!  we read this field lazily from the interface file
729
730
731         mi_decls    :: [(Fingerprint,IfaceDecl)],
732                 -- ^ Type, class and variable declarations
733                 -- The hash of an Id changes if its fixity or deprecations change
734                 --      (as well as its type of course)
735                 -- Ditto data constructors, class operations, except that
736                 -- the hash of the parent class/tycon changes
737
738         mi_globals  :: !(Maybe GlobalRdrEnv),
739                 -- ^ Binds all the things defined at the top level in
740                 -- the /original source/ code for this module. which
741                 -- is NOT the same as mi_exports, nor mi_decls (which
742                 -- may contains declarations for things not actually
743                 -- defined by the user).  Used for GHCi and for inspecting
744                 -- the contents of modules via the GHC API only.
745                 --
746                 -- (We need the source file to figure out the
747                 -- top-level environment, if we didn't compile this module
748                 -- from source then this field contains @Nothing@).
749                 --
750                 -- Strictly speaking this field should live in the
751                 -- 'HomeModInfo', but that leads to more plumbing.
752
753                 -- Instance declarations and rules
754         mi_insts       :: [IfaceClsInst],     -- ^ Sorted class instance
755         mi_fam_insts   :: [IfaceFamInst],  -- ^ Sorted family instances
756         mi_rules       :: [IfaceRule],     -- ^ Sorted rules
757         mi_orphan_hash :: !Fingerprint,    -- ^ Hash for orphan rules, class and family
758                                            -- instances, and vectorise pragmas combined
759
760         mi_vect_info :: !IfaceVectInfo,    -- ^ Vectorisation information
761
762                 -- Cached environments for easy lookup
763                 -- These are computed (lazily) from other fields
764                 -- and are not put into the interface file
765         mi_warn_fn   :: Name -> Maybe WarningTxt,        -- ^ Cached lookup for 'mi_warns'
766         mi_fix_fn    :: OccName -> Fixity,               -- ^ Cached lookup for 'mi_fixities'
767         mi_hash_fn   :: OccName -> Maybe (OccName, Fingerprint),
768                 -- ^ Cached lookup for 'mi_decls'.
769                 -- The @Nothing@ in 'mi_hash_fn' means that the thing
770                 -- isn't in decls. It's useful to know that when
771                 -- seeing if we are up to date wrt. the old interface.
772                 -- The 'OccName' is the parent of the name, if it has one.
773
774         mi_hpc       :: !AnyHpcUsage,
775                 -- ^ True if this program uses Hpc at any point in the program.
776
777         mi_trust     :: !IfaceTrustInfo,
778                 -- ^ Safe Haskell Trust information for this module.
779
780         mi_trust_pkg :: !Bool
781                 -- ^ Do we require the package this module resides in be trusted
782                 -- to trust this module? This is used for the situation where a
783                 -- module is Safe (so doesn't require the package be trusted
784                 -- itself) but imports some trustworthy modules from its own
785                 -- package (which does require its own package be trusted).
786                 -- See Note [RnNames . Trust Own Package]
787      }
788
789 instance Binary ModIface where
790    put_ bh (ModIface {
791                  mi_module    = mod,
792                  mi_boot      = is_boot,
793                  mi_iface_hash= iface_hash,
794                  mi_mod_hash  = mod_hash,
795                  mi_flag_hash = flag_hash,
796                  mi_orphan    = orphan,
797                  mi_finsts    = hasFamInsts,
798                  mi_deps      = deps,
799                  mi_usages    = usages,
800                  mi_exports   = exports,
801                  mi_exp_hash  = exp_hash,
802                  mi_used_th   = used_th,
803                  mi_fixities  = fixities,
804                  mi_warns     = warns,
805                  mi_anns      = anns,
806                  mi_decls     = decls,
807                  mi_insts     = insts,
808                  mi_fam_insts = fam_insts,
809                  mi_rules     = rules,
810                  mi_orphan_hash = orphan_hash,
811                  mi_vect_info = vect_info,
812                  mi_hpc       = hpc_info,
813                  mi_trust     = trust,
814                  mi_trust_pkg = trust_pkg }) = do
815         put_ bh mod
816         put_ bh is_boot
817         put_ bh iface_hash
818         put_ bh mod_hash
819         put_ bh flag_hash
820         put_ bh orphan
821         put_ bh hasFamInsts
822         lazyPut bh deps
823         lazyPut bh usages
824         put_ bh exports
825         put_ bh exp_hash
826         put_ bh used_th
827         put_ bh fixities
828         lazyPut bh warns
829         lazyPut bh anns
830         put_ bh decls
831         put_ bh insts
832         put_ bh fam_insts
833         lazyPut bh rules
834         put_ bh orphan_hash
835         put_ bh vect_info
836         put_ bh hpc_info
837         put_ bh trust
838         put_ bh trust_pkg
839
840    get bh = do
841         mod_name    <- get bh
842         is_boot     <- get bh
843         iface_hash  <- get bh
844         mod_hash    <- get bh
845         flag_hash   <- get bh
846         orphan      <- get bh
847         hasFamInsts <- get bh
848         deps        <- lazyGet bh
849         usages      <- {-# SCC "bin_usages" #-} lazyGet bh
850         exports     <- {-# SCC "bin_exports" #-} get bh
851         exp_hash    <- get bh
852         used_th     <- get bh
853         fixities    <- {-# SCC "bin_fixities" #-} get bh
854         warns       <- {-# SCC "bin_warns" #-} lazyGet bh
855         anns        <- {-# SCC "bin_anns" #-} lazyGet bh
856         decls       <- {-# SCC "bin_tycldecls" #-} get bh
857         insts       <- {-# SCC "bin_insts" #-} get bh
858         fam_insts   <- {-# SCC "bin_fam_insts" #-} get bh
859         rules       <- {-# SCC "bin_rules" #-} lazyGet bh
860         orphan_hash <- get bh
861         vect_info   <- get bh
862         hpc_info    <- get bh
863         trust       <- get bh
864         trust_pkg   <- get bh
865         return (ModIface {
866                  mi_module      = mod_name,
867                  mi_boot        = is_boot,
868                  mi_iface_hash  = iface_hash,
869                  mi_mod_hash    = mod_hash,
870                  mi_flag_hash   = flag_hash,
871                  mi_orphan      = orphan,
872                  mi_finsts      = hasFamInsts,
873                  mi_deps        = deps,
874                  mi_usages      = usages,
875                  mi_exports     = exports,
876                  mi_exp_hash    = exp_hash,
877                  mi_used_th     = used_th,
878                  mi_anns        = anns,
879                  mi_fixities    = fixities,
880                  mi_warns       = warns,
881                  mi_decls       = decls,
882                  mi_globals     = Nothing,
883                  mi_insts       = insts,
884                  mi_fam_insts   = fam_insts,
885                  mi_rules       = rules,
886                  mi_orphan_hash = orphan_hash,
887                  mi_vect_info   = vect_info,
888                  mi_hpc         = hpc_info,
889                  mi_trust       = trust,
890                  mi_trust_pkg   = trust_pkg,
891                         -- And build the cached values
892                  mi_warn_fn     = mkIfaceWarnCache warns,
893                  mi_fix_fn      = mkIfaceFixCache fixities,
894                  mi_hash_fn     = mkIfaceHashCache decls })
895
896 -- | The original names declared of a certain module that are exported
897 type IfaceExport = AvailInfo
898
899 -- | Constructs an empty ModIface
900 emptyModIface :: Module -> ModIface
901 emptyModIface mod
902   = ModIface { mi_module      = mod,
903                mi_iface_hash  = fingerprint0,
904                mi_mod_hash    = fingerprint0,
905                mi_flag_hash   = fingerprint0,
906                mi_orphan      = False,
907                mi_finsts      = False,
908                mi_boot        = False,
909                mi_deps        = noDependencies,
910                mi_usages      = [],
911                mi_exports     = [],
912                mi_exp_hash    = fingerprint0,
913                mi_used_th     = False,
914                mi_fixities    = [],
915                mi_warns       = NoWarnings,
916                mi_anns        = [],
917                mi_insts       = [],
918                mi_fam_insts   = [],
919                mi_rules       = [],
920                mi_decls       = [],
921                mi_globals     = Nothing,
922                mi_orphan_hash = fingerprint0,
923                mi_vect_info   = noIfaceVectInfo,
924                mi_warn_fn     = emptyIfaceWarnCache,
925                mi_fix_fn      = emptyIfaceFixCache,
926                mi_hash_fn     = emptyIfaceHashCache,
927                mi_hpc         = False,
928                mi_trust       = noIfaceTrustInfo,
929                mi_trust_pkg   = False }
930
931
932 -- | Constructs cache for the 'mi_hash_fn' field of a 'ModIface'
933 mkIfaceHashCache :: [(Fingerprint,IfaceDecl)]
934                  -> (OccName -> Maybe (OccName, Fingerprint))
935 mkIfaceHashCache pairs
936   = \occ -> lookupOccEnv env occ
937   where
938     env = foldr add_decl emptyOccEnv pairs
939     add_decl (v,d) env0 = foldr add env0 (ifaceDeclFingerprints v d)
940       where
941         add (occ,hash) env0 = extendOccEnv env0 occ (occ,hash)
942
943 emptyIfaceHashCache :: OccName -> Maybe (OccName, Fingerprint)
944 emptyIfaceHashCache _occ = Nothing
945
946
947 -- | The 'ModDetails' is essentially a cache for information in the 'ModIface'
948 -- for home modules only. Information relating to packages will be loaded into
949 -- global environments in 'ExternalPackageState'.
950 data ModDetails
951   = ModDetails {
952         -- The next two fields are created by the typechecker
953         md_exports   :: [AvailInfo],
954         md_types     :: !TypeEnv,       -- ^ Local type environment for this particular module
955                                         -- Includes Ids, TyCons, PatSyns
956         md_insts     :: ![ClsInst],     -- ^ 'DFunId's for the instances in this module
957         md_fam_insts :: ![FamInst],
958         md_rules     :: ![CoreRule],    -- ^ Domain may include 'Id's from other modules
959         md_anns      :: ![Annotation],  -- ^ Annotations present in this module: currently
960                                         -- they only annotate things also declared in this module
961         md_vect_info :: !VectInfo       -- ^ Module vectorisation information
962      }
963
964 -- | Constructs an empty ModDetails
965 emptyModDetails :: ModDetails
966 emptyModDetails
967   = ModDetails { md_types     = emptyTypeEnv,
968                  md_exports   = [],
969                  md_insts     = [],
970                  md_rules     = [],
971                  md_fam_insts = [],
972                  md_anns      = [],
973                  md_vect_info = noVectInfo }
974
975 -- | Records the modules directly imported by a module for extracting e.g. usage information
976 type ImportedMods = ModuleEnv [ImportedModsVal]
977 type ImportedModsVal = (ModuleName, Bool, SrcSpan, IsSafeImport)
978
979 -- | A ModGuts is carried through the compiler, accumulating stuff as it goes
980 -- There is only one ModGuts at any time, the one for the module
981 -- being compiled right now.  Once it is compiled, a 'ModIface' and
982 -- 'ModDetails' are extracted and the ModGuts is discarded.
983 data ModGuts
984   = ModGuts {
985         mg_module    :: !Module,         -- ^ Module being compiled
986         mg_boot      :: IsBootInterface, -- ^ Whether it's an hs-boot module
987         mg_exports   :: ![AvailInfo],    -- ^ What it exports
988         mg_deps      :: !Dependencies,   -- ^ What it depends on, directly or
989                                          -- otherwise
990         mg_dir_imps  :: !ImportedMods,   -- ^ Directly-imported modules; used to
991                                          -- generate initialisation code
992         mg_used_names:: !NameSet,        -- ^ What the module needed (used in 'MkIface.mkIface')
993
994         mg_used_th   :: !Bool,           -- ^ Did we run a TH splice?
995         mg_rdr_env   :: !GlobalRdrEnv,   -- ^ Top-level lexical environment
996
997         -- These fields all describe the things **declared in this module**
998         mg_fix_env   :: !FixityEnv,      -- ^ Fixities declared in this module
999                                          -- ToDo: I'm unconvinced this is actually used anywhere
1000         mg_tcs       :: ![TyCon],        -- ^ TyCons declared in this module
1001                                          -- (includes TyCons for classes)
1002         mg_insts     :: ![ClsInst],      -- ^ Class instances declared in this module
1003         mg_fam_insts :: ![FamInst],
1004                                          -- ^ Family instances declared in this module
1005         mg_patsyns   :: ![PatSyn],       -- ^ Pattern synonyms declared in this module
1006         mg_rules     :: ![CoreRule],     -- ^ Before the core pipeline starts, contains
1007                                          -- See Note [Overall plumbing for rules] in Rules.lhs
1008         mg_binds     :: !CoreProgram,    -- ^ Bindings for this module
1009         mg_foreign   :: !ForeignStubs,   -- ^ Foreign exports declared in this module
1010         mg_warns     :: !Warnings,       -- ^ Warnings declared in the module
1011         mg_anns      :: [Annotation],    -- ^ Annotations declared in this module
1012         mg_hpc_info  :: !HpcInfo,        -- ^ Coverage tick boxes in the module
1013         mg_modBreaks :: !ModBreaks,      -- ^ Breakpoints for the module
1014         mg_vect_decls:: ![CoreVect],     -- ^ Vectorisation declarations in this module
1015                                          --   (produced by desugarer & consumed by vectoriser)
1016         mg_vect_info :: !VectInfo,       -- ^ Pool of vectorised declarations in the module
1017
1018         -- The next two fields are unusual, because they give instance
1019         -- environments for *all* modules in the home package, including
1020         -- this module, rather than for *just* this module.
1021         -- Reason: when looking up an instance we don't want to have to
1022         --        look at each module in the home package in turn
1023         mg_inst_env     :: InstEnv,
1024         -- ^ Class instance environment from /home-package/ modules (including
1025         -- this one); c.f. 'tcg_inst_env'
1026         mg_fam_inst_env :: FamInstEnv,
1027         -- ^ Type-family instance environment for /home-package/ modules
1028         -- (including this one); c.f. 'tcg_fam_inst_env'
1029         mg_safe_haskell :: SafeHaskellMode,
1030         -- ^ Safe Haskell mode
1031         mg_trust_pkg    :: Bool,
1032         -- ^ Do we need to trust our own package for Safe Haskell?
1033         -- See Note [RnNames . Trust Own Package]
1034         mg_dependent_files :: [FilePath] -- ^ dependencies from addDependentFile
1035     }
1036
1037 -- The ModGuts takes on several slightly different forms:
1038 --
1039 -- After simplification, the following fields change slightly:
1040 --      mg_rules        Orphan rules only (local ones now attached to binds)
1041 --      mg_binds        With rules attached
1042
1043
1044 ---------------------------------------------------------
1045 -- The Tidy pass forks the information about this module:
1046 --      * one lot goes to interface file generation (ModIface)
1047 --        and later compilations (ModDetails)
1048 --      * the other lot goes to code generation (CgGuts)
1049
1050 -- | A restricted form of 'ModGuts' for code generation purposes
1051 data CgGuts
1052   = CgGuts {
1053         cg_module    :: !Module,
1054                 -- ^ Module being compiled
1055
1056         cg_tycons    :: [TyCon],
1057                 -- ^ Algebraic data types (including ones that started
1058                 -- life as classes); generate constructors and info
1059                 -- tables. Includes newtypes, just for the benefit of
1060                 -- External Core
1061
1062         cg_binds     :: CoreProgram,
1063                 -- ^ The tidied main bindings, including
1064                 -- previously-implicit bindings for record and class
1065                 -- selectors, and data constructor wrappers.  But *not*
1066                 -- data constructor workers; reason: we we regard them
1067                 -- as part of the code-gen of tycons
1068
1069         cg_foreign   :: !ForeignStubs,   -- ^ Foreign export stubs
1070         cg_dep_pkgs  :: ![PackageKey],    -- ^ Dependent packages, used to
1071                                          -- generate #includes for C code gen
1072         cg_hpc_info  :: !HpcInfo,        -- ^ Program coverage tick box information
1073         cg_modBreaks :: !ModBreaks       -- ^ Module breakpoints
1074     }
1075
1076 -----------------------------------
1077 -- | Foreign export stubs
1078 data ForeignStubs
1079   = NoStubs
1080       -- ^ We don't have any stubs
1081   | ForeignStubs SDoc SDoc
1082       -- ^ There are some stubs. Parameters:
1083       --
1084       --  1) Header file prototypes for
1085       --     "foreign exported" functions
1086       --
1087       --  2) C stubs to use when calling
1088       --     "foreign exported" functions
1089
1090 appendStubC :: ForeignStubs -> SDoc -> ForeignStubs
1091 appendStubC NoStubs            c_code = ForeignStubs empty c_code
1092 appendStubC (ForeignStubs h c) c_code = ForeignStubs h (c $$ c_code)
1093 \end{code}
1094
1095 %************************************************************************
1096 %*                                                                      *
1097 \subsection{The interactive context}
1098 %*                                                                      *
1099 %************************************************************************
1100
1101 Note [The interactive package]
1102 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1103 Type and class declarations at the command prompt are treated as if
1104 they were defined in modules
1105    interactive:Ghci1
1106    interactive:Ghci2
1107    ...etc...
1108 with each bunch of declarations using a new module, all sharing a
1109 common package 'interactive' (see Module.interactivePackageKey, and
1110 PrelNames.mkInteractiveModule).
1111
1112 This scheme deals well with shadowing.  For example:
1113
1114    ghci> data T = A
1115    ghci> data T = B
1116    ghci> :i A
1117    data Ghci1.T = A  -- Defined at <interactive>:2:10
1118
1119 Here we must display info about constructor A, but its type T has been
1120 shadowed by the second declaration.  But it has a respectable
1121 qualified name (Ghci1.T), and its source location says where it was
1122 defined.
1123
1124 So the main invariant continues to hold, that in any session an
1125 original name M.T only refers to one unique thing.  (In a previous
1126 iteration both the T's above were called :Interactive.T, albeit with
1127 different uniques, which gave rise to all sorts of trouble.)
1128
1129 The details are a bit tricky though:
1130
1131  * The field ic_mod_index counts which Ghci module we've got up to.
1132    It is incremented when extending ic_tythings
1133
1134  * ic_tythings contains only things from the 'interactive' package.
1135
1136  * Module from the 'interactive' package (Ghci1, Ghci2 etc) never go
1137    in the Home Package Table (HPT).  When you say :load, that's when we
1138    extend the HPT.
1139
1140  * The 'thisPackage' field of DynFlags is *not* set to 'interactive'.
1141    It stays as 'main' (or whatever -package-name says), and is the
1142    package to which :load'ed modules are added to.
1143
1144  * So how do we arrange that declarations at the command prompt get
1145    to be in the 'interactive' package?  Simply by setting the tcg_mod
1146    field of the TcGblEnv to "interactive:Ghci1".  This is done by the
1147    call to initTc in initTcInteractive, initTcForLookup, which in 
1148    turn get the module from it 'icInteractiveModule' field of the 
1149    interactive context.
1150
1151    The 'thisPackage' field stays as 'main' (or whatever -package-name says.
1152
1153  * The main trickiness is that the type environment (tcg_type_env and
1154    fixity envt (tcg_fix_env) now contains entities from all the
1155    GhciN modules together, rather than just a single module as is usually
1156    the case.  So you can't use "nameIsLocalOrFrom" to decide whether
1157    to look in the TcGblEnv vs the HPT/PTE.  This is a change, but not
1158    a problem provided you know.
1159
1160
1161 Note [Interactively-bound Ids in GHCi]
1162 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1163 The Ids bound by previous Stmts in GHCi are currently
1164         a) GlobalIds
1165         b) with an Internal Name (not External)
1166         c) and a tidied type
1167
1168  (a) They must be GlobalIds (not LocalIds) otherwise when we come to
1169      compile an expression using these ids later, the byte code
1170      generator will consider the occurrences to be free rather than
1171      global.
1172
1173  (b) They start with an Internal Name because a Stmt is a local
1174      construct, so the renamer naturally builds an Internal name for
1175      each of its binders.  It would be possible subsequently to give
1176      them an External Name (in a GhciN module) but then we'd have
1177      to substitute it out.  So for now they stay Internal.
1178
1179  (c) Their types are tidied. This is important, because :info may ask
1180      to look at them, and :info expects the things it looks up to have
1181      tidy types
1182
1183 However note that TyCons, Classes, and even Ids bound by other top-level
1184 declarations in GHCi (eg foreign import, record selectors) currently get
1185 External Names, with Ghci9 (or 8, or 7, etc) as the module name. 
1186
1187
1188 Note [ic_tythings]
1189 ~~~~~~~~~~~~~~~~~~
1190 The ic_tythings field contains
1191   * The TyThings declared by the user at the command prompt
1192     (eg Ids, TyCons, Classes)
1193
1194   * The user-visible Ids that arise from such things, which 
1195     *don't* come from 'implicitTyThings', notably:
1196        - record selectors
1197        - class ops
1198     The implicitTyThings are readily obtained from the TyThings
1199     but record selectors etc are not
1200
1201 It does *not* contain
1202   * DFunIds (they can be gotten from ic_instances)
1203   * CoAxioms (ditto)
1204
1205 See also Note [Interactively-bound Ids in GHCi]
1206
1207
1208 \begin{code}
1209 -- | Interactive context, recording information about the state of the
1210 -- context in which statements are executed in a GHC session.
1211 data InteractiveContext
1212   = InteractiveContext {
1213          ic_dflags     :: DynFlags,
1214              -- ^ The 'DynFlags' used to evaluate interative expressions
1215              -- and statements.
1216
1217          ic_mod_index :: Int,
1218              -- ^ Each GHCi stmt or declaration brings some new things into
1219              -- scope. We give them names like interactive:Ghci9.T,
1220              -- where the ic_index is the '9'.  The ic_mod_index is
1221              -- incremented whenever we add something to ic_tythings
1222              -- See Note [The interactive package]
1223
1224          ic_imports :: [InteractiveImport],
1225              -- ^ The GHCi top-level scope (ic_rn_gbl_env) is extended with
1226              -- these imports
1227              --
1228              -- This field is only stored here so that the client
1229              -- can retrieve it with GHC.getContext. GHC itself doesn't
1230              -- use it, but does reset it to empty sometimes (such
1231              -- as before a GHC.load). The context is set with GHC.setContext.
1232
1233          ic_tythings   :: [TyThing],
1234              -- ^ TyThings defined by the user, in reverse order of
1235              -- definition (ie most recent at the front)
1236              -- See Note [ic_tythings]
1237
1238          ic_rn_gbl_env :: GlobalRdrEnv,
1239              -- ^ The cached 'GlobalRdrEnv', built by
1240              -- 'InteractiveEval.setContext' and updated regularly
1241              -- It contains everything in scope at the command line,
1242              -- including everything in ic_tythings
1243
1244          ic_instances  :: ([ClsInst], [FamInst]),
1245              -- ^ All instances and family instances created during
1246              -- this session.  These are grabbed en masse after each
1247              -- update to be sure that proper overlapping is retained.
1248              -- That is, rather than re-check the overlapping each
1249              -- time we update the context, we just take the results
1250              -- from the instance code that already does that.
1251
1252          ic_fix_env :: FixityEnv,
1253             -- ^ Fixities declared in let statements
1254
1255          ic_default :: Maybe [Type],
1256              -- ^ The current default types, set by a 'default' declaration
1257
1258 #ifdef GHCI
1259           ic_resume :: [Resume],
1260              -- ^ The stack of breakpoint contexts
1261 #endif
1262
1263          ic_monad      :: Name,
1264              -- ^ The monad that GHCi is executing in
1265
1266          ic_int_print  :: Name,
1267              -- ^ The function that is used for printing results
1268              -- of expressions in ghci and -e mode.
1269
1270          ic_cwd :: Maybe FilePath
1271              -- virtual CWD of the program
1272     }
1273
1274 data InteractiveImport
1275   = IIDecl (ImportDecl RdrName)
1276       -- ^ Bring the exports of a particular module
1277       -- (filtered by an import decl) into scope
1278
1279   | IIModule ModuleName
1280       -- ^ Bring into scope the entire top-level envt of
1281       -- of this module, including the things imported
1282       -- into it.
1283
1284
1285 -- | Constructs an empty InteractiveContext.
1286 emptyInteractiveContext :: DynFlags -> InteractiveContext
1287 emptyInteractiveContext dflags
1288   = InteractiveContext {
1289        ic_dflags     = dflags,
1290        ic_imports    = [],
1291        ic_rn_gbl_env = emptyGlobalRdrEnv,
1292        ic_mod_index  = 1,
1293        ic_tythings   = [],
1294        ic_instances  = ([],[]),
1295        ic_fix_env    = emptyNameEnv,
1296        ic_monad      = ioTyConName,  -- IO monad by default
1297        ic_int_print  = printName,    -- System.IO.print by default
1298        ic_default    = Nothing,
1299 #ifdef GHCI
1300        ic_resume     = [],
1301 #endif
1302        ic_cwd        = Nothing }
1303
1304 icInteractiveModule :: InteractiveContext -> Module
1305 icInteractiveModule (InteractiveContext { ic_mod_index = index }) 
1306   = mkInteractiveModule index
1307
1308 -- | This function returns the list of visible TyThings (useful for
1309 -- e.g. showBindings)
1310 icInScopeTTs :: InteractiveContext -> [TyThing]
1311 icInScopeTTs = ic_tythings
1312
1313 -- | Get the PrintUnqualified function based on the flags and this InteractiveContext
1314 icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified
1315 icPrintUnqual dflags InteractiveContext{ ic_rn_gbl_env = grenv } =
1316     mkPrintUnqualified dflags grenv
1317
1318 -- | This function is called with new TyThings recently defined to update the
1319 -- InteractiveContext to include them.  Ids are easily removed when shadowed,
1320 -- but Classes and TyCons are not.  Some work could be done to determine
1321 -- whether they are entirely shadowed, but as you could still have references
1322 -- to them (e.g. instances for classes or values of the type for TyCons), it's
1323 -- not clear whether removing them is even the appropriate behavior.
1324 extendInteractiveContext :: InteractiveContext -> [TyThing] -> InteractiveContext
1325 extendInteractiveContext ictxt new_tythings
1326   | null new_tythings
1327   = ictxt
1328   | otherwise
1329   = ictxt { ic_mod_index  = ic_mod_index ictxt + 1
1330           , ic_tythings   = new_tythings ++ old_tythings
1331           , ic_rn_gbl_env = ic_rn_gbl_env ictxt `icExtendGblRdrEnv` new_tythings
1332           }
1333   where
1334     old_tythings = filter (not . shadowed) (ic_tythings ictxt)
1335
1336     shadowed (AnId id) = ((`elem` new_names) . nameOccName . idName) id
1337     shadowed _         = False
1338
1339     new_names = [ nameOccName (getName id) | AnId id <- new_tythings ]
1340
1341 setInteractivePackage :: HscEnv -> HscEnv
1342 -- Set the 'thisPackage' DynFlag to 'interactive'
1343 setInteractivePackage hsc_env
1344    = hsc_env { hsc_dflags = (hsc_dflags hsc_env) { thisPackage = interactivePackageKey } }
1345
1346 setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext
1347 setInteractivePrintName ic n = ic{ic_int_print = n}
1348
1349     -- ToDo: should not add Ids to the gbl env here
1350
1351 -- | Add TyThings to the GlobalRdrEnv, earlier ones in the list shadowing
1352 -- later ones, and shadowing existing entries in the GlobalRdrEnv.
1353 icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv
1354 icExtendGblRdrEnv env tythings
1355   = foldr add env tythings  -- Foldr makes things in the front of
1356                             -- the list shadow things at the back
1357   where
1358     add thing env = extendGlobalRdrEnv True {- Shadowing please -} env
1359                                        [tyThingAvailInfo thing]
1360        -- One at a time, to ensure each shadows the previous ones
1361
1362 substInteractiveContext :: InteractiveContext -> TvSubst -> InteractiveContext
1363 substInteractiveContext ictxt@InteractiveContext{ ic_tythings = tts } subst
1364   | isEmptyTvSubst subst = ictxt
1365   | otherwise            = ictxt { ic_tythings = map subst_ty tts }
1366   where
1367     subst_ty (AnId id) = AnId $ id `setIdType` substTy subst (idType id)
1368     subst_ty tt        = tt
1369
1370 instance Outputable InteractiveImport where
1371   ppr (IIModule m) = char '*' <> ppr m
1372   ppr (IIDecl d)   = ppr d
1373 \end{code}
1374
1375 %************************************************************************
1376 %*                                                                      *
1377         Building a PrintUnqualified
1378 %*                                                                      *
1379 %************************************************************************
1380
1381 Note [Printing original names]
1382 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1383 Deciding how to print names is pretty tricky.  We are given a name
1384 P:M.T, where P is the package name, M is the defining module, and T is
1385 the occurrence name, and we have to decide in which form to display
1386 the name given a GlobalRdrEnv describing the current scope.
1387
1388 Ideally we want to display the name in the form in which it is in
1389 scope.  However, the name might not be in scope at all, and that's
1390 where it gets tricky.  Here are the cases:
1391
1392  1. T uniquely maps to  P:M.T      --->  "T"      NameUnqual
1393  2. There is an X for which X.T
1394        uniquely maps to  P:M.T     --->  "X.T"    NameQual X
1395  3. There is no binding for "M.T"  --->  "M.T"    NameNotInScope1
1396  4. Otherwise                      --->  "P:M.T"  NameNotInScope2
1397
1398 (3) and (4) apply when the entity P:M.T is not in the GlobalRdrEnv at
1399 all. In these cases we still want to refer to the name as "M.T", *but*
1400 "M.T" might mean something else in the current scope (e.g. if there's
1401 an "import X as M"), so to avoid confusion we avoid using "M.T" if
1402 there's already a binding for it.  Instead we write P:M.T.
1403
1404 There's one further subtlety: in case (3), what if there are two
1405 things around, P1:M.T and P2:M.T?  Then we don't want to print both of
1406 them as M.T!  However only one of the modules P1:M and P2:M can be
1407 exposed (say P2), so we use M.T for that, and P1:M.T for the other one.
1408 This is handled by the qual_mod component of PrintUnqualified, inside
1409 the (ppr mod) of case (3), in Name.pprModulePrefix
1410
1411 \begin{code}
1412 -- | Creates some functions that work out the best ways to format
1413 -- names for the user according to a set of heuristics
1414 mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified
1415 mkPrintUnqualified dflags env = (qual_name, qual_mod)
1416   where
1417   qual_name mod occ
1418         | [gre] <- unqual_gres
1419         , right_name gre
1420         = NameUnqual
1421                 -- If there's a unique entity that's in scope unqualified with 'occ'
1422                 -- AND that entity is the right one, then we can use the unqualified name
1423
1424         | [gre] <- qual_gres
1425         = NameQual (get_qual_mod (gre_prov gre))
1426
1427         | null qual_gres
1428         = if null (lookupGRE_RdrName (mkRdrQual (moduleName mod) occ) env)
1429           then NameNotInScope1
1430           else NameNotInScope2
1431
1432         | otherwise
1433         = NameNotInScope1   -- Can happen if 'f' is bound twice in the module
1434                             -- Eg  f = True; g = 0; f = False
1435       where
1436         right_name gre = nameModule_maybe (gre_name gre) == Just mod
1437
1438         unqual_gres = lookupGRE_RdrName (mkRdrUnqual occ) env
1439         qual_gres   = filter right_name (lookupGlobalRdrEnv env occ)
1440
1441         get_qual_mod LocalDef      = moduleName mod
1442         get_qual_mod (Imported is) = ASSERT( not (null is) ) is_as (is_decl (head is))
1443
1444     -- we can mention a module P:M without the P: qualifier iff
1445     -- "import M" would resolve unambiguously to P:M.  (if P is the
1446     -- current package we can just assume it is unqualified).
1447
1448   qual_mod mod
1449      | modulePackageKey mod == thisPackage dflags = False
1450
1451      | [pkgconfig] <- [modConfPkg m | m <- lookup
1452                                     , modConfVisible m ],
1453        packageConfigId pkgconfig == modulePackageKey mod
1454         -- this says: we are given a module P:M, is there just one exposed package
1455         -- that exposes a module M, and is it package P?
1456      = False
1457
1458      | otherwise = True
1459      where lookup = eltsUFM $ lookupModuleInAllPackages dflags (moduleName mod)
1460 \end{code}
1461
1462
1463 %************************************************************************
1464 %*                                                                      *
1465                 Implicit TyThings
1466 %*                                                                      *
1467 %************************************************************************
1468
1469 Note [Implicit TyThings]
1470 ~~~~~~~~~~~~~~~~~~~~~~~~
1471   DEFINITION: An "implicit" TyThing is one that does not have its own
1472   IfaceDecl in an interface file.  Instead, its binding in the type
1473   environment is created as part of typechecking the IfaceDecl for
1474   some other thing.
1475
1476 Examples:
1477   * All DataCons are implicit, because they are generated from the
1478     IfaceDecl for the data/newtype.  Ditto class methods.
1479
1480   * Record selectors are *not* implicit, because they get their own
1481     free-standing IfaceDecl.
1482
1483   * Associated data/type families are implicit because they are
1484     included in the IfaceDecl of the parent class.  (NB: the
1485     IfaceClass decl happens to use IfaceDecl recursively for the
1486     associated types, but that's irrelevant here.)
1487
1488   * Dictionary function Ids are not implicit.
1489
1490   * Axioms for newtypes are implicit (same as above), but axioms
1491     for data/type family instances are *not* implicit (like DFunIds).
1492
1493 \begin{code}
1494 -- | Determine the 'TyThing's brought into scope by another 'TyThing'
1495 -- /other/ than itself. For example, Id's don't have any implicit TyThings
1496 -- as they just bring themselves into scope, but classes bring their
1497 -- dictionary datatype, type constructor and some selector functions into
1498 -- scope, just for a start!
1499
1500 -- N.B. the set of TyThings returned here *must* match the set of
1501 -- names returned by LoadIface.ifaceDeclImplicitBndrs, in the sense that
1502 -- TyThing.getOccName should define a bijection between the two lists.
1503 -- This invariant is used in LoadIface.loadDecl (see note [Tricky iface loop])
1504 -- The order of the list does not matter.
1505 implicitTyThings :: TyThing -> [TyThing]
1506 implicitTyThings (AnId _)       = []
1507 implicitTyThings (ACoAxiom _cc) = []
1508 implicitTyThings (ATyCon tc)    = implicitTyConThings tc
1509 implicitTyThings (AConLike cl)  = implicitConLikeThings cl
1510
1511 implicitConLikeThings :: ConLike -> [TyThing]
1512 implicitConLikeThings (RealDataCon dc)
1513   = map AnId (dataConImplicitIds dc)
1514     -- For data cons add the worker and (possibly) wrapper
1515
1516 implicitConLikeThings (PatSynCon {})
1517   = []  -- Pattern synonyms have no implicit Ids; the wrapper and matcher
1518         -- are not "implicit"; they are simply new top-level bindings,
1519         -- and they have their own declaration in an interface fiel
1520
1521 implicitClassThings :: Class -> [TyThing]
1522 implicitClassThings cl
1523   = -- Does not include default methods, because those Ids may have
1524     --    their own pragmas, unfoldings etc, not derived from the Class object
1525     -- associated types
1526     --    No extras_plus (recursive call) for the classATs, because they
1527     --    are only the family decls; they have no implicit things
1528     map ATyCon (classATs cl) ++
1529     -- superclass and operation selectors
1530     map AnId (classAllSelIds cl)
1531
1532 implicitTyConThings :: TyCon -> [TyThing]
1533 implicitTyConThings tc
1534   = class_stuff ++
1535       -- fields (names of selectors)
1536
1537       -- (possibly) implicit newtype coercion
1538     implicitCoTyCon tc ++
1539
1540       -- for each data constructor in order,
1541       --   the contructor, worker, and (possibly) wrapper
1542     concatMap (extras_plus . AConLike . RealDataCon) (tyConDataCons tc)
1543       -- NB. record selectors are *not* implicit, they have fully-fledged
1544       -- bindings that pass through the compilation pipeline as normal.
1545   where
1546     class_stuff = case tyConClass_maybe tc of
1547         Nothing -> []
1548         Just cl -> implicitClassThings cl
1549
1550 -- add a thing and recursive call
1551 extras_plus :: TyThing -> [TyThing]
1552 extras_plus thing = thing : implicitTyThings thing
1553
1554 -- For newtypes and closed type families (only) add the implicit coercion tycon
1555 implicitCoTyCon :: TyCon -> [TyThing]
1556 implicitCoTyCon tc
1557   | Just co <- newTyConCo_maybe tc = [ACoAxiom $ toBranchedAxiom co]
1558   | Just co <- isClosedSynFamilyTyCon_maybe tc
1559                                    = [ACoAxiom co]
1560   | otherwise                      = []
1561
1562 -- | Returns @True@ if there should be no interface-file declaration
1563 -- for this thing on its own: either it is built-in, or it is part
1564 -- of some other declaration, or it is generated implicitly by some
1565 -- other declaration.
1566 isImplicitTyThing :: TyThing -> Bool
1567 isImplicitTyThing (AConLike cl) = case cl of
1568                                     RealDataCon {} -> True
1569                                     PatSynCon {}   -> False
1570 isImplicitTyThing (AnId id)     = isImplicitId id
1571 isImplicitTyThing (ATyCon tc)   = isImplicitTyCon tc
1572 isImplicitTyThing (ACoAxiom ax) = isImplicitCoAxiom ax
1573
1574 -- | tyThingParent_maybe x returns (Just p)
1575 -- when pprTyThingInContext sould print a declaration for p
1576 -- (albeit with some "..." in it) when asked to show x
1577 -- It returns the *immediate* parent.  So a datacon returns its tycon
1578 -- but the tycon could be the associated type of a class, so it in turn
1579 -- might have a parent.
1580 tyThingParent_maybe :: TyThing -> Maybe TyThing
1581 tyThingParent_maybe (AConLike cl) = case cl of
1582     RealDataCon dc  -> Just (ATyCon (dataConTyCon dc))
1583     PatSynCon{}     -> Nothing
1584 tyThingParent_maybe (ATyCon tc)   = case tyConAssoc_maybe tc of
1585                                       Just cls -> Just (ATyCon (classTyCon cls))
1586                                       Nothing  -> Nothing
1587 tyThingParent_maybe (AnId id)     = case idDetails id of
1588                                          RecSelId { sel_tycon = tc } -> Just (ATyCon tc)
1589                                          ClassOpId cls               -> Just (ATyCon (classTyCon cls))
1590                                          _other                      -> Nothing
1591 tyThingParent_maybe _other = Nothing
1592
1593 tyThingsTyVars :: [TyThing] -> TyVarSet
1594 tyThingsTyVars tts =
1595     unionVarSets $ map ttToVarSet tts
1596     where
1597         ttToVarSet (AnId id)     = tyVarsOfType $ idType id
1598         ttToVarSet (AConLike cl) = case cl of
1599             RealDataCon dc  -> tyVarsOfType $ dataConRepType dc
1600             PatSynCon{}     -> emptyVarSet
1601         ttToVarSet (ATyCon tc)
1602           = case tyConClass_maybe tc of
1603               Just cls -> (mkVarSet . fst . classTvsFds) cls
1604               Nothing  -> tyVarsOfType $ tyConKind tc
1605         ttToVarSet _             = emptyVarSet
1606
1607 -- | The Names that a TyThing should bring into scope.  Used to build
1608 -- the GlobalRdrEnv for the InteractiveContext.
1609 tyThingAvailInfo :: TyThing -> AvailInfo
1610 tyThingAvailInfo (ATyCon t)
1611    = case tyConClass_maybe t of
1612         Just c  -> AvailTC n (n : map getName (classMethods c)
1613                   ++ map getName (classATs c))
1614              where n = getName c
1615         Nothing -> AvailTC n (n : map getName dcs ++
1616                                    concatMap dataConFieldLabels dcs)
1617              where n = getName t
1618                    dcs = tyConDataCons t
1619 tyThingAvailInfo t
1620    = Avail (getName t)
1621 \end{code}
1622
1623 %************************************************************************
1624 %*                                                                      *
1625                 TypeEnv
1626 %*                                                                      *
1627 %************************************************************************
1628
1629 \begin{code}
1630 -- | A map from 'Name's to 'TyThing's, constructed by typechecking
1631 -- local declarations or interface files
1632 type TypeEnv = NameEnv TyThing
1633
1634 emptyTypeEnv    :: TypeEnv
1635 typeEnvElts     :: TypeEnv -> [TyThing]
1636 typeEnvTyCons   :: TypeEnv -> [TyCon]
1637 typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]
1638 typeEnvIds      :: TypeEnv -> [Id]
1639 typeEnvPatSyns  :: TypeEnv -> [PatSyn]
1640 typeEnvDataCons :: TypeEnv -> [DataCon]
1641 typeEnvClasses  :: TypeEnv -> [Class]
1642 lookupTypeEnv   :: TypeEnv -> Name -> Maybe TyThing
1643
1644 emptyTypeEnv        = emptyNameEnv
1645 typeEnvElts     env = nameEnvElts env
1646 typeEnvTyCons   env = [tc | ATyCon tc   <- typeEnvElts env]
1647 typeEnvCoAxioms env = [ax | ACoAxiom ax <- typeEnvElts env]
1648 typeEnvIds      env = [id | AnId id     <- typeEnvElts env]
1649 typeEnvPatSyns  env = [ps | AConLike (PatSynCon ps) <- typeEnvElts env]
1650 typeEnvDataCons env = [dc | AConLike (RealDataCon dc) <- typeEnvElts env]
1651 typeEnvClasses  env = [cl | tc <- typeEnvTyCons env,
1652                             Just cl <- [tyConClass_maybe tc]]
1653
1654 mkTypeEnv :: [TyThing] -> TypeEnv
1655 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
1656
1657 mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv
1658 mkTypeEnvWithImplicits things =
1659   mkTypeEnv things
1660     `plusNameEnv`
1661   mkTypeEnv (concatMap implicitTyThings things)
1662
1663 typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv
1664 typeEnvFromEntities ids tcs famInsts =
1665   mkTypeEnv (   map AnId ids
1666              ++ map ATyCon all_tcs
1667              ++ concatMap implicitTyConThings all_tcs
1668              ++ map (ACoAxiom . toBranchedAxiom . famInstAxiom) famInsts
1669             )
1670  where
1671   all_tcs = tcs ++ famInstsRepTyCons famInsts
1672
1673 lookupTypeEnv = lookupNameEnv
1674
1675 -- Extend the type environment
1676 extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
1677 extendTypeEnv env thing = extendNameEnv env (getName thing) thing
1678
1679 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
1680 extendTypeEnvList env things = foldl extendTypeEnv env things
1681
1682 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
1683 extendTypeEnvWithIds env ids
1684   = extendNameEnvList env [(getName id, AnId id) | id <- ids]
1685 \end{code}
1686
1687 \begin{code}
1688 -- | Find the 'TyThing' for the given 'Name' by using all the resources
1689 -- at our disposal: the compiled modules in the 'HomePackageTable' and the
1690 -- compiled modules in other packages that live in 'PackageTypeEnv'. Note
1691 -- that this does NOT look up the 'TyThing' in the module being compiled: you
1692 -- have to do that yourself, if desired
1693 lookupType :: DynFlags
1694            -> HomePackageTable
1695            -> PackageTypeEnv
1696            -> Name
1697            -> Maybe TyThing
1698
1699 lookupType dflags hpt pte name
1700   | isOneShot (ghcMode dflags)  -- in one-shot, we don't use the HPT
1701   = lookupNameEnv pte name
1702   | otherwise
1703   = case lookupHptByModule hpt mod of
1704        Just hm -> lookupNameEnv (md_types (hm_details hm)) name
1705        Nothing -> lookupNameEnv pte name
1706   where
1707     mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1708
1709 -- | As 'lookupType', but with a marginally easier-to-use interface
1710 -- if you have a 'HscEnv'
1711 lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)
1712 lookupTypeHscEnv hsc_env name = do
1713     eps <- readIORef (hsc_EPS hsc_env)
1714     return $! lookupType dflags hpt (eps_PTE eps) name
1715   where
1716     dflags = hsc_dflags hsc_env
1717     hpt = hsc_HPT hsc_env
1718 \end{code}
1719
1720 \begin{code}
1721 -- | Get the 'TyCon' from a 'TyThing' if it is a type constructor thing. Panics otherwise
1722 tyThingTyCon :: TyThing -> TyCon
1723 tyThingTyCon (ATyCon tc) = tc
1724 tyThingTyCon other       = pprPanic "tyThingTyCon" (pprTyThing other)
1725
1726 -- | Get the 'CoAxiom' from a 'TyThing' if it is a coercion axiom thing. Panics otherwise
1727 tyThingCoAxiom :: TyThing -> CoAxiom Branched
1728 tyThingCoAxiom (ACoAxiom ax) = ax
1729 tyThingCoAxiom other         = pprPanic "tyThingCoAxiom" (pprTyThing other)
1730
1731 -- | Get the 'DataCon' from a 'TyThing' if it is a data constructor thing. Panics otherwise
1732 tyThingDataCon :: TyThing -> DataCon
1733 tyThingDataCon (AConLike (RealDataCon dc)) = dc
1734 tyThingDataCon other                       = pprPanic "tyThingDataCon" (pprTyThing other)
1735
1736 -- | Get the 'Id' from a 'TyThing' if it is a id *or* data constructor thing. Panics otherwise
1737 tyThingId :: TyThing -> Id
1738 tyThingId (AnId id)                   = id
1739 tyThingId (AConLike (RealDataCon dc)) = dataConWrapId dc
1740 tyThingId other                       = pprPanic "tyThingId" (pprTyThing other)
1741 \end{code}
1742
1743 %************************************************************************
1744 %*                                                                      *
1745 \subsection{MonadThings and friends}
1746 %*                                                                      *
1747 %************************************************************************
1748
1749 \begin{code}
1750 -- | Class that abstracts out the common ability of the monads in GHC
1751 -- to lookup a 'TyThing' in the monadic environment by 'Name'. Provides
1752 -- a number of related convenience functions for accessing particular
1753 -- kinds of 'TyThing'
1754 class Monad m => MonadThings m where
1755         lookupThing :: Name -> m TyThing
1756
1757         lookupId :: Name -> m Id
1758         lookupId = liftM tyThingId . lookupThing
1759
1760         lookupDataCon :: Name -> m DataCon
1761         lookupDataCon = liftM tyThingDataCon . lookupThing
1762
1763         lookupTyCon :: Name -> m TyCon
1764         lookupTyCon = liftM tyThingTyCon . lookupThing
1765 \end{code}
1766
1767 %************************************************************************
1768 %*                                                                      *
1769 \subsection{Auxiliary types}
1770 %*                                                                      *
1771 %************************************************************************
1772
1773 These types are defined here because they are mentioned in ModDetails,
1774 but they are mostly elaborated elsewhere
1775
1776 \begin{code}
1777 ------------------ Warnings -------------------------
1778 -- | Warning information for a module
1779 data Warnings
1780   = NoWarnings                          -- ^ Nothing deprecated
1781   | WarnAll WarningTxt                  -- ^ Whole module deprecated
1782   | WarnSome [(OccName,WarningTxt)]     -- ^ Some specific things deprecated
1783
1784      -- Only an OccName is needed because
1785      --    (1) a deprecation always applies to a binding
1786      --        defined in the module in which the deprecation appears.
1787      --    (2) deprecations are only reported outside the defining module.
1788      --        this is important because, otherwise, if we saw something like
1789      --
1790      --        {-# DEPRECATED f "" #-}
1791      --        f = ...
1792      --        h = f
1793      --        g = let f = undefined in f
1794      --
1795      --        we'd need more information than an OccName to know to say something
1796      --        about the use of f in h but not the use of the locally bound f in g
1797      --
1798      --        however, because we only report about deprecations from the outside,
1799      --        and a module can only export one value called f,
1800      --        an OccName suffices.
1801      --
1802      --        this is in contrast with fixity declarations, where we need to map
1803      --        a Name to its fixity declaration.
1804   deriving( Eq )
1805
1806 instance Binary Warnings where
1807     put_ bh NoWarnings     = putByte bh 0
1808     put_ bh (WarnAll t) = do
1809             putByte bh 1
1810             put_ bh t
1811     put_ bh (WarnSome ts) = do
1812             putByte bh 2
1813             put_ bh ts
1814
1815     get bh = do
1816             h <- getByte bh
1817             case h of
1818               0 -> return NoWarnings
1819               1 -> do aa <- get bh
1820                       return (WarnAll aa)
1821               _ -> do aa <- get bh
1822                       return (WarnSome aa)
1823
1824 -- | Constructs the cache for the 'mi_warn_fn' field of a 'ModIface'
1825 mkIfaceWarnCache :: Warnings -> Name -> Maybe WarningTxt
1826 mkIfaceWarnCache NoWarnings  = \_ -> Nothing
1827 mkIfaceWarnCache (WarnAll t) = \_ -> Just t
1828 mkIfaceWarnCache (WarnSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
1829
1830 emptyIfaceWarnCache :: Name -> Maybe WarningTxt
1831 emptyIfaceWarnCache _ = Nothing
1832
1833 plusWarns :: Warnings -> Warnings -> Warnings
1834 plusWarns d NoWarnings = d
1835 plusWarns NoWarnings d = d
1836 plusWarns _ (WarnAll t) = WarnAll t
1837 plusWarns (WarnAll t) _ = WarnAll t
1838 plusWarns (WarnSome v1) (WarnSome v2) = WarnSome (v1 ++ v2)
1839 \end{code}
1840
1841 \begin{code}
1842 -- | Creates cached lookup for the 'mi_fix_fn' field of 'ModIface'
1843 mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
1844 mkIfaceFixCache pairs
1845   = \n -> lookupOccEnv env n `orElse` defaultFixity
1846   where
1847    env = mkOccEnv pairs
1848
1849 emptyIfaceFixCache :: OccName -> Fixity
1850 emptyIfaceFixCache _ = defaultFixity
1851
1852 -- | Fixity environment mapping names to their fixities
1853 type FixityEnv = NameEnv FixItem
1854
1855 -- | Fixity information for an 'Name'. We keep the OccName in the range
1856 -- so that we can generate an interface from it
1857 data FixItem = FixItem OccName Fixity
1858
1859 instance Outputable FixItem where
1860   ppr (FixItem occ fix) = ppr fix <+> ppr occ
1861
1862 emptyFixityEnv :: FixityEnv
1863 emptyFixityEnv = emptyNameEnv
1864
1865 lookupFixity :: FixityEnv -> Name -> Fixity
1866 lookupFixity env n = case lookupNameEnv env n of
1867                         Just (FixItem _ fix) -> fix
1868                         Nothing         -> defaultFixity
1869 \end{code}
1870
1871 %************************************************************************
1872 %*                                                                      *
1873 \subsection{WhatsImported}
1874 %*                                                                      *
1875 %************************************************************************
1876
1877 \begin{code}
1878 -- | Records whether a module has orphans. An \"orphan\" is one of:
1879 --
1880 -- * An instance declaration in a module other than the definition
1881 --   module for one of the type constructors or classes in the instance head
1882 --
1883 -- * A transformation rule in a module other than the one defining
1884 --   the function in the head of the rule
1885 --
1886 -- * A vectorisation pragma
1887 type WhetherHasOrphans   = Bool
1888
1889 -- | Does this module define family instances?
1890 type WhetherHasFamInst = Bool
1891
1892 -- | Did this module originate from a *-boot file?
1893 type IsBootInterface = Bool
1894
1895 -- | Dependency information about ALL modules and packages below this one
1896 -- in the import hierarchy.
1897 --
1898 -- Invariant: the dependencies of a module @M@ never includes @M@.
1899 --
1900 -- Invariant: none of the lists contain duplicates.
1901 data Dependencies
1902   = Deps { dep_mods   :: [(ModuleName, IsBootInterface)]
1903                         -- ^ All home-package modules transitively below this one
1904                         -- I.e. modules that this one imports, or that are in the
1905                         --      dep_mods of those directly-imported modules
1906
1907          , dep_pkgs   :: [(PackageKey, Bool)]
1908                         -- ^ All packages transitively below this module
1909                         -- I.e. packages to which this module's direct imports belong,
1910                         --      or that are in the dep_pkgs of those modules
1911                         -- The bool indicates if the package is required to be
1912                         -- trusted when the module is imported as a safe import
1913                         -- (Safe Haskell). See Note [RnNames . Tracking Trust Transitively]
1914
1915          , dep_orphs  :: [Module]
1916                         -- ^ Orphan modules (whether home or external pkg),
1917                         -- *not* including family instance orphans as they
1918                         -- are anyway included in 'dep_finsts'
1919
1920          , dep_finsts :: [Module]
1921                         -- ^ Modules that contain family instances (whether the
1922                         -- instances are from the home or an external package)
1923          }
1924   deriving( Eq )
1925         -- Equality used only for old/new comparison in MkIface.addFingerprints
1926         -- See 'TcRnTypes.ImportAvails' for details on dependencies.
1927
1928 instance Binary Dependencies where
1929     put_ bh deps = do put_ bh (dep_mods deps)
1930                       put_ bh (dep_pkgs deps)
1931                       put_ bh (dep_orphs deps)
1932                       put_ bh (dep_finsts deps)
1933
1934     get bh = do ms <- get bh
1935                 ps <- get bh
1936                 os <- get bh
1937                 fis <- get bh
1938                 return (Deps { dep_mods = ms, dep_pkgs = ps, dep_orphs = os,
1939                                dep_finsts = fis })
1940
1941 noDependencies :: Dependencies
1942 noDependencies = Deps [] [] [] []
1943
1944 -- | Records modules for which changes may force recompilation of this module
1945 -- See wiki: http://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/RecompilationAvoidance
1946 --
1947 -- This differs from Dependencies.  A module X may be in the dep_mods of this
1948 -- module (via an import chain) but if we don't use anything from X it won't
1949 -- appear in our Usage
1950 data Usage
1951   -- | Module from another package
1952   = UsagePackageModule {
1953         usg_mod      :: Module,
1954            -- ^ External package module depended on
1955         usg_mod_hash :: Fingerprint,
1956             -- ^ Cached module fingerprint
1957         usg_safe :: IsSafeImport
1958             -- ^ Was this module imported as a safe import
1959     }
1960   -- | Module from the current package
1961   | UsageHomeModule {
1962         usg_mod_name :: ModuleName,
1963             -- ^ Name of the module
1964         usg_mod_hash :: Fingerprint,
1965             -- ^ Cached module fingerprint
1966         usg_entities :: [(OccName,Fingerprint)],
1967             -- ^ Entities we depend on, sorted by occurrence name and fingerprinted.
1968             -- NB: usages are for parent names only, e.g. type constructors
1969             -- but not the associated data constructors.
1970         usg_exports  :: Maybe Fingerprint,
1971             -- ^ Fingerprint for the export list of this module,
1972             -- if we directly imported it (and hence we depend on its export list)
1973         usg_safe :: IsSafeImport
1974             -- ^ Was this module imported as a safe import
1975     }                                           -- ^ Module from the current package
1976   -- | A file upon which the module depends, e.g. a CPP #include, or using TH's
1977   -- 'addDependentFile'
1978   | UsageFile {
1979         usg_file_path  :: FilePath,
1980         -- ^ External file dependency. From a CPP #include or TH
1981         -- addDependentFile. Should be absolute.
1982         usg_file_hash  :: Fingerprint
1983         -- ^ 'Fingerprint' of the file contents.
1984
1985         -- Note: We don't consider things like modification timestamps
1986         -- here, because there's no reason to recompile if the actual
1987         -- contents don't change.  This previously lead to odd
1988         -- recompilation behaviors; see #8114
1989   }
1990     deriving( Eq )
1991         -- The export list field is (Just v) if we depend on the export list:
1992         --      i.e. we imported the module directly, whether or not we
1993         --           enumerated the things we imported, or just imported
1994         --           everything
1995         -- We need to recompile if M's exports change, because
1996         -- if the import was    import M,       we might now have a name clash
1997         --                                      in the importing module.
1998         -- if the import was    import M(x)     M might no longer export x
1999         -- The only way we don't depend on the export list is if we have
2000         --                      import M()
2001         -- And of course, for modules that aren't imported directly we don't
2002         -- depend on their export lists
2003
2004 instance Binary Usage where
2005     put_ bh usg@UsagePackageModule{} = do
2006         putByte bh 0
2007         put_ bh (usg_mod usg)
2008         put_ bh (usg_mod_hash usg)
2009         put_ bh (usg_safe     usg)
2010
2011     put_ bh usg@UsageHomeModule{} = do
2012         putByte bh 1
2013         put_ bh (usg_mod_name usg)
2014         put_ bh (usg_mod_hash usg)
2015         put_ bh (usg_exports  usg)
2016         put_ bh (usg_entities usg)
2017         put_ bh (usg_safe     usg)
2018
2019     put_ bh usg@UsageFile{} = do
2020         putByte bh 2
2021         put_ bh (usg_file_path usg)
2022         put_ bh (usg_file_hash usg)
2023
2024     get bh = do
2025         h <- getByte bh
2026         case h of
2027           0 -> do
2028             nm    <- get bh
2029             mod   <- get bh
2030             safe  <- get bh
2031             return UsagePackageModule { usg_mod = nm, usg_mod_hash = mod, usg_safe = safe }
2032           1 -> do
2033             nm    <- get bh
2034             mod   <- get bh
2035             exps  <- get bh
2036             ents  <- get bh
2037             safe  <- get bh
2038             return UsageHomeModule { usg_mod_name = nm, usg_mod_hash = mod,
2039                      usg_exports = exps, usg_entities = ents, usg_safe = safe }
2040           2 -> do
2041             fp   <- get bh
2042             hash <- get bh
2043             return UsageFile { usg_file_path = fp, usg_file_hash = hash }
2044           i -> error ("Binary.get(Usage): " ++ show i)
2045
2046 \end{code}
2047
2048
2049 %************************************************************************
2050 %*                                                                      *
2051                 The External Package State
2052 %*                                                                      *
2053 %************************************************************************
2054
2055 \begin{code}
2056 type PackageTypeEnv    = TypeEnv
2057 type PackageRuleBase   = RuleBase
2058 type PackageInstEnv    = InstEnv
2059 type PackageFamInstEnv = FamInstEnv
2060 type PackageVectInfo   = VectInfo
2061 type PackageAnnEnv     = AnnEnv
2062
2063 -- | Information about other packages that we have slurped in by reading
2064 -- their interface files
2065 data ExternalPackageState
2066   = EPS {
2067         eps_is_boot :: !(ModuleNameEnv (ModuleName, IsBootInterface)),
2068                 -- ^ In OneShot mode (only), home-package modules
2069                 -- accumulate in the external package state, and are
2070                 -- sucked in lazily.  For these home-pkg modules
2071                 -- (only) we need to record which are boot modules.
2072                 -- We set this field after loading all the
2073                 -- explicitly-imported interfaces, but before doing
2074                 -- anything else
2075                 --
2076                 -- The 'ModuleName' part is not necessary, but it's useful for
2077                 -- debug prints, and it's convenient because this field comes
2078                 -- direct from 'TcRnTypes.imp_dep_mods'
2079
2080         eps_PIT :: !PackageIfaceTable,
2081                 -- ^ The 'ModIface's for modules in external packages
2082                 -- whose interfaces we have opened.
2083                 -- The declarations in these interface files are held in the
2084                 -- 'eps_decls', 'eps_inst_env', 'eps_fam_inst_env' and 'eps_rules'
2085                 -- fields of this record, not in the 'mi_decls' fields of the
2086                 -- interface we have sucked in.
2087                 --
2088                 -- What /is/ in the PIT is:
2089                 --
2090                 -- * The Module
2091                 --
2092                 -- * Fingerprint info
2093                 --
2094                 -- * Its exports
2095                 --
2096                 -- * Fixities
2097                 --
2098                 -- * Deprecations and warnings
2099
2100         eps_PTE :: !PackageTypeEnv,
2101                 -- ^ Result of typechecking all the external package
2102                 -- interface files we have sucked in. The domain of
2103                 -- the mapping is external-package modules
2104
2105         eps_inst_env     :: !PackageInstEnv,   -- ^ The total 'InstEnv' accumulated
2106                                                -- from all the external-package modules
2107         eps_fam_inst_env :: !PackageFamInstEnv,-- ^ The total 'FamInstEnv' accumulated
2108                                                -- from all the external-package modules
2109         eps_rule_base    :: !PackageRuleBase,  -- ^ The total 'RuleEnv' accumulated
2110                                                -- from all the external-package modules
2111         eps_vect_info    :: !PackageVectInfo,  -- ^ The total 'VectInfo' accumulated
2112                                                -- from all the external-package modules
2113         eps_ann_env      :: !PackageAnnEnv,    -- ^ The total 'AnnEnv' accumulated
2114                                                -- from all the external-package modules
2115
2116         eps_mod_fam_inst_env :: !(ModuleEnv FamInstEnv), -- ^ The family instances accumulated from external
2117                                                          -- packages, keyed off the module that declared them
2118
2119         eps_stats :: !EpsStats                 -- ^ Stastics about what was loaded from external packages
2120   }
2121
2122 -- | Accumulated statistics about what we are putting into the 'ExternalPackageState'.
2123 -- \"In\" means stuff that is just /read/ from interface files,
2124 -- \"Out\" means actually sucked in and type-checked
2125 data EpsStats = EpsStats { n_ifaces_in
2126                          , n_decls_in, n_decls_out
2127                          , n_rules_in, n_rules_out
2128                          , n_insts_in, n_insts_out :: !Int }
2129
2130 addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
2131 -- ^ Add stats for one newly-read interface
2132 addEpsInStats stats n_decls n_insts n_rules
2133   = stats { n_ifaces_in = n_ifaces_in stats + 1
2134           , n_decls_in  = n_decls_in stats + n_decls
2135           , n_insts_in  = n_insts_in stats + n_insts
2136           , n_rules_in  = n_rules_in stats + n_rules }
2137 \end{code}
2138
2139 Names in a NameCache are always stored as a Global, and have the SrcLoc
2140 of their binding locations.
2141
2142 Actually that's not quite right.  When we first encounter the original
2143 name, we might not be at its binding site (e.g. we are reading an
2144 interface file); so we give it 'noSrcLoc' then.  Later, when we find
2145 its binding site, we fix it up.
2146
2147 \begin{code}
2148 -- | The NameCache makes sure that there is just one Unique assigned for
2149 -- each original name; i.e. (module-name, occ-name) pair and provides
2150 -- something of a lookup mechanism for those names.
2151 data NameCache
2152  = NameCache {  nsUniqs :: !UniqSupply,
2153                 -- ^ Supply of uniques
2154                 nsNames :: !OrigNameCache
2155                 -- ^ Ensures that one original name gets one unique
2156    }
2157
2158 -- | Per-module cache of original 'OccName's given 'Name's
2159 type OrigNameCache   = ModuleEnv (OccEnv Name)
2160 \end{code}
2161
2162
2163 \begin{code}
2164 mkSOName :: Platform -> FilePath -> FilePath
2165 mkSOName platform root
2166     = case platformOS platform of
2167       OSDarwin  -> ("lib" ++ root) <.> "dylib"
2168       OSMinGW32 ->           root  <.> "dll"
2169       _         -> ("lib" ++ root) <.> "so"
2170
2171 mkHsSOName :: Platform -> FilePath -> FilePath
2172 mkHsSOName platform root = ("lib" ++ root) <.> soExt platform
2173
2174 soExt :: Platform -> FilePath
2175 soExt platform
2176     = case platformOS platform of
2177       OSDarwin  -> "dylib"
2178       OSMinGW32 -> "dll"
2179       _         -> "so"
2180 \end{code}
2181
2182
2183 %************************************************************************
2184 %*                                                                      *
2185                 The module graph and ModSummary type
2186         A ModSummary is a node in the compilation manager's
2187         dependency graph, and it's also passed to hscMain
2188 %*                                                                      *
2189 %************************************************************************
2190
2191 \begin{code}
2192 -- | A ModuleGraph contains all the nodes from the home package (only).
2193 -- There will be a node for each source module, plus a node for each hi-boot
2194 -- module.
2195 --
2196 -- The graph is not necessarily stored in topologically-sorted order.  Use
2197 -- 'GHC.topSortModuleGraph' and 'Digraph.flattenSCC' to achieve this.
2198 type ModuleGraph = [ModSummary]
2199
2200 emptyMG :: ModuleGraph
2201 emptyMG = []
2202
2203 -- | A single node in a 'ModuleGraph'. The nodes of the module graph
2204 -- are one of:
2205 --
2206 -- * A regular Haskell source module
2207 -- * A hi-boot source module
2208 -- * An external-core source module
2209 --
2210 data ModSummary
2211    = ModSummary {
2212         ms_mod          :: Module,
2213           -- ^ Identity of the module
2214         ms_hsc_src      :: HscSource,
2215           -- ^ The module source either plain Haskell, hs-boot or external core
2216         ms_location     :: ModLocation,
2217           -- ^ Location of the various files belonging to the module
2218         ms_hs_date      :: UTCTime,
2219           -- ^ Timestamp of source file
2220         ms_obj_date     :: Maybe UTCTime,
2221           -- ^ Timestamp of object, if we have one
2222         ms_srcimps      :: [Located (ImportDecl RdrName)],
2223           -- ^ Source imports of the module
2224         ms_textual_imps :: [Located (ImportDecl RdrName)],
2225           -- ^ Non-source imports of the module from the module *text*
2226         ms_hspp_file    :: FilePath,
2227           -- ^ Filename of preprocessed source file
2228         ms_hspp_opts    :: DynFlags,
2229           -- ^ Cached flags from @OPTIONS@, @INCLUDE@ and @LANGUAGE@
2230           -- pragmas in the modules source code
2231         ms_hspp_buf     :: Maybe StringBuffer
2232           -- ^ The actual preprocessed source, if we have it
2233      }
2234
2235 ms_mod_name :: ModSummary -> ModuleName
2236 ms_mod_name = moduleName . ms_mod
2237
2238 ms_imps :: ModSummary -> [Located (ImportDecl RdrName)]
2239 ms_imps ms =
2240   ms_textual_imps ms ++
2241   map mk_additional_import (dynFlagDependencies (ms_hspp_opts ms))
2242   where
2243     -- This is a not-entirely-satisfactory means of creating an import
2244     -- that corresponds to an import that did not occur in the program
2245     -- text, such as those induced by the use of plugins (the -plgFoo
2246     -- flag)
2247     mk_additional_import mod_nm = noLoc $ ImportDecl {
2248       ideclName      = noLoc mod_nm,
2249       ideclPkgQual   = Nothing,
2250       ideclSource    = False,
2251       ideclImplicit  = True, -- Maybe implicit because not "in the program text"
2252       ideclQualified = False,
2253       ideclAs        = Nothing,
2254       ideclHiding    = Nothing,
2255       ideclSafe      = False
2256     }
2257
2258 -- The ModLocation contains both the original source filename and the
2259 -- filename of the cleaned-up source file after all preprocessing has been
2260 -- done.  The point is that the summariser will have to cpp/unlit/whatever
2261 -- all files anyway, and there's no point in doing this twice -- just
2262 -- park the result in a temp file, put the name of it in the location,
2263 -- and let @compile@ read from that file on the way back up.
2264
2265 -- The ModLocation is stable over successive up-sweeps in GHCi, wheres
2266 -- the ms_hs_date and imports can, of course, change
2267
2268 msHsFilePath, msHiFilePath, msObjFilePath :: ModSummary -> FilePath
2269 msHsFilePath  ms = expectJust "msHsFilePath" (ml_hs_file  (ms_location ms))
2270 msHiFilePath  ms = ml_hi_file  (ms_location ms)
2271 msObjFilePath ms = ml_obj_file (ms_location ms)
2272
2273 -- | Did this 'ModSummary' originate from a hs-boot file?
2274 isBootSummary :: ModSummary -> Bool
2275 isBootSummary ms = isHsBoot (ms_hsc_src ms)
2276
2277 instance Outputable ModSummary where
2278    ppr ms
2279       = sep [text "ModSummary {",
2280              nest 3 (sep [text "ms_hs_date = " <> text (show (ms_hs_date ms)),
2281                           text "ms_mod =" <+> ppr (ms_mod ms)
2282                                 <> text (hscSourceString (ms_hsc_src ms)) <> comma,
2283                           text "ms_textual_imps =" <+> ppr (ms_textual_imps ms),
2284                           text "ms_srcimps =" <+> ppr (ms_srcimps ms)]),
2285              char '}'
2286             ]
2287
2288 showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String
2289 showModMsg dflags target recomp mod_summary
2290   = showSDoc dflags $
2291         hsep [text (mod_str ++ replicate (max 0 (16 - length mod_str)) ' '),
2292               char '(', text (normalise $ msHsFilePath mod_summary) <> comma,
2293               case target of
2294                   HscInterpreted | recomp
2295                              -> text "interpreted"
2296                   HscNothing -> text "nothing"
2297                   _          -> text (normalise $ msObjFilePath mod_summary),
2298               char ')']
2299  where
2300     mod     = moduleName (ms_mod mod_summary)
2301     mod_str = showPpr dflags mod ++ hscSourceString (ms_hsc_src mod_summary)
2302 \end{code}
2303
2304 %************************************************************************
2305 %*                                                                      *
2306 \subsection{Recmpilation}
2307 %*                                                                      *
2308 %************************************************************************
2309
2310 \begin{code}
2311 -- | Indicates whether a given module's source has been modified since it
2312 -- was last compiled.
2313 data SourceModified
2314   = SourceModified
2315        -- ^ the source has been modified
2316   | SourceUnmodified
2317        -- ^ the source has not been modified.  Compilation may or may
2318        -- not be necessary, depending on whether any dependencies have
2319        -- changed since we last compiled.
2320   | SourceUnmodifiedAndStable
2321        -- ^ the source has not been modified, and furthermore all of
2322        -- its (transitive) dependencies are up to date; it definitely
2323        -- does not need to be recompiled.  This is important for two
2324        -- reasons: (a) we can omit the version check in checkOldIface,
2325        -- and (b) if the module used TH splices we don't need to force
2326        -- recompilation.
2327 \end{code}
2328
2329 %************************************************************************
2330 %*                                                                      *
2331 \subsection{Hpc Support}
2332 %*                                                                      *
2333 %************************************************************************
2334
2335 \begin{code}
2336 -- | Information about a modules use of Haskell Program Coverage
2337 data HpcInfo
2338   = HpcInfo
2339      { hpcInfoTickCount :: Int
2340      , hpcInfoHash      :: Int
2341      }
2342   | NoHpcInfo
2343      { hpcUsed          :: AnyHpcUsage  -- ^ Is hpc used anywhere on the module \*tree\*?
2344      }
2345
2346 -- | This is used to signal if one of my imports used HPC instrumentation
2347 -- even if there is no module-local HPC usage
2348 type AnyHpcUsage = Bool
2349
2350 emptyHpcInfo :: AnyHpcUsage -> HpcInfo
2351 emptyHpcInfo = NoHpcInfo
2352
2353 -- | Find out if HPC is used by this module or any of the modules
2354 -- it depends upon
2355 isHpcUsed :: HpcInfo -> AnyHpcUsage
2356 isHpcUsed (HpcInfo {})                   = True
2357 isHpcUsed (NoHpcInfo { hpcUsed = used }) = used
2358 \end{code}
2359
2360 %************************************************************************
2361 %*                                                                      *
2362 \subsection{Vectorisation Support}
2363 %*                                                                      *
2364 %************************************************************************
2365
2366 The following information is generated and consumed by the vectorisation
2367 subsystem.  It communicates the vectorisation status of declarations from one
2368 module to another.
2369
2370 Why do we need both f and f_v in the ModGuts/ModDetails/EPS version VectInfo
2371 below?  We need to know `f' when converting to IfaceVectInfo.  However, during
2372 vectorisation, we need to know `f_v', whose `Var' we cannot lookup based
2373 on just the OccName easily in a Core pass.
2374
2375 \begin{code}
2376 -- |Vectorisation information for 'ModGuts', 'ModDetails' and 'ExternalPackageState'; see also
2377 -- documentation at 'Vectorise.Env.GlobalEnv'.
2378 --
2379 -- NB: The following tables may also include 'Var's, 'TyCon's and 'DataCon's from imported modules,
2380 --     which have been subsequently vectorised in the current module.
2381 --
2382 data VectInfo
2383   = VectInfo
2384     { vectInfoVar            :: VarEnv  (Var    , Var  )    -- ^ @(f, f_v)@ keyed on @f@
2385     , vectInfoTyCon          :: NameEnv (TyCon  , TyCon)    -- ^ @(T, T_v)@ keyed on @T@
2386     , vectInfoDataCon        :: NameEnv (DataCon, DataCon)  -- ^ @(C, C_v)@ keyed on @C@
2387     , vectInfoParallelVars   :: VarSet                      -- ^ set of parallel variables
2388     , vectInfoParallelTyCons :: NameSet                     -- ^ set of parallel type constructors
2389     }
2390
2391 -- |Vectorisation information for 'ModIface'; i.e, the vectorisation information propagated
2392 -- across module boundaries.
2393 --
2394 -- NB: The field 'ifaceVectInfoVar' explicitly contains the workers of data constructors as well as
2395 --     class selectors — i.e., their mappings are /not/ implicitly generated from the data types.
2396 --     Moreover, whether the worker of a data constructor is in 'ifaceVectInfoVar' determines
2397 --     whether that data constructor was vectorised (or is part of an abstractly vectorised type
2398 --     constructor).
2399 --
2400 data IfaceVectInfo
2401   = IfaceVectInfo
2402     { ifaceVectInfoVar            :: [Name]  -- ^ All variables in here have a vectorised variant
2403     , ifaceVectInfoTyCon          :: [Name]  -- ^ All 'TyCon's in here have a vectorised variant;
2404                                              -- the name of the vectorised variant and those of its
2405                                              -- data constructors are determined by
2406                                              -- 'OccName.mkVectTyConOcc' and
2407                                              -- 'OccName.mkVectDataConOcc'; the names of the
2408                                              -- isomorphisms are determined by 'OccName.mkVectIsoOcc'
2409     , ifaceVectInfoTyConReuse     :: [Name]  -- ^ The vectorised form of all the 'TyCon's in here
2410                                              -- coincides with the unconverted form; the name of the
2411                                              -- isomorphisms is determined by 'OccName.mkVectIsoOcc'
2412     , ifaceVectInfoParallelVars   :: [Name]  -- iface version of 'vectInfoParallelVar'
2413     , ifaceVectInfoParallelTyCons :: [Name]  -- iface version of 'vectInfoParallelTyCon'
2414     }
2415
2416 noVectInfo :: VectInfo
2417 noVectInfo
2418   = VectInfo emptyVarEnv emptyNameEnv emptyNameEnv emptyVarSet emptyNameSet
2419
2420 plusVectInfo :: VectInfo -> VectInfo -> VectInfo
2421 plusVectInfo vi1 vi2 =
2422   VectInfo (vectInfoVar            vi1 `plusVarEnv`    vectInfoVar            vi2)
2423            (vectInfoTyCon          vi1 `plusNameEnv`   vectInfoTyCon          vi2)
2424            (vectInfoDataCon        vi1 `plusNameEnv`   vectInfoDataCon        vi2)
2425            (vectInfoParallelVars   vi1 `unionVarSet`   vectInfoParallelVars   vi2)
2426            (vectInfoParallelTyCons vi1 `unionNameSets` vectInfoParallelTyCons vi2)
2427
2428 concatVectInfo :: [VectInfo] -> VectInfo
2429 concatVectInfo = foldr plusVectInfo noVectInfo
2430
2431 noIfaceVectInfo :: IfaceVectInfo
2432 noIfaceVectInfo = IfaceVectInfo [] [] [] [] []
2433
2434 isNoIfaceVectInfo :: IfaceVectInfo -> Bool
2435 isNoIfaceVectInfo (IfaceVectInfo l1 l2 l3 l4 l5)
2436   = null l1 && null l2 && null l3 && null l4 && null l5
2437
2438 instance Outputable VectInfo where
2439   ppr info = vcat
2440              [ ptext (sLit "variables       :") <+> ppr (vectInfoVar            info)
2441              , ptext (sLit "tycons          :") <+> ppr (vectInfoTyCon          info)
2442              , ptext (sLit "datacons        :") <+> ppr (vectInfoDataCon        info)
2443              , ptext (sLit "parallel vars   :") <+> ppr (vectInfoParallelVars   info)
2444              , ptext (sLit "parallel tycons :") <+> ppr (vectInfoParallelTyCons info)
2445              ]
2446
2447 instance Binary IfaceVectInfo where
2448     put_ bh (IfaceVectInfo a1 a2 a3 a4 a5) = do
2449         put_ bh a1
2450         put_ bh a2
2451         put_ bh a3
2452         put_ bh a4
2453         put_ bh a5
2454     get bh = do
2455         a1 <- get bh
2456         a2 <- get bh
2457         a3 <- get bh
2458         a4 <- get bh
2459         a5 <- get bh
2460         return (IfaceVectInfo a1 a2 a3 a4 a5)
2461 \end{code}
2462
2463 %************************************************************************
2464 %*                                                                      *
2465 \subsection{Safe Haskell Support}
2466 %*                                                                      *
2467 %************************************************************************
2468
2469 This stuff here is related to supporting the Safe Haskell extension,
2470 primarily about storing under what trust type a module has been compiled.
2471
2472 \begin{code}
2473 -- | Is an import a safe import?
2474 type IsSafeImport = Bool
2475
2476 -- | Safe Haskell information for 'ModIface'
2477 -- Simply a wrapper around SafeHaskellMode to sepperate iface and flags
2478 newtype IfaceTrustInfo = TrustInfo SafeHaskellMode
2479
2480 getSafeMode :: IfaceTrustInfo -> SafeHaskellMode
2481 getSafeMode (TrustInfo x) = x
2482
2483 setSafeMode :: SafeHaskellMode -> IfaceTrustInfo
2484 setSafeMode = TrustInfo
2485
2486 noIfaceTrustInfo :: IfaceTrustInfo
2487 noIfaceTrustInfo = setSafeMode Sf_None
2488
2489 trustInfoToNum :: IfaceTrustInfo -> Word8
2490 trustInfoToNum it
2491   = case getSafeMode it of
2492             Sf_None         -> 0
2493             Sf_Unsafe       -> 1
2494             Sf_Trustworthy  -> 2
2495             Sf_Safe         -> 3
2496             Sf_SafeInferred -> 4
2497
2498 numToTrustInfo :: Word8 -> IfaceTrustInfo
2499 numToTrustInfo 0 = setSafeMode Sf_None
2500 numToTrustInfo 1 = setSafeMode Sf_Unsafe
2501 numToTrustInfo 2 = setSafeMode Sf_Trustworthy
2502 numToTrustInfo 3 = setSafeMode Sf_Safe
2503 numToTrustInfo 4 = setSafeMode Sf_SafeInferred
2504 numToTrustInfo n = error $ "numToTrustInfo: bad input number! (" ++ show n ++ ")"
2505
2506 instance Outputable IfaceTrustInfo where
2507     ppr (TrustInfo Sf_None)          = ptext $ sLit "none"
2508     ppr (TrustInfo Sf_Unsafe)        = ptext $ sLit "unsafe"
2509     ppr (TrustInfo Sf_Trustworthy)   = ptext $ sLit "trustworthy"
2510     ppr (TrustInfo Sf_Safe)          = ptext $ sLit "safe"
2511     ppr (TrustInfo Sf_SafeInferred)  = ptext $ sLit "safe-inferred"
2512
2513 instance Binary IfaceTrustInfo where
2514     put_ bh iftrust = putByte bh $ trustInfoToNum iftrust
2515     get bh = getByte bh >>= (return . numToTrustInfo)
2516 \end{code}
2517
2518 %************************************************************************
2519 %*                                                                      *
2520 \subsection{Parser result}
2521 %*                                                                      *
2522 %************************************************************************
2523
2524 \begin{code}
2525 data HsParsedModule = HsParsedModule {
2526     hpm_module    :: Located (HsModule RdrName),
2527     hpm_src_files :: [FilePath]
2528        -- ^ extra source files (e.g. from #includes).  The lexer collects
2529        -- these from '# <file> <line>' pragmas, which the C preprocessor
2530        -- leaves behind.  These files and their timestamps are stored in
2531        -- the .hi file, so that we can force recompilation if any of
2532        -- them change (#3589)
2533   }
2534 \end{code}
2535
2536 %************************************************************************
2537 %*                                                                      *
2538 \subsection{Linkable stuff}
2539 %*                                                                      *
2540 %************************************************************************
2541
2542 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
2543 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
2544
2545 \begin{code}
2546 -- | Information we can use to dynamically link modules into the compiler
2547 data Linkable = LM {
2548   linkableTime     :: UTCTime,          -- ^ Time at which this linkable was built
2549                                         -- (i.e. when the bytecodes were produced,
2550                                         --       or the mod date on the files)
2551   linkableModule   :: Module,           -- ^ The linkable module itself
2552   linkableUnlinked :: [Unlinked]
2553     -- ^ Those files and chunks of code we have yet to link.
2554     --
2555     -- INVARIANT: A valid linkable always has at least one 'Unlinked' item.
2556     -- If this list is empty, the Linkable represents a fake linkable, which
2557     -- is generated in HscNothing mode to avoid recompiling modules.
2558     --
2559     -- ToDo: Do items get removed from this list when they get linked?
2560  }
2561
2562 isObjectLinkable :: Linkable -> Bool
2563 isObjectLinkable l = not (null unlinked) && all isObject unlinked
2564   where unlinked = linkableUnlinked l
2565         -- A linkable with no Unlinked's is treated as a BCO.  We can
2566         -- generate a linkable with no Unlinked's as a result of
2567         -- compiling a module in HscNothing mode, and this choice
2568         -- happens to work well with checkStability in module GHC.
2569
2570 linkableObjs :: Linkable -> [FilePath]
2571 linkableObjs l = [ f | DotO f <- linkableUnlinked l ]
2572
2573 instance Outputable Linkable where
2574    ppr (LM when_made mod unlinkeds)
2575       = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
2576         $$ nest 3 (ppr unlinkeds)
2577
2578 -------------------------------------------
2579
2580 -- | Objects which have yet to be linked by the compiler
2581 data Unlinked
2582    = DotO FilePath      -- ^ An object file (.o)
2583    | DotA FilePath      -- ^ Static archive file (.a)
2584    | DotDLL FilePath    -- ^ Dynamically linked library file (.so, .dll, .dylib)
2585    | BCOs CompiledByteCode ModBreaks    -- ^ A byte-code object, lives only in memory
2586
2587 #ifndef GHCI
2588 data CompiledByteCode = CompiledByteCodeUndefined
2589 _unused :: CompiledByteCode
2590 _unused = CompiledByteCodeUndefined
2591 #endif
2592
2593 instance Outputable Unlinked where
2594    ppr (DotO path)   = text "DotO" <+> text path
2595    ppr (DotA path)   = text "DotA" <+> text path
2596    ppr (DotDLL path) = text "DotDLL" <+> text path
2597 #ifdef GHCI
2598    ppr (BCOs bcos _) = text "BCOs" <+> ppr bcos
2599 #else
2600    ppr (BCOs _ _)    = text "No byte code"
2601 #endif
2602
2603 -- | Is this an actual file on disk we can link in somehow?
2604 isObject :: Unlinked -> Bool
2605 isObject (DotO _)   = True
2606 isObject (DotA _)   = True
2607 isObject (DotDLL _) = True
2608 isObject _          = False
2609
2610 -- | Is this a bytecode linkable with no file on disk?
2611 isInterpretable :: Unlinked -> Bool
2612 isInterpretable = not . isObject
2613
2614 -- | Retrieve the filename of the linkable if possible. Panic if it is a byte-code object
2615 nameOfObject :: Unlinked -> FilePath
2616 nameOfObject (DotO fn)   = fn
2617 nameOfObject (DotA fn)   = fn
2618 nameOfObject (DotDLL fn) = fn
2619 nameOfObject other       = pprPanic "nameOfObject" (ppr other)
2620
2621 -- | Retrieve the compiled byte-code if possible. Panic if it is a file-based linkable
2622 byteCodeOfObject :: Unlinked -> CompiledByteCode
2623 byteCodeOfObject (BCOs bc _) = bc
2624 byteCodeOfObject other       = pprPanic "byteCodeOfObject" (ppr other)
2625 \end{code}
2626
2627 %************************************************************************
2628 %*                                                                      *
2629 \subsection{Breakpoint Support}
2630 %*                                                                      *
2631 %************************************************************************
2632
2633 \begin{code}
2634 -- | Breakpoint index
2635 type BreakIndex = Int
2636
2637 -- | All the information about the breakpoints for a given module
2638 data ModBreaks
2639    = ModBreaks
2640    { modBreaks_flags :: BreakArray
2641         -- ^ The array of flags, one per breakpoint,
2642         -- indicating which breakpoints are enabled.
2643    , modBreaks_locs :: !(Array BreakIndex SrcSpan)
2644         -- ^ An array giving the source span of each breakpoint.
2645    , modBreaks_vars :: !(Array BreakIndex [OccName])
2646         -- ^ An array giving the names of the free variables at each breakpoint.
2647    , modBreaks_decls :: !(Array BreakIndex [String])
2648         -- ^ An array giving the names of the declarations enclosing each breakpoint.
2649    }
2650
2651 -- | Construct an empty ModBreaks
2652 emptyModBreaks :: ModBreaks
2653 emptyModBreaks = ModBreaks
2654    { modBreaks_flags = error "ModBreaks.modBreaks_array not initialised"
2655          -- ToDo: can we avoid this?
2656    , modBreaks_locs  = array (0,-1) []
2657    , modBreaks_vars  = array (0,-1) []
2658    , modBreaks_decls = array (0,-1) []
2659    }
2660 \end{code}