1e40d4225f0c76b9cf0058076b9e8a022afc1046
[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, extendTypeEnvWithPatSyns,
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 PackageId
638         -- ^ The requested package was not found
639   | FoundMultiple [PackageId]
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 PackageId  -- Just p => module is in this package's
647                                            --           manifest, but couldn't find
648                                            --           the .hi file
649
650       , fr_mods_hidden :: [PackageId]      -- Module is in these packages,
651                                            --   but the *module* is hidden
652
653       , fr_pkgs_hidden :: [PackageId]      -- 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         md_insts     :: ![ClsInst],    -- ^ 'DFunId's for the instances in this module
956         md_fam_insts :: ![FamInst],
957         md_rules     :: ![CoreRule],    -- ^ Domain may include 'Id's from other modules
958         md_anns      :: ![Annotation],  -- ^ Annotations present in this module: currently
959                                         -- they only annotate things also declared in this module
960         md_vect_info :: !VectInfo       -- ^ Module vectorisation information
961      }
962
963 -- | Constructs an empty ModDetails
964 emptyModDetails :: ModDetails
965 emptyModDetails
966   = ModDetails { md_types     = emptyTypeEnv,
967                  md_exports   = [],
968                  md_insts     = [],
969                  md_rules     = [],
970                  md_fam_insts = [],
971                  md_anns      = [],
972                  md_vect_info = noVectInfo }
973
974 -- | Records the modules directly imported by a module for extracting e.g. usage information
975 type ImportedMods = ModuleEnv [ImportedModsVal]
976 type ImportedModsVal = (ModuleName, Bool, SrcSpan, IsSafeImport)
977
978 -- | A ModGuts is carried through the compiler, accumulating stuff as it goes
979 -- There is only one ModGuts at any time, the one for the module
980 -- being compiled right now.  Once it is compiled, a 'ModIface' and
981 -- 'ModDetails' are extracted and the ModGuts is discarded.
982 data ModGuts
983   = ModGuts {
984         mg_module    :: !Module,         -- ^ Module being compiled
985         mg_boot      :: IsBootInterface, -- ^ Whether it's an hs-boot module
986         mg_exports   :: ![AvailInfo],    -- ^ What it exports
987         mg_deps      :: !Dependencies,   -- ^ What it depends on, directly or
988                                          -- otherwise
989         mg_dir_imps  :: !ImportedMods,   -- ^ Directly-imported modules; used to
990                                          -- generate initialisation code
991         mg_used_names:: !NameSet,        -- ^ What the module needed (used in 'MkIface.mkIface')
992
993         mg_used_th   :: !Bool,           -- ^ Did we run a TH splice?
994         mg_rdr_env   :: !GlobalRdrEnv,   -- ^ Top-level lexical environment
995
996         -- These fields all describe the things **declared in this module**
997         mg_fix_env   :: !FixityEnv,      -- ^ Fixities declared in this module
998                                          -- ToDo: I'm unconvinced this is actually used anywhere
999         mg_tcs       :: ![TyCon],        -- ^ TyCons declared in this module
1000                                          -- (includes TyCons for classes)
1001         mg_insts     :: ![ClsInst],      -- ^ Class instances declared in this module
1002         mg_fam_insts :: ![FamInst],
1003                                          -- ^ Family instances declared in this module
1004         mg_patsyns   :: ![PatSyn],       -- ^ Pattern synonyms declared in this module
1005         mg_rules     :: ![CoreRule],     -- ^ Before the core pipeline starts, contains
1006                                          -- See Note [Overall plumbing for rules] in Rules.lhs
1007         mg_binds     :: !CoreProgram,    -- ^ Bindings for this module
1008         mg_foreign   :: !ForeignStubs,   -- ^ Foreign exports declared in this module
1009         mg_warns     :: !Warnings,       -- ^ Warnings declared in the module
1010         mg_anns      :: [Annotation],    -- ^ Annotations declared in this module
1011         mg_hpc_info  :: !HpcInfo,        -- ^ Coverage tick boxes in the module
1012         mg_modBreaks :: !ModBreaks,      -- ^ Breakpoints for the module
1013         mg_vect_decls:: ![CoreVect],     -- ^ Vectorisation declarations in this module
1014                                          --   (produced by desugarer & consumed by vectoriser)
1015         mg_vect_info :: !VectInfo,       -- ^ Pool of vectorised declarations in the module
1016
1017         -- The next two fields are unusual, because they give instance
1018         -- environments for *all* modules in the home package, including
1019         -- this module, rather than for *just* this module.
1020         -- Reason: when looking up an instance we don't want to have to
1021         --        look at each module in the home package in turn
1022         mg_inst_env     :: InstEnv,
1023         -- ^ Class instance environment from /home-package/ modules (including
1024         -- this one); c.f. 'tcg_inst_env'
1025         mg_fam_inst_env :: FamInstEnv,
1026         -- ^ Type-family instance environment for /home-package/ modules
1027         -- (including this one); c.f. 'tcg_fam_inst_env'
1028         mg_safe_haskell :: SafeHaskellMode,
1029         -- ^ Safe Haskell mode
1030         mg_trust_pkg    :: Bool,
1031         -- ^ Do we need to trust our own package for Safe Haskell?
1032         -- See Note [RnNames . Trust Own Package]
1033         mg_dependent_files :: [FilePath] -- ^ dependencies from addDependentFile
1034     }
1035
1036 -- The ModGuts takes on several slightly different forms:
1037 --
1038 -- After simplification, the following fields change slightly:
1039 --      mg_rules        Orphan rules only (local ones now attached to binds)
1040 --      mg_binds        With rules attached
1041
1042
1043 ---------------------------------------------------------
1044 -- The Tidy pass forks the information about this module:
1045 --      * one lot goes to interface file generation (ModIface)
1046 --        and later compilations (ModDetails)
1047 --      * the other lot goes to code generation (CgGuts)
1048
1049 -- | A restricted form of 'ModGuts' for code generation purposes
1050 data CgGuts
1051   = CgGuts {
1052         cg_module    :: !Module,
1053                 -- ^ Module being compiled
1054
1055         cg_tycons    :: [TyCon],
1056                 -- ^ Algebraic data types (including ones that started
1057                 -- life as classes); generate constructors and info
1058                 -- tables. Includes newtypes, just for the benefit of
1059                 -- External Core
1060
1061         cg_binds     :: CoreProgram,
1062                 -- ^ The tidied main bindings, including
1063                 -- previously-implicit bindings for record and class
1064                 -- selectors, and data constructor wrappers.  But *not*
1065                 -- data constructor workers; reason: we we regard them
1066                 -- as part of the code-gen of tycons
1067
1068         cg_foreign   :: !ForeignStubs,   -- ^ Foreign export stubs
1069         cg_dep_pkgs  :: ![PackageId],    -- ^ Dependent packages, used to
1070                                          -- generate #includes for C code gen
1071         cg_hpc_info  :: !HpcInfo,        -- ^ Program coverage tick box information
1072         cg_modBreaks :: !ModBreaks       -- ^ Module breakpoints
1073     }
1074
1075 -----------------------------------
1076 -- | Foreign export stubs
1077 data ForeignStubs
1078   = NoStubs
1079       -- ^ We don't have any stubs
1080   | ForeignStubs SDoc SDoc
1081       -- ^ There are some stubs. Parameters:
1082       --
1083       --  1) Header file prototypes for
1084       --     "foreign exported" functions
1085       --
1086       --  2) C stubs to use when calling
1087       --     "foreign exported" functions
1088
1089 appendStubC :: ForeignStubs -> SDoc -> ForeignStubs
1090 appendStubC NoStubs            c_code = ForeignStubs empty c_code
1091 appendStubC (ForeignStubs h c) c_code = ForeignStubs h (c $$ c_code)
1092 \end{code}
1093
1094 %************************************************************************
1095 %*                                                                      *
1096 \subsection{The interactive context}
1097 %*                                                                      *
1098 %************************************************************************
1099
1100 Note [The interactive package]
1101 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1102 Type and class declarations at the command prompt are treated as if
1103 they were defined in modules
1104    interactive:Ghci1
1105    interactive:Ghci2
1106    ...etc...
1107 with each bunch of declarations using a new module, all sharing a
1108 common package 'interactive' (see Module.interactivePackageId, and
1109 PrelNames.mkInteractiveModule).
1110
1111 This scheme deals well with shadowing.  For example:
1112
1113    ghci> data T = A
1114    ghci> data T = B
1115    ghci> :i A
1116    data Ghci1.T = A  -- Defined at <interactive>:2:10
1117
1118 Here we must display info about constructor A, but its type T has been
1119 shadowed by the second declaration.  But it has a respectable
1120 qualified name (Ghci1.T), and its source location says where it was
1121 defined.
1122
1123 So the main invariant continues to hold, that in any session an
1124 original name M.T only refers to one unique thing.  (In a previous
1125 iteration both the T's above were called :Interactive.T, albeit with
1126 different uniques, which gave rise to all sorts of trouble.)
1127
1128 The details are a bit tricky though:
1129
1130  * The field ic_mod_index counts which Ghci module we've got up to.
1131    It is incremented when extending ic_tythings
1132
1133  * ic_tythings contains only things from the 'interactive' package.
1134
1135  * Module from the 'interactive' package (Ghci1, Ghci2 etc) never go
1136    in the Home Package Table (HPT).  When you say :load, that's when we
1137    extend the HPT.
1138
1139  * The 'thisPackage' field of DynFlags is *not* set to 'interactive'.
1140    It stays as 'main' (or whatever -package-name says), and is the
1141    package to which :load'ed modules are added to.
1142
1143  * So how do we arrange that declarations at the command prompt get
1144    to be in the 'interactive' package?  Simply by setting the tcg_mod
1145    field of the TcGblEnv to "interactive:Ghci1".  This is done by the
1146    call to initTc in initTcInteractive, initTcForLookup, which in 
1147    turn get the module from it 'icInteractiveModule' field of the 
1148    interactive context.
1149
1150    The 'thisPackage' field stays as 'main' (or whatever -package-name says.
1151
1152  * The main trickiness is that the type environment (tcg_type_env and
1153    fixity envt (tcg_fix_env) now contains entities from all the
1154    GhciN modules together, rather than just a single module as is usually
1155    the case.  So you can't use "nameIsLocalOrFrom" to decide whether
1156    to look in the TcGblEnv vs the HPT/PTE.  This is a change, but not
1157    a problem provided you know.
1158
1159
1160 Note [Interactively-bound Ids in GHCi]
1161 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1162 The Ids bound by previous Stmts in GHCi are currently
1163         a) GlobalIds
1164         b) with an Internal Name (not External)
1165         c) and a tidied type
1166
1167  (a) They must be GlobalIds (not LocalIds) otherwise when we come to
1168      compile an expression using these ids later, the byte code
1169      generator will consider the occurrences to be free rather than
1170      global.
1171
1172  (b) They start with an Internal Name because a Stmt is a local
1173      construct, so the renamer naturally builds an Internal name for
1174      each of its binders.  It would be possible subsequently to give
1175      them an External Name (in a GhciN module) but then we'd have
1176      to substitute it out.  So for now they stay Internal.
1177
1178  (c) Their types are tidied. This is important, because :info may ask
1179      to look at them, and :info expects the things it looks up to have
1180      tidy types
1181
1182 However note that TyCons, Classes, and even Ids bound by other top-level
1183 declarations in GHCi (eg foreign import, record selectors) currently get
1184 External Names, with Ghci9 (or 8, or 7, etc) as the module name. 
1185
1186
1187 Note [ic_tythings]
1188 ~~~~~~~~~~~~~~~~~~
1189 The ic_tythings field contains
1190   * The TyThings declared by the user at the command prompt
1191     (eg Ids, TyCons, Classes)
1192
1193   * The user-visible Ids that arise from such things, which 
1194     *don't* come from 'implicitTyThings', notably:
1195        - record selectors
1196        - class ops
1197     The implicitTyThings are readily obtained from the TyThings
1198     but record selectors etc are not
1199
1200 It does *not* contain
1201   * DFunIds (they can be gotten from ic_instances)
1202   * CoAxioms (ditto)
1203
1204 See also Note [Interactively-bound Ids in GHCi]
1205
1206
1207 \begin{code}
1208 -- | Interactive context, recording information about the state of the
1209 -- context in which statements are executed in a GHC session.
1210 data InteractiveContext
1211   = InteractiveContext {
1212          ic_dflags     :: DynFlags,
1213              -- ^ The 'DynFlags' used to evaluate interative expressions
1214              -- and statements.
1215
1216          ic_mod_index :: Int,
1217              -- ^ Each GHCi stmt or declaration brings some new things into
1218              -- scope. We give them names like interactive:Ghci9.T,
1219              -- where the ic_index is the '9'.  The ic_mod_index is
1220              -- incremented whenever we add something to ic_tythings
1221              -- See Note [The interactive package]
1222
1223          ic_imports :: [InteractiveImport],
1224              -- ^ The GHCi top-level scope (ic_rn_gbl_env) is extended with
1225              -- these imports
1226              --
1227              -- This field is only stored here so that the client
1228              -- can retrieve it with GHC.getContext. GHC itself doesn't
1229              -- use it, but does reset it to empty sometimes (such
1230              -- as before a GHC.load). The context is set with GHC.setContext.
1231
1232          ic_tythings   :: [TyThing],
1233              -- ^ TyThings defined by the user, in reverse order of
1234              -- definition (ie most recent at the front)
1235              -- See Note [ic_tythings]
1236
1237          ic_rn_gbl_env :: GlobalRdrEnv,
1238              -- ^ The cached 'GlobalRdrEnv', built by
1239              -- 'InteractiveEval.setContext' and updated regularly
1240              -- It contains everything in scope at the command line,
1241              -- including everything in ic_tythings
1242
1243          ic_instances  :: ([ClsInst], [FamInst]),
1244              -- ^ All instances and family instances created during
1245              -- this session.  These are grabbed en masse after each
1246              -- update to be sure that proper overlapping is retained.
1247              -- That is, rather than re-check the overlapping each
1248              -- time we update the context, we just take the results
1249              -- from the instance code that already does that.
1250
1251          ic_fix_env :: FixityEnv,
1252             -- ^ Fixities declared in let statements
1253
1254          ic_default :: Maybe [Type],
1255              -- ^ The current default types, set by a 'default' declaration
1256
1257 #ifdef GHCI
1258           ic_resume :: [Resume],
1259              -- ^ The stack of breakpoint contexts
1260 #endif
1261
1262          ic_monad      :: Name,
1263              -- ^ The monad that GHCi is executing in
1264
1265          ic_int_print  :: Name,
1266              -- ^ The function that is used for printing results
1267              -- of expressions in ghci and -e mode.
1268
1269          ic_cwd :: Maybe FilePath
1270              -- virtual CWD of the program
1271     }
1272
1273 data InteractiveImport
1274   = IIDecl (ImportDecl RdrName)
1275       -- ^ Bring the exports of a particular module
1276       -- (filtered by an import decl) into scope
1277
1278   | IIModule ModuleName
1279       -- ^ Bring into scope the entire top-level envt of
1280       -- of this module, including the things imported
1281       -- into it.
1282
1283
1284 -- | Constructs an empty InteractiveContext.
1285 emptyInteractiveContext :: DynFlags -> InteractiveContext
1286 emptyInteractiveContext dflags
1287   = InteractiveContext {
1288        ic_dflags     = dflags,
1289        ic_imports    = [],
1290        ic_rn_gbl_env = emptyGlobalRdrEnv,
1291        ic_mod_index  = 1,
1292        ic_tythings   = [],
1293        ic_instances  = ([],[]),
1294        ic_fix_env    = emptyNameEnv,
1295        ic_monad      = ioTyConName,  -- IO monad by default
1296        ic_int_print  = printName,    -- System.IO.print by default
1297        ic_default    = Nothing,
1298 #ifdef GHCI
1299        ic_resume     = [],
1300 #endif
1301        ic_cwd        = Nothing }
1302
1303 icInteractiveModule :: InteractiveContext -> Module
1304 icInteractiveModule (InteractiveContext { ic_mod_index = index }) 
1305   = mkInteractiveModule index
1306
1307 -- | This function returns the list of visible TyThings (useful for
1308 -- e.g. showBindings)
1309 icInScopeTTs :: InteractiveContext -> [TyThing]
1310 icInScopeTTs = ic_tythings
1311
1312 -- | Get the PrintUnqualified function based on the flags and this InteractiveContext
1313 icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified
1314 icPrintUnqual dflags InteractiveContext{ ic_rn_gbl_env = grenv } =
1315     mkPrintUnqualified dflags grenv
1316
1317 -- | This function is called with new TyThings recently defined to update the
1318 -- InteractiveContext to include them.  Ids are easily removed when shadowed,
1319 -- but Classes and TyCons are not.  Some work could be done to determine
1320 -- whether they are entirely shadowed, but as you could still have references
1321 -- to them (e.g. instances for classes or values of the type for TyCons), it's
1322 -- not clear whether removing them is even the appropriate behavior.
1323 extendInteractiveContext :: InteractiveContext -> [TyThing] -> InteractiveContext
1324 extendInteractiveContext ictxt new_tythings
1325   | null new_tythings
1326   = ictxt
1327   | otherwise
1328   = ictxt { ic_mod_index  = ic_mod_index ictxt + 1
1329           , ic_tythings   = new_tythings ++ old_tythings
1330           , ic_rn_gbl_env = ic_rn_gbl_env ictxt `icExtendGblRdrEnv` new_tythings
1331           }
1332   where
1333     old_tythings = filter (not . shadowed) (ic_tythings ictxt)
1334
1335     shadowed (AnId id) = ((`elem` new_names) . nameOccName . idName) id
1336     shadowed _         = False
1337
1338     new_names = [ nameOccName (getName id) | AnId id <- new_tythings ]
1339
1340 setInteractivePackage :: HscEnv -> HscEnv
1341 -- Set the 'thisPackage' DynFlag to 'interactive'
1342 setInteractivePackage hsc_env
1343    = hsc_env { hsc_dflags = (hsc_dflags hsc_env) { thisPackage = interactivePackageId } }
1344
1345 setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext
1346 setInteractivePrintName ic n = ic{ic_int_print = n}
1347
1348     -- ToDo: should not add Ids to the gbl env here
1349
1350 -- | Add TyThings to the GlobalRdrEnv, earlier ones in the list shadowing
1351 -- later ones, and shadowing existing entries in the GlobalRdrEnv.
1352 icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv
1353 icExtendGblRdrEnv env tythings
1354   = foldr add env tythings  -- Foldr makes things in the front of
1355                             -- the list shadow things at the back
1356   where
1357     add thing env = extendGlobalRdrEnv True {- Shadowing please -} env
1358                                        [tyThingAvailInfo thing]
1359        -- One at a time, to ensure each shadows the previous ones
1360
1361 substInteractiveContext :: InteractiveContext -> TvSubst -> InteractiveContext
1362 substInteractiveContext ictxt@InteractiveContext{ ic_tythings = tts } subst
1363   | isEmptyTvSubst subst = ictxt
1364   | otherwise            = ictxt { ic_tythings = map subst_ty tts }
1365   where
1366     subst_ty (AnId id) = AnId $ id `setIdType` substTy subst (idType id)
1367     subst_ty tt        = tt
1368
1369 instance Outputable InteractiveImport where
1370   ppr (IIModule m) = char '*' <> ppr m
1371   ppr (IIDecl d)   = ppr d
1372 \end{code}
1373
1374 %************************************************************************
1375 %*                                                                      *
1376         Building a PrintUnqualified
1377 %*                                                                      *
1378 %************************************************************************
1379
1380 Note [Printing original names]
1381 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1382 Deciding how to print names is pretty tricky.  We are given a name
1383 P:M.T, where P is the package name, M is the defining module, and T is
1384 the occurrence name, and we have to decide in which form to display
1385 the name given a GlobalRdrEnv describing the current scope.
1386
1387 Ideally we want to display the name in the form in which it is in
1388 scope.  However, the name might not be in scope at all, and that's
1389 where it gets tricky.  Here are the cases:
1390
1391  1. T uniquely maps to  P:M.T      --->  "T"      NameUnqual
1392  2. There is an X for which X.T
1393        uniquely maps to  P:M.T     --->  "X.T"    NameQual X
1394  3. There is no binding for "M.T"  --->  "M.T"    NameNotInScope1
1395  4. Otherwise                      --->  "P:M.T"  NameNotInScope2
1396
1397 (3) and (4) apply when the entity P:M.T is not in the GlobalRdrEnv at
1398 all. In these cases we still want to refer to the name as "M.T", *but*
1399 "M.T" might mean something else in the current scope (e.g. if there's
1400 an "import X as M"), so to avoid confusion we avoid using "M.T" if
1401 there's already a binding for it.  Instead we write P:M.T.
1402
1403 There's one further subtlety: in case (3), what if there are two
1404 things around, P1:M.T and P2:M.T?  Then we don't want to print both of
1405 them as M.T!  However only one of the modules P1:M and P2:M can be
1406 exposed (say P2), so we use M.T for that, and P1:M.T for the other one.
1407 This is handled by the qual_mod component of PrintUnqualified, inside
1408 the (ppr mod) of case (3), in Name.pprModulePrefix
1409
1410 \begin{code}
1411 -- | Creates some functions that work out the best ways to format
1412 -- names for the user according to a set of heuristics
1413 mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified
1414 mkPrintUnqualified dflags env = (qual_name, qual_mod)
1415   where
1416   qual_name mod occ
1417         | [gre] <- unqual_gres
1418         , right_name gre
1419         = NameUnqual
1420                 -- If there's a unique entity that's in scope unqualified with 'occ'
1421                 -- AND that entity is the right one, then we can use the unqualified name
1422
1423         | [gre] <- qual_gres
1424         = NameQual (get_qual_mod (gre_prov gre))
1425
1426         | null qual_gres
1427         = if null (lookupGRE_RdrName (mkRdrQual (moduleName mod) occ) env)
1428           then NameNotInScope1
1429           else NameNotInScope2
1430
1431         | otherwise
1432         = NameNotInScope1   -- Can happen if 'f' is bound twice in the module
1433                             -- Eg  f = True; g = 0; f = False
1434       where
1435         right_name gre = nameModule_maybe (gre_name gre) == Just mod
1436
1437         unqual_gres = lookupGRE_RdrName (mkRdrUnqual occ) env
1438         qual_gres   = filter right_name (lookupGlobalRdrEnv env occ)
1439
1440         get_qual_mod LocalDef      = moduleName mod
1441         get_qual_mod (Imported is) = ASSERT( not (null is) ) is_as (is_decl (head is))
1442
1443     -- we can mention a module P:M without the P: qualifier iff
1444     -- "import M" would resolve unambiguously to P:M.  (if P is the
1445     -- current package we can just assume it is unqualified).
1446
1447   qual_mod mod
1448      | modulePackageId mod == thisPackage dflags = False
1449
1450      | [pkgconfig] <- [pkg | (pkg,exposed_module) <- lookup,
1451                              exposed pkg && exposed_module],
1452        packageConfigId pkgconfig == modulePackageId mod
1453         -- this says: we are given a module P:M, is there just one exposed package
1454         -- that exposes a module M, and is it package P?
1455      = False
1456
1457      | otherwise = True
1458      where lookup = lookupModuleInAllPackages dflags (moduleName mod)
1459 \end{code}
1460
1461
1462 %************************************************************************
1463 %*                                                                      *
1464                 Implicit TyThings
1465 %*                                                                      *
1466 %************************************************************************
1467
1468 Note [Implicit TyThings]
1469 ~~~~~~~~~~~~~~~~~~~~~~~~
1470   DEFINITION: An "implicit" TyThing is one that does not have its own
1471   IfaceDecl in an interface file.  Instead, its binding in the type
1472   environment is created as part of typechecking the IfaceDecl for
1473   some other thing.
1474
1475 Examples:
1476   * All DataCons are implicit, because they are generated from the
1477     IfaceDecl for the data/newtype.  Ditto class methods.
1478
1479   * Record selectors are *not* implicit, because they get their own
1480     free-standing IfaceDecl.
1481
1482   * Associated data/type families are implicit because they are
1483     included in the IfaceDecl of the parent class.  (NB: the
1484     IfaceClass decl happens to use IfaceDecl recursively for the
1485     associated types, but that's irrelevant here.)
1486
1487   * Dictionary function Ids are not implicit.
1488
1489   * Axioms for newtypes are implicit (same as above), but axioms
1490     for data/type family instances are *not* implicit (like DFunIds).
1491
1492 \begin{code}
1493 -- | Determine the 'TyThing's brought into scope by another 'TyThing'
1494 -- /other/ than itself. For example, Id's don't have any implicit TyThings
1495 -- as they just bring themselves into scope, but classes bring their
1496 -- dictionary datatype, type constructor and some selector functions into
1497 -- scope, just for a start!
1498
1499 -- N.B. the set of TyThings returned here *must* match the set of
1500 -- names returned by LoadIface.ifaceDeclImplicitBndrs, in the sense that
1501 -- TyThing.getOccName should define a bijection between the two lists.
1502 -- This invariant is used in LoadIface.loadDecl (see note [Tricky iface loop])
1503 -- The order of the list does not matter.
1504 implicitTyThings :: TyThing -> [TyThing]
1505 implicitTyThings (AnId _)       = []
1506 implicitTyThings (ACoAxiom _cc) = []
1507 implicitTyThings (ATyCon tc)    = implicitTyConThings tc
1508 implicitTyThings (AConLike cl)  = implicitConLikeThings cl
1509
1510 implicitConLikeThings :: ConLike -> [TyThing]
1511 implicitConLikeThings (RealDataCon dc)
1512   = map AnId (dataConImplicitIds dc)
1513     -- For data cons add the worker and (possibly) wrapper
1514
1515 implicitConLikeThings (PatSynCon {})
1516   = []  -- Pattern synonyms have no implicit Ids; the wrapper and matcher
1517         -- are not "implicit"; they are simply new top-level bindings,
1518         -- and they have their own declaration in an interface fiel
1519
1520 implicitClassThings :: Class -> [TyThing]
1521 implicitClassThings cl
1522   = -- Does not include default methods, because those Ids may have
1523     --    their own pragmas, unfoldings etc, not derived from the Class object
1524     -- associated types
1525     --    No extras_plus (recursive call) for the classATs, because they
1526     --    are only the family decls; they have no implicit things
1527     map ATyCon (classATs cl) ++
1528     -- superclass and operation selectors
1529     map AnId (classAllSelIds cl)
1530
1531 implicitTyConThings :: TyCon -> [TyThing]
1532 implicitTyConThings tc
1533   = class_stuff ++
1534       -- fields (names of selectors)
1535
1536       -- (possibly) implicit newtype coercion
1537     implicitCoTyCon tc ++
1538
1539       -- for each data constructor in order,
1540       --   the contructor, worker, and (possibly) wrapper
1541     concatMap (extras_plus . AConLike . RealDataCon) (tyConDataCons tc)
1542       -- NB. record selectors are *not* implicit, they have fully-fledged
1543       -- bindings that pass through the compilation pipeline as normal.
1544   where
1545     class_stuff = case tyConClass_maybe tc of
1546         Nothing -> []
1547         Just cl -> implicitClassThings cl
1548
1549 -- add a thing and recursive call
1550 extras_plus :: TyThing -> [TyThing]
1551 extras_plus thing = thing : implicitTyThings thing
1552
1553 -- For newtypes and closed type families (only) add the implicit coercion tycon
1554 implicitCoTyCon :: TyCon -> [TyThing]
1555 implicitCoTyCon tc
1556   | Just co <- newTyConCo_maybe tc = [ACoAxiom $ toBranchedAxiom co]
1557   | Just co <- isClosedSynFamilyTyCon_maybe tc
1558                                    = [ACoAxiom co]
1559   | otherwise                      = []
1560
1561 -- | Returns @True@ if there should be no interface-file declaration
1562 -- for this thing on its own: either it is built-in, or it is part
1563 -- of some other declaration, or it is generated implicitly by some
1564 -- other declaration.
1565 isImplicitTyThing :: TyThing -> Bool
1566 isImplicitTyThing (AConLike cl) = case cl of
1567     RealDataCon{}  -> True
1568     PatSynCon ps   -> isImplicitId (patSynId ps)
1569 isImplicitTyThing (AnId id)     = isImplicitId id
1570 isImplicitTyThing (ATyCon tc)   = isImplicitTyCon tc
1571 isImplicitTyThing (ACoAxiom ax) = isImplicitCoAxiom ax
1572
1573 -- | tyThingParent_maybe x returns (Just p)
1574 -- when pprTyThingInContext sould print a declaration for p
1575 -- (albeit with some "..." in it) when asked to show x
1576 -- It returns the *immediate* parent.  So a datacon returns its tycon
1577 -- but the tycon could be the associated type of a class, so it in turn
1578 -- might have a parent.
1579 tyThingParent_maybe :: TyThing -> Maybe TyThing
1580 tyThingParent_maybe (AConLike cl) = case cl of
1581     RealDataCon dc  -> Just (ATyCon (dataConTyCon dc))
1582     PatSynCon{}     -> Nothing
1583 tyThingParent_maybe (ATyCon tc)   = case tyConAssoc_maybe tc of
1584                                       Just cls -> Just (ATyCon (classTyCon cls))
1585                                       Nothing  -> Nothing
1586 tyThingParent_maybe (AnId id)     = case idDetails id of
1587                                          RecSelId { sel_tycon = tc } -> Just (ATyCon tc)
1588                                          ClassOpId cls               -> Just (ATyCon (classTyCon cls))
1589                                          _other                      -> Nothing
1590 tyThingParent_maybe _other = Nothing
1591
1592 tyThingsTyVars :: [TyThing] -> TyVarSet
1593 tyThingsTyVars tts =
1594     unionVarSets $ map ttToVarSet tts
1595     where
1596         ttToVarSet (AnId id)     = tyVarsOfType $ idType id
1597         ttToVarSet (AConLike cl) = case cl of
1598             RealDataCon dc  -> tyVarsOfType $ dataConRepType dc
1599             PatSynCon{}     -> emptyVarSet
1600         ttToVarSet (ATyCon tc)
1601           = case tyConClass_maybe tc of
1602               Just cls -> (mkVarSet . fst . classTvsFds) cls
1603               Nothing  -> tyVarsOfType $ tyConKind tc
1604         ttToVarSet _             = emptyVarSet
1605
1606 -- | The Names that a TyThing should bring into scope.  Used to build
1607 -- the GlobalRdrEnv for the InteractiveContext.
1608 tyThingAvailInfo :: TyThing -> AvailInfo
1609 tyThingAvailInfo (ATyCon t)
1610    = case tyConClass_maybe t of
1611         Just c  -> AvailTC n (n : map getName (classMethods c)
1612                   ++ map getName (classATs c))
1613              where n = getName c
1614         Nothing -> AvailTC n (n : map getName dcs ++
1615                                    concatMap dataConFieldLabels dcs)
1616              where n = getName t
1617                    dcs = tyConDataCons t
1618 tyThingAvailInfo t
1619    = Avail (getName t)
1620 \end{code}
1621
1622 %************************************************************************
1623 %*                                                                      *
1624                 TypeEnv
1625 %*                                                                      *
1626 %************************************************************************
1627
1628 \begin{code}
1629 -- | A map from 'Name's to 'TyThing's, constructed by typechecking
1630 -- local declarations or interface files
1631 type TypeEnv = NameEnv TyThing
1632
1633 emptyTypeEnv    :: TypeEnv
1634 typeEnvElts     :: TypeEnv -> [TyThing]
1635 typeEnvTyCons   :: TypeEnv -> [TyCon]
1636 typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]
1637 typeEnvIds      :: TypeEnv -> [Id]
1638 typeEnvPatSyns  :: TypeEnv -> [PatSyn]
1639 typeEnvDataCons :: TypeEnv -> [DataCon]
1640 typeEnvClasses  :: TypeEnv -> [Class]
1641 lookupTypeEnv   :: TypeEnv -> Name -> Maybe TyThing
1642
1643 emptyTypeEnv        = emptyNameEnv
1644 typeEnvElts     env = nameEnvElts env
1645 typeEnvTyCons   env = [tc | ATyCon tc   <- typeEnvElts env]
1646 typeEnvCoAxioms env = [ax | ACoAxiom ax <- typeEnvElts env]
1647 typeEnvIds      env = [id | AnId id     <- typeEnvElts env]
1648 typeEnvPatSyns  env = [ps | AConLike (PatSynCon ps) <- typeEnvElts env]
1649 typeEnvDataCons env = [dc | AConLike (RealDataCon dc) <- typeEnvElts env]
1650 typeEnvClasses  env = [cl | tc <- typeEnvTyCons env,
1651                             Just cl <- [tyConClass_maybe tc]]
1652
1653 mkTypeEnv :: [TyThing] -> TypeEnv
1654 mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
1655
1656 mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv
1657 mkTypeEnvWithImplicits things =
1658   mkTypeEnv things
1659     `plusNameEnv`
1660   mkTypeEnv (concatMap implicitTyThings things)
1661
1662 typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv
1663 typeEnvFromEntities ids tcs famInsts =
1664   mkTypeEnv (   map AnId ids
1665              ++ map ATyCon all_tcs
1666              ++ concatMap implicitTyConThings all_tcs
1667              ++ map (ACoAxiom . toBranchedAxiom . famInstAxiom) famInsts
1668             )
1669  where
1670   all_tcs = tcs ++ famInstsRepTyCons famInsts
1671
1672 lookupTypeEnv = lookupNameEnv
1673
1674 -- Extend the type environment
1675 extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
1676 extendTypeEnv env thing = extendNameEnv env (getName thing) thing
1677
1678 extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
1679 extendTypeEnvList env things = foldl extendTypeEnv env things
1680
1681 extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
1682 extendTypeEnvWithIds env ids
1683   = extendNameEnvList env [(getName id, AnId id) | id <- ids]
1684
1685 extendTypeEnvWithPatSyns :: TypeEnv -> [PatSyn] -> TypeEnv
1686 extendTypeEnvWithPatSyns env patsyns
1687   = extendNameEnvList env $ concatMap pat_syn_things patsyns
1688   where
1689     pat_syn_things :: PatSyn -> [(Name, TyThing)]
1690     pat_syn_things ps = (getName ps, AConLike (PatSynCon ps)):
1691                         case patSynWrapper ps of
1692                             Just wrap_id -> [(getName wrap_id, AnId wrap_id)]
1693                             Nothing -> []
1694
1695 \end{code}
1696
1697 \begin{code}
1698 -- | Find the 'TyThing' for the given 'Name' by using all the resources
1699 -- at our disposal: the compiled modules in the 'HomePackageTable' and the
1700 -- compiled modules in other packages that live in 'PackageTypeEnv'. Note
1701 -- that this does NOT look up the 'TyThing' in the module being compiled: you
1702 -- have to do that yourself, if desired
1703 lookupType :: DynFlags
1704            -> HomePackageTable
1705            -> PackageTypeEnv
1706            -> Name
1707            -> Maybe TyThing
1708
1709 lookupType dflags hpt pte name
1710   | isOneShot (ghcMode dflags)  -- in one-shot, we don't use the HPT
1711   = lookupNameEnv pte name
1712   | otherwise
1713   = case lookupHptByModule hpt mod of
1714        Just hm -> lookupNameEnv (md_types (hm_details hm)) name
1715        Nothing -> lookupNameEnv pte name
1716   where
1717     mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1718
1719 -- | As 'lookupType', but with a marginally easier-to-use interface
1720 -- if you have a 'HscEnv'
1721 lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)
1722 lookupTypeHscEnv hsc_env name = do
1723     eps <- readIORef (hsc_EPS hsc_env)
1724     return $! lookupType dflags hpt (eps_PTE eps) name
1725   where
1726     dflags = hsc_dflags hsc_env
1727     hpt = hsc_HPT hsc_env
1728 \end{code}
1729
1730 \begin{code}
1731 -- | Get the 'TyCon' from a 'TyThing' if it is a type constructor thing. Panics otherwise
1732 tyThingTyCon :: TyThing -> TyCon
1733 tyThingTyCon (ATyCon tc) = tc
1734 tyThingTyCon other       = pprPanic "tyThingTyCon" (pprTyThing other)
1735
1736 -- | Get the 'CoAxiom' from a 'TyThing' if it is a coercion axiom thing. Panics otherwise
1737 tyThingCoAxiom :: TyThing -> CoAxiom Branched
1738 tyThingCoAxiom (ACoAxiom ax) = ax
1739 tyThingCoAxiom other         = pprPanic "tyThingCoAxiom" (pprTyThing other)
1740
1741 -- | Get the 'DataCon' from a 'TyThing' if it is a data constructor thing. Panics otherwise
1742 tyThingDataCon :: TyThing -> DataCon
1743 tyThingDataCon (AConLike (RealDataCon dc)) = dc
1744 tyThingDataCon other                       = pprPanic "tyThingDataCon" (pprTyThing other)
1745
1746 -- | Get the 'Id' from a 'TyThing' if it is a id *or* data constructor thing. Panics otherwise
1747 tyThingId :: TyThing -> Id
1748 tyThingId (AnId id)                   = id
1749 tyThingId (AConLike (RealDataCon dc)) = dataConWrapId dc
1750 tyThingId other                       = pprPanic "tyThingId" (pprTyThing other)
1751 \end{code}
1752
1753 %************************************************************************
1754 %*                                                                      *
1755 \subsection{MonadThings and friends}
1756 %*                                                                      *
1757 %************************************************************************
1758
1759 \begin{code}
1760 -- | Class that abstracts out the common ability of the monads in GHC
1761 -- to lookup a 'TyThing' in the monadic environment by 'Name'. Provides
1762 -- a number of related convenience functions for accessing particular
1763 -- kinds of 'TyThing'
1764 class Monad m => MonadThings m where
1765         lookupThing :: Name -> m TyThing
1766
1767         lookupId :: Name -> m Id
1768         lookupId = liftM tyThingId . lookupThing
1769
1770         lookupDataCon :: Name -> m DataCon
1771         lookupDataCon = liftM tyThingDataCon . lookupThing
1772
1773         lookupTyCon :: Name -> m TyCon
1774         lookupTyCon = liftM tyThingTyCon . lookupThing
1775 \end{code}
1776
1777 %************************************************************************
1778 %*                                                                      *
1779 \subsection{Auxiliary types}
1780 %*                                                                      *
1781 %************************************************************************
1782
1783 These types are defined here because they are mentioned in ModDetails,
1784 but they are mostly elaborated elsewhere
1785
1786 \begin{code}
1787 ------------------ Warnings -------------------------
1788 -- | Warning information for a module
1789 data Warnings
1790   = NoWarnings                          -- ^ Nothing deprecated
1791   | WarnAll WarningTxt                  -- ^ Whole module deprecated
1792   | WarnSome [(OccName,WarningTxt)]     -- ^ Some specific things deprecated
1793
1794      -- Only an OccName is needed because
1795      --    (1) a deprecation always applies to a binding
1796      --        defined in the module in which the deprecation appears.
1797      --    (2) deprecations are only reported outside the defining module.
1798      --        this is important because, otherwise, if we saw something like
1799      --
1800      --        {-# DEPRECATED f "" #-}
1801      --        f = ...
1802      --        h = f
1803      --        g = let f = undefined in f
1804      --
1805      --        we'd need more information than an OccName to know to say something
1806      --        about the use of f in h but not the use of the locally bound f in g
1807      --
1808      --        however, because we only report about deprecations from the outside,
1809      --        and a module can only export one value called f,
1810      --        an OccName suffices.
1811      --
1812      --        this is in contrast with fixity declarations, where we need to map
1813      --        a Name to its fixity declaration.
1814   deriving( Eq )
1815
1816 instance Binary Warnings where
1817     put_ bh NoWarnings     = putByte bh 0
1818     put_ bh (WarnAll t) = do
1819             putByte bh 1
1820             put_ bh t
1821     put_ bh (WarnSome ts) = do
1822             putByte bh 2
1823             put_ bh ts
1824
1825     get bh = do
1826             h <- getByte bh
1827             case h of
1828               0 -> return NoWarnings
1829               1 -> do aa <- get bh
1830                       return (WarnAll aa)
1831               _ -> do aa <- get bh
1832                       return (WarnSome aa)
1833
1834 -- | Constructs the cache for the 'mi_warn_fn' field of a 'ModIface'
1835 mkIfaceWarnCache :: Warnings -> Name -> Maybe WarningTxt
1836 mkIfaceWarnCache NoWarnings  = \_ -> Nothing
1837 mkIfaceWarnCache (WarnAll t) = \_ -> Just t
1838 mkIfaceWarnCache (WarnSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
1839
1840 emptyIfaceWarnCache :: Name -> Maybe WarningTxt
1841 emptyIfaceWarnCache _ = Nothing
1842
1843 plusWarns :: Warnings -> Warnings -> Warnings
1844 plusWarns d NoWarnings = d
1845 plusWarns NoWarnings d = d
1846 plusWarns _ (WarnAll t) = WarnAll t
1847 plusWarns (WarnAll t) _ = WarnAll t
1848 plusWarns (WarnSome v1) (WarnSome v2) = WarnSome (v1 ++ v2)
1849 \end{code}
1850
1851 \begin{code}
1852 -- | Creates cached lookup for the 'mi_fix_fn' field of 'ModIface'
1853 mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
1854 mkIfaceFixCache pairs
1855   = \n -> lookupOccEnv env n `orElse` defaultFixity
1856   where
1857    env = mkOccEnv pairs
1858
1859 emptyIfaceFixCache :: OccName -> Fixity
1860 emptyIfaceFixCache _ = defaultFixity
1861
1862 -- | Fixity environment mapping names to their fixities
1863 type FixityEnv = NameEnv FixItem
1864
1865 -- | Fixity information for an 'Name'. We keep the OccName in the range
1866 -- so that we can generate an interface from it
1867 data FixItem = FixItem OccName Fixity
1868
1869 instance Outputable FixItem where
1870   ppr (FixItem occ fix) = ppr fix <+> ppr occ
1871
1872 emptyFixityEnv :: FixityEnv
1873 emptyFixityEnv = emptyNameEnv
1874
1875 lookupFixity :: FixityEnv -> Name -> Fixity
1876 lookupFixity env n = case lookupNameEnv env n of
1877                         Just (FixItem _ fix) -> fix
1878                         Nothing         -> defaultFixity
1879 \end{code}
1880
1881 %************************************************************************
1882 %*                                                                      *
1883 \subsection{WhatsImported}
1884 %*                                                                      *
1885 %************************************************************************
1886
1887 \begin{code}
1888 -- | Records whether a module has orphans. An \"orphan\" is one of:
1889 --
1890 -- * An instance declaration in a module other than the definition
1891 --   module for one of the type constructors or classes in the instance head
1892 --
1893 -- * A transformation rule in a module other than the one defining
1894 --   the function in the head of the rule
1895 --
1896 -- * A vectorisation pragma
1897 type WhetherHasOrphans   = Bool
1898
1899 -- | Does this module define family instances?
1900 type WhetherHasFamInst = Bool
1901
1902 -- | Did this module originate from a *-boot file?
1903 type IsBootInterface = Bool
1904
1905 -- | Dependency information about ALL modules and packages below this one
1906 -- in the import hierarchy.
1907 --
1908 -- Invariant: the dependencies of a module @M@ never includes @M@.
1909 --
1910 -- Invariant: none of the lists contain duplicates.
1911 data Dependencies
1912   = Deps { dep_mods   :: [(ModuleName, IsBootInterface)]
1913                         -- ^ All home-package modules transitively below this one
1914                         -- I.e. modules that this one imports, or that are in the
1915                         --      dep_mods of those directly-imported modules
1916
1917          , dep_pkgs   :: [(PackageId, Bool)]
1918                         -- ^ All packages transitively below this module
1919                         -- I.e. packages to which this module's direct imports belong,
1920                         --      or that are in the dep_pkgs of those modules
1921                         -- The bool indicates if the package is required to be
1922                         -- trusted when the module is imported as a safe import
1923                         -- (Safe Haskell). See Note [RnNames . Tracking Trust Transitively]
1924
1925          , dep_orphs  :: [Module]
1926                         -- ^ Orphan modules (whether home or external pkg),
1927                         -- *not* including family instance orphans as they
1928                         -- are anyway included in 'dep_finsts'
1929
1930          , dep_finsts :: [Module]
1931                         -- ^ Modules that contain family instances (whether the
1932                         -- instances are from the home or an external package)
1933          }
1934   deriving( Eq )
1935         -- Equality used only for old/new comparison in MkIface.addFingerprints
1936         -- See 'TcRnTypes.ImportAvails' for details on dependencies.
1937
1938 instance Binary Dependencies where
1939     put_ bh deps = do put_ bh (dep_mods deps)
1940                       put_ bh (dep_pkgs deps)
1941                       put_ bh (dep_orphs deps)
1942                       put_ bh (dep_finsts deps)
1943
1944     get bh = do ms <- get bh
1945                 ps <- get bh
1946                 os <- get bh
1947                 fis <- get bh
1948                 return (Deps { dep_mods = ms, dep_pkgs = ps, dep_orphs = os,
1949                                dep_finsts = fis })
1950
1951 noDependencies :: Dependencies
1952 noDependencies = Deps [] [] [] []
1953
1954 -- | Records modules for which changes may force recompilation of this module
1955 -- See wiki: http://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/RecompilationAvoidance
1956 --
1957 -- This differs from Dependencies.  A module X may be in the dep_mods of this
1958 -- module (via an import chain) but if we don't use anything from X it won't
1959 -- appear in our Usage
1960 data Usage
1961   -- | Module from another package
1962   = UsagePackageModule {
1963         usg_mod      :: Module,
1964            -- ^ External package module depended on
1965         usg_mod_hash :: Fingerprint,
1966             -- ^ Cached module fingerprint
1967         usg_safe :: IsSafeImport
1968             -- ^ Was this module imported as a safe import
1969     }
1970   -- | Module from the current package
1971   | UsageHomeModule {
1972         usg_mod_name :: ModuleName,
1973             -- ^ Name of the module
1974         usg_mod_hash :: Fingerprint,
1975             -- ^ Cached module fingerprint
1976         usg_entities :: [(OccName,Fingerprint)],
1977             -- ^ Entities we depend on, sorted by occurrence name and fingerprinted.
1978             -- NB: usages are for parent names only, e.g. type constructors
1979             -- but not the associated data constructors.
1980         usg_exports  :: Maybe Fingerprint,
1981             -- ^ Fingerprint for the export list of this module,
1982             -- if we directly imported it (and hence we depend on its export list)
1983         usg_safe :: IsSafeImport
1984             -- ^ Was this module imported as a safe import
1985     }                                           -- ^ Module from the current package
1986   -- | A file upon which the module depends, e.g. a CPP #include, or using TH's
1987   -- 'addDependentFile'
1988   | UsageFile {
1989         usg_file_path  :: FilePath,
1990         -- ^ External file dependency. From a CPP #include or TH
1991         -- addDependentFile. Should be absolute.
1992         usg_file_hash  :: Fingerprint
1993         -- ^ 'Fingerprint' of the file contents.
1994
1995         -- Note: We don't consider things like modification timestamps
1996         -- here, because there's no reason to recompile if the actual
1997         -- contents don't change.  This previously lead to odd
1998         -- recompilation behaviors; see #8114
1999   }
2000     deriving( Eq )
2001         -- The export list field is (Just v) if we depend on the export list:
2002         --      i.e. we imported the module directly, whether or not we
2003         --           enumerated the things we imported, or just imported
2004         --           everything
2005         -- We need to recompile if M's exports change, because
2006         -- if the import was    import M,       we might now have a name clash
2007         --                                      in the importing module.
2008         -- if the import was    import M(x)     M might no longer export x
2009         -- The only way we don't depend on the export list is if we have
2010         --                      import M()
2011         -- And of course, for modules that aren't imported directly we don't
2012         -- depend on their export lists
2013
2014 instance Binary Usage where
2015     put_ bh usg@UsagePackageModule{} = do
2016         putByte bh 0
2017         put_ bh (usg_mod usg)
2018         put_ bh (usg_mod_hash usg)
2019         put_ bh (usg_safe     usg)
2020
2021     put_ bh usg@UsageHomeModule{} = do
2022         putByte bh 1
2023         put_ bh (usg_mod_name usg)
2024         put_ bh (usg_mod_hash usg)
2025         put_ bh (usg_exports  usg)
2026         put_ bh (usg_entities usg)
2027         put_ bh (usg_safe     usg)
2028
2029     put_ bh usg@UsageFile{} = do
2030         putByte bh 2
2031         put_ bh (usg_file_path usg)
2032         put_ bh (usg_file_hash usg)
2033
2034     get bh = do
2035         h <- getByte bh
2036         case h of
2037           0 -> do
2038             nm    <- get bh
2039             mod   <- get bh
2040             safe  <- get bh
2041             return UsagePackageModule { usg_mod = nm, usg_mod_hash = mod, usg_safe = safe }
2042           1 -> do
2043             nm    <- get bh
2044             mod   <- get bh
2045             exps  <- get bh
2046             ents  <- get bh
2047             safe  <- get bh
2048             return UsageHomeModule { usg_mod_name = nm, usg_mod_hash = mod,
2049                      usg_exports = exps, usg_entities = ents, usg_safe = safe }
2050           2 -> do
2051             fp   <- get bh
2052             hash <- get bh
2053             return UsageFile { usg_file_path = fp, usg_file_hash = hash }
2054           i -> error ("Binary.get(Usage): " ++ show i)
2055
2056 \end{code}
2057
2058
2059 %************************************************************************
2060 %*                                                                      *
2061                 The External Package State
2062 %*                                                                      *
2063 %************************************************************************
2064
2065 \begin{code}
2066 type PackageTypeEnv    = TypeEnv
2067 type PackageRuleBase   = RuleBase
2068 type PackageInstEnv    = InstEnv
2069 type PackageFamInstEnv = FamInstEnv
2070 type PackageVectInfo   = VectInfo
2071 type PackageAnnEnv     = AnnEnv
2072
2073 -- | Information about other packages that we have slurped in by reading
2074 -- their interface files
2075 data ExternalPackageState
2076   = EPS {
2077         eps_is_boot :: !(ModuleNameEnv (ModuleName, IsBootInterface)),
2078                 -- ^ In OneShot mode (only), home-package modules
2079                 -- accumulate in the external package state, and are
2080                 -- sucked in lazily.  For these home-pkg modules
2081                 -- (only) we need to record which are boot modules.
2082                 -- We set this field after loading all the
2083                 -- explicitly-imported interfaces, but before doing
2084                 -- anything else
2085                 --
2086                 -- The 'ModuleName' part is not necessary, but it's useful for
2087                 -- debug prints, and it's convenient because this field comes
2088                 -- direct from 'TcRnTypes.imp_dep_mods'
2089
2090         eps_PIT :: !PackageIfaceTable,
2091                 -- ^ The 'ModIface's for modules in external packages
2092                 -- whose interfaces we have opened.
2093                 -- The declarations in these interface files are held in the
2094                 -- 'eps_decls', 'eps_inst_env', 'eps_fam_inst_env' and 'eps_rules'
2095                 -- fields of this record, not in the 'mi_decls' fields of the
2096                 -- interface we have sucked in.
2097                 --
2098                 -- What /is/ in the PIT is:
2099                 --
2100                 -- * The Module
2101                 --
2102                 -- * Fingerprint info
2103                 --
2104                 -- * Its exports
2105                 --
2106                 -- * Fixities
2107                 --
2108                 -- * Deprecations and warnings
2109
2110         eps_PTE :: !PackageTypeEnv,
2111                 -- ^ Result of typechecking all the external package
2112                 -- interface files we have sucked in. The domain of
2113                 -- the mapping is external-package modules
2114
2115         eps_inst_env     :: !PackageInstEnv,   -- ^ The total 'InstEnv' accumulated
2116                                                -- from all the external-package modules
2117         eps_fam_inst_env :: !PackageFamInstEnv,-- ^ The total 'FamInstEnv' accumulated
2118                                                -- from all the external-package modules
2119         eps_rule_base    :: !PackageRuleBase,  -- ^ The total 'RuleEnv' accumulated
2120                                                -- from all the external-package modules
2121         eps_vect_info    :: !PackageVectInfo,  -- ^ The total 'VectInfo' accumulated
2122                                                -- from all the external-package modules
2123         eps_ann_env      :: !PackageAnnEnv,    -- ^ The total 'AnnEnv' accumulated
2124                                                -- from all the external-package modules
2125
2126         eps_mod_fam_inst_env :: !(ModuleEnv FamInstEnv), -- ^ The family instances accumulated from external
2127                                                          -- packages, keyed off the module that declared them
2128
2129         eps_stats :: !EpsStats                 -- ^ Stastics about what was loaded from external packages
2130   }
2131
2132 -- | Accumulated statistics about what we are putting into the 'ExternalPackageState'.
2133 -- \"In\" means stuff that is just /read/ from interface files,
2134 -- \"Out\" means actually sucked in and type-checked
2135 data EpsStats = EpsStats { n_ifaces_in
2136                          , n_decls_in, n_decls_out
2137                          , n_rules_in, n_rules_out
2138                          , n_insts_in, n_insts_out :: !Int }
2139
2140 addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
2141 -- ^ Add stats for one newly-read interface
2142 addEpsInStats stats n_decls n_insts n_rules
2143   = stats { n_ifaces_in = n_ifaces_in stats + 1
2144           , n_decls_in  = n_decls_in stats + n_decls
2145           , n_insts_in  = n_insts_in stats + n_insts
2146           , n_rules_in  = n_rules_in stats + n_rules }
2147 \end{code}
2148
2149 Names in a NameCache are always stored as a Global, and have the SrcLoc
2150 of their binding locations.
2151
2152 Actually that's not quite right.  When we first encounter the original
2153 name, we might not be at its binding site (e.g. we are reading an
2154 interface file); so we give it 'noSrcLoc' then.  Later, when we find
2155 its binding site, we fix it up.
2156
2157 \begin{code}
2158 -- | The NameCache makes sure that there is just one Unique assigned for
2159 -- each original name; i.e. (module-name, occ-name) pair and provides
2160 -- something of a lookup mechanism for those names.
2161 data NameCache
2162  = NameCache {  nsUniqs :: !UniqSupply,
2163                 -- ^ Supply of uniques
2164                 nsNames :: !OrigNameCache
2165                 -- ^ Ensures that one original name gets one unique
2166    }
2167
2168 -- | Per-module cache of original 'OccName's given 'Name's
2169 type OrigNameCache   = ModuleEnv (OccEnv Name)
2170 \end{code}
2171
2172
2173 \begin{code}
2174 mkSOName :: Platform -> FilePath -> FilePath
2175 mkSOName platform root
2176     = case platformOS platform of
2177       OSDarwin  -> ("lib" ++ root) <.> "dylib"
2178       OSMinGW32 ->           root  <.> "dll"
2179       _         -> ("lib" ++ root) <.> "so"
2180
2181 mkHsSOName :: Platform -> FilePath -> FilePath
2182 mkHsSOName platform root = ("lib" ++ root) <.> soExt platform
2183
2184 soExt :: Platform -> FilePath
2185 soExt platform
2186     = case platformOS platform of
2187       OSDarwin  -> "dylib"
2188       OSMinGW32 -> "dll"
2189       _         -> "so"
2190 \end{code}
2191
2192
2193 %************************************************************************
2194 %*                                                                      *
2195                 The module graph and ModSummary type
2196         A ModSummary is a node in the compilation manager's
2197         dependency graph, and it's also passed to hscMain
2198 %*                                                                      *
2199 %************************************************************************
2200
2201 \begin{code}
2202 -- | A ModuleGraph contains all the nodes from the home package (only).
2203 -- There will be a node for each source module, plus a node for each hi-boot
2204 -- module.
2205 --
2206 -- The graph is not necessarily stored in topologically-sorted order.  Use
2207 -- 'GHC.topSortModuleGraph' and 'Digraph.flattenSCC' to achieve this.
2208 type ModuleGraph = [ModSummary]
2209
2210 emptyMG :: ModuleGraph
2211 emptyMG = []
2212
2213 -- | A single node in a 'ModuleGraph'. The nodes of the module graph
2214 -- are one of:
2215 --
2216 -- * A regular Haskell source module
2217 -- * A hi-boot source module
2218 -- * An external-core source module
2219 --
2220 data ModSummary
2221    = ModSummary {
2222         ms_mod          :: Module,
2223           -- ^ Identity of the module
2224         ms_hsc_src      :: HscSource,
2225           -- ^ The module source either plain Haskell, hs-boot or external core
2226         ms_location     :: ModLocation,
2227           -- ^ Location of the various files belonging to the module
2228         ms_hs_date      :: UTCTime,
2229           -- ^ Timestamp of source file
2230         ms_obj_date     :: Maybe UTCTime,
2231           -- ^ Timestamp of object, if we have one
2232         ms_srcimps      :: [Located (ImportDecl RdrName)],
2233           -- ^ Source imports of the module
2234         ms_textual_imps :: [Located (ImportDecl RdrName)],
2235           -- ^ Non-source imports of the module from the module *text*
2236         ms_hspp_file    :: FilePath,
2237           -- ^ Filename of preprocessed source file
2238         ms_hspp_opts    :: DynFlags,
2239           -- ^ Cached flags from @OPTIONS@, @INCLUDE@ and @LANGUAGE@
2240           -- pragmas in the modules source code
2241         ms_hspp_buf     :: Maybe StringBuffer
2242           -- ^ The actual preprocessed source, if we have it
2243      }
2244
2245 ms_mod_name :: ModSummary -> ModuleName
2246 ms_mod_name = moduleName . ms_mod
2247
2248 ms_imps :: ModSummary -> [Located (ImportDecl RdrName)]
2249 ms_imps ms =
2250   ms_textual_imps ms ++
2251   map mk_additional_import (dynFlagDependencies (ms_hspp_opts ms))
2252   where
2253     -- This is a not-entirely-satisfactory means of creating an import
2254     -- that corresponds to an import that did not occur in the program
2255     -- text, such as those induced by the use of plugins (the -plgFoo
2256     -- flag)
2257     mk_additional_import mod_nm = noLoc $ ImportDecl {
2258       ideclName      = noLoc mod_nm,
2259       ideclPkgQual   = Nothing,
2260       ideclSource    = False,
2261       ideclImplicit  = True, -- Maybe implicit because not "in the program text"
2262       ideclQualified = False,
2263       ideclAs        = Nothing,
2264       ideclHiding    = Nothing,
2265       ideclSafe      = False
2266     }
2267
2268 -- The ModLocation contains both the original source filename and the
2269 -- filename of the cleaned-up source file after all preprocessing has been
2270 -- done.  The point is that the summariser will have to cpp/unlit/whatever
2271 -- all files anyway, and there's no point in doing this twice -- just
2272 -- park the result in a temp file, put the name of it in the location,
2273 -- and let @compile@ read from that file on the way back up.
2274
2275 -- The ModLocation is stable over successive up-sweeps in GHCi, wheres
2276 -- the ms_hs_date and imports can, of course, change
2277
2278 msHsFilePath, msHiFilePath, msObjFilePath :: ModSummary -> FilePath
2279 msHsFilePath  ms = expectJust "msHsFilePath" (ml_hs_file  (ms_location ms))
2280 msHiFilePath  ms = ml_hi_file  (ms_location ms)
2281 msObjFilePath ms = ml_obj_file (ms_location ms)
2282
2283 -- | Did this 'ModSummary' originate from a hs-boot file?
2284 isBootSummary :: ModSummary -> Bool
2285 isBootSummary ms = isHsBoot (ms_hsc_src ms)
2286
2287 instance Outputable ModSummary where
2288    ppr ms
2289       = sep [text "ModSummary {",
2290              nest 3 (sep [text "ms_hs_date = " <> text (show (ms_hs_date ms)),
2291                           text "ms_mod =" <+> ppr (ms_mod ms)
2292                                 <> text (hscSourceString (ms_hsc_src ms)) <> comma,
2293                           text "ms_textual_imps =" <+> ppr (ms_textual_imps ms),
2294                           text "ms_srcimps =" <+> ppr (ms_srcimps ms)]),
2295              char '}'
2296             ]
2297
2298 showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String
2299 showModMsg dflags target recomp mod_summary
2300   = showSDoc dflags $
2301         hsep [text (mod_str ++ replicate (max 0 (16 - length mod_str)) ' '),
2302               char '(', text (normalise $ msHsFilePath mod_summary) <> comma,
2303               case target of
2304                   HscInterpreted | recomp
2305                              -> text "interpreted"
2306                   HscNothing -> text "nothing"
2307                   _          -> text (normalise $ msObjFilePath mod_summary),
2308               char ')']
2309  where
2310     mod     = moduleName (ms_mod mod_summary)
2311     mod_str = showPpr dflags mod ++ hscSourceString (ms_hsc_src mod_summary)
2312 \end{code}
2313
2314 %************************************************************************
2315 %*                                                                      *
2316 \subsection{Recmpilation}
2317 %*                                                                      *
2318 %************************************************************************
2319
2320 \begin{code}
2321 -- | Indicates whether a given module's source has been modified since it
2322 -- was last compiled.
2323 data SourceModified
2324   = SourceModified
2325        -- ^ the source has been modified
2326   | SourceUnmodified
2327        -- ^ the source has not been modified.  Compilation may or may
2328        -- not be necessary, depending on whether any dependencies have
2329        -- changed since we last compiled.
2330   | SourceUnmodifiedAndStable
2331        -- ^ the source has not been modified, and furthermore all of
2332        -- its (transitive) dependencies are up to date; it definitely
2333        -- does not need to be recompiled.  This is important for two
2334        -- reasons: (a) we can omit the version check in checkOldIface,
2335        -- and (b) if the module used TH splices we don't need to force
2336        -- recompilation.
2337 \end{code}
2338
2339 %************************************************************************
2340 %*                                                                      *
2341 \subsection{Hpc Support}
2342 %*                                                                      *
2343 %************************************************************************
2344
2345 \begin{code}
2346 -- | Information about a modules use of Haskell Program Coverage
2347 data HpcInfo
2348   = HpcInfo
2349      { hpcInfoTickCount :: Int
2350      , hpcInfoHash      :: Int
2351      }
2352   | NoHpcInfo
2353      { hpcUsed          :: AnyHpcUsage  -- ^ Is hpc used anywhere on the module \*tree\*?
2354      }
2355
2356 -- | This is used to signal if one of my imports used HPC instrumentation
2357 -- even if there is no module-local HPC usage
2358 type AnyHpcUsage = Bool
2359
2360 emptyHpcInfo :: AnyHpcUsage -> HpcInfo
2361 emptyHpcInfo = NoHpcInfo
2362
2363 -- | Find out if HPC is used by this module or any of the modules
2364 -- it depends upon
2365 isHpcUsed :: HpcInfo -> AnyHpcUsage
2366 isHpcUsed (HpcInfo {})                   = True
2367 isHpcUsed (NoHpcInfo { hpcUsed = used }) = used
2368 \end{code}
2369
2370 %************************************************************************
2371 %*                                                                      *
2372 \subsection{Vectorisation Support}
2373 %*                                                                      *
2374 %************************************************************************
2375
2376 The following information is generated and consumed by the vectorisation
2377 subsystem.  It communicates the vectorisation status of declarations from one
2378 module to another.
2379
2380 Why do we need both f and f_v in the ModGuts/ModDetails/EPS version VectInfo
2381 below?  We need to know `f' when converting to IfaceVectInfo.  However, during
2382 vectorisation, we need to know `f_v', whose `Var' we cannot lookup based
2383 on just the OccName easily in a Core pass.
2384
2385 \begin{code}
2386 -- |Vectorisation information for 'ModGuts', 'ModDetails' and 'ExternalPackageState'; see also
2387 -- documentation at 'Vectorise.Env.GlobalEnv'.
2388 --
2389 -- NB: The following tables may also include 'Var's, 'TyCon's and 'DataCon's from imported modules,
2390 --     which have been subsequently vectorised in the current module.
2391 --
2392 data VectInfo
2393   = VectInfo
2394     { vectInfoVar            :: VarEnv  (Var    , Var  )    -- ^ @(f, f_v)@ keyed on @f@
2395     , vectInfoTyCon          :: NameEnv (TyCon  , TyCon)    -- ^ @(T, T_v)@ keyed on @T@
2396     , vectInfoDataCon        :: NameEnv (DataCon, DataCon)  -- ^ @(C, C_v)@ keyed on @C@
2397     , vectInfoParallelVars   :: VarSet                      -- ^ set of parallel variables
2398     , vectInfoParallelTyCons :: NameSet                     -- ^ set of parallel type constructors
2399     }
2400
2401 -- |Vectorisation information for 'ModIface'; i.e, the vectorisation information propagated
2402 -- across module boundaries.
2403 --
2404 -- NB: The field 'ifaceVectInfoVar' explicitly contains the workers of data constructors as well as
2405 --     class selectors — i.e., their mappings are /not/ implicitly generated from the data types.
2406 --     Moreover, whether the worker of a data constructor is in 'ifaceVectInfoVar' determines
2407 --     whether that data constructor was vectorised (or is part of an abstractly vectorised type
2408 --     constructor).
2409 --
2410 data IfaceVectInfo
2411   = IfaceVectInfo
2412     { ifaceVectInfoVar            :: [Name]  -- ^ All variables in here have a vectorised variant
2413     , ifaceVectInfoTyCon          :: [Name]  -- ^ All 'TyCon's in here have a vectorised variant;
2414                                              -- the name of the vectorised variant and those of its
2415                                              -- data constructors are determined by
2416                                              -- 'OccName.mkVectTyConOcc' and
2417                                              -- 'OccName.mkVectDataConOcc'; the names of the
2418                                              -- isomorphisms are determined by 'OccName.mkVectIsoOcc'
2419     , ifaceVectInfoTyConReuse     :: [Name]  -- ^ The vectorised form of all the 'TyCon's in here
2420                                              -- coincides with the unconverted form; the name of the
2421                                              -- isomorphisms is determined by 'OccName.mkVectIsoOcc'
2422     , ifaceVectInfoParallelVars   :: [Name]  -- iface version of 'vectInfoParallelVar'
2423     , ifaceVectInfoParallelTyCons :: [Name]  -- iface version of 'vectInfoParallelTyCon'
2424     }
2425
2426 noVectInfo :: VectInfo
2427 noVectInfo
2428   = VectInfo emptyVarEnv emptyNameEnv emptyNameEnv emptyVarSet emptyNameSet
2429
2430 plusVectInfo :: VectInfo -> VectInfo -> VectInfo
2431 plusVectInfo vi1 vi2 =
2432   VectInfo (vectInfoVar            vi1 `plusVarEnv`    vectInfoVar            vi2)
2433            (vectInfoTyCon          vi1 `plusNameEnv`   vectInfoTyCon          vi2)
2434            (vectInfoDataCon        vi1 `plusNameEnv`   vectInfoDataCon        vi2)
2435            (vectInfoParallelVars   vi1 `unionVarSet`   vectInfoParallelVars   vi2)
2436            (vectInfoParallelTyCons vi1 `unionNameSets` vectInfoParallelTyCons vi2)
2437
2438 concatVectInfo :: [VectInfo] -> VectInfo
2439 concatVectInfo = foldr plusVectInfo noVectInfo
2440
2441 noIfaceVectInfo :: IfaceVectInfo
2442 noIfaceVectInfo = IfaceVectInfo [] [] [] [] []
2443
2444 isNoIfaceVectInfo :: IfaceVectInfo -> Bool
2445 isNoIfaceVectInfo (IfaceVectInfo l1 l2 l3 l4 l5)
2446   = null l1 && null l2 && null l3 && null l4 && null l5
2447
2448 instance Outputable VectInfo where
2449   ppr info = vcat
2450              [ ptext (sLit "variables       :") <+> ppr (vectInfoVar            info)
2451              , ptext (sLit "tycons          :") <+> ppr (vectInfoTyCon          info)
2452              , ptext (sLit "datacons        :") <+> ppr (vectInfoDataCon        info)
2453              , ptext (sLit "parallel vars   :") <+> ppr (vectInfoParallelVars   info)
2454              , ptext (sLit "parallel tycons :") <+> ppr (vectInfoParallelTyCons info)
2455              ]
2456
2457 instance Binary IfaceVectInfo where
2458     put_ bh (IfaceVectInfo a1 a2 a3 a4 a5) = do
2459         put_ bh a1
2460         put_ bh a2
2461         put_ bh a3
2462         put_ bh a4
2463         put_ bh a5
2464     get bh = do
2465         a1 <- get bh
2466         a2 <- get bh
2467         a3 <- get bh
2468         a4 <- get bh
2469         a5 <- get bh
2470         return (IfaceVectInfo a1 a2 a3 a4 a5)
2471 \end{code}
2472
2473 %************************************************************************
2474 %*                                                                      *
2475 \subsection{Safe Haskell Support}
2476 %*                                                                      *
2477 %************************************************************************
2478
2479 This stuff here is related to supporting the Safe Haskell extension,
2480 primarily about storing under what trust type a module has been compiled.
2481
2482 \begin{code}
2483 -- | Is an import a safe import?
2484 type IsSafeImport = Bool
2485
2486 -- | Safe Haskell information for 'ModIface'
2487 -- Simply a wrapper around SafeHaskellMode to sepperate iface and flags
2488 newtype IfaceTrustInfo = TrustInfo SafeHaskellMode
2489
2490 getSafeMode :: IfaceTrustInfo -> SafeHaskellMode
2491 getSafeMode (TrustInfo x) = x
2492
2493 setSafeMode :: SafeHaskellMode -> IfaceTrustInfo
2494 setSafeMode = TrustInfo
2495
2496 noIfaceTrustInfo :: IfaceTrustInfo
2497 noIfaceTrustInfo = setSafeMode Sf_None
2498
2499 trustInfoToNum :: IfaceTrustInfo -> Word8
2500 trustInfoToNum it
2501   = case getSafeMode it of
2502             Sf_None         -> 0
2503             Sf_Unsafe       -> 1
2504             Sf_Trustworthy  -> 2
2505             Sf_Safe         -> 3
2506             Sf_SafeInferred -> 4
2507
2508 numToTrustInfo :: Word8 -> IfaceTrustInfo
2509 numToTrustInfo 0 = setSafeMode Sf_None
2510 numToTrustInfo 1 = setSafeMode Sf_Unsafe
2511 numToTrustInfo 2 = setSafeMode Sf_Trustworthy
2512 numToTrustInfo 3 = setSafeMode Sf_Safe
2513 numToTrustInfo 4 = setSafeMode Sf_SafeInferred
2514 numToTrustInfo n = error $ "numToTrustInfo: bad input number! (" ++ show n ++ ")"
2515
2516 instance Outputable IfaceTrustInfo where
2517     ppr (TrustInfo Sf_None)          = ptext $ sLit "none"
2518     ppr (TrustInfo Sf_Unsafe)        = ptext $ sLit "unsafe"
2519     ppr (TrustInfo Sf_Trustworthy)   = ptext $ sLit "trustworthy"
2520     ppr (TrustInfo Sf_Safe)          = ptext $ sLit "safe"
2521     ppr (TrustInfo Sf_SafeInferred)  = ptext $ sLit "safe-inferred"
2522
2523 instance Binary IfaceTrustInfo where
2524     put_ bh iftrust = putByte bh $ trustInfoToNum iftrust
2525     get bh = getByte bh >>= (return . numToTrustInfo)
2526 \end{code}
2527
2528 %************************************************************************
2529 %*                                                                      *
2530 \subsection{Parser result}
2531 %*                                                                      *
2532 %************************************************************************
2533
2534 \begin{code}
2535 data HsParsedModule = HsParsedModule {
2536     hpm_module    :: Located (HsModule RdrName),
2537     hpm_src_files :: [FilePath]
2538        -- ^ extra source files (e.g. from #includes).  The lexer collects
2539        -- these from '# <file> <line>' pragmas, which the C preprocessor
2540        -- leaves behind.  These files and their timestamps are stored in
2541        -- the .hi file, so that we can force recompilation if any of
2542        -- them change (#3589)
2543   }
2544 \end{code}
2545
2546 %************************************************************************
2547 %*                                                                      *
2548 \subsection{Linkable stuff}
2549 %*                                                                      *
2550 %************************************************************************
2551
2552 This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
2553 stuff is the *dynamic* linker, and isn't present in a stage-1 compiler
2554
2555 \begin{code}
2556 -- | Information we can use to dynamically link modules into the compiler
2557 data Linkable = LM {
2558   linkableTime     :: UTCTime,          -- ^ Time at which this linkable was built
2559                                         -- (i.e. when the bytecodes were produced,
2560                                         --       or the mod date on the files)
2561   linkableModule   :: Module,           -- ^ The linkable module itself
2562   linkableUnlinked :: [Unlinked]
2563     -- ^ Those files and chunks of code we have yet to link.
2564     --
2565     -- INVARIANT: A valid linkable always has at least one 'Unlinked' item.
2566     -- If this list is empty, the Linkable represents a fake linkable, which
2567     -- is generated in HscNothing mode to avoid recompiling modules.
2568     --
2569     -- ToDo: Do items get removed from this list when they get linked?
2570  }
2571
2572 isObjectLinkable :: Linkable -> Bool
2573 isObjectLinkable l = not (null unlinked) && all isObject unlinked
2574   where unlinked = linkableUnlinked l
2575         -- A linkable with no Unlinked's is treated as a BCO.  We can
2576         -- generate a linkable with no Unlinked's as a result of
2577         -- compiling a module in HscNothing mode, and this choice
2578         -- happens to work well with checkStability in module GHC.
2579
2580 linkableObjs :: Linkable -> [FilePath]
2581 linkableObjs l = [ f | DotO f <- linkableUnlinked l ]
2582
2583 instance Outputable Linkable where
2584    ppr (LM when_made mod unlinkeds)
2585       = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
2586         $$ nest 3 (ppr unlinkeds)
2587
2588 -------------------------------------------
2589
2590 -- | Objects which have yet to be linked by the compiler
2591 data Unlinked
2592    = DotO FilePath      -- ^ An object file (.o)
2593    | DotA FilePath      -- ^ Static archive file (.a)
2594    | DotDLL FilePath    -- ^ Dynamically linked library file (.so, .dll, .dylib)
2595    | BCOs CompiledByteCode ModBreaks    -- ^ A byte-code object, lives only in memory
2596
2597 #ifndef GHCI
2598 data CompiledByteCode = CompiledByteCodeUndefined
2599 _unused :: CompiledByteCode
2600 _unused = CompiledByteCodeUndefined
2601 #endif
2602
2603 instance Outputable Unlinked where
2604    ppr (DotO path)   = text "DotO" <+> text path
2605    ppr (DotA path)   = text "DotA" <+> text path
2606    ppr (DotDLL path) = text "DotDLL" <+> text path
2607 #ifdef GHCI
2608    ppr (BCOs bcos _) = text "BCOs" <+> ppr bcos
2609 #else
2610    ppr (BCOs _ _)    = text "No byte code"
2611 #endif
2612
2613 -- | Is this an actual file on disk we can link in somehow?
2614 isObject :: Unlinked -> Bool
2615 isObject (DotO _)   = True
2616 isObject (DotA _)   = True
2617 isObject (DotDLL _) = True
2618 isObject _          = False
2619
2620 -- | Is this a bytecode linkable with no file on disk?
2621 isInterpretable :: Unlinked -> Bool
2622 isInterpretable = not . isObject
2623
2624 -- | Retrieve the filename of the linkable if possible. Panic if it is a byte-code object
2625 nameOfObject :: Unlinked -> FilePath
2626 nameOfObject (DotO fn)   = fn
2627 nameOfObject (DotA fn)   = fn
2628 nameOfObject (DotDLL fn) = fn
2629 nameOfObject other       = pprPanic "nameOfObject" (ppr other)
2630
2631 -- | Retrieve the compiled byte-code if possible. Panic if it is a file-based linkable
2632 byteCodeOfObject :: Unlinked -> CompiledByteCode
2633 byteCodeOfObject (BCOs bc _) = bc
2634 byteCodeOfObject other       = pprPanic "byteCodeOfObject" (ppr other)
2635 \end{code}
2636
2637 %************************************************************************
2638 %*                                                                      *
2639 \subsection{Breakpoint Support}
2640 %*                                                                      *
2641 %************************************************************************
2642
2643 \begin{code}
2644 -- | Breakpoint index
2645 type BreakIndex = Int
2646
2647 -- | All the information about the breakpoints for a given module
2648 data ModBreaks
2649    = ModBreaks
2650    { modBreaks_flags :: BreakArray
2651         -- ^ The array of flags, one per breakpoint,
2652         -- indicating which breakpoints are enabled.
2653    , modBreaks_locs :: !(Array BreakIndex SrcSpan)
2654         -- ^ An array giving the source span of each breakpoint.
2655    , modBreaks_vars :: !(Array BreakIndex [OccName])
2656         -- ^ An array giving the names of the free variables at each breakpoint.
2657    , modBreaks_decls :: !(Array BreakIndex [String])
2658         -- ^ An array giving the names of the declarations enclosing each breakpoint.
2659    }
2660
2661 -- | Construct an empty ModBreaks
2662 emptyModBreaks :: ModBreaks
2663 emptyModBreaks = ModBreaks
2664    { modBreaks_flags = error "ModBreaks.modBreaks_array not initialised"
2665          -- ToDo: can we avoid this?
2666    , modBreaks_locs  = array (0,-1) []
2667    , modBreaks_vars  = array (0,-1) []
2668    , modBreaks_decls = array (0,-1) []
2669    }
2670 \end{code}