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