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

\begin{code}
7
8
9
module RnIfaces
#if 0
       (
10
 	findAndReadIface, 
11
12

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

18
	checkModUsage, outOfDate, upToDate,
19

20
21
	getDeclBinders, getDeclSysBinders,
	removeContext	 	-- removeContext probably belongs somewhere else
22
       )
23
#endif
24
where
25

26
#include "HsVersions.h"
27

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

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

import List	( nub )
72
73
74

#if 1
import Panic ( panic )
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
lookupFixityRn      = panic "lookupFixityRn"
findAndReadIface    = panic "findAndReadIface"
getInterfaceExports = panic "getInterfaceExports"
getDeclBinders      = panic "getDeclBinders"
recordLocalSlurps   = panic "recordLocalSlurps"
checkModUsage       = panic "checkModUsage"
outOfDate           = panic "outOfDate"
getSlurped          = panic "getSlurped"
removeContext       = panic "removeContext"
loadBuiltinRules    = panic "loadBuiltinRules"
getDeferredDecls    = panic "getDeferredDecls"
data ImportDeclResult
  = AlreadySlurped
  | WiredIn	
  | Deferred
  | HereItIs (Module, RdrNameHsDecl)
getImportedInstDecls = panic "getImportedInstDecls"
importDecl           = panic "importDecl"
mkImportExportInfo   = panic "mkImportExportInfo"
getImportedRules     = panic "getImportedRules"
95
#else
96
97
\end{code}

98

99
100
101
102
103
%*********************************************************
%*							*
\subsection{Loading a new interface file}
%*							*
%*********************************************************
104

105
\begin{code}
106
loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
107
loadHomeInterface doc_str name
108
  = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
109
110
111
112

loadOrphanModules :: [ModuleName] -> RnM d ()
loadOrphanModules mods
  | null mods = returnRn ()
113
  | otherwise = traceRn (text "Loading orphan modules:" <+> 
114
			 fsep (map mods))			`thenRn_` 
115
		mapRn_ load mods				`thenRn_`
116
117
		returnRn ()
  where
118
    load mod   = loadInterface (mk_doc mod) mod ImportBySystem
119
    mk_doc mod = ppr mod <+> ptext SLIT("is a orphan-instance module")
120
	   
121

122
123
124
125
126
127
128
129
130
131
132
133
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
134
 = getIfacesRn 			`thenRn` \ ifaces ->
sof's avatar
sof committed
135
   let
136
137
138
	mod_map  = iImpModInfo ifaces
	mod_info = lookupFM mod_map mod_name

139
140
141
142
143
144
145
146
147
148
149
	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.

150
151
	redundant_source_import 
	  = case (from, mod_info) of 
152
		(ImportByUserSource, Just (_,False,_)) -> True
153
		other				       -> False
154
   in
155
	-- CHECK WHETHER WE HAVE IT ALREADY
156
   case mod_info of {
157
	Just (_, _, True)
158
		-> 	-- We're read it already so don't re-read it
159
		    returnRn (ifaces, Nothing) ;
160

161
162
163
164
165
166
167
	_ ->

	-- 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_`
168
169

	-- READ THE MODULE IN
170
   findAndReadIface doc_str mod_name hi_boot_file   `thenRn` \ read_resultb ->
sof's avatar
sof committed
171
   case read_result of {
172
	Left err -> 	-- Not found, so add an empty export env to the Ifaces map
173
			-- so that we don't look again
174
	   let
175
		new_mod_map = addToFM mod_map mod_name (False, False, True)
176
177
178
		new_ifaces  = ifaces { iImpModInfo = new_mod_map }
	   in
	   setIfacesRn new_ifaces		`thenRn_`
179
	   returnRn (new_ifaces, Just err) ;
180
181

	-- Found and parsed!
182
	Right (mod, iface) ->
183
184

	-- LOAD IT INTO Ifaces
185

sof's avatar
sof committed
186
187
188
189
	-- 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)
190

191

192
193
194
195
	-- 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 } &&
196
	  isModuleInThisPackage mod,
197
	  ppr mod )
198
199
200
201
202

    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 ->
203
    foldlRn (loadInstDecl mod)	(iInsts ifaces)   (pi_insts iface)	`thenRn` \ new_insts ->
204
    loadExports 			 	  (pi_exports iface)	`thenRn` \ avails ->
205
    let
206
207
208
209
210
	version	= VersionInfo { modVers  = pi_vers iface, 
				fixVers  = fix_vers,
				ruleVers = rule_vers,
				declVers = decl_vers }

211
212
213
214
	-- 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
215
			ImportByUser -> addModDeps mod (pi_usages iface) mod_map
216
			other        -> mod_map
217
	mod_map2 = addToFM mod_map1 mod_name (pi_orphan iface, hi_boot_file, True)
218

219
220
221
222
223
	-- 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 }
224

225
	new_ifaces = ifaces { iPST	  = new_pst,
226
			      iDecls      = new_decls,
227
			      iInsts      = new_insts,
228
			      iRules	  = new_rules,
229
			      iImpModInfo = mod_map2  }
230
    in
231
    setIfacesRn new_ifaces		`thenRn_`
232
    returnRn (new_ifaces, Nothing)
sof's avatar
sof committed
233
234
    }}

235
236
237
238
239
-----------------------------------------------------
--	Adding module dependencies from the 
--	import decls in the interface file
-----------------------------------------------------

240
addModDeps :: Module -> PackageSymbolTable -> [ImportVersion a] 
241
242
243
244
245
	   -> 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
246
  where
247
248
249
	-- 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
250
    filtered_new_deps :: (ModuleName, (WhetherHasOrphans, IsBootInterface))
251
    filtered_new_deps
252
253
	| isModuleInThisPackage mod 
			    = [ (imp_mod, (has_orphans, is_boot, False))
254
			      | (imp_mod, has_orphans, is_boot, _) <- new_deps 
255
			      ]			      
256
	| otherwise	    = [ (imp_mod, (True, False, False))
257
			      | (imp_mod, has_orphans, _, _) <- new_deps, 
258
259
260
				has_orphans
			      ]
    add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
261

262
263
    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
264
							-- or if it's a non-boot pending load
265
	| otherwise			    = new	-- Otherwise pick new info
266

267
268
269
270
271

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

272
273
274
275
276
277
278
loadExports :: [ExportItem] -> RnM d Avails
loadExports items
  = getModuleRn 				`thenRn` \ this_mod ->
    mapRn (loadExport this_mod) items		`thenRn` \ avails_s ->
    returnRn (concat avails_s)


279
loadExport :: Module -> ExportItem -> RnM d [AvailInfo]
280
loadExport this_mod (mod, entities)
281
  | mod == moduleName this_mod = returnRn []
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
	-- 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
299
  = mapRn (load_entity mod) entities
300
  where
301
    new_name mod occ = newGlobalName mod occ
302

sof's avatar
sof committed
303
304
    load_entity mod (Avail occ)
      =	new_name mod occ	`thenRn` \ name ->
sof's avatar
sof committed
305
	returnRn (Avail name)
sof's avatar
sof committed
306
307
308
    load_entity mod (AvailTC occ occs)
      =	new_name mod occ	      `thenRn` \ name ->
        mapRn (new_name mod) occs     `thenRn` \ names ->
sof's avatar
sof committed
309
        returnRn (AvailTC name names)
310

311

312
313
314
-----------------------------------------------------
--	Loading type/class/value decls
-----------------------------------------------------
315

316
317
318
319
320
321
322
loadDecls :: Module 
	  -> DeclsMap
	  -> [(Version, RdrNameHsDecl)]
	  -> RnM d (NameEnv Version, DeclsMap)
loadDecls mod decls_map decls
  = foldlRn (loadDecl mod) (emptyNameEnv, decls_map) decls

323
loadDecl :: Module 
324
	 -> (NameEnv Version, DeclsMap)
325
	 -> (Version, RdrNameHsDecl)
326
327
	 -> RnM d (NameEnv Version, DeclsMap)
loadDecl mod (version_map, decls_map) (version, decl)
328
329
  = getDeclBinders new_name decl	`thenRn` \ maybe_avail ->
    case maybe_avail of {
330
331
	Nothing    -> returnRn (version_map, decls_map);	-- No bindings
	Just avail -> 
332

333
334
    getDeclSysBinders new_name decl	`thenRn` \ sys_bndrs ->
    let
335
336
337
338
339
	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!

340
341
	main_name     = availName avail
	new_decls_map = foldl add_decl decls_map
342
				       [ (name, (full_avail, name==main_name, (mod, decl'))) 
343
				       | name <- availNames full_avail]
344
	add_decl decls_map (name, stuff)
345
	  = WARN( name `elemNameEnv` decls_map, ppr name )
346
	    extendNameEnv decls_map name stuff
347
348

	new_version_map = extendNameEnv version_map main_name version
349
    in
350
    returnRn (new_version_map, new_decls_map)
351
    }
352
  where
353
	-- newTopBinder puts into the cache the binder with the
354
355
	-- module information set correctly.  When the decl is later renamed,
	-- the binding site will thereby get the correct module.
356
357
358
	-- 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
359
    new_name rdr_name loc = newTopBinder mod rdr_name loc
360

sof's avatar
sof committed
361
    {-
362
363
      If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
      we toss away unfolding information.
sof's avatar
sof committed
364
365
366
367
368

      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
369
370
      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
371
      just ignore unfolding info.
372
373
374
375

      [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
376
    -}
377
    decl' = case decl of
378
379
380
	       SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
			 ->  SigD (IfaceSig name tp [] loc)
	       other	 -> decl
sof's avatar
sof committed
381

382
383
384
385
-----------------------------------------------------
--	Loading fixity decls
-----------------------------------------------------

386
387
loadFixDecls mod_name (version, decls)
  | null decls = returnRn (version, emptyNameEnv)
388
389
390

  | otherwise
  = mapRn (loadFixDecl mod_name) decls	`thenRn` \ to_add ->
391
    returnRn (version, mkNameEnv to_add)
392
393

loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
394
  = newGlobalName mod_name (rdrNameOcc rdr_name) 	`thenRn` \ name ->
395
396
397
398
399
400
401
    returnRn (name, FixitySig name fixity loc)


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

402
loadInstDecl :: Module
403
	     -> IfaceInsts
404
	     -> RdrNameInstDecl
405
	     -> RnM d IfaceInsts
406
loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
407
408
409
410
411
412
413
414
  = 
	-- 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 ...
415
	--
416
417
	-- Here the gates are Baz and T, but *not* Foo.
    let 
418
419
	munged_inst_ty = removeContext inst_ty
	free_names     = extractHsTyRdrNames munged_inst_ty
420
    in
421
422
    setModuleRn mod $
    mapRn lookupOrigName free_names	`thenRn` \ gate_names ->
423
424
    returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)

425
426
427
428
429
430
431
432

-- 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

433
removeFuns (HsFunTy _ ty) = removeFuns ty
434
435
436
removeFuns ty		    = ty


437
438
439
440
441
442
-----------------------------------------------------
--	Loading Rules
-----------------------------------------------------

loadRules :: Module -> IfaceRules 
	  -> (Version, [RdrNameRuleDecl])
443
	  -> RnM d (Version, IfaceRules)
444
445
loadRules mod rule_bag (version, rules)
  | null rules || opt_IgnoreIfacePragmas 
446
  = returnRn (version, rule_bag)
447
  | otherwise
448
  = setModuleRn mod		 	$
449
    mapRn (loadRule mod) rules		`thenRn` \ new_rules ->
450
    returnRn (version, rule_bag `unionBags` listToBag new_rules)
451
452

loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
453
454
-- "Gate" the rule simply by whether the rule variable is
-- needed.  We can refine this later.
455
loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
456
  = lookupOrigName var		`thenRn` \ var_name ->
457
458
459
460
461
462
463
464
465
    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)
466
  = lookupOrigName var		`thenRn` \ var_name ->
467
468
469
470
471
472
    returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))


-----------------------------------------------------
--	Loading Deprecations
-----------------------------------------------------
473
474

loadDeprec :: Module -> DeprecationEnv -> RdrNameDeprecation -> RnM d DeprecationEnv
475
loadDeprec mod deprec_env (Deprecation (IEModuleContents _) txt _)
476
  = traceRn (text "module deprecation not yet implemented:" <+> ppr mod <> colon <+> ppr txt) `thenRn_`
477
	-- SUP: TEMPORARY HACK, ignoring module deprecations for now
478
    returnRn deprec_env
479
480

loadDeprec mod deprec_env (Deprecation ie txt _)
481
482
  = setModuleRn mod					$
    mapRn lookupOrigName (ieNames ie)		`thenRn` \ names ->
483
    traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
484
    returnRn (extendNameEnvList deprec_env (zip names (repeat txt)))
485
\end{code}
486

487

488
489
%********************************************************
%*							*
490
\subsection{Checking usage information}
491
492
493
494
%*							*
%********************************************************

\begin{code}
495
496
497
upToDate  = True
outOfDate = False

498
499
500
501
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.
502

503
checkModUsage [] = returnRn upToDate		-- Yes!  Everything is up to date!
504

505
checkModUsage ((mod_name, _, _, NothingAtAll) : rest)
506
507
508
509
510
511
512
513
	-- 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

514
checkModUsage ((mod_name, _, _, whats_imported)  : rest)
515
516
  = tryLoadInterface doc_str mod_name ImportBySystem	`thenRn` \ (ifaces, maybe_err) ->
    case maybe_err of {
517
	Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"), 
518
				      ppr mod_name]) ;
519
520
521
		-- 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
522

523
	Nothing -> 
524
    let
525
526
527
528
529
530
531
532
	(_, 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
533
    in
534
535
	-- If the module version hasn't changed, just move on
    if new_mod_vers == old_mod_vers then
536
	traceRn (sep [ptext SLIT("Module version unchanged:"), ppr mod_name])
537
	`thenRn_` checkModUsage rest
538
    else
539
    traceRn (sep [ptext SLIT("Module version has changed:"), ppr mod_name])
540
    `thenRn_`
541
542
543
544
545
	-- 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
546
547
548
549
    case whats_imported of {	-- NothingAtAll dealt with earlier
	
      Everything _ 
	-> out_of_date (ptext SLIT("...and I needed the whole module")) ;
550

551
      Specifically _ old_fix_vers old_rule_vers old_local_vers ->
552

553
554
555
556
557
    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	
558
	-- Non-empty usage list, so check item by item
559
    checkEntityUsage mod_name (iDecls ifaces) old_local_vers	`thenRn` \ up_to_date ->
560
    if up_to_date then
sof's avatar
sof committed
561
	traceRn (ptext SLIT("...but the bits I use haven't."))	`thenRn_`
562
563
	checkModUsage rest	-- This one's ok, so check the rest
    else
564
	returnRn outOfDate	-- This one failed, so just bail out now
565
    }}
566
  where
567
    doc_str = sep [ptext SLIT("need version info for"), ppr mod_name]
568
569


570
checkEntityUsage mod decls [] 
571
  = returnRn upToDate	-- Yes!  All up to date!
572

573
checkEntityUsage mod decls ((occ_name,old_vers) : rest)
574
  = newGlobalName mod occ_name 	`thenRn` \ name ->
575
    case lookupNameEnv decls name of
576
577

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

580
	Just (new_vers,_,_,_) 	-- It's there, but is it up to date?
581
582
583
584
585
586
		| new_vers == old_vers
			-- Up to date, so check the rest
		-> checkEntityUsage mod decls rest

		| otherwise
			-- Out of date, so bale out
587
588
589
		-> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])

out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
590
591
592
\end{code}


593
594
595
596
597
%*********************************************************
%*							*
\subsection{Getting in a declaration}
%*							*
%*********************************************************
598

599
\begin{code}
600
601
602
603
604
605
606
importDecl :: Name -> RnMG ImportDeclResult

data ImportDeclResult
  = AlreadySlurped
  | WiredIn	
  | Deferred
  | HereItIs (Module, RdrNameHsDecl)
607
608

importDecl name
609
610
611
612
613
614
615
  = getIfacesRn				`thenRn` \ ifaces ->
    getHomeSymbolTableRn		`thenRn` \ hst ->
    if name `elemNameSet` iSlurp ifaces
    || inTypeEnv (iPST ifaces) name
    || inTypeEnv hst	       name
    then	-- Already dealt with
	returnRn AlreadySlurped	
616
617

    else if isLocallyDefined name then	-- Don't bring in decls from
618
					-- the renamed module's own interface file
619
620
	addWarnRn (importDeclWarn name) `thenRn_`
	returnRn AlreadySlurped
621

622
623
624
625
626
627
628
629
630
631
632
    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
633
getNonWiredInDecl needed_name 
634
  = traceRn doc_str				`thenRn_`
635
    loadHomeInterface doc_str needed_name	`thenRn` \ ifaces ->
636
    case lookupNameEnv (iDecls ifaces) needed_name of
sof's avatar
sof committed
637

638
      Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _ _ _)))
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
	-- 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

673
      Just (version,avail,_,decl)
674
675
	-> setIfacesRn (recordSlurp ifaces version avail)	`thenRn_`
	   returnRn (HereItIs decl)
676

677
      Nothing 
678
	-> addErrRn (getDeclErr needed_name)	`thenRn_` 
679
	   returnRn AlreadySlurped
680
  where
681
     doc_str = ptext SLIT("need decl for") <+> ppr needed_name
682
683
684
685
686
687
688
689
690
691
692
693

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)
694
695
\end{code}

696
697
698
@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,
699
700
\begin{itemize}
\item	if the wired-in name is a data type constructor or a data constructor, 
701
	it brings in the type constructor and all the data constructors; and
702
	marks as ``occurrences'' any free vars of the data con.
703

704
\item 	similarly for synonum type constructor
705

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

709
\item	it loads the interface file for the wired-in thing for the
710
	sole purpose of making sure that its instance declarations are available
711
712
\end{itemize}
All this is necessary so that we know all types that are ``in play'', so
713
714
that we know just what instances to bring into scope.
	
715
716


717
    
718
719
%*********************************************************
%*							*
sof's avatar
sof committed
720
\subsection{Getting what a module exports}
721
722
%*							*
%*********************************************************
723

724
@getInterfaceExports@ is called only for directly-imported modules.
725

726
\begin{code}
727
728
getInterfaceExports :: ModuleName -> WhereFrom -> RnMG (Module, Avails)
getInterfaceExports mod_name from
729
730
731
  = getHomeSymbolTableRn 		`thenRn` \ hst ->
    case lookupModuleEnvByName hst mod_name of {
	Just mds -> returnRn (mdModule mds, mdExports mds) ;
732
733
734
735
736
737
738
739
740
        Nothing  -> pprPanic "getInterfaceExports" (ppr mod_name)

-- I think this is what it _used_ to say.  JRS, 001017 
--    loadInterface doc_str mod_name from	`thenRn` \ ifaces ->
--    case lookupModuleEnv (iPST ifaces) mod_name of
--	Just mds -> returnRn (mdModule mod, mdExports mds)
--	-- loadInterface always puts something in the map
--	-- even if it's a fake

741
742
    }
    where
743
      doc_str = sep [ppr mod_name, ptext SLIT("is directly imported")]
sof's avatar
sof committed
744
745
746
747
748
\end{code}


%*********************************************************
%*							*
749
\subsection{Instance declarations are handled specially}
sof's avatar
sof committed
750
751
752
753
%*							*
%*********************************************************

\begin{code}
754
755
getImportedInstDecls :: NameSet -> RnMG [(Module,RdrNameHsDecl)]
getImportedInstDecls gates
756
  =    	-- First, load any orphan-instance modules that aren't aready loaded
757
	-- Orphan-instance modules are recorded in the module dependecnies
758
    getIfacesRn 					`thenRn` \ ifaces ->
sof's avatar
sof committed
759
    let
760
	orphan_mods =
761
	  [mod | (mod, (True, _, Nothing)) <- fmToList (iImpModInfo ifaces)]
sof's avatar
sof committed
762
    in
763
    loadOrphanModules orphan_mods			`thenRn_` 
764

765
	-- Now we're ready to grab the instance declarations
766
767
	-- Find the un-gated ones and return them, 
	-- removing them from the bag kept in Ifaces
768
    getIfacesRn 					`thenRn` \ ifaces ->
769
    let
770
771
772
	(decls, new_insts) = selectGated gates (iInsts ifaces)
    in
    setIfacesRn (ifaces { iInsts = new_insts })		`thenRn_`
773

774
    traceRn (sep [text "getImportedInstDecls:", 
775
		  nest 4 (fsep (map ppr gate_list)),
776
777
		  text "Slurped" <+> int (length decls) <+> text "instance declarations",
		  nest 4 (vcat (map ppr_brief_inst_decl decls))])	`thenRn_`
778
779
    returnRn decls
  where
780
781
    gate_list      = nameSetToList gates

782
783
784
785
786
ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
  = case inst_ty of
	HsForAllTy _ _ tau -> ppr tau
	other		   -> ppr inst_ty

787
getImportedRules :: RnMG [(Module,RdrNameHsDecl)]
788
789
790
getImportedRules 
  | opt_IgnoreIfacePragmas = returnRn []
  | otherwise
791
792
793
  = getIfacesRn 	`thenRn` \ ifaces ->
    let
	gates		   = iSlurp ifaces	-- Anything at all that's been slurped
794
795
	rules		   = iRules ifaces
	(decls, new_rules) = selectGated gates rules
796
    in
797
798
799
800
    if null decls then
	returnRn []
    else
    setIfacesRn (ifaces { iRules = new_rules })		     `thenRn_`
801
    traceRn (sep [text "getImportedRules:", 
802
		  text "Slurped" <+> int (length decls) <+> text "rules"])   `thenRn_`
803
    returnRn decls
804

805
selectGated gates decl_bag
806
	-- Select only those decls whose gates are *all* in 'gates'
807
808
809
#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
810

811
812
813
  | otherwise
#endif
  = foldrBag select ([], emptyBag) decl_bag
814
  where
815
816
817
818
    select (reqd, decl) (yes, no)
	| isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
	| otherwise				     = (yes,      (reqd,decl) `consBag` no)

819
820
lookupFixityRn :: Name -> RnMS Fixity
lookupFixityRn name
821
822
  | isLocallyDefined name
  = getFixityEnv			`thenRn` \ local_fix_env ->
823
    returnRn (lookupLocalFixity local_fix_env name)
824
825

  | otherwise	-- Imported
826
827
828
829
830
831
832
      -- 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.
833
834
835
836
837
838
839
840
  = getHomeSymbolTableRn 		`thenRn` \ hst ->
    case lookupFixityEnv hst name of {
	Just fixity -> returnRn fixity ;
	Nothing	    -> 

    loadHomeInterface doc name		`thenRn` \ ifaces ->
    returnRn (lookupFixityEnv (iPST ifaces) name `orElse` defaultFixity) 
    }
841
  where
842
    doc = ptext SLIT("Checking fixity for") <+> ppr name
843
844
\end{code}

sof's avatar
sof committed
845
846
847
848
849
850
851

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

852
853
854
855
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:

856
\begin{itemize}
857
858
859
\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
860
\end{itemize}
861
862

Why (b)?  Because if @Foo@ changes then this module's export list
863
864
865
866
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.

867
Why (c)?  Consider this:
868
869
870
871
872
\begin{verbatim}
	module A( f, g ) where	|	module B( f ) where
	  import B( f )		|	  f = h 3
	  g = ...		|	  h = ...
\end{verbatim}
873

874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
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> :: ... ;
898
899
900
901
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.
902

903
\begin{code}
904
905
906
907
908
909
910
911
912
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
913
914
  = getIfacesRn					`thenRn` \ ifaces ->
    let
915
916
917
918
919
	export_all_mods = case exports of
				Nothing -> []
				Just es -> [mod | IEModuleContents mod <- es, 
						  mod /= this_mod]

920
921
	mod_map   = iImpModInfo ifaces
	imp_names = iVSlurp     ifaces
922

923
	-- mv_map groups together all the things imported from a particular module.
924
	mv_map :: FiniteMap ModuleName [(OccName,Version)]
925
	mv_map = foldr add_mv emptyFM imp_names
926

927
928
929
        add_mv (name, version) mv_map = addItem mv_map (moduleName (nameModule name)) 
						       (nameOccName name, version)

930
	-- Build the result list by adding info for each module.
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
	-- 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.

946
	mk_imp_info mod_name (has_orphans, is_boot, contents) so_far
947
948
949
950
951
952
953
	   | 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
954
	   = let
955
		go_for_it exports = (mod_name, has_orphans, is_boot, exports) 
956
                                    : so_far
957
958
959
960
961
962
963
964
	     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.
965
			-- The module in question must be a local module (in the same package)
966
		   go_for_it NothingAtAll
967

968
		Just (mod, mod_vers, fix_vers, rule_vers, how_imported, _)
969
		   |  is_sys_import && is_lib_module && not has_orphans
970
		   -> so_far		
971
	   
972
973
		   |  is_lib_module 			-- Record the module but not detailed
		   || mod_name `elem` export_all_mods	-- version information for the imports
974
		   -> go_for_it (Everything mod_vers)
975
976
977

		   |  otherwise
		   -> case lookupFM mv_map mod_name of
978
979
980
			Just whats_imported -> go_for_it (Specifically mod_vers fix_vers rule_vers 
								       (sortImport whats_imported))
			Nothing		    -> go_for_it NothingAtAll
981
982
983
984
985
						-- This happens if you have
						--	import Foo
						-- but don't actually *use* anything from Foo
					 	-- In which case record an empty dependency list
		   where
986
		     is_lib_module = not (isModuleInThisPackage mod)
987
988
989
		     is_sys_import = case how_imported of
					ImportBySystem -> True
					other	       -> False
990
	     
991
992
993
994
995
996
997
998
999
1000
1001

	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
1002
    in
1003
    traceRn (text "Modules in Ifaces: " <+> fsep (map ppr (keysFM mod_map)))	`thenRn_`
1004
    returnRn (export_info, import_info)
1005

1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021

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
1022
\end{code}
1023

sof's avatar
sof committed
1024
\begin{code}
1025
getSlurped
sof's avatar
sof committed
1026
  = getIfacesRn 	`thenRn` \ ifaces ->
1027
    returnRn (iSlurp ifaces)
sof's avatar
sof committed
1028

1029
1030
1031
recordSlurp ifaces@(Ifaces { iSlurp = slurped_names, iVSlurp = imp_names })
	    version avail
  = let
sof's avatar
sof committed
1032
	new_slurped_names = addAvailToNameSet slurped_names avail
1033
1034
1035
	new_imp_names = (availName avail, version) : imp_names
    in
    ifaces { iSlurp  = new_slurped_names, iVSlurp = new_imp_names }
sof's avatar
sof committed
1036

1037
1038
1039
1040
recordLocalSlurps local_avails
  = getIfacesRn 	`thenRn` \ ifaces ->
    let
	new_slurped_names = foldl addAvailToNameSet (iSlurp ifaces) local_avails
sof's avatar
sof committed
1041
    in
1042
    setIfacesRn (ifaces { iSlurp  = new_slurped_names })
sof's avatar
sof committed
1043
1044
1045
\end{code}


1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
%*********************************************************
%*							*
\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@).

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

1059
\begin{code}
1060
getDeclBinders :: (RdrName -> SrcLoc -> RnM d Name)	-- New-name function
1061
		-> RdrNameHsDecl
1062
		-> RnM d (Maybe AvailInfo)
1063

1064
getDeclBinders new_name (TyClD (TyData _ _ tycon _ condecls _ _ _ src_loc _ _))
1065
1066
  = new_name tycon src_loc			`thenRn` \ tycon_name ->
    getConFieldNames new_name condecls		`thenRn` \ sub_names ->
1067
    returnRn (Just (AvailTC tycon_name (tycon_name : nub sub_names)))
sof's avatar
sof committed
1068
1069
	-- The "nub" is because getConFieldNames can legitimately return duplicates,
	-- when a record declaration has the same field in multiple constructors
1070

1071
getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
1072
  = new_name tycon src_loc		`thenRn` \ tycon_name ->
1073
    returnRn (Just (AvailTC tycon_name [tycon_name]))
1074

1075
getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ src_loc))
1076
  = new_name cname src_loc			`thenRn` \ class_name ->
1077
1078

	-- Record the names for the class ops
sof's avatar
sof committed
1079
    let
sof's avatar
sof committed
1080
1081
	-- just want class-op sigs
	op_sigs = filter isClassOpSig sigs
sof's avatar
sof committed
1082
    in
sof's avatar
sof committed
1083
    mapRn (getClassOpNames new_name) op_sigs	`thenRn` \ sub_names ->
1084

1085
    returnRn (Just (AvailTC class_name (class_name : sub_names)))
1086
1087
1088

getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
  = new_name var src_loc			`thenRn` \ var_name ->