Revert "Revert "Revert "Support for multiple signature files in scope."""
[ghc.git] / compiler / iface / LoadIface.hs
1 {-
2 (c) The University of Glasgow 2006
3 (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4
5
6 Loading interface files
7 -}
8
9 {-# LANGUAGE CPP #-}
10 {-# OPTIONS_GHC -fno-warn-orphans #-}
11 module LoadIface (
12 -- Importing one thing
13 tcLookupImported_maybe, importDecl,
14 checkWiredInTyCon, ifCheckWiredInThing,
15
16 -- RnM/TcM functions
17 loadModuleInterface, loadModuleInterfaces,
18 loadSrcInterface, loadSrcInterface_maybe,
19 loadInterfaceForName, loadInterfaceForModule,
20
21 -- IfM functions
22 loadInterface, loadWiredInHomeIface,
23 loadSysInterface, loadUserInterface, loadPluginInterface,
24 findAndReadIface, readIface, -- Used when reading the module's old interface
25 loadDecls, -- Should move to TcIface and be renamed
26 initExternalPackageState,
27
28 ifaceStats, pprModIface, showIface
29 ) where
30
31 #include "HsVersions.h"
32
33 import {-# SOURCE #-} TcIface( tcIfaceDecl, tcIfaceRules, tcIfaceInst,
34 tcIfaceFamInst, tcIfaceVectInfo, tcIfaceAnnotations )
35
36 import DynFlags
37 import IfaceSyn
38 import IfaceEnv
39 import HscTypes
40
41 import BasicTypes hiding (SuccessFlag(..))
42 import TcRnMonad
43
44 import Constants
45 import PrelNames
46 import PrelInfo
47 import PrimOp ( allThePrimOps, primOpFixity, primOpOcc )
48 import MkId ( seqId )
49 import TysPrim ( funTyConName )
50 import Rules
51 import TyCon
52 import Annotations
53 import InstEnv
54 import FamInstEnv
55 import Name
56 import NameEnv
57 import Avail
58 import Module
59 import Maybes
60 import ErrUtils
61 import Finder
62 import UniqFM
63 import SrcLoc
64 import Outputable
65 import BinIface
66 import Panic
67 import Util
68 import FastString
69 import Fingerprint
70 import Hooks
71
72 import Control.Monad
73 import Data.IORef
74 import System.FilePath
75
76 {-
77 ************************************************************************
78 * *
79 * tcImportDecl is the key function for "faulting in" *
80 * imported things
81 * *
82 ************************************************************************
83
84 The main idea is this. We are chugging along type-checking source code, and
85 find a reference to GHC.Base.map. We call tcLookupGlobal, which doesn't find
86 it in the EPS type envt. So it
87 1 loads GHC.Base.hi
88 2 gets the decl for GHC.Base.map
89 3 typechecks it via tcIfaceDecl
90 4 and adds it to the type env in the EPS
91
92 Note that DURING STEP 4, we may find that map's type mentions a type
93 constructor that also
94
95 Notice that for imported things we read the current version from the EPS
96 mutable variable. This is important in situations like
97 ...$(e1)...$(e2)...
98 where the code that e1 expands to might import some defns that
99 also turn out to be needed by the code that e2 expands to.
100 -}
101
102 tcLookupImported_maybe :: Name -> TcM (MaybeErr MsgDoc TyThing)
103 -- Returns (Failed err) if we can't find the interface file for the thing
104 tcLookupImported_maybe name
105 = do { hsc_env <- getTopEnv
106 ; mb_thing <- liftIO (lookupTypeHscEnv hsc_env name)
107 ; case mb_thing of
108 Just thing -> return (Succeeded thing)
109 Nothing -> tcImportDecl_maybe name }
110
111 tcImportDecl_maybe :: Name -> TcM (MaybeErr MsgDoc TyThing)
112 -- Entry point for *source-code* uses of importDecl
113 tcImportDecl_maybe name
114 | Just thing <- wiredInNameTyThing_maybe name
115 = do { when (needWiredInHomeIface thing)
116 (initIfaceTcRn (loadWiredInHomeIface name))
117 -- See Note [Loading instances for wired-in things]
118 ; return (Succeeded thing) }
119 | otherwise
120 = initIfaceTcRn (importDecl name)
121
122 importDecl :: Name -> IfM lcl (MaybeErr MsgDoc TyThing)
123 -- Get the TyThing for this Name from an interface file
124 -- It's not a wired-in thing -- the caller caught that
125 importDecl name
126 = ASSERT( not (isWiredInName name) )
127 do { traceIf nd_doc
128
129 -- Load the interface, which should populate the PTE
130 ; mb_iface <- ASSERT2( isExternalName name, ppr name )
131 loadInterface nd_doc (nameModule name) ImportBySystem
132 ; case mb_iface of {
133 Failed err_msg -> return (Failed err_msg) ;
134 Succeeded _ -> do
135
136 -- Now look it up again; this time we should find it
137 { eps <- getEps
138 ; case lookupTypeEnv (eps_PTE eps) name of
139 Just thing -> return (Succeeded thing)
140 Nothing -> return (Failed not_found_msg)
141 }}}
142 where
143 nd_doc = ptext (sLit "Need decl for") <+> ppr name
144 not_found_msg = hang (ptext (sLit "Can't find interface-file declaration for") <+>
145 pprNameSpace (occNameSpace (nameOccName name)) <+> ppr name)
146 2 (vcat [ptext (sLit "Probable cause: bug in .hi-boot file, or inconsistent .hi file"),
147 ptext (sLit "Use -ddump-if-trace to get an idea of which file caused the error")])
148
149
150 {-
151 ************************************************************************
152 * *
153 Checks for wired-in things
154 * *
155 ************************************************************************
156
157 Note [Loading instances for wired-in things]
158 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
159 We need to make sure that we have at least *read* the interface files
160 for any module with an instance decl or RULE that we might want.
161
162 * If the instance decl is an orphan, we have a whole separate mechanism
163 (loadOrphanModules)
164
165 * If the instance decl is not an orphan, then the act of looking at the
166 TyCon or Class will force in the defining module for the
167 TyCon/Class, and hence the instance decl
168
169 * BUT, if the TyCon is a wired-in TyCon, we don't really need its interface;
170 but we must make sure we read its interface in case it has instances or
171 rules. That is what LoadIface.loadWiredInHomeInterface does. It's called
172 from TcIface.{tcImportDecl, checkWiredInTyCon, ifCheckWiredInThing}
173
174 * HOWEVER, only do this for TyCons. There are no wired-in Classes. There
175 are some wired-in Ids, but we don't want to load their interfaces. For
176 example, Control.Exception.Base.recSelError is wired in, but that module
177 is compiled late in the base library, and we don't want to force it to
178 load before it's been compiled!
179
180 All of this is done by the type checker. The renamer plays no role.
181 (It used to, but no longer.)
182 -}
183
184 checkWiredInTyCon :: TyCon -> TcM ()
185 -- Ensure that the home module of the TyCon (and hence its instances)
186 -- are loaded. See Note [Loading instances for wired-in things]
187 -- It might not be a wired-in tycon (see the calls in TcUnify),
188 -- in which case this is a no-op.
189 checkWiredInTyCon tc
190 | not (isWiredInName tc_name)
191 = return ()
192 | otherwise
193 = do { mod <- getModule
194 ; traceIf (text "checkWiredInTyCon" <+> ppr tc_name $$ ppr mod)
195 ; ASSERT( isExternalName tc_name )
196 when (mod /= nameModule tc_name)
197 (initIfaceTcRn (loadWiredInHomeIface tc_name))
198 -- Don't look for (non-existent) Float.hi when
199 -- compiling Float.hs, which mentions Float of course
200 -- A bit yukky to call initIfaceTcRn here
201 }
202 where
203 tc_name = tyConName tc
204
205 ifCheckWiredInThing :: TyThing -> IfL ()
206 -- Even though we are in an interface file, we want to make
207 -- sure the instances of a wired-in thing are loaded (imagine f :: Double -> Double)
208 -- Ditto want to ensure that RULES are loaded too
209 -- See Note [Loading instances for wired-in things]
210 ifCheckWiredInThing thing
211 = do { mod <- getIfModule
212 -- Check whether we are typechecking the interface for this
213 -- very module. E.g when compiling the base library in --make mode
214 -- we may typecheck GHC.Base.hi. At that point, GHC.Base is not in
215 -- the HPT, so without the test we'll demand-load it into the PIT!
216 -- C.f. the same test in checkWiredInTyCon above
217 ; let name = getName thing
218 ; ASSERT2( isExternalName name, ppr name )
219 when (needWiredInHomeIface thing && mod /= nameModule name)
220 (loadWiredInHomeIface name) }
221
222 needWiredInHomeIface :: TyThing -> Bool
223 -- Only for TyCons; see Note [Loading instances for wired-in things]
224 needWiredInHomeIface (ATyCon {}) = True
225 needWiredInHomeIface _ = False
226
227
228 {-
229 ************************************************************************
230 * *
231 loadSrcInterface, loadOrphanModules, loadInterfaceForName
232
233 These three are called from TcM-land
234 * *
235 ************************************************************************
236 -}
237
238 -- Note [Un-ambiguous multiple interfaces]
239 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
240 -- When a user writes an import statement, this usually causes a *single*
241 -- interface file to be loaded. However, the game is different when
242 -- signatures are being imported. Suppose in packages p and q we have
243 -- signatures:
244 --
245 -- module A where
246 -- foo :: Int
247 --
248 -- module A where
249 -- bar :: Int
250 --
251 -- If both packages are exposed and I am importing A, I should see a
252 -- "unified" signature:
253 --
254 -- module A where
255 -- foo :: Int
256 -- bar :: Int
257 --
258 -- The way we achieve this is having the module lookup for A load and return
259 -- multiple interface files, which we will then process as if there were
260 -- "multiple" imports:
261 --
262 -- import "p" A
263 -- import "q" A
264 --
265 -- Doing so does not cause any ambiguity, because any overlapping identifiers
266 -- are guaranteed to have the same name if the backing implementations of the
267 -- two signatures are the same (a condition which is checked by 'Packages'.)
268
269
270 -- | Load the interface corresponding to an @import@ directive in
271 -- source code. On a failure, fail in the monad with an error message.
272 -- See Note [Un-ambiguous multiple interfaces] for why the return type
273 -- is @[ModIface]@
274 loadSrcInterface :: SDoc
275 -> ModuleName
276 -> IsBootInterface -- {-# SOURCE #-} ?
277 -> Maybe FastString -- "package", if any
278 -> RnM [ModIface]
279
280 loadSrcInterface doc mod want_boot maybe_pkg
281 = do { res <- loadSrcInterface_maybe doc mod want_boot maybe_pkg
282 ; case res of
283 Failed err -> failWithTc err
284 Succeeded ifaces -> return ifaces }
285
286 -- | Like 'loadSrcInterface', but returns a 'MaybeErr'. See also
287 -- Note [Un-ambiguous multiple interfaces]
288 loadSrcInterface_maybe :: SDoc
289 -> ModuleName
290 -> IsBootInterface -- {-# SOURCE #-} ?
291 -> Maybe FastString -- "package", if any
292 -> RnM (MaybeErr MsgDoc [ModIface])
293
294 loadSrcInterface_maybe doc mod want_boot maybe_pkg
295 -- We must first find which Module this import refers to. This involves
296 -- calling the Finder, which as a side effect will search the filesystem
297 -- and create a ModLocation. If successful, loadIface will read the
298 -- interface; it will call the Finder again, but the ModLocation will be
299 -- cached from the first search.
300 = do { hsc_env <- getTopEnv
301 -- ToDo: findImportedModule should return a list of interfaces
302 ; res <- liftIO $ findImportedModule hsc_env mod maybe_pkg
303 ; case res of
304 Found _ mod -> fmap (fmap (:[]))
305 . initIfaceTcRn
306 $ loadInterface doc mod (ImportByUser want_boot)
307 err -> return (Failed (cannotFindInterface (hsc_dflags hsc_env) mod err)) }
308
309 -- | Load interface directly for a fully qualified 'Module'. (This is a fairly
310 -- rare operation, but in particular it is used to load orphan modules
311 -- in order to pull their instances into the global package table and to
312 -- handle some operations in GHCi).
313 loadModuleInterface :: SDoc -> Module -> TcM ModIface
314 loadModuleInterface doc mod = initIfaceTcRn (loadSysInterface doc mod)
315
316 -- | Load interfaces for a collection of modules.
317 loadModuleInterfaces :: SDoc -> [Module] -> TcM ()
318 loadModuleInterfaces doc mods
319 | null mods = return ()
320 | otherwise = initIfaceTcRn (mapM_ load mods)
321 where
322 load mod = loadSysInterface (doc <+> parens (ppr mod)) mod
323
324 -- | Loads the interface for a given Name.
325 -- Should only be called for an imported name;
326 -- otherwise loadSysInterface may not find the interface
327 loadInterfaceForName :: SDoc -> Name -> TcRn ModIface
328 loadInterfaceForName doc name
329 = do { when debugIsOn $ -- Check pre-condition
330 do { this_mod <- getModule
331 ; MASSERT2( not (nameIsLocalOrFrom this_mod name), ppr name <+> parens doc ) }
332 ; ASSERT2( isExternalName name, ppr name )
333 initIfaceTcRn $ loadSysInterface doc (nameModule name) }
334
335 -- | Loads the interface for a given Module.
336 loadInterfaceForModule :: SDoc -> Module -> TcRn ModIface
337 loadInterfaceForModule doc m
338 = do
339 -- Should not be called with this module
340 when debugIsOn $ do
341 this_mod <- getModule
342 MASSERT2( this_mod /= m, ppr m <+> parens doc )
343 initIfaceTcRn $ loadSysInterface doc m
344
345 {-
346 *********************************************************
347 * *
348 loadInterface
349
350 The main function to load an interface
351 for an imported module, and put it in
352 the External Package State
353 * *
354 *********************************************************
355 -}
356
357 -- | An 'IfM' function to load the home interface for a wired-in thing,
358 -- so that we're sure that we see its instance declarations and rules
359 -- See Note [Loading instances for wired-in things]
360 loadWiredInHomeIface :: Name -> IfM lcl ()
361 loadWiredInHomeIface name
362 = ASSERT( isWiredInName name )
363 do _ <- loadSysInterface doc (nameModule name); return ()
364 where
365 doc = ptext (sLit "Need home interface for wired-in thing") <+> ppr name
366
367 ------------------
368 -- | Loads a system interface and throws an exception if it fails
369 loadSysInterface :: SDoc -> Module -> IfM lcl ModIface
370 loadSysInterface doc mod_name = loadInterfaceWithException doc mod_name ImportBySystem
371
372 ------------------
373 -- | Loads a user interface and throws an exception if it fails. The first parameter indicates
374 -- whether we should import the boot variant of the module
375 loadUserInterface :: Bool -> SDoc -> Module -> IfM lcl ModIface
376 loadUserInterface is_boot doc mod_name
377 = loadInterfaceWithException doc mod_name (ImportByUser is_boot)
378
379 loadPluginInterface :: SDoc -> Module -> IfM lcl ModIface
380 loadPluginInterface doc mod_name
381 = loadInterfaceWithException doc mod_name ImportByPlugin
382
383 ------------------
384 -- | A wrapper for 'loadInterface' that throws an exception if it fails
385 loadInterfaceWithException :: SDoc -> Module -> WhereFrom -> IfM lcl ModIface
386 loadInterfaceWithException doc mod_name where_from
387 = do { mb_iface <- loadInterface doc mod_name where_from
388 ; dflags <- getDynFlags
389 ; case mb_iface of
390 Failed err -> liftIO $ throwGhcExceptionIO (ProgramError (showSDoc dflags err))
391 Succeeded iface -> return iface }
392
393 ------------------
394 loadInterface :: SDoc -> Module -> WhereFrom
395 -> IfM lcl (MaybeErr MsgDoc ModIface)
396
397 -- loadInterface looks in both the HPT and PIT for the required interface
398 -- If not found, it loads it, and puts it in the PIT (always).
399
400 -- If it can't find a suitable interface file, we
401 -- a) modify the PackageIfaceTable to have an empty entry
402 -- (to avoid repeated complaints)
403 -- b) return (Left message)
404 --
405 -- It's not necessarily an error for there not to be an interface
406 -- file -- perhaps the module has changed, and that interface
407 -- is no longer used
408
409 loadInterface doc_str mod from
410 = do { -- Read the state
411 (eps,hpt) <- getEpsAndHpt
412 ; gbl_env <- getGblEnv
413
414 ; traceIf (text "Considering whether to load" <+> ppr mod <+> ppr from)
415
416 -- Check whether we have the interface already
417 ; dflags <- getDynFlags
418 ; case lookupIfaceByModule dflags hpt (eps_PIT eps) mod of {
419 Just iface
420 -> return (Succeeded iface) ; -- Already loaded
421 -- The (src_imp == mi_boot iface) test checks that the already-loaded
422 -- interface isn't a boot iface. This can conceivably happen,
423 -- if an earlier import had a before we got to real imports. I think.
424 _ -> do {
425
426 -- READ THE MODULE IN
427 ; read_result <- case (wantHiBootFile dflags eps mod from) of
428 Failed err -> return (Failed err)
429 Succeeded hi_boot_file ->
430 -- Stoutly warn against an EPS-updating import
431 -- of one's own boot file! (one-shot only)
432 --See Note [Do not update EPS with your own hi-boot]
433 -- in MkIface.
434 WARN( hi_boot_file &&
435 fmap fst (if_rec_types gbl_env) == Just mod,
436 ppr mod )
437 findAndReadIface doc_str mod hi_boot_file
438 ; case read_result of {
439 Failed err -> do
440 { let fake_iface = emptyModIface mod
441
442 ; updateEps_ $ \eps ->
443 eps { eps_PIT = extendModuleEnv (eps_PIT eps) (mi_module fake_iface) fake_iface }
444 -- Not found, so add an empty iface to
445 -- the EPS map so that we don't look again
446
447 ; return (Failed err) } ;
448
449 -- Found and parsed!
450 -- We used to have a sanity check here that looked for:
451 -- * System importing ..
452 -- * a home package module ..
453 -- * that we know nothing about (mb_dep == Nothing)!
454 --
455 -- But this is no longer valid because thNameToGhcName allows users to
456 -- cause the system to load arbitrary interfaces (by supplying an appropriate
457 -- Template Haskell original-name).
458 Succeeded (iface, file_path) ->
459
460 let
461 loc_doc = text file_path
462 in
463 initIfaceLcl mod loc_doc $ do
464
465 -- Load the new ModIface into the External Package State
466 -- Even home-package interfaces loaded by loadInterface
467 -- (which only happens in OneShot mode; in Batch/Interactive
468 -- mode, home-package modules are loaded one by one into the HPT)
469 -- are put in the EPS.
470 --
471 -- The main thing is to add the ModIface to the PIT, but
472 -- we also take the
473 -- IfaceDecls, IfaceClsInst, IfaceFamInst, IfaceRules, IfaceVectInfo
474 -- out of the ModIface and put them into the big EPS pools
475
476 -- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
477 --- names is done correctly (notably, whether this is an .hi file or .hi-boot file).
478 -- If we do loadExport first the wrong info gets into the cache (unless we
479 -- explicitly tag each export which seems a bit of a bore)
480
481 ; ignore_prags <- goptM Opt_IgnoreInterfacePragmas
482 ; new_eps_decls <- loadDecls ignore_prags (mi_decls iface)
483 ; new_eps_insts <- mapM tcIfaceInst (mi_insts iface)
484 ; new_eps_fam_insts <- mapM tcIfaceFamInst (mi_fam_insts iface)
485 ; new_eps_rules <- tcIfaceRules ignore_prags (mi_rules iface)
486 ; new_eps_anns <- tcIfaceAnnotations (mi_anns iface)
487 ; new_eps_vect_info <- tcIfaceVectInfo mod (mkNameEnv new_eps_decls) (mi_vect_info iface)
488
489 ; let { final_iface = iface {
490 mi_decls = panic "No mi_decls in PIT",
491 mi_insts = panic "No mi_insts in PIT",
492 mi_fam_insts = panic "No mi_fam_insts in PIT",
493 mi_rules = panic "No mi_rules in PIT",
494 mi_anns = panic "No mi_anns in PIT"
495 }
496 }
497
498 ; updateEps_ $ \ eps ->
499 if elemModuleEnv mod (eps_PIT eps) then eps else
500 eps {
501 eps_PIT = extendModuleEnv (eps_PIT eps) mod final_iface,
502 eps_PTE = addDeclsToPTE (eps_PTE eps) new_eps_decls,
503 eps_rule_base = extendRuleBaseList (eps_rule_base eps)
504 new_eps_rules,
505 eps_inst_env = extendInstEnvList (eps_inst_env eps)
506 new_eps_insts,
507 eps_fam_inst_env = extendFamInstEnvList (eps_fam_inst_env eps)
508 new_eps_fam_insts,
509 eps_vect_info = plusVectInfo (eps_vect_info eps)
510 new_eps_vect_info,
511 eps_ann_env = extendAnnEnvList (eps_ann_env eps)
512 new_eps_anns,
513 eps_mod_fam_inst_env
514 = let
515 fam_inst_env =
516 extendFamInstEnvList emptyFamInstEnv
517 new_eps_fam_insts
518 in
519 extendModuleEnv (eps_mod_fam_inst_env eps)
520 mod
521 fam_inst_env,
522 eps_stats = addEpsInStats (eps_stats eps)
523 (length new_eps_decls)
524 (length new_eps_insts)
525 (length new_eps_rules) }
526
527 ; return (Succeeded final_iface)
528 }}}}
529
530 wantHiBootFile :: DynFlags -> ExternalPackageState -> Module -> WhereFrom
531 -> MaybeErr MsgDoc IsBootInterface
532 -- Figure out whether we want Foo.hi or Foo.hi-boot
533 wantHiBootFile dflags eps mod from
534 = case from of
535 ImportByUser usr_boot
536 | usr_boot && not this_package
537 -> Failed (badSourceImport mod)
538 | otherwise -> Succeeded usr_boot
539
540 ImportByPlugin
541 -> Succeeded False
542
543 ImportBySystem
544 | not this_package -- If the module to be imported is not from this package
545 -> Succeeded False -- don't look it up in eps_is_boot, because that is keyed
546 -- on the ModuleName of *home-package* modules only.
547 -- We never import boot modules from other packages!
548
549 | otherwise
550 -> case lookupUFM (eps_is_boot eps) (moduleName mod) of
551 Just (_, is_boot) -> Succeeded is_boot
552 Nothing -> Succeeded False
553 -- The boot-ness of the requested interface,
554 -- based on the dependencies in directly-imported modules
555 where
556 this_package = thisPackage dflags == modulePackageKey mod
557
558 badSourceImport :: Module -> SDoc
559 badSourceImport mod
560 = hang (ptext (sLit "You cannot {-# SOURCE #-} import a module from another package"))
561 2 (ptext (sLit "but") <+> quotes (ppr mod) <+> ptext (sLit "is from package")
562 <+> quotes (ppr (modulePackageKey mod)))
563
564 -----------------------------------------------------
565 -- Loading type/class/value decls
566 -- We pass the full Module name here, replete with
567 -- its package info, so that we can build a Name for
568 -- each binder with the right package info in it
569 -- All subsequent lookups, including crucially lookups during typechecking
570 -- the declaration itself, will find the fully-glorious Name
571 --
572 -- We handle ATs specially. They are not main declarations, but also not
573 -- implicit things (in particular, adding them to `implicitTyThings' would mess
574 -- things up in the renaming/type checking of source programs).
575 -----------------------------------------------------
576
577 addDeclsToPTE :: PackageTypeEnv -> [(Name,TyThing)] -> PackageTypeEnv
578 addDeclsToPTE pte things = extendNameEnvList pte things
579
580 loadDecls :: Bool
581 -> [(Fingerprint, IfaceDecl)]
582 -> IfL [(Name,TyThing)]
583 loadDecls ignore_prags ver_decls
584 = do { thingss <- mapM (loadDecl ignore_prags) ver_decls
585 ; return (concat thingss)
586 }
587
588 loadDecl :: Bool -- Don't load pragmas into the decl pool
589 -> (Fingerprint, IfaceDecl)
590 -> IfL [(Name,TyThing)] -- The list can be poked eagerly, but the
591 -- TyThings are forkM'd thunks
592 loadDecl ignore_prags (_version, decl)
593 = do { -- Populate the name cache with final versions of all
594 -- the names associated with the decl
595 main_name <- lookupIfaceTop (ifName decl)
596
597 -- Typecheck the thing, lazily
598 -- NB. Firstly, the laziness is there in case we never need the
599 -- declaration (in one-shot mode), and secondly it is there so that
600 -- we don't look up the occurrence of a name before calling mk_new_bndr
601 -- on the binder. This is important because we must get the right name
602 -- which includes its nameParent.
603
604 ; thing <- forkM doc $ do { bumpDeclStats main_name
605 ; tcIfaceDecl ignore_prags decl }
606
607 -- Populate the type environment with the implicitTyThings too.
608 --
609 -- Note [Tricky iface loop]
610 -- ~~~~~~~~~~~~~~~~~~~~~~~~
611 -- Summary: The delicate point here is that 'mini-env' must be
612 -- buildable from 'thing' without demanding any of the things
613 -- 'forkM'd by tcIfaceDecl.
614 --
615 -- In more detail: Consider the example
616 -- data T a = MkT { x :: T a }
617 -- The implicitTyThings of T are: [ <datacon MkT>, <selector x>]
618 -- (plus their workers, wrappers, coercions etc etc)
619 --
620 -- We want to return an environment
621 -- [ "MkT" -> <datacon MkT>, "x" -> <selector x>, ... ]
622 -- (where the "MkT" is the *Name* associated with MkT, etc.)
623 --
624 -- We do this by mapping the implicit_names to the associated
625 -- TyThings. By the invariant on ifaceDeclImplicitBndrs and
626 -- implicitTyThings, we can use getOccName on the implicit
627 -- TyThings to make this association: each Name's OccName should
628 -- be the OccName of exactly one implicitTyThing. So the key is
629 -- to define a "mini-env"
630 --
631 -- [ 'MkT' -> <datacon MkT>, 'x' -> <selector x>, ... ]
632 -- where the 'MkT' here is the *OccName* associated with MkT.
633 --
634 -- However, there is a subtlety: due to how type checking needs
635 -- to be staged, we can't poke on the forkM'd thunks inside the
636 -- implicitTyThings while building this mini-env.
637 -- If we poke these thunks too early, two problems could happen:
638 -- (1) When processing mutually recursive modules across
639 -- hs-boot boundaries, poking too early will do the
640 -- type-checking before the recursive knot has been tied,
641 -- so things will be type-checked in the wrong
642 -- environment, and necessary variables won't be in
643 -- scope.
644 --
645 -- (2) Looking up one OccName in the mini_env will cause
646 -- others to be looked up, which might cause that
647 -- original one to be looked up again, and hence loop.
648 --
649 -- The code below works because of the following invariant:
650 -- getOccName on a TyThing does not force the suspended type
651 -- checks in order to extract the name. For example, we don't
652 -- poke on the "T a" type of <selector x> on the way to
653 -- extracting <selector x>'s OccName. Of course, there is no
654 -- reason in principle why getting the OccName should force the
655 -- thunks, but this means we need to be careful in
656 -- implicitTyThings and its helper functions.
657 --
658 -- All a bit too finely-balanced for my liking.
659
660 -- This mini-env and lookup function mediates between the
661 --'Name's n and the map from 'OccName's to the implicit TyThings
662 ; let mini_env = mkOccEnv [(getOccName t, t) | t <- implicitTyThings thing]
663 lookup n = case lookupOccEnv mini_env (getOccName n) of
664 Just thing -> thing
665 Nothing ->
666 pprPanic "loadDecl" (ppr main_name <+> ppr n $$ ppr (decl))
667
668 ; implicit_names <- mapM lookupIfaceTop (ifaceDeclImplicitBndrs decl)
669
670 -- ; traceIf (text "Loading decl for " <> ppr main_name $$ ppr implicit_names)
671 ; return $ (main_name, thing) :
672 -- uses the invariant that implicit_names and
673 -- implicitTyThings are bijective
674 [(n, lookup n) | n <- implicit_names]
675 }
676 where
677 doc = ptext (sLit "Declaration for") <+> ppr (ifName decl)
678
679 bumpDeclStats :: Name -> IfL () -- Record that one more declaration has actually been used
680 bumpDeclStats name
681 = do { traceIf (text "Loading decl for" <+> ppr name)
682 ; updateEps_ (\eps -> let stats = eps_stats eps
683 in eps { eps_stats = stats { n_decls_out = n_decls_out stats + 1 } })
684 }
685
686 {-
687 *********************************************************
688 * *
689 \subsection{Reading an interface file}
690 * *
691 *********************************************************
692
693 Note [Home module load error]
694 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
695 If the sought-for interface is in the current package (as determined
696 by -package-name flag) then it jolly well should already be in the HPT
697 because we process home-package modules in dependency order. (Except
698 in one-shot mode; see notes with hsc_HPT decl in HscTypes).
699
700 It is possible (though hard) to get this error through user behaviour.
701 * Suppose package P (modules P1, P2) depends on package Q (modules Q1,
702 Q2, with Q2 importing Q1)
703 * We compile both packages.
704 * Now we edit package Q so that it somehow depends on P
705 * Now recompile Q with --make (without recompiling P).
706 * Then Q1 imports, say, P1, which in turn depends on Q2. So Q2
707 is a home-package module which is not yet in the HPT! Disaster.
708
709 This actually happened with P=base, Q=ghc-prim, via the AMP warnings.
710 See Trac #8320.
711 -}
712
713 findAndReadIface :: SDoc -> Module
714 -> IsBootInterface -- True <=> Look for a .hi-boot file
715 -- False <=> Look for .hi file
716 -> TcRnIf gbl lcl (MaybeErr MsgDoc (ModIface, FilePath))
717 -- Nothing <=> file not found, or unreadable, or illegible
718 -- Just x <=> successfully found and parsed
719
720 -- It *doesn't* add an error to the monad, because
721 -- sometimes it's ok to fail... see notes with loadInterface
722
723 findAndReadIface doc_str mod hi_boot_file
724 = do traceIf (sep [hsep [ptext (sLit "Reading"),
725 if hi_boot_file
726 then ptext (sLit "[boot]")
727 else Outputable.empty,
728 ptext (sLit "interface for"),
729 ppr mod <> semi],
730 nest 4 (ptext (sLit "reason:") <+> doc_str)])
731
732 -- Check for GHC.Prim, and return its static interface
733 if mod == gHC_PRIM
734 then do
735 iface <- getHooked ghcPrimIfaceHook ghcPrimIface
736 return (Succeeded (iface,
737 "<built in interface for GHC.Prim>"))
738 else do
739 dflags <- getDynFlags
740 -- Look for the file
741 hsc_env <- getTopEnv
742 mb_found <- liftIO (findExactModule hsc_env mod)
743 case mb_found of
744 Found loc mod -> do
745
746 -- Found file, so read it
747 let file_path = addBootSuffix_maybe hi_boot_file
748 (ml_hi_file loc)
749
750 -- See Note [Home module load error]
751 if thisPackage dflags == modulePackageKey mod &&
752 not (isOneShot (ghcMode dflags))
753 then return (Failed (homeModError mod loc))
754 else do r <- read_file file_path
755 checkBuildDynamicToo r
756 return r
757 err -> do
758 traceIf (ptext (sLit "...not found"))
759 dflags <- getDynFlags
760 return (Failed (cannotFindInterface dflags
761 (moduleName mod) err))
762 where read_file file_path = do
763 traceIf (ptext (sLit "readIFace") <+> text file_path)
764 read_result <- readIface mod file_path
765 case read_result of
766 Failed err -> return (Failed (badIfaceFile file_path err))
767 Succeeded iface
768 | mi_module iface /= mod ->
769 return (Failed (wrongIfaceModErr iface mod file_path))
770 | otherwise ->
771 return (Succeeded (iface, file_path))
772 -- Don't forget to fill in the package name...
773 checkBuildDynamicToo (Succeeded (iface, filePath)) = do
774 dflags <- getDynFlags
775 whenGeneratingDynamicToo dflags $ withDoDynamicToo $ do
776 let ref = canGenerateDynamicToo dflags
777 dynFilePath = addBootSuffix_maybe hi_boot_file
778 $ replaceExtension filePath (dynHiSuf dflags)
779 r <- read_file dynFilePath
780 case r of
781 Succeeded (dynIface, _)
782 | mi_mod_hash iface == mi_mod_hash dynIface ->
783 return ()
784 | otherwise ->
785 do traceIf (text "Dynamic hash doesn't match")
786 liftIO $ writeIORef ref False
787 Failed err ->
788 do traceIf (text "Failed to load dynamic interface file:" $$ err)
789 liftIO $ writeIORef ref False
790 checkBuildDynamicToo _ = return ()
791
792 -- @readIface@ tries just the one file.
793
794 readIface :: Module -> FilePath
795 -> TcRnIf gbl lcl (MaybeErr MsgDoc ModIface)
796 -- Failed err <=> file not found, or unreadable, or illegible
797 -- Succeeded iface <=> successfully found and parsed
798
799 readIface wanted_mod file_path
800 = do { res <- tryMostM $
801 readBinIface CheckHiWay QuietBinIFaceReading file_path
802 ; case res of
803 Right iface
804 | wanted_mod == actual_mod -> return (Succeeded iface)
805 | otherwise -> return (Failed err)
806 where
807 actual_mod = mi_module iface
808 err = hiModuleNameMismatchWarn wanted_mod actual_mod
809
810 Left exn -> return (Failed (text (showException exn)))
811 }
812
813 {-
814 *********************************************************
815 * *
816 Wired-in interface for GHC.Prim
817 * *
818 *********************************************************
819 -}
820
821 initExternalPackageState :: ExternalPackageState
822 initExternalPackageState
823 = EPS {
824 eps_is_boot = emptyUFM,
825 eps_PIT = emptyPackageIfaceTable,
826 eps_PTE = emptyTypeEnv,
827 eps_inst_env = emptyInstEnv,
828 eps_fam_inst_env = emptyFamInstEnv,
829 eps_rule_base = mkRuleBase builtinRules,
830 -- Initialise the EPS rule pool with the built-in rules
831 eps_mod_fam_inst_env
832 = emptyModuleEnv,
833 eps_vect_info = noVectInfo,
834 eps_ann_env = emptyAnnEnv,
835 eps_stats = EpsStats { n_ifaces_in = 0, n_decls_in = 0, n_decls_out = 0
836 , n_insts_in = 0, n_insts_out = 0
837 , n_rules_in = length builtinRules, n_rules_out = 0 }
838 }
839
840 {-
841 *********************************************************
842 * *
843 Wired-in interface for GHC.Prim
844 * *
845 *********************************************************
846 -}
847
848 ghcPrimIface :: ModIface
849 ghcPrimIface
850 = (emptyModIface gHC_PRIM) {
851 mi_exports = ghcPrimExports,
852 mi_decls = [],
853 mi_fixities = fixities,
854 mi_fix_fn = mkIfaceFixCache fixities
855 }
856 where
857 fixities = (getOccName seqId, Fixity 0 InfixR) -- seq is infixr 0
858 : (occName funTyConName, funTyFixity) -- trac #10145
859 : mapMaybe mkFixity allThePrimOps
860 mkFixity op = (,) (primOpOcc op) <$> primOpFixity op
861
862 {-
863 *********************************************************
864 * *
865 \subsection{Statistics}
866 * *
867 *********************************************************
868 -}
869
870 ifaceStats :: ExternalPackageState -> SDoc
871 ifaceStats eps
872 = hcat [text "Renamer stats: ", msg]
873 where
874 stats = eps_stats eps
875 msg = vcat
876 [int (n_ifaces_in stats) <+> text "interfaces read",
877 hsep [ int (n_decls_out stats), text "type/class/variable imported, out of",
878 int (n_decls_in stats), text "read"],
879 hsep [ int (n_insts_out stats), text "instance decls imported, out of",
880 int (n_insts_in stats), text "read"],
881 hsep [ int (n_rules_out stats), text "rule decls imported, out of",
882 int (n_rules_in stats), text "read"]
883 ]
884
885 {-
886 ************************************************************************
887 * *
888 Printing interfaces
889 * *
890 ************************************************************************
891 -}
892
893 -- | Read binary interface, and print it out
894 showIface :: HscEnv -> FilePath -> IO ()
895 showIface hsc_env filename = do
896 -- skip the hi way check; we don't want to worry about profiled vs.
897 -- non-profiled interfaces, for example.
898 iface <- initTcRnIf 's' hsc_env () () $
899 readBinIface IgnoreHiWay TraceBinIFaceReading filename
900 let dflags = hsc_dflags hsc_env
901 log_action dflags dflags SevDump noSrcSpan defaultDumpStyle (pprModIface iface)
902
903 pprModIface :: ModIface -> SDoc
904 -- Show a ModIface
905 pprModIface iface
906 = vcat [ ptext (sLit "interface")
907 <+> ppr (mi_module iface) <+> pp_hsc_src (mi_hsc_src iface)
908 <+> (if mi_orphan iface then ptext (sLit "[orphan module]") else Outputable.empty)
909 <+> (if mi_finsts iface then ptext (sLit "[family instance module]") else Outputable.empty)
910 <+> (if mi_hpc iface then ptext (sLit "[hpc]") else Outputable.empty)
911 <+> integer hiVersion
912 , nest 2 (text "interface hash:" <+> ppr (mi_iface_hash iface))
913 , nest 2 (text "ABI hash:" <+> ppr (mi_mod_hash iface))
914 , nest 2 (text "export-list hash:" <+> ppr (mi_exp_hash iface))
915 , nest 2 (text "orphan hash:" <+> ppr (mi_orphan_hash iface))
916 , nest 2 (text "flag hash:" <+> ppr (mi_flag_hash iface))
917 , nest 2 (text "sig of:" <+> ppr (mi_sig_of iface))
918 , nest 2 (text "used TH splices:" <+> ppr (mi_used_th iface))
919 , nest 2 (ptext (sLit "where"))
920 , ptext (sLit "exports:")
921 , nest 2 (vcat (map pprExport (mi_exports iface)))
922 , pprDeps (mi_deps iface)
923 , vcat (map pprUsage (mi_usages iface))
924 , vcat (map pprIfaceAnnotation (mi_anns iface))
925 , pprFixities (mi_fixities iface)
926 , vcat [ppr ver $$ nest 2 (ppr decl) | (ver,decl) <- mi_decls iface]
927 , vcat (map ppr (mi_insts iface))
928 , vcat (map ppr (mi_fam_insts iface))
929 , vcat (map ppr (mi_rules iface))
930 , pprVectInfo (mi_vect_info iface)
931 , ppr (mi_warns iface)
932 , pprTrustInfo (mi_trust iface)
933 , pprTrustPkg (mi_trust_pkg iface)
934 ]
935 where
936 pp_hsc_src HsBootFile = ptext (sLit "[boot]")
937 pp_hsc_src HsigFile = ptext (sLit "[hsig]")
938 pp_hsc_src HsSrcFile = Outputable.empty
939
940 {-
941 When printing export lists, we print like this:
942 Avail f f
943 AvailTC C [C, x, y] C(x,y)
944 AvailTC C [x, y] C!(x,y) -- Exporting x, y but not C
945 -}
946
947 pprExport :: IfaceExport -> SDoc
948 pprExport (Avail n) = ppr n
949 pprExport (AvailTC _ []) = Outputable.empty
950 pprExport (AvailTC n (n':ns))
951 | n==n' = ppr n <> pp_export ns
952 | otherwise = ppr n <> char '|' <> pp_export (n':ns)
953 where
954 pp_export [] = Outputable.empty
955 pp_export names = braces (hsep (map ppr names))
956
957 pprUsage :: Usage -> SDoc
958 pprUsage usage@UsagePackageModule{}
959 = pprUsageImport usage usg_mod
960 pprUsage usage@UsageHomeModule{}
961 = pprUsageImport usage usg_mod_name $$
962 nest 2 (
963 maybe Outputable.empty (\v -> text "exports: " <> ppr v) (usg_exports usage) $$
964 vcat [ ppr n <+> ppr v | (n,v) <- usg_entities usage ]
965 )
966 pprUsage usage@UsageFile{}
967 = hsep [ptext (sLit "addDependentFile"),
968 doubleQuotes (text (usg_file_path usage))]
969
970 pprUsageImport :: Outputable a => Usage -> (Usage -> a) -> SDoc
971 pprUsageImport usage usg_mod'
972 = hsep [ptext (sLit "import"), safe, ppr (usg_mod' usage),
973 ppr (usg_mod_hash usage)]
974 where
975 safe | usg_safe usage = ptext $ sLit "safe"
976 | otherwise = ptext $ sLit " -/ "
977
978 pprDeps :: Dependencies -> SDoc
979 pprDeps (Deps { dep_mods = mods, dep_pkgs = pkgs, dep_orphs = orphs,
980 dep_finsts = finsts })
981 = vcat [ptext (sLit "module dependencies:") <+> fsep (map ppr_mod mods),
982 ptext (sLit "package dependencies:") <+> fsep (map ppr_pkg pkgs),
983 ptext (sLit "orphans:") <+> fsep (map ppr orphs),
984 ptext (sLit "family instance modules:") <+> fsep (map ppr finsts)
985 ]
986 where
987 ppr_mod (mod_name, boot) = ppr mod_name <+> ppr_boot boot
988 ppr_pkg (pkg,trust_req) = ppr pkg <>
989 (if trust_req then text "*" else Outputable.empty)
990 ppr_boot True = text "[boot]"
991 ppr_boot False = Outputable.empty
992
993 pprFixities :: [(OccName, Fixity)] -> SDoc
994 pprFixities [] = Outputable.empty
995 pprFixities fixes = ptext (sLit "fixities") <+> pprWithCommas pprFix fixes
996 where
997 pprFix (occ,fix) = ppr fix <+> ppr occ
998
999 pprVectInfo :: IfaceVectInfo -> SDoc
1000 pprVectInfo (IfaceVectInfo { ifaceVectInfoVar = vars
1001 , ifaceVectInfoTyCon = tycons
1002 , ifaceVectInfoTyConReuse = tyconsReuse
1003 , ifaceVectInfoParallelVars = parallelVars
1004 , ifaceVectInfoParallelTyCons = parallelTyCons
1005 }) =
1006 vcat
1007 [ ptext (sLit "vectorised variables:") <+> hsep (map ppr vars)
1008 , ptext (sLit "vectorised tycons:") <+> hsep (map ppr tycons)
1009 , ptext (sLit "vectorised reused tycons:") <+> hsep (map ppr tyconsReuse)
1010 , ptext (sLit "parallel variables:") <+> hsep (map ppr parallelVars)
1011 , ptext (sLit "parallel tycons:") <+> hsep (map ppr parallelTyCons)
1012 ]
1013
1014 pprTrustInfo :: IfaceTrustInfo -> SDoc
1015 pprTrustInfo trust = ptext (sLit "trusted:") <+> ppr trust
1016
1017 pprTrustPkg :: Bool -> SDoc
1018 pprTrustPkg tpkg = ptext (sLit "require own pkg trusted:") <+> ppr tpkg
1019
1020 instance Outputable Warnings where
1021 ppr = pprWarns
1022
1023 pprWarns :: Warnings -> SDoc
1024 pprWarns NoWarnings = Outputable.empty
1025 pprWarns (WarnAll txt) = ptext (sLit "Warn all") <+> ppr txt
1026 pprWarns (WarnSome prs) = ptext (sLit "Warnings")
1027 <+> vcat (map pprWarning prs)
1028 where pprWarning (name, txt) = ppr name <+> ppr txt
1029
1030 pprIfaceAnnotation :: IfaceAnnotation -> SDoc
1031 pprIfaceAnnotation (IfaceAnnotation { ifAnnotatedTarget = target, ifAnnotatedValue = serialized })
1032 = ppr target <+> ptext (sLit "annotated by") <+> ppr serialized
1033
1034 {-
1035 *********************************************************
1036 * *
1037 \subsection{Errors}
1038 * *
1039 *********************************************************
1040 -}
1041
1042 badIfaceFile :: String -> SDoc -> SDoc
1043 badIfaceFile file err
1044 = vcat [ptext (sLit "Bad interface file:") <+> text file,
1045 nest 4 err]
1046
1047 hiModuleNameMismatchWarn :: Module -> Module -> MsgDoc
1048 hiModuleNameMismatchWarn requested_mod read_mod =
1049 -- ToDo: This will fail to have enough qualification when the package IDs
1050 -- are the same
1051 withPprStyle (mkUserStyle alwaysQualify AllTheWay) $
1052 -- we want the Modules below to be qualified with package names,
1053 -- so reset the PrintUnqualified setting.
1054 hsep [ ptext (sLit "Something is amiss; requested module ")
1055 , ppr requested_mod
1056 , ptext (sLit "differs from name found in the interface file")
1057 , ppr read_mod
1058 ]
1059
1060 wrongIfaceModErr :: ModIface -> Module -> String -> SDoc
1061 wrongIfaceModErr iface mod_name file_path
1062 = sep [ptext (sLit "Interface file") <+> iface_file,
1063 ptext (sLit "contains module") <+> quotes (ppr (mi_module iface)) <> comma,
1064 ptext (sLit "but we were expecting module") <+> quotes (ppr mod_name),
1065 sep [ptext (sLit "Probable cause: the source code which generated"),
1066 nest 2 iface_file,
1067 ptext (sLit "has an incompatible module name")
1068 ]
1069 ]
1070 where iface_file = doubleQuotes (text file_path)
1071
1072 homeModError :: Module -> ModLocation -> SDoc
1073 -- See Note [Home module load error]
1074 homeModError mod location
1075 = ptext (sLit "attempting to use module ") <> quotes (ppr mod)
1076 <> (case ml_hs_file location of
1077 Just file -> space <> parens (text file)
1078 Nothing -> Outputable.empty)
1079 <+> ptext (sLit "which is not loaded")