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