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