RnIfaces.lhs 44.9 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
import BasicTypes	( Version, NewOrData(..), defaultFixity )
import RdrHsSyn		( RdrNameHsDecl, RdrNameInstDecl, RdrNameTyClDecl, RdrNameRuleDecl,
35
36
			  RdrNameFixitySig, RdrNameDeprecation, RdrNameIE,
			  extractHsTyRdrNames 
37
			)
38
import RnEnv		( mkImportedGlobalName, newTopBinder, mkImportedGlobalFromRdrName,
sof's avatar
sof committed
39
			  lookupOccRn, lookupImplicitOccRn,
40
			  pprAvail, rdrAvailInfo,
41
			  availName, availNames, addAvailToNameSet, addSysAvails,
42
			  FreeVars, emptyFVs
43
			)
44
import RnMonad
45
import RnHsSyn          ( RenamedHsDecl, RenamedDeprecation )
46
import ParseIface	( parseIface, IfaceStuff(..) )
47

48
49
import Name		( Name {-instance NamedThing-}, nameOccName,
			  nameModule, isLocallyDefined, 
50
			  isWiredInName, nameUnique, NamedThing(..)
51
			 )
52
53
import Module		( Module, moduleString, pprModule,
			  mkVanillaModule, pprModuleName,
54
			  moduleUserString, moduleName, isLocalModule,
55
			  ModuleName, WhereFrom(..),
56
57
			)
import RdrName		( RdrName, rdrNameOcc )
58
59
import NameSet
import Var		( Id )
60
import SrcLoc		( mkSrcLoc, SrcLoc )
61
import PrelInfo		( pREL_GHC, cCallishTyKeys )
62
import Maybes		( MaybeErr(..), maybeToBool, orElse )
63
import ListSetOps	( unionLists )
64
import Unique		( Unique, Uniquable(..) )
65
import StringBuffer     ( StringBuffer, hGetStringBuffer )
66
import FastString	( mkFastString )
sof's avatar
sof committed
67
import ErrUtils         ( Message )
68
import Util		( sortLt, lengthExceeds )
69
import Lex
70
import FiniteMap
sof's avatar
sof committed
71
import Outputable
72
import Bag
73
74
75

import IO	( isDoesNotExistError )
import List	( nub )
76
77
\end{code}

78

79
80
81
82
83
%*********************************************************
%*							*
\subsection{Loading a new interface file}
%*							*
%*********************************************************
84

85
\begin{code}
86
loadHomeInterface :: SDoc -> Name -> RnM d Ifaces
87
loadHomeInterface doc_str name
88
  = loadInterface doc_str (moduleName (nameModule name)) ImportBySystem
89
90
91
92

loadOrphanModules :: [ModuleName] -> RnM d ()
loadOrphanModules mods
  | null mods = returnRn ()
93
94
95
  | otherwise = traceRn (text "Loading orphan modules:" <+> 
			 fsep (map pprModuleName mods))		`thenRn_` 
		mapRn_ load mods				`thenRn_`
96
97
		returnRn ()
  where
98
99
100
    load mod   = loadInterface (mk_doc mod) mod ImportBySystem
    mk_doc mod = pprModuleName mod <+> ptext SLIT("is a orphan-instance module")
	   
101

102
103
104
105
106
107
108
109
110
111
112
113
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
114
 = getIfacesRn 			`thenRn` \ ifaces ->
sof's avatar
sof committed
115
   let
116
117
118
	mod_map  = iImpModInfo ifaces
	mod_info = lookupFM mod_map mod_name

119
120
121
122
123
	hi_boot_file = case from of {
		     	 ImportByUser       -> False ;		-- Not hi-boot
		     	 ImportByUserSource -> True ;		-- hi-boot
			 ImportBySystem     -> 
		       case mod_info of
124
			 Just (_, is_boot, _) -> is_boot
125
126
127
128
129
130
131
132
133

			 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.
		       }
	redundant_source_import 
	  = case (from, mod_info) of 
134
		(ImportByUserSource, Just (_,False,_)) -> True
135
136
		other					 -> False
   in
137
	-- CHECK WHETHER WE HAVE IT ALREADY
138
   case mod_info of {
139
	Just (_, _, Just _)
140
		-> 	-- We're read it already so don't re-read it
141
		    returnRn (ifaces, Nothing) ;
142

143
144
145
146
147
148
149
	_ ->

	-- 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_`
150
151

	-- READ THE MODULE IN
152
   findAndReadIface doc_str mod_name hi_boot_file   `thenRn` \ read_result ->
sof's avatar
sof committed
153
   case read_result of {
154
	Left err -> 	-- Not found, so add an empty export env to the Ifaces map
155
			-- so that we don't look again
156
157
	   let
		mod         = mkVanillaModule mod_name
158
		new_mod_map = addToFM mod_map mod_name (False, False, Just (mod, 0, 0, 0, from, []))
159
160
161
		new_ifaces  = ifaces { iImpModInfo = new_mod_map }
	   in
	   setIfacesRn new_ifaces		`thenRn_`
162
	   returnRn (new_ifaces, Just err) ;
163
164

	-- Found and parsed!
165
	Right iface ->
166
167

	-- LOAD IT INTO Ifaces
168

sof's avatar
sof committed
169
170
171
172
	-- 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)
173

174
    getModuleRn 		`thenRn` \ this_mod_nm ->
175
    let
176
	mod = pi_mod   iface
177
    in
178
179
180
181
182
183
	-- 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 )
184
185
186
187
188
189
    foldlRn (loadDecl mod)	   (iDecls ifaces)   (pi_decls iface)	`thenRn` \ new_decls ->
    foldlRn (loadInstDecl mod)	   (iInsts ifaces)   (pi_insts iface)	`thenRn` \ new_insts ->
    loadRules mod		   (iRules ifaces)   (pi_rules iface)	`thenRn` \ new_rules ->
    loadFixDecls mod_name	   (iFixes ifaces)   (pi_fixity iface)	`thenRn` \ new_fixities ->
    foldlRn (loadDeprec mod)	   (iDeprecs ifaces) (pi_deprecs iface)	`thenRn` \ new_deprecs ->
    mapRn (loadExport this_mod_nm) (pi_exports iface)			`thenRn` \ avails_s ->
190
191
192
193
194
    let
	-- 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
195
			ImportByUser -> addModDeps mod (pi_usages iface) mod_map
196
197
198
199
			other        -> mod_map

	-- Now add info about this module
	mod_map2    = addToFM mod_map1 mod_name mod_details
200
201
202
203
	cts	    = (pi_mod iface, pi_vers iface, 
		       fst (pi_fixity iface), fst (pi_rules iface), 
		       from, concat avails_s)
	mod_details = (pi_orphan iface, hi_boot_file, Just cts)
204
205
206
207

	new_ifaces = ifaces { iImpModInfo = mod_map2,
			      iDecls      = new_decls,
			      iFixes      = new_fixities,
208
			      iInsts      = new_insts,
209
			      iRules	  = new_rules,
210
			      iDeprecs	  = new_deprecs }
211
    in
212
    setIfacesRn new_ifaces		`thenRn_`
213
    returnRn (new_ifaces, Nothing)
sof's avatar
sof committed
214
215
    }}

216
217
218
219
220
-----------------------------------------------------
--	Adding module dependencies from the 
--	import decls in the interface file
-----------------------------------------------------

221
222
223
224
225
226
addModDeps :: Module -> [ImportVersion a] 
	   -> 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
227
  where
228
229
230
231
	-- 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
    filtered_new_deps
232
233
	| isLocalModule mod = [ (imp_mod, (has_orphans, is_boot, Nothing))
			      | (imp_mod, has_orphans, is_boot, _) <- new_deps 
234
			      ]			      
235
236
	| otherwise	    = [ (imp_mod, (True, False, Nothing))
			      | (imp_mod, has_orphans, _, _) <- new_deps, 
237
238
239
				has_orphans
			      ]
    add (imp_mod, dep) deps = addToFM_C combine deps imp_mod dep
240

241
    combine old@(_, old_is_boot, cts) new
242
243
244
	| maybeToBool cts || not old_is_boot = old	-- Keep the old info if it's already loaded
							-- or if it's a non-boot pending load
	| otherwise			     = new	-- Otherwise pick new info
245

246
247
248
249
250

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

251
loadExport :: ModuleName -> ExportItem -> RnM d [AvailInfo]
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
loadExport this_mod (mod, entities)
  | mod == this_mod = returnRn []
	-- 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
271
  = mapRn (load_entity mod) entities
272
  where
273
    new_name mod occ = mkImportedGlobalName mod occ
274

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

283

284
285
286
-----------------------------------------------------
--	Loading type/class/value decls
-----------------------------------------------------
287

288
289
loadDecl :: Module 
	 -> DeclsMap
290
	 -> (Version, RdrNameHsDecl)
291
	 -> RnM d DeclsMap
292

293
loadDecl mod decls_map (version, decl)
294
295
296
297
298
  = getDeclBinders new_name decl	`thenRn` \ maybe_avail ->
    case maybe_avail of {
	Nothing -> returnRn decls_map;	-- No bindings
	Just avail ->

299
300
    getDeclSysBinders new_name decl	`thenRn` \ sys_bndrs ->
    let
301
302
303
304
305
	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!

306
307
	main_name     = availName avail
	new_decls_map = foldl add_decl decls_map
308
309
				       [ (name, (version, full_avail, name==main_name, (mod, decl'))) 
				       | name <- availNames full_avail]
310
	add_decl decls_map (name, stuff)
311
	  = WARN( name `elemNameEnv` decls_map, ppr name )
312
313
314
	    addToNameEnv decls_map name stuff
    in
    returnRn new_decls_map
315
    }
316
  where
317
	-- newTopBinder puts into the cache the binder with the
318
319
	-- module information set correctly.  When the decl is later renamed,
	-- the binding site will thereby get the correct module.
320
321
322
323
	-- 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
    new_name rdr_name loc = newTopBinder mod (rdrNameOcc rdr_name)
324

sof's avatar
sof committed
325
    {-
326
327
      If a signature decl is being loaded, and optIgnoreIfacePragmas is on,
      we toss away unfolding information.
sof's avatar
sof committed
328
329
330
331
332

      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
333
334
      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
335
      just ignore unfolding info.
336
337
338
339

      [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
340
    -}
341
    decl' = case decl of
342
343
344
	       SigD (IfaceSig name tp ls loc) | opt_IgnoreIfacePragmas
			 ->  SigD (IfaceSig name tp [] loc)
	       other	 -> decl
sof's avatar
sof committed
345

346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
-----------------------------------------------------
--	Loading fixity decls
-----------------------------------------------------

loadFixDecls mod_name fixity_env (version, decls)
  | null decls = returnRn fixity_env

  | otherwise
  = mapRn (loadFixDecl mod_name) decls	`thenRn` \ to_add ->
    returnRn (addListToNameEnv fixity_env to_add)

loadFixDecl mod_name sig@(FixitySig rdr_name fixity loc)
  = mkImportedGlobalName mod_name (rdrNameOcc rdr_name) 	`thenRn` \ name ->
    returnRn (name, FixitySig name fixity loc)


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

366
loadInstDecl :: Module
367
	     -> IfaceInsts
368
	     -> RdrNameInstDecl
369
	     -> RnM d IfaceInsts
370
loadInstDecl mod insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
371
372
373
374
375
376
377
378
  = 
	-- 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 ...
379
	--
380
381
	-- Here the gates are Baz and T, but *not* Foo.
    let 
382
383
	munged_inst_ty = removeContext inst_ty
	free_names     = extractHsTyRdrNames munged_inst_ty
384
    in
385
386
387
388
    setModuleRn (moduleName mod) $
    mapRn mkImportedGlobalFromRdrName free_names	`thenRn` \ gate_names ->
    returnRn ((mkNameSet gate_names, (mod, InstD decl)) `consBag` insts)

389
390
391
392
393
394
395
396

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

397
removeFuns (HsFunTy _ ty) = removeFuns ty
398
399
400
removeFuns ty		    = ty


401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
-----------------------------------------------------
--	Loading Rules
-----------------------------------------------------

loadRules :: Module -> IfaceRules 
	  -> (Version, [RdrNameRuleDecl])
	  -> RnM d IfaceRules
loadRules mod rule_bag (version, rules)
  | null rules || opt_IgnoreIfacePragmas 
  = returnRn rule_bag
  | otherwise
  = setModuleRn mod_name	 	$
    mapRn (loadRule mod) rules		`thenRn` \ new_rules ->
    returnRn (rule_bag `unionBags` listToBag new_rules)
  where
    mod_name = moduleName mod

loadRule :: Module -> RdrNameRuleDecl -> RnM d GatedDecl
419
420
-- "Gate" the rule simply by whether the rule variable is
-- needed.  We can refine this later.
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
loadRule mod decl@(IfaceRule _ _ var _ _ src_loc)
  = mkImportedGlobalFromRdrName var		`thenRn` \ var_name ->
    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)
  = mkImportedGlobalFromRdrName var		`thenRn` \ var_name ->
    returnRn (unitNameSet var_name, (nameModule var_name, RuleD (IfaceRuleOut var rule)))


-----------------------------------------------------
--	Loading Deprecations
-----------------------------------------------------
439
440

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

loadDeprec mod deprec_env (Deprecation ie txt _)
447
  = setModuleRn (moduleName mod) $
448
    mapRn mkImportedGlobalFromRdrName (ieNames ie) `thenRn` \ names ->
449
450
    traceRn (text "loaded deprecation(s) for" <+> hcat (punctuate comma (map ppr names)) <> colon <+> ppr txt) `thenRn_`
    returnRn (extendNameEnv deprec_env (zip names (repeat txt)))
451
\end{code}
452

453

454
455
%********************************************************
%*							*
456
\subsection{Checking usage information}
457
458
459
460
%*							*
%********************************************************

\begin{code}
461
462
463
upToDate  = True
outOfDate = False

464
465
466
467
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.
468

469
checkModUsage [] = returnRn upToDate		-- Yes!  Everything is up to date!
470

471
checkModUsage ((mod_name, _, _, NothingAtAll) : rest)
472
473
474
475
476
477
478
479
	-- 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

480
checkModUsage ((mod_name, _, _, whats_imported)  : rest)
481
482
  = tryLoadInterface doc_str mod_name ImportBySystem	`thenRn` \ (ifaces, maybe_err) ->
    case maybe_err of {
483
484
	Just err -> out_of_date (sep [ptext SLIT("Can't find version number for module"), 
				      pprModuleName mod_name]) ;
485
486
487
		-- 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
488

489
	Nothing -> 
490
    let
491
492
493
494
495
496
497
498
	(_, 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
499
    in
500
501
	-- If the module version hasn't changed, just move on
    if new_mod_vers == old_mod_vers then
502
503
	traceRn (sep [ptext SLIT("Module version unchanged:"), pprModuleName mod_name])
	`thenRn_` checkModUsage rest
504
    else
505
506
    traceRn (sep [ptext SLIT("Module version has changed:"), pprModuleName mod_name])
    `thenRn_`
507
508
509
510
511
	-- 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
512
513
514
515
    case whats_imported of {	-- NothingAtAll dealt with earlier
	
      Everything _ 
	-> out_of_date (ptext SLIT("...and I needed the whole module")) ;
516

517
      Specifically _ old_fix_vers old_rule_vers old_local_vers ->
518

519
520
521
522
523
    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	
524
	-- Non-empty usage list, so check item by item
525
    checkEntityUsage mod_name (iDecls ifaces) old_local_vers	`thenRn` \ up_to_date ->
526
    if up_to_date then
sof's avatar
sof committed
527
	traceRn (ptext SLIT("...but the bits I use haven't."))	`thenRn_`
528
529
	checkModUsage rest	-- This one's ok, so check the rest
    else
530
	returnRn outOfDate	-- This one failed, so just bail out now
531
    }}
532
  where
533
    doc_str = sep [ptext SLIT("need version info for"), pprModuleName mod_name]
534
535


536
checkEntityUsage mod decls [] 
537
  = returnRn upToDate	-- Yes!  All up to date!
538

539
checkEntityUsage mod decls ((occ_name,old_vers) : rest)
540
  = mkImportedGlobalName mod occ_name 	`thenRn` \ name ->
541
    case lookupNameEnv decls name of
542
543

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

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

		| otherwise
			-- Out of date, so bale out
553
554
555
		-> out_of_date (sep [ptext SLIT("Out of date:"), ppr name])

out_of_date msg = traceRn msg `thenRn_` returnRn outOfDate
556
557
558
\end{code}


559
560
561
562
563
%*********************************************************
%*							*
\subsection{Getting in a declaration}
%*							*
%*********************************************************
564

565
\begin{code}
566
567
568
569
570
571
572
importDecl :: Name -> RnMG ImportDeclResult

data ImportDeclResult
  = AlreadySlurped
  | WiredIn	
  | Deferred
  | HereItIs (Module, RdrNameHsDecl)
573
574
575
576

importDecl name
  = getSlurped 				`thenRn` \ already_slurped ->
    if name `elemNameSet` already_slurped then
577
578
579
	returnRn AlreadySlurped	-- Already dealt with

    else if isLocallyDefined name then	-- Don't bring in decls from
580
					-- the renamed module's own interface file
581
582
	addWarnRn (importDeclWarn name) `thenRn_`
	returnRn AlreadySlurped
583

584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
    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


{-	I don't think this is necessary any more; SLPJ May 00
    load_home name 
	| name `elemNameSet` source_binders = returnRn ()
		-- When compiling the prelude, a wired-in thing may
		-- be defined in this module, in which case we don't
		-- want to load its home module!
		-- Using 'isLocallyDefined' doesn't work because some of
		-- the free variables returned are simply 'listTyCon_Name',
		-- with a system provenance.  We could look them up every time
		-- but that seems a waste.
	| otherwise = loadHomeInterface doc name	`thenRn_`
		      returnRn ()
-}

getNonWiredInDecl :: Name -> RnMG ImportDeclResult
610
getNonWiredInDecl needed_name 
611
  = traceRn doc_str				`thenRn_`
612
    loadHomeInterface doc_str needed_name	`thenRn` \ ifaces ->
613
    case lookupNameEnv (iDecls ifaces) needed_name of
sof's avatar
sof committed
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
643
644
645
646
647
648
649
      Just (version, avail, is_tycon_name, decl@(_, TyClD (TyData DataType _ _ _ _ ncons _ _ _)))
	-- 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

650
      Just (version,avail,_,decl)
651
652
	-> setIfacesRn (recordSlurp ifaces version avail)	`thenRn_`
	   returnRn (HereItIs decl)
653

654
      Nothing 
655
	-> addErrRn (getDeclErr needed_name)	`thenRn_` 
656
	   returnRn AlreadySlurped
657
  where
658
     doc_str = ptext SLIT("need decl for") <+> ppr needed_name
659
660
661
662
663
664
665
666
667
668
669
670

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)
671
672
\end{code}

673
674
675
@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,
676
677
\begin{itemize}
\item	if the wired-in name is a data type constructor or a data constructor, 
678
	it brings in the type constructor and all the data constructors; and
679
	marks as ``occurrences'' any free vars of the data con.
680

681
\item 	similarly for synonum type constructor
682

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

686
\item	it loads the interface file for the wired-in thing for the
687
	sole purpose of making sure that its instance declarations are available
688
689
\end{itemize}
All this is necessary so that we know all types that are ``in play'', so
690
691
that we know just what instances to bring into scope.
	
692
693


694
    
695
696
%*********************************************************
%*							*
sof's avatar
sof committed
697
\subsection{Getting what a module exports}
698
699
%*							*
%*********************************************************
700

701
@getInterfaceExports@ is called only for directly-imported modules.
702

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


%*********************************************************
%*							*
718
\subsection{Instance declarations are handled specially}
sof's avatar
sof committed
719
720
721
722
%*							*
%*********************************************************

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

734
	-- Now we're ready to grab the instance declarations
735
736
	-- Find the un-gated ones and return them, 
	-- removing them from the bag kept in Ifaces
737
    getIfacesRn 					`thenRn` \ ifaces ->
738
    let
739
740
741
	(decls, new_insts) = selectGated gates (iInsts ifaces)
    in
    setIfacesRn (ifaces { iInsts = new_insts })		`thenRn_`
742

743
    traceRn (sep [text "getImportedInstDecls:", 
744
		  nest 4 (fsep (map ppr gate_list)),
745
746
		  text "Slurped" <+> int (length decls) <+> text "instance declarations",
		  nest 4 (vcat (map ppr_brief_inst_decl decls))])	`thenRn_`
747
748
    returnRn decls
  where
749
750
    gate_list      = nameSetToList gates

751
752
753
754
755
ppr_brief_inst_decl (mod, InstD (InstDecl inst_ty _ _ _ _))
  = case inst_ty of
	HsForAllTy _ _ tau -> ppr tau
	other		   -> ppr inst_ty

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

774
selectGated gates decl_bag
775
	-- Select only those decls whose gates are *all* in 'gates'
776
777
778
#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
779

780
781
782
  | otherwise
#endif
  = foldrBag select ([], emptyBag) decl_bag
783
  where
784
785
786
787
    select (reqd, decl) (yes, no)
	| isEmptyNameSet (reqd `minusNameSet` gates) = (decl:yes, no)
	| otherwise				     = (yes,      (reqd,decl) `consBag` no)

788
789
lookupFixityRn :: Name -> RnMS Fixity
lookupFixityRn name
790
791
  | isLocallyDefined name
  = getFixityEnv			`thenRn` \ local_fix_env ->
792
    returnRn (lookupFixity local_fix_env name)
793
794

  | otherwise	-- Imported
795
796
797
798
799
800
801
      -- 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.
802
  = loadHomeInterface doc name		`thenRn` \ ifaces ->
803
    returnRn (lookupFixity (iFixes ifaces) name)
804
  where
805
    doc = ptext SLIT("Checking fixity for") <+> ppr name
806
807
\end{code}

sof's avatar
sof committed
808
809
810
811
812
813
814

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

815
816
817
818
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:

819
\begin{itemize}
820
821
822
\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
823
\end{itemize}
824
825

Why (b)?  Because if @Foo@ changes then this module's export list
826
827
828
829
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.

830
Why (c)?  Consider this:
831
832
833
834
835
\begin{verbatim}
	module A( f, g ) where	|	module B( f ) where
	  import B( f )		|	  f = h 3
	  g = ...		|	  h = ...
\end{verbatim}
836

837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
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> :: ... ;
861
862
863
864
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.
865

866
\begin{code}
867
868
869
870
871
872
873
874
875
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
876
877
  = getIfacesRn					`thenRn` \ ifaces ->
    let
878
879
880
881
882
	export_all_mods = case exports of
				Nothing -> []
				Just es -> [mod | IEModuleContents mod <- es, 
						  mod /= this_mod]

883
884
	mod_map   = iImpModInfo ifaces
	imp_names = iVSlurp     ifaces
885

886
	-- mv_map groups together all the things imported from a particular module.
887
	mv_map :: FiniteMap ModuleName [(OccName,Version)]
888
	mv_map = foldr add_mv emptyFM imp_names
889

890
891
892
        add_mv (name, version) mv_map = addItem mv_map (moduleName (nameModule name)) 
						       (nameOccName name, version)

893
	-- Build the result list by adding info for each module.
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
	-- 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.

909
	mk_imp_info mod_name (has_orphans, is_boot, contents) so_far
910
911
912
913
914
915
916
	   | 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
917
	   = let
918
		go_for_it exports = (mod_name, has_orphans, is_boot, exports) 
919
                                    : so_far
920
921
922
923
924
925
926
927
	     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.
928
			-- The module in question must be a local module (in the same package)
929
		   go_for_it NothingAtAll
930

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

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

	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
965
    in
966
    returnRn (export_info, import_info)
967

968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983

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
984
\end{code}
985

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

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

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


1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
%*********************************************************
%*							*
\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@).

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

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

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

1033
getDeclBinders new_name (TyClD (TySynonym tycon _ _ src_loc))
1034
  = new_name tycon src_loc		`thenRn` \ tycon_name ->
1035
    returnRn (Just (AvailTC tycon_name [tycon_name]))
1036

1037
getDeclBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ _ _ _ _ src_loc))
1038
  = new_name cname src_loc			`thenRn` \ class_name ->
1039
1040

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

1047
    returnRn (Just (AvailTC class_name (class_name : sub_names)))
1048
1049
1050

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

1053
1054
getDeclBinders new_name (FixD _)    = returnRn Nothing
getDeclBinders new_name (DeprecD _) = returnRn Nothing
sof's avatar
sof committed
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065

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

  | otherwise -- a foreign export
  = lookupImplicitOccRn nm `thenRn_` 
    returnRn Nothing

1066
1067
getDeclBinders new_name (DefD _)  = returnRn Nothing
getDeclBinders new_name (InstD _) = returnRn Nothing
1068
getDeclBinders new_name (RuleD _) = returnRn Nothing
1069

sof's avatar
sof committed
1070
1071
binds_haskell_name (FoImport _) _   = True
binds_haskell_name FoLabel      _   = True
1072
binds_haskell_name FoExport  ext_nm = isDynamicExtName ext_nm
sof's avatar
sof committed
1073

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

1082
getConFieldNames new_name (ConDecl con _ _ _ condecl src_loc : rest)
sof's avatar
sof committed
1083
  = new_name con src_loc		`thenRn` \ n ->
sof's avatar
sof committed
1084
1085
1086
1087
1088
    (case condecl of
      NewCon _ (Just f) -> 
        new_name f src_loc `thenRn` \ new_f ->
	returnRn [n,new_f]
      _ -> returnRn [n])		`thenRn` \ nn ->
sof's avatar
sof committed
1089
    getConFieldNames new_name rest	`thenRn` \ ns -> 
sof's avatar
sof committed
1090
    returnRn (nn ++ ns)
sof's avatar
sof committed
1091

1092
getConFieldNames new_name [] = returnRn []
1093

1094
getClassOpNames new_name (ClassOpSig op _ _ _ src_loc) = new_name op src_loc
1095
1096
\end{code}

1097
1098
@getDeclSysBinders@ gets the implicit binders introduced by a decl.
A the moment that's just the tycon and datacon that come with a class decl.
1099
1100
They aren't returned by @getDeclBinders@ because they aren't in scope;
but they {\em should} be put into the @DeclsMap@ of this module.
1101

1102
1103
1104
1105
Note that this excludes the default-method names of a class decl,
and the dict fun of an instance decl, because both of these have 
bindings of their own elsewhere.

1106
\begin{code}
1107
1108
1109
getDeclSysBinders new_name (TyClD (ClassDecl _ cname _ _ sigs _ _ tname dname dwname snames src_loc))
  = sequenceRn [new_name n src_loc | n <- (tname : dname : dwname : snames)]

1110
getDeclSysBinders new_name (TyClD (TyData _ _ _ _ cons _ _ _ _))
1111
  = sequenceRn [new_name wkr_name src_loc | ConDecl _ wkr_name _ _ _ src_loc <- cons]
1112
1113
1114
1115

getDeclSysBinders new_name other_decl
  = returnRn []
\end{code}
1116

1117
1118
1119
1120
1121
1122
%*********************************************************
%*							*
\subsection{Reading an interface file}
%*							*
%*********************************************************

1123
\begin{code}
1124
1125
1126
findAndReadIface :: SDoc -> ModuleName 
		 -> IsBootInterface	-- True  <=> Look for a .hi-boot file
					-- False <=> Look for .hi file
1127
		 -> RnM d (Either Message ParsedIface)
1128
1129
	-- Nothing <=> file not found, or unreadable, or illegible
	-- Just x  <=> successfully found and parsed 
1130

1131
findAndReadIface doc_str mod_name hi_boot_file
1132
  = traceRn trace_msg			`thenRn_`