RnIfaces.lhs 44.4 KB
Newer Older
1
%
2
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
3
4
5
6
7
%
\section[RnIfaces]{Cacheing and Renaming of Interfaces}

\begin{code}
module RnIfaces (
8
9
10
	findAndReadIface, 

	getInterfaceExports, getDeferredDecls,
11
	getImportedInstDecls, getImportedRules,
12
13
14
	lookupFixityRn, loadHomeInterface,
	importDecl, ImportDeclResult(..), recordLocalSlurps, loadBuiltinRules,
	mkImportExportInfo, getSlurped, 
15

16
	checkModUsage, outOfDate, upToDate,
17

18
19
	getDeclBinders, getDeclSysBinders,
	removeContext	 	-- removeContext probably belongs somewhere else
20
21
    ) where

22
#include "HsVersions.h"
23

24
import CmdLineOpts	( opt_NoPruneDecls, opt_NoPruneTyDecls, opt_IgnoreIfacePragmas )
25
import HsSyn		( HsDecl(..), TyClDecl(..), InstDecl(..), IfaceSig(..), 
26
			  HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
27
			  ForeignDecl(..), ForKind(..), isDynamicExtName,
28
			  FixitySig(..), RuleDecl(..),
29
			  isClassOpSig, DeprecDecl(..)
30
			)
31
32
import HsImpExp		( ieNames )
import CoreSyn		( CoreRule )
33
34
35
import BasicTypes	( Version, NewOrData(..) )
import RdrHsSyn		( RdrNameHsDecl, RdrNameInstDecl, RdrNameRuleDecl,
			  RdrNameDeprecation, RdrNameIE,
36
			  extractHsTyRdrNames 
37
			)
38
import RnEnv
39
import RnMonad
40
import ParseIface	( parseIface, IfaceStuff(..) )
41

42
43
import Name		( Name {-instance NamedThing-}, nameOccName,
			  nameModule, isLocallyDefined, 
44
			  isWiredInName, NamedThing(..),
45
			  elemNameEnv, extendNameEnv
46
			 )
47
48
import Module		( Module, mkVanillaModule, pprModuleName,
			  moduleName, isLocalModule,
49
			  ModuleName, WhereFrom(..),
50
51
			)
import RdrName		( RdrName, rdrNameOcc )
52
import NameSet
53
import SrcLoc		( mkSrcLoc, SrcLoc )
54
import PrelInfo		( cCallishTyKeys )
55
import Maybes		( maybeToBool )
56
57
import Unique		( Uniquable(..) )
import StringBuffer     ( hGetStringBuffer )
58
import FastString	( mkFastString )
sof's avatar
sof committed
59
import ErrUtils         ( Message )
60
import Util		( sortLt )
61
import Lex
62
import FiniteMap
sof's avatar
sof committed
63
import Outputable
64
import Bag
65
66

import List	( nub )
67
68
\end{code}

69

70
71
72
73
74
%*********************************************************
%*							*
\subsection{Loading a new interface file}
%*							*
%*********************************************************
75

76
\begin{code}
77
loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
78
loadHomeInterface doc_str name
79
  = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
80
81
82
83

loadOrphanModules :: [ModuleName] -> RnM d ()
loadOrphanModules mods
  | null mods = returnRn ()
84
85
86
  | otherwise = traceRn (text "Loading orphan modules:" <+> 
			 fsep (map pprModuleName mods))		`thenRn_` 
		mapRn_ load mods				`thenRn_`
87
88
		returnRn ()
  where
89
90
91
    load mod   = loadInterface (mk_doc mod) mod ImportBySystem
    mk_doc mod = pprModuleName mod <+> ptext SLIT("is a orphan-instance module")
	   
92

93
94
95
96
97
98
99
100
101
102
103
104
loadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d Ifaces
loadInterface doc mod from 
  = tryLoadInterface doc mod from	`thenRn` \ (ifaces, maybe_err) ->
    case maybe_err of
	Nothing  -> returnRn ifaces
	Just err -> failWithRn ifaces err

tryLoadInterface :: SDoc -> ModuleName -> WhereFrom -> RnM d (Ifaces, Maybe Message)
	-- Returns (Just err) if an error happened
	-- Guarantees to return with iImpModInfo m --> (... Just cts)
	-- (If the load fails, we plug in a vanilla placeholder
tryLoadInterface doc_str mod_name from
105
 = getIfacesRn 			`thenRn` \ ifaces ->
sof's avatar
sof committed
106
   let
107
108
109
	mod_map  = iImpModInfo ifaces
	mod_info = lookupFM mod_map mod_name

110
111
112
113
114
115
116
117
118
119
120
	hi_boot_file 
	  = case (from, mod_info) of
		(ImportByUser,       _)    	       -> False 	-- Not hi-boot
		(ImportByUserSource, _)		       -> True 		-- hi-boot
		(ImportBySystem, Just (_, is_boot, _)) -> is_boot 	-- 
		(ImportBySystem, Nothing)	       -> False
			-- We're importing a module we know absolutely
			-- nothing about, so we assume it's from
			-- another package, where we aren't doing 
			-- dependency tracking. So it won't be a hi-boot file.

121
122
	redundant_source_import 
	  = case (from, mod_info) of 
123
		(ImportByUserSource, Just (_,False,_)) -> True
124
		other				       -> False
125
   in
126
	-- CHECK WHETHER WE HAVE IT ALREADY
127
   case mod_info of {
128
	Just (_, _, True)
129
		-> 	-- We're read it already so don't re-read it
130
		    returnRn (ifaces, Nothing) ;
131

132
133
134
135
136
137
138
	_ ->

	-- Issue a warning for a redundant {- SOURCE -} import
	-- NB that we arrange to read all the ordinary imports before 
	-- any of the {- SOURCE -} imports
   warnCheckRn	(not redundant_source_import)
		(warnRedundantSourceImport mod_name)	`thenRn_`
139
140

	-- READ THE MODULE IN
141
   findAndReadIface doc_str mod_name hi_boot_file   `thenRn` \ read_resultb ->
sof's avatar
sof committed
142
   case read_result of {
143
	Left err -> 	-- Not found, so add an empty export env to the Ifaces map
144
			-- so that we don't look again
145
	   let
146
		new_mod_map = addToFM mod_map mod_name (False, False, True)
147
148
149
		new_ifaces  = ifaces { iImpModInfo = new_mod_map }
	   in
	   setIfacesRn new_ifaces		`thenRn_`
150
	   returnRn (new_ifaces, Just err) ;
151
152

	-- Found and parsed!
153
	Right (mod, iface) ->
154
155

	-- LOAD IT INTO Ifaces
156

sof's avatar
sof committed
157
158
159
160
	-- NB: *first* we do loadDecl, so that the provenance of all the locally-defined
	---    names is done correctly (notably, whether this is an .hi file or .hi-boot file).
	--     If we do loadExport first the wrong info gets into the cache (unless we
	-- 	explicitly tag each export which seems a bit of a bore)
161

162

163
164
165
166
167
168
	-- Sanity check.  If we're system-importing a module we know nothing at all
	-- about, it should be from a different package to this one
    WARN( not (maybeToBool mod_info) && 
	  case from of { ImportBySystem -> True; other -> False } &&
	  isLocalModule mod,
	  ppr mod )
169
170
171
172
173

    loadDecls mod		(iDecls ifaces)	  (pi_decls iface)	`thenRn` \ (decls_vers, new_decls) ->
    loadRules mod		(iRules ifaces)   (pi_rules iface)	`thenRn` \ (rule_vers, new_rules) ->
    loadFixDecls mod_name	 		  (pi_fixity iface)	`thenRn` \ (fix_vers, fix_env) ->
    foldlRn (loadDeprec mod)	emptyDeprecEnv	  (pi_deprecs iface)	`thenRn` \ deprec_env ->
174
    foldlRn (loadInstDecl mod)	(iInsts ifaces)   (pi_insts iface)	`thenRn` \ new_insts ->
175
    loadExports 			 	  (pi_exports iface)	`thenRn` \ avails ->
176
    let
177
178
179
180
181
	version	= VersionInfo { modVers  = pi_vers iface, 
				fixVers  = fix_vers,
				ruleVers = rule_vers,
				declVers = decl_vers }

182
183
184
185
	-- For an explicit user import, add to mod_map info about
	-- the things the imported module depends on, extracted
	-- from its usage info.
	mod_map1 = case from of
186
			ImportByUser -> addModDeps mod (pi_usages iface) mod_map
187
			other        -> mod_map
188
	mod_map2 = addToFM mod_map1 mod_name (pi_orphan iface, hi_boot_file, True)
189

190
191
192
193
194
	-- Now add info about this module to the PST
	new_pst     = extendModuleEnv pst mod mod_detils
 	mod_details = ModDetails { mdModule = mod, mvVersion = version,
				   mdExports = avails,
				   mdFixEnv = fix_env, mdDeprecEnv = deprec_env }
195

196
	new_ifaces = ifaces { iPST	  = new_pst,
197
			      iDecls      = new_decls,
198
			      iInsts      = new_insts,
199
			      iRules	  = new_rules,
200
			      iImpModInfo = mod_map2  }
201
    in
202
    setIfacesRn new_ifaces		`thenRn_`
203
    returnRn (new_ifaces, Nothing)
sof's avatar
sof committed
204
205
    }}

206
207
208
209
210
-----------------------------------------------------
--	Adding module dependencies from the 
--	import decls in the interface file
-----------------------------------------------------

211
addModDeps :: Module -> PackageSymbolTable -> [ImportVersion a] 
212
213
214
215
216
	   -> ImportedModuleInfo -> ImportedModuleInfo
-- (addModDeps M ivs deps)
-- We are importing module M, and M.hi contains 'import' decls given by ivs
addModDeps mod new_deps mod_deps
  = foldr add mod_deps filtered_new_deps
217
  where
218
219
220
	-- Don't record dependencies when importing a module from another package
	-- Except for its descendents which contain orphans,
	-- and in that case, forget about the boot indicator
221
    filtered_new_deps :: (ModuleName, (WhetherHasOrphans, IsBootInterface))
222
    filtered_new_deps
223
	| isLocalModule mod = [ (imp_mod, (has_orphans, is_boot, False))
224
			      | (imp_mod, has_orphans, is_boot, _) <- new_deps 
225
			      ]			      
226
	| otherwise	    = [ (imp_mod, (True, False, False))
227
			      | (imp_mod, has_orphans, _, _) <- new_deps, 
228
229
230
				has_orphans
			      ]
    add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
231

232
233
    combine old@(_, old_is_boot, old_is_loaded) new
	| old_is_loaded || not old_is_boot = old	-- Keep the old info if it's already loaded
234
							-- or if it's a non-boot pending load
235
	| otherwise			    = new	-- Otherwise pick new info
236

237
238
239
240
241

-----------------------------------------------------
--	Loading the export list
-----------------------------------------------------

242
243
244
245
246
247
248
loadExports :: [ExportItem] -> RnM d Avails
loadExports items
  = getModuleRn 				`thenRn` \ this_mod ->
    mapRn (loadExport this_mod) items		`thenRn` \ avails_s ->
    returnRn (concat avails_s)


249
loadExport :: Module -> ExportItem -> RnM d [AvailInfo]
250
loadExport this_mod (mod, entities)
251
  | mod == moduleName this_mod = returnRn []
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
	-- If the module exports anything defined in this module, just ignore it.
	-- Reason: otherwise it looks as if there are two local definition sites
	-- for the thing, and an error gets reported.  Easiest thing is just to
	-- filter them out up front. This situation only arises if a module
	-- imports itself, or another module that imported it.  (Necessarily,
	-- this invoves a loop.)  Consequence: if you say
	--	module A where
	--	   import B( AType )
	--	   type AType = ...
	--
	--	module B( AType ) where
	--	   import {-# SOURCE #-} A( AType )
	--
	-- then you'll get a 'B does not export AType' message.  A bit bogus
	-- but it's a bogus thing to do!

  | otherwise
269
  = mapRn (load_entity mod) entities
270
  where
271
    new_name mod occ = newGlobalName mod occ
272

sof's avatar
sof committed
273
274
    load_entity mod (Avail occ)
      =	new_name mod occ	`thenRn` \ name ->
sof's avatar
sof committed
275
	returnRn (Avail name)
sof's avatar
sof committed
276
277
278
    load_entity mod (AvailTC occ occs)
      =	new_name mod occ	      `thenRn` \ name ->
        mapRn (new_name mod) occs     `thenRn` \ names ->
sof's avatar
sof committed
279
        returnRn (AvailTC name names)
280

281

282
283
284
-----------------------------------------------------
--	Loading type/class/value decls
-----------------------------------------------------
285

286
287
288
289
290
291
292
loadDecls :: Module 
	  -> DeclsMap
	  -> [(Version, RdrNameHsDecl)]
	  -> RnM d (NameEnv Version, DeclsMap)
loadDecls mod decls_map decls
  = foldlRn (loadDecl mod) (emptyNameEnv, decls_map) decls

293
loadDecl :: Module 
294
	 -> (NameEnv Version, DeclsMap)
295
	 -> (Version, RdrNameHsDecl)
296
297
	 -> RnM d (NameEnv Version, DeclsMap)
loadDecl mod (version_map, decls_map) (version, decl)
298
299
  = getDeclBinders new_name decl	`thenRn` \ maybe_avail ->
    case maybe_avail of {
300
301
	Nothing    -> returnRn (version_map, decls_map);	-- No bindings
	Just avail -> 
302

303
304
    getDeclSysBinders new_name decl	`thenRn` \ sys_bndrs ->
    let
305
306
307
308
309
	full_avail    = addSysAvails avail sys_bndrs
		-- Add the sys-binders to avail.  When we import the decl,
		-- it's full_avail that will get added to the 'already-slurped' set (iSlurp)
		-- If we miss out sys-binders, we'll read the decl multiple times!

310
311
	main_name     = availName avail
	new_decls_map = foldl add_decl decls_map
312
				       [ (name, (full_avail, name==main_name, (mod, decl'))) 
313
				       | name <- availNames full_avail]
314
	add_decl decls_map (name, stuff)
315
	  = WARN( name `elemNameEnv` decls_map, ppr name )
316
	    extendNameEnv decls_map name stuff
317
318

	new_version_map = extendNameEnv version_map main_name version
319
    in
320
    returnRn (new_version_map, new_decls_map)
321
    }
322
  where
323
	-- newTopBinder puts into the cache the binder with the
324
325
	-- module information set correctly.  When the decl is later renamed,
	-- the binding site will thereby get the correct module.
326
327
328
	-- There maybe occurrences that don't have the correct Module, but
	-- by the typechecker will propagate the binding definition to all 
	-- the occurrences, so that doesn't matter
329
    new_name rdr_name loc = newTopBinder mod rdr_name loc
330

sof's avatar
sof committed
331
    {-
332
333
      If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
      we toss away unfolding information.
sof's avatar
sof committed
334
335
336
337
338

      Also, if the signature is loaded from a module we're importing from source,
      we do the same. This is to avoid situations when compiling a pair of mutually
      recursive modules, peering at unfolding info in the interface file of the other, 
      e.g., you compile A, it looks at B's interface file and may as a result change
339
340
      its interface file. Hence, B is recompiled, maybe changing its interface file,
      which will the unfolding info used in A to become invalid. Simple way out is to
sof's avatar
sof committed
341
      just ignore unfolding info.
342
343
344
345

      [Jan 99: I junked the second test above.  If we're importing from an hi-boot
       file there isn't going to *be* any pragma info.  Maybe the above comment
       dates from a time where we picked up a .hi file first if it existed?]
sof's avatar
sof committed
346
    -}
347
    decl' = case decl of
348
349
350
	       SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
			 ->  SigD (IfaceSig name tp [] loc)
	       other	 -> decl
sof's avatar
sof committed
351

352
353
354
355
-----------------------------------------------------
--	Loading fixity decls
-----------------------------------------------------

356
357
loadFixDecls mod_name (version, decls)
  | null decls = returnRn (version, emptyNameEnv)
358
359
360

  | otherwise
  = mapRn (loadFixDecl mod_name) decls	`thenRn` \ to_add ->
361
    returnRn (version, mkNameEnv to_add)
362
363

loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
364
  = newGlobalName mod_name (rdrNameOcc rdr_name) 	`thenRn` \ name ->
365
366
367
368
369
370
371
    returnRn (name, FixitySig name fixity loc)


-----------------------------------------------------
--	Loading instance decls
-----------------------------------------------------

372
loadInstDecl :: Module
373
	     -> IfaceInsts
374
	     -> RdrNameInstDecl
375
	     -> RnM d IfaceInsts
376
loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
377
378
379
380
381
382
383
384
  = 
	-- Find out what type constructors and classes are "gates" for the
	-- instance declaration.  If all these "gates" are slurped in then
	-- we should slurp the instance decl too.
	-- 
	-- We *don't* want to count names in the context part as gates, though.
	-- For example:
	--		instance Foo a => Baz (T a) where ...
385
	--
386
387
	-- Here the gates are Baz and T, but *not* Foo.
    let 
388
389
	munged_inst_ty = removeContext inst_ty
	free_names     = extractHsTyRdrNames munged_inst_ty
390
    in
391
392
    setModuleRn mod $
    mapRn lookupOrigName free_names	`thenRn` \ gate_names ->
393
394
    returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)

395
396
397
398
399
400
401
402

-- In interface files, the instance decls now look like
--	forall a. Foo a -> Baz (T a)
-- so we have to strip off function argument types as well
-- as the bit before the '=>' (which is always empty in interface files)
removeContext (HsForAllTy tvs cxt ty) = HsForAllTy tvs [] (removeFuns ty)
removeContext ty		      = removeFuns ty

403
removeFuns (HsFunTy _ ty) = removeFuns ty
404
405
406
removeFuns ty		    = ty


407
408
409
410
411
412
-----------------------------------------------------
--	Loading Rules
-----------------------------------------------------

loadRules :: Module -> IfaceRules 
	  -> (Version, [RdrNameRuleDecl])
413
	  -> RnM d (Version, IfaceRules)
414
415
loadRules mod rule_bag (version, rules)
  | null rules || opt_IgnoreIfacePragmas 
416
  = returnRn (version, rule_bag)
417
  | otherwise
418
  = setModuleRn mod		 	$
419
    mapRn (loadRule mod) rules		`thenRn` \ new_rules ->
420
    returnRn (version, rule_bag `unionBags` listToBag new_rules)
421
422

loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
423
424
-- "Gate" the rule simply by whether the rule variable is
-- needed.  We can refine this later.
425
loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
426
  = lookupOrigName var		`thenRn` \ var_name ->
427
428
429
430
431
432
433
434
435
    returnRn (unitNameSet var_name, (mod, RuleD decl))

loadBuiltinRules :: [(RdrName, CoreRule)] -> RnMG ()
loadBuiltinRules builtin_rules
  = getIfacesRn				`thenRn` \ ifaces ->
    mapRn loadBuiltinRule builtin_rules	`thenRn` \ rule_decls ->
    setIfacesRn (ifaces { iRules = iRules ifaces `unionBags` listToBag rule_decls })

loadBuiltinRule (var, rule)
436
  = lookupOrigName var		`thenRn` \ var_name ->
437
438
439
440
441
442
    returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))


-----------------------------------------------------
--	Loading Deprecations
-----------------------------------------------------
443
444

loadDeprec :: Module -> DeprecationEnv -> RdrNameDeprecation -> RnM d DeprecationEnv
445
loadDeprec mod deprec_env (Deprecation (IEModuleContents _) txt _)
446
  = traceRn (text "module deprecation not yet implemented:" <+> ppr mod <> colon <+> ppr txt) `thenRn_`
447
	-- SUP: TEMPORARY HACK, ignoring module deprecations for now
448
    returnRn deprec_env
449
450

loadDeprec mod deprec_env (Deprecation ie txt _)
451
452
  = setModuleRn mod					$
    mapRn lookupOrigName (ieNames ie)		`thenRn` \ names ->
453
    traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
454
    returnRn (extendNameEnvList deprec_env (zip names (repeat txt)))
455
\end{code}
456

457

458
459
%********************************************************
%*							*
460
\subsection{Checking usage information}
461
462
463
464
%*							*
%********************************************************

\begin{code}
465
466
467
upToDate  = True
outOfDate = False

468
469
470
471
checkModUsage :: [ImportVersion OccName] -> RnMG Bool
-- Given the usage information extracted from the old
-- M.hi file for the module being compiled, figure out
-- whether M needs to be recompiled.
472

473
checkModUsage [] = returnRn upToDate		-- Yes!  Everything is up to date!
474

475
checkModUsage ((mod_name, _, _, NothingAtAll) : rest)
476
477
478
479
480
481
482
483
	-- If CurrentModule.hi contains 
	--	import Foo :: ;
	-- then that simply records that Foo lies below CurrentModule in the
	-- hierarchy, but CurrentModule doesn't depend in any way on Foo.
	-- In this case we don't even want to open Foo's interface.
  = traceRn (ptext SLIT("Nothing used from:") <+> ppr mod_name)	`thenRn_`
    checkModUsage rest	-- This one's ok, so check the rest

484
checkModUsage ((mod_name, _, _, whats_imported)  : rest)
485
486
  = tryLoadInterface doc_str mod_name ImportBySystem	`thenRn` \ (ifaces, maybe_err) ->
    case maybe_err of {
487
488
	Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"), 
				      pprModuleName mod_name]) ;
489
490
491
		-- Couldn't find or parse a module mentioned in the
		-- old interface file.  Don't complain -- it might just be that
		-- the current module doesn't need that import and it's been deleted
492

493
	Nothing -> 
494
    let
495
496
497
498
499
500
501
502
	(_, new_mod_vers, new_fix_vers, new_rule_vers, _, _) 
		= case lookupFM (iImpModInfo ifaces) mod_name of
			   Just (_, _, Just stuff) -> stuff

        old_mod_vers = case whats_imported of
			 Everything v 	     -> v
			 Specifically v _ _ _ -> v
			 -- NothingAtAll case dealt with by previous eqn for checkModUsage
503
    in
504
505
	-- If the module version hasn't changed, just move on
    if new_mod_vers == old_mod_vers then
506
507
	traceRn (sep [ptext SLIT("Module version unchanged:"), pprModuleName mod_name])
	`thenRn_` checkModUsage rest
508
    else
509
510
    traceRn (sep [ptext SLIT("Module version has changed:"), pprModuleName mod_name])
    `thenRn_`
511
512
513
514
515
	-- Module version changed, so check entities inside

	-- If the usage info wants to say "I imported everything from this module"
	--     it does so by making whats_imported equal to Everything
	-- In that case, we must recompile
516
517
518
519
    case whats_imported of {	-- NothingAtAll dealt with earlier
	
      Everything _ 
	-> out_of_date (ptext SLIT("...and I needed the whole module")) ;
520

521
      Specifically _ old_fix_vers old_rule_vers old_local_vers ->
522

523
524
525
526
527
    if old_fix_vers /= new_fix_vers then
	out_of_date (ptext SLIT("Fixities changed"))
    else if old_rule_vers /= new_rule_vers then
	out_of_date (ptext SLIT("Rules changed"))
    else	
528
	-- Non-empty usage list, so check item by item
529
    checkEntityUsage mod_name (iDecls ifaces) old_local_vers	`thenRn` \ up_to_date ->
530
    if up_to_date then
sof's avatar
sof committed
531
	traceRn (ptext SLIT("...but the bits I use haven't."))	`thenRn_`
532
533
	checkModUsage rest	-- This one's ok, so check the rest
    else
534
	returnRn outOfDate	-- This one failed, so just bail out now
535
    }}
536
  where
537
    doc_str = sep [ptext SLIT("need version info for"), pprModuleName mod_name]
538
539


540
checkEntityUsage mod decls [] 
541
  = returnRn upToDate	-- Yes!  All up to date!
542

543
checkEntityUsage mod decls ((occ_name,old_vers) : rest)
544
  = newGlobalName mod occ_name 	`thenRn` \ name ->
545
    case lookupNameEnv decls name of
546
547

	Nothing       -> 	-- We used it before, but it ain't there now
548
			  out_of_date (sep [ptext SLIT("No longer exported:"), ppr name])
549

550
	Just (new_vers,_,_,_) 	-- It's there, but is it up to date?
551
552
553
554
555
556
		| new_vers == old_vers
			-- Up to date, so check the rest
		-> checkEntityUsage mod decls rest

		| otherwise
			-- Out of date, so bale out
557
558
559
		-> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])

out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
560
561
562
\end{code}


563
564
565
566
567
%*********************************************************
%*							*
\subsection{Getting in a declaration}
%*							*
%*********************************************************
568

569
\begin{code}
570
571
572
573
574
575
576
importDecl :: Name -> RnMG ImportDeclResult

data ImportDeclResult
  = AlreadySlurped
  | WiredIn	
  | Deferred
  | HereItIs (Module, RdrNameHsDecl)
577
578

importDecl name
579
580
581
582
583
584
585
  = getIfacesRn				`thenRn` \ ifaces ->
    getHomeSymbolTableRn		`thenRn` \ hst ->
    if name `elemNameSet` iSlurp ifaces
    || inTypeEnv (iPST ifaces) name
    || inTypeEnv hst	       name
    then	-- Already dealt with
	returnRn AlreadySlurped	
586
587

    else if isLocallyDefined name then	-- Don't bring in decls from
588
					-- the renamed module's own interface file
589
590
	addWarnRn (importDeclWarn name) `thenRn_`
	returnRn AlreadySlurped
591

592
593
594
595
596
597
598
599
600
601
602
    else if isWiredInName name then
	-- When we find a wired-in name we must load its
	-- home module so that we find any instance decls therein
	loadHomeInterface doc name	`thenRn_`
	returnRn WiredIn

    else getNonWiredInDecl name
  where
    doc = ptext SLIT("need home module for wired in thing") <+> ppr name

getNonWiredInDecl :: Name -> RnMG ImportDeclResult
603
getNonWiredInDecl needed_name 
604
  = traceRn doc_str				`thenRn_`
605
    loadHomeInterface doc_str needed_name	`thenRn` \ ifaces ->
606
    case lookupNameEnv (iDecls ifaces) needed_name of
sof's avatar
sof committed
607

608
      Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _ _)))
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
	-- This case deals with deferred import of algebraic data types

	|  not opt_NoPruneTyDecls

	&& (opt_IgnoreIfacePragmas || ncons > 1)
		-- We only defer if imported interface pragmas are ingored
		-- or if it's not a product type.
		-- Sole reason: The wrapper for a strict function may need to look
		-- inside its arg, and hence need to see its arg type's constructors.

	&& not (getUnique tycon_name `elem` cCallishTyKeys)
		-- Never defer ccall types; we have to unbox them, 
		-- and importing them does no harm

	-> 	-- OK, so we're importing a deferrable data type
	    if needed_name == tycon_name then	
		-- The needed_name is the TyCon of a data type decl
		-- Record that it's slurped, put it in the deferred set
		-- and don't return a declaration at all
		setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces 
							      `addOneToNameSet` tycon_name})
				    	 version (AvailTC needed_name [needed_name]))	`thenRn_`
		returnRn Deferred
	    else
	 	-- The needed name is a constructor of a data type decl,
		-- getting a constructor, so remove the TyCon from the deferred set
		-- (if it's there) and return the full declaration
		 setIfacesRn (recordSlurp (ifaces {iDeferred = iDeferred ifaces 
							       `delFromNameSet` tycon_name})
				    version avail)	`thenRn_`
		 returnRn (HereItIs decl)
	where
	   tycon_name = availName avail

643
      Just (version,avail,_,decl)
644
645
	-> setIfacesRn (recordSlurp ifaces version avail)	`thenRn_`
	   returnRn (HereItIs decl)
646

647
      Nothing 
648
	-> addErrRn (getDeclErr needed_name)	`thenRn_` 
649
	   returnRn AlreadySlurped
650
  where
651
     doc_str = ptext SLIT("need decl for") <+> ppr needed_name
652
653
654
655
656
657
658
659
660
661
662
663

getDeferredDecls :: RnMG [(Module, RdrNameHsDecl)]
getDeferredDecls 
  = getIfacesRn		`thenRn` \ ifaces ->
    let
	decls_map   	    = iDecls ifaces
	deferred_names	    = nameSetToList (iDeferred ifaces)
        get_abstract_decl n = case lookupNameEnv decls_map n of
				 Just (_, _, _, decl) -> decl
    in
    traceRn (sep [text "getDeferredDecls", nest 4 (fsep (map ppr deferred_names))])	`thenRn_`
    returnRn (map get_abstract_decl deferred_names)
664
665
\end{code}

666
667
668
@getWiredInDecl@ maps a wired-in @Name@ to what it makes available.
It behaves exactly as if the wired in decl were actually in an interface file.
Specifically,
669
670
\begin{itemize}
\item	if the wired-in name is a data type constructor or a data constructor, 
671
	it brings in the type constructor and all the data constructors; and
672
	marks as ``occurrences'' any free vars of the data con.
673

674
\item 	similarly for synonum type constructor
675

676
\item 	if the wired-in name is another wired-in Id, it marks as ``occurrences''
677
	the free vars of the Id's type.
678

679
\item	it loads the interface file for the wired-in thing for the
680
	sole purpose of making sure that its instance declarations are available
681
682
\end{itemize}
All this is necessary so that we know all types that are ``in play'', so
683
684
that we know just what instances to bring into scope.
	
685
686


687
    
688
689
%*********************************************************
%*							*
sof's avatar
sof committed
690
\subsection{Getting what a module exports}
691
692
%*							*
%*********************************************************
693

694
@getInterfaceExports@ is called only for directly-imported modules.
695

696
\begin{code}
697
698
getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
getInterfaceExports mod_name from
699
  = loadInterface doc_str mod_name from	`thenRn` \ ifaces ->
700
    case lookupFM (iImpModInfo ifaces) mod_name of
701
	Just (_, _, Just (mod, _, _, _, _, avails)) -> returnRn (mod, avails)
702
703
	-- loadInterface always puts something in the map
	-- even if it's a fake
704
  where
705
    doc_str = sep [pprModuleName mod_name, ptext SLIT("is directly imported")]
sof's avatar
sof committed
706
707
708
709
710
\end{code}


%*********************************************************
%*							*
711
\subsection{Instance declarations are handled specially}
sof's avatar
sof committed
712
713
714
715
%*							*
%*********************************************************

\begin{code}
716
717
getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
getImportedInstDecls gates
718
  =    	-- First, load any orphan-instance modules that aren't aready loaded
719
	-- Orphan-instance modules are recorded in the module dependecnies
720
    getIfacesRn 					`thenRn` \ ifaces ->
sof's avatar
sof committed
721
    let
722
	orphan_mods =
723
	  [mod | (mod, (True, _, Nothing)) <- fmToList (iImpModInfo ifaces)]
sof's avatar
sof committed
724
    in
725
    loadOrphanModules orphan_mods			`thenRn_` 
726

727
	-- Now we're ready to grab the instance declarations
728
729
	-- Find the un-gated ones and return them, 
	-- removing them from the bag kept in Ifaces
730
    getIfacesRn 					`thenRn` \ ifaces ->
731
    let
732
733
734
	(decls, new_insts) = selectGated gates (iInsts ifaces)
    in
    setIfacesRn (ifaces { iInsts = new_insts })		`thenRn_`
735

736
    traceRn (sep [text "getImportedInstDecls:", 
737
		  nest 4 (fsep (map ppr gate_list)),
738
739
		  text "Slurped" <+> int (length decls) <+> text "instance declarations",
		  nest 4 (vcat (map ppr_brief_inst_decl decls))])	`thenRn_`
740
741
    returnRn decls
  where
742
743
    gate_list      = nameSetToList gates

744
745
746
747
748
ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
  = case inst_ty of
	HsForAllTy _ _ tau -> ppr tau
	other		   -> ppr inst_ty

749
getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
750
751
752
getImportedRules 
  | opt_IgnoreIfacePragmas = returnRn []
  | otherwise
753
754
755
  = getIfacesRn 	`thenRn` \ ifaces ->
    let
	gates		   = iSlurp ifaces	-- Anything at all that's been slurped
756
757
	rules		   = iRules ifaces
	(decls, new_rules) = selectGated gates rules
758
    in
759
760
761
762
    if null decls then
	returnRn []
    else
    setIfacesRn (ifaces { iRules = new_rules })		     `thenRn_`
763
    traceRn (sep [text "getImportedRules:", 
764
		  text "Slurped" <+> int (length decls) <+> text "rules"])   `thenRn_`
765
    returnRn decls
766

767
selectGated gates decl_bag
768
	-- Select only those decls whose gates are *all* in 'gates'
769
770
771
#ifdef DEBUG
  | opt_NoPruneDecls	-- Just to try the effect of not gating at all
  = (foldrBag (\ (_,d) ds -> d:ds) [] decl_bag, emptyBag)	-- Grab them all
772

773
774
775
  | otherwise
#endif
  = foldrBag select ([], emptyBag) decl_bag
776
  where
777
778
779
780
    select (reqd, decl) (yes, no)
	| isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
	| otherwise				     = (yes,      (reqd,decl) `consBag` no)

781
782
lookupFixityRn :: Name -> RnMS Fixity
lookupFixityRn name
783
784
  | isLocallyDefined name
  = getFixityEnv			`thenRn` \ local_fix_env ->
785
    returnRn (lookupLocalFixity local_fix_env name)
786
787

  | otherwise	-- Imported
788
789
790
791
792
793
794
      -- For imported names, we have to get their fixities by doing a loadHomeInterface,
      -- and consulting the Ifaces that comes back from that, because the interface
      -- file for the Name might not have been loaded yet.  Why not?  Suppose you import module A,
      -- which exports a function 'f', which is defined in module B.  Then B isn't loaded
      -- right away (after all, it's possible that nothing from B will be used).
      -- When we come across a use of 'f', we need to know its fixity, and it's then,
      -- and only then, that we load B.hi.  That is what's happening here.
795
  = loadHomeInterface doc name		`thenRn` \ ifaces ->
796
797
798
799
    getHomeSymbolTableRn 		`thenRn` \ hst ->
    returnRn (lookupFixityEnv hst name		   `orElse`
	      lookupFixityEnv (iPST ifaces) name)  `orElse`
	      defaultFixity)
800
  where
801
    doc = ptext SLIT("Checking fixity for") <+> ppr name
802
803
\end{code}

sof's avatar
sof committed
804
805
806
807
808
809
810

%*********************************************************
%*							*
\subsection{Keeping track of what we've slurped, and version numbers}
%*							*
%*********************************************************

811
812
813
814
getImportVersions figures out what the ``usage information'' for this
moudule is; that is, what it must record in its interface file as the
things it uses.  It records:

815
\begin{itemize}
816
817
818
\item	(a) anything reachable from its body code
\item	(b) any module exported with a @module Foo@
\item   (c) anything reachable from an exported item
819
\end{itemize}
820
821

Why (b)?  Because if @Foo@ changes then this module's export list
822
823
824
825
will change, so we must recompile this module at least as far as
making a new interface file --- but in practice that means complete
recompilation.

826
Why (c)?  Consider this:
827
828
829
830
831
\begin{verbatim}
	module A( f, g ) where	|	module B( f ) where
	  import B( f )		|	  f = h 3
	  g = ...		|	  h = ...
\end{verbatim}
832

833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
Here, @B.f@ isn't used in A.  Should we nevertheless record @B.f@ in
@A@'s usages?  Our idea is that we aren't going to touch A.hi if it is
*identical* to what it was before.  If anything about @B.f@ changes
than anyone who imports @A@ should be recompiled in case they use
@B.f@ (they'll get an early exit if they don't).  So, if anything
about @B.f@ changes we'd better make sure that something in A.hi
changes, and the convenient way to do that is to record the version
number @B.f@ in A.hi in the usage list.  If B.f changes that'll force a
complete recompiation of A, which is overkill but it's the only way to 
write a new, slightly different, A.hi.

But the example is tricker.  Even if @B.f@ doesn't change at all,
@B.h@ may do so, and this change may not be reflected in @f@'s version
number.  But with -O, a module that imports A must be recompiled if
@B.h@ changes!  So A must record a dependency on @B.h@.  So we treat
the occurrence of @B.f@ in the export list *just as if* it were in the
code of A, and thereby haul in all the stuff reachable from it.

[NB: If B was compiled with -O, but A isn't, we should really *still*
haul in all the unfoldings for B, in case the module that imports A *is*
compiled with -O.  I think this is the case.]

Even if B is used at all we get a usage line for B
	import B <n> :: ... ;
857
858
859
860
in A.hi, to record the fact that A does import B.  This is used to decide
to look to look for B.hi rather than B.hi-boot when compiling a module that
imports A.  This line says that A imports B, but uses nothing in it.
So we'll get an early bale-out when compiling A if B's version changes.
861

862
\begin{code}
863
864
865
866
867
868
869
870
871
mkImportExportInfo :: ModuleName			-- Name of this module
		   -> Avails				-- Info about exports 
		   -> Maybe [RdrNameIE]			-- The export header
		   -> RnMG ([ExportItem], 		-- Export info for iface file; sorted
			    [ImportVersion OccName])	-- Import info for iface file; sorted
			-- Both results are sorted into canonical order to
			-- reduce needless wobbling of interface files

mkImportExportInfo this_mod export_avails exports
872
873
  = getIfacesRn					`thenRn` \ ifaces ->
    let
874
875
876
877
878
	export_all_mods = case exports of
				Nothing -> []
				Just es -> [mod | IEModuleContents mod <- es, 
						  mod /= this_mod]

879
880
	mod_map   = iImpModInfo ifaces
	imp_names = iVSlurp     ifaces
881

882
	-- mv_map groups together all the things imported from a particular module.
883
	mv_map :: FiniteMap ModuleName [(OccName,Version)]
884
	mv_map = foldr add_mv emptyFM imp_names
885

886
887
888
        add_mv (name, version) mv_map = addItem mv_map (moduleName (nameModule name)) 
						       (nameOccName name, version)

889
	-- Build the result list by adding info for each module.
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
	-- For (a) a library module, we don't record it at all unless it contains orphans
	-- 	   (We must never lose track of orphans.)
	-- 
	--     (b) a source-imported module, don't record the dependency at all
	--	
	-- (b) may seem a bit strange.  The idea is that the usages in a .hi file records
	-- *all* the module's dependencies other than the loop-breakers.  We use
	-- this info in findAndReadInterface to decide whether to look for a .hi file or
	-- a .hi-boot file.  
	--
	-- This means we won't track version changes, or orphans, from .hi-boot files.
	-- The former is potentially rather bad news.  It could be fixed by recording
	-- whether something is a boot file along with the usage info for it, but 
	-- I can't be bothered just now.

905
	mk_imp_info mod_name (has_orphans, is_boot, contents) so_far
906
907
908
909
910
911
912
	   | mod_name == this_mod	-- Check if M appears in the set of modules 'below' M
					-- This seems like a convenient place to check
	   = WARN( not is_boot, ptext SLIT("Wierd:") <+> ppr this_mod <+> 
			        ptext SLIT("imports itself (perhaps indirectly)") )
	     so_far
 
	   | otherwise
913
	   = let
914
		go_for_it exports = (mod_name, has_orphans, is_boot, exports) 
915
                                    : so_far
916
917
918
919
920
921
922
923
	     in 
	     case contents of
		Nothing -> 	-- We didn't even open the interface
			-- This happens when a module, Foo, that we explicitly imported has 
			-- 'import Baz' in its interface file, recording that Baz is below
			-- Foo in the module dependency hierarchy.  We want to propagate this
			-- information.  The Nothing says that we didn't even open the interface
			-- file but we must still propagate the dependeny info.
924
			-- The module in question must be a local module (in the same package)
925
		   go_for_it NothingAtAll
926

927
		Just (mod, mod_vers, fix_vers, rule_vers, how_imported, _)
928
		   |  is_sys_import && is_lib_module && not has_orphans
929
		   -> so_far		
930
	   
931
932
		   |  is_lib_module 			-- Record the module but not detailed
		   || mod_name `elem` export_all_mods	-- version information for the imports
933
		   -> go_for_it (Everything mod_vers)
934
935
936

		   |  otherwise
		   -> case lookupFM mv_map mod_name of
937
938
939
			Just whats_imported -> go_for_it (Specifically mod_vers fix_vers rule_vers 
								       (sortImport whats_imported))
			Nothing		    -> go_for_it NothingAtAll
940
941
942
943
944
						-- This happens if you have
						--	import Foo
						-- but don't actually *use* anything from Foo
					 	-- In which case record an empty dependency list
		   where
945
946
947
948
		     is_lib_module = not (isLocalModule mod)
		     is_sys_import = case how_imported of
					ImportBySystem -> True
					other	       -> False
949
	     
950
951
952
953
954
955
956
957
958
959
960

	import_info = foldFM mk_imp_info [] mod_map

	-- Sort exports into groups by module
	export_fm :: FiniteMap ModuleName [RdrAvailInfo]
	export_fm = foldr insert emptyFM export_avails

        insert avail efm = addItem efm (moduleName (nameModule (availName avail)))
				       (rdrAvailInfo avail)

	export_info = [(m, sortExport as) | (m,as) <- fmToList export_fm]
sof's avatar
sof committed
961
    in
962
    traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map)))	`thenRn_`
963
    returnRn (export_info, import_info)
964

965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980

addItem :: FiniteMap ModuleName [a] -> ModuleName -> a -> FiniteMap ModuleName [a]
addItem fm mod x = addToFM_C add_item fm mod [x]
		 where
		   add_item xs _ = x:xs

sortImport :: [(OccName,Version)] -> [(OccName,Version)]
	-- Make the usage lists appear in canonical order
sortImport vs = sortLt lt vs
	      where
		lt (n1,v1) (n2,v2) = n1 < n2

sortExport :: [RdrAvailInfo] -> [RdrAvailInfo]
sortExport as = sortLt lt as
	      where
		lt a1 a2 = availName a1 < availName a2
981
\end{code}
982

sof's avatar
sof committed
983
\begin{code}
984
getSlurped
sof's avatar
sof committed
985
  = getIfacesRn 	`thenRn` \ ifaces ->
986
    returnRn (iSlurp ifaces)
sof's avatar
sof committed
987

988
989
990
recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
	    version avail
  = let
sof's avatar
sof committed
991
	new_slurped_names = addAvailToNameSet slurped_names avail
992
993
994
	new_imp_names = (availName avail, version) : imp_names
    in
    ifaces { iSlurp  = new_slurped_names, iVSlurp = new_imp_names }
sof's avatar
sof committed
995

996
997
998
999
recordLocalSlurps local_avails
  = getIfacesRn 	`thenRn` \ ifaces ->
    let
	new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
sof's avatar
sof committed
1000
    in
1001
    setIfacesRn (ifaces { iSlurp  = new_slurped_names })
sof's avatar
sof committed
1002
1003
1004
\end{code}


1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
%*********************************************************
%*							*
\subsection{Getting binders out of a declaration}
%*							*
%*********************************************************

@getDeclBinders@ returns the names for a @RdrNameHsDecl@.
It's used for both source code (from @availsFromDecl@) and interface files
(from @loadDecl@).

1015
1016
It doesn't deal with source-code specific things: @ValD@, @DefD@.  They
are handled by the sourc-code specific stuff in @RnNames@.
1017

1018
\begin{code}
1019
getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name)	-- New-name function
1020
		-> RdrNameHsDecl
1021
		-> RnM d (Maybe AvailInfo)
1022

1023
getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc _ _))
1024
1025
  = new_name tycon src_loc			`thenRn` \ tycon_name ->
    getConFieldNames new_name condecls		`thenRn` \ sub_names ->
1026
    returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
sof's avatar
sof committed
1027
1028
	-- The "nub" is because getConFieldNames can legitimately return duplicates,
	-- when a record declaration has the same field in multiple constructors
1029

1030
getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
1031
  = new_name tycon src_loc		`thenRn` \ tycon_name ->
1032
    returnRn (Just (AvailTC tycon_name [tycon_name]))
1033

1034
getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ src_loc))
1035
  = new_name cname src_loc			`thenRn` \ class_name ->
1036
1037

	-- Record the names for the class ops
sof's avatar
sof committed
1038
    let
sof's avatar
sof committed
1039
1040
	-- just want class-op sigs
	op_sigs = filter isClassOpSig sigs
sof's avatar
sof committed
1041
    in
sof's avatar
sof committed
1042
    mapRn (getClassOpNames new_name) op_sigs	`thenRn` \ sub_names ->
1043

1044
    returnRn (Just (AvailTC class_name (class_name : sub_names)))
1045
1046
1047

getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
  = new_name var src_loc			`thenRn` \ var_name ->
1048
    returnRn (Just (Avail var_name))
1049

1050
1051
getDeclBinders new_name (FixD _)    = returnRn Nothing
getDeclBinders new_name (DeprecD _) = returnRn Nothing
sof's avatar
sof committed
1052
1053
1054
1055
1056
1057
1058

    -- foreign declarations
getDeclBinders new_name (ForD (ForeignDecl nm kind _ dyn _ loc))
  | binds_haskell_name kind dyn
  = new_name nm loc		    `thenRn` \ name ->
    returnRn (Just (Avail name))

1059
1060
  | otherwise 		-- a foreign export
  = lookupOrigName nm `thenRn_` 
sof's avatar
sof committed
1061
1062
    returnRn Nothing

1063
1064
getDeclBinders new_name (DefD _)  = returnRn Nothing
getDeclBinders new_name (InstD _) = returnRn Nothing
1065
getDeclBinders new_name (RuleD _) = returnRn Nothing
1066

sof's avatar
sof committed
1067
1068
binds_haskell_name (FoImport _) _   = True
binds_haskell_name FoLabel      _   = True
1069
binds_haskell_name FoExport  ext_nm = isDynamicExtName ext_nm
sof's avatar
sof committed
1070

1071
----------------
1072
getConFieldNames new_name (ConDecl con _ _ _ (RecCon fielddecls) src_loc : rest)
1073
1074
1075
  = mapRn (\n -> new_name n src_loc) (con:fields)	`thenRn` \ cfs ->
    getConFieldNames new_name rest			`thenRn` \ ns  -> 
    returnRn (cfs ++ ns)
1076
  where
1077
1078
    fields = concat (map fst fielddecls)

1079
getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)