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

\begin{code}
module RnIfaces (
8
9
	getInterfaceExports,
	getImportedInstDecls,
sof's avatar
sof committed
10
	getSpecialInstModules, getDeferredDataDecls,
11
	importDecl, recordSlurp,
sof's avatar
sof committed
12
	getImportVersions, getSlurpedNames, getRnStats,
13
14
15
16
17

	checkUpToDate,

	getDeclBinders,
	mkSearchPath
18
19
    ) where

20
#include "HsVersions.h"
21

sof's avatar
sof committed
22
import CmdLineOpts	( opt_PruneTyDecls,  opt_PruneInstDecls, 
23
			  opt_IgnoreIfacePragmas
sof's avatar
sof committed
24
			)
25
26
27
import HsSyn		( HsDecl(..), TyDecl(..), ClassDecl(..), InstDecl(..), IfaceSig(..), 
			  HsType(..), ConDecl(..), IE(..), ConDetails(..), Sig(..),
			  hsDeclName
28
29
			)
import HsPragmas	( noGenPragmas )
30
31
32
import BasicTypes	( Version, NewOrData(..), IfaceFlavour(..) )
import RdrHsSyn		( RdrNameHsDecl, RdrNameInstDecl, RdrNameTyDecl,
			  RdrName(..), rdrNameOcc
33
			)
34
import RnEnv		( newImportedGlobalName, addImplicitOccsRn, ifaceFlavour,
35
36
			  availName, availNames, addAvailToNameSet, pprAvail
			)
sof's avatar
sof committed
37
import RnSource		( rnHsSigType )
38
import RnMonad
39
40
import RnHsSyn          ( RenamedHsDecl )
import ParseIface	( parseIface, IfaceStuff(..) )
41

sof's avatar
sof committed
42
43
44
45
import FiniteMap	( FiniteMap, sizeFM, emptyFM, unitFM,  delFromFM,
			  lookupFM, addToFM, addToFM_C, addListToFM, 
			  fmToList, eltsFM 
			)
46
import Name		( Name {-instance NamedThing-}, Provenance, OccName(..),
sof's avatar
sof committed
47
			  nameModule, occNameString, moduleString, pprModule, isLocallyDefined,
48
			  NameSet(..), emptyNameSet, unionNameSets, nameSetToList,
sof's avatar
sof committed
49
			  minusNameSet, mkNameSet, elemNameSet, nameUnique, addOneToNameSet,
sof's avatar
sof committed
50
51
			  isWiredInName, maybeWiredInTyConName, maybeWiredInIdName,
			  NamedThing(..)
52
			 )
sof's avatar
sof committed
53
import Id		( GenId, Id(..), idType, dataConTyCon, isAlgCon )
54
55
56
import TyCon		( TyCon, tyConDataCons, isSynTyCon, getSynTyConDefn )
import Type		( namesOfType )
import TyVar		( GenTyVar )
57
import SrcLoc		( mkSrcLoc, SrcLoc )
sof's avatar
sof committed
58
59
import PrelMods		( gHC__ )
import PrelInfo		( cCallishTyKeys )
60
61
62
import Bag
import Maybes		( MaybeErr(..), expectJust, maybeToBool )
import ListSetOps	( unionLists )
63
import Outputable
sof's avatar
sof committed
64
import Unique		( Unique )
65
import StringBuffer     ( StringBuffer, hGetStringBuffer, freeStringBuffer )
66
import FastString	( mkFastString )
sof's avatar
sof committed
67
import Outputable
68
69
70

import IO	( isDoesNotExistError )
import List	( nub )
71
72
\end{code}

73
74


sof's avatar
sof committed
75
76
77
78
79
80
81
%*********************************************************
%*							*
\subsection{Statistics}
%*							*
%*********************************************************

\begin{code}
82
getRnStats :: [RenamedHsDecl] -> RnMG SDoc
sof's avatar
sof committed
83
84
85
getRnStats all_decls
  = getIfacesRn 		`thenRn` \ ifaces ->
    let
sof's avatar
sof committed
86
87
	Ifaces this_mod mod_map decls_fm all_names imp_names (unslurped_insts,_) deferred_data_decls inst_mods = ifaces
	n_mods	    = sizeFM mod_map
sof's avatar
sof committed
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

	decls_imported = filter is_imported_decl all_decls
	decls_read     = [decl | (name, (_, avail, decl)) <- fmToList decls_fm,
				 name == availName avail,
					-- Data, newtype, and class decls are in the decls_fm
					-- under multiple names; the tycon/class, and each
					-- constructor/class op too.
				 not (isLocallyDefined name)
			     ]

	(cd_rd, dd_rd, add_rd, nd_rd, and_rd, sd_rd, vd_rd,     _) = count_decls decls_read
	(cd_sp, dd_sp, add_sp, nd_sp, and_sp, sd_sp, vd_sp, id_sp) = count_decls decls_imported

	inst_decls_unslurped  = length (bagToList unslurped_insts)
	inst_decls_read	      = id_sp + inst_decls_unslurped

	stats = vcat 
		[int n_mods <> text " interfaces read",
		 hsep [int cd_sp, text "class decls imported, out of", 
		        int cd_rd, text "read"],
		 hsep [int dd_sp, text "data decls imported (of which", int add_sp, text "abstractly), out of",  
			int dd_rd, text "read"],
		 hsep [int nd_sp, text "newtype decls imported (of which", int and_sp, text "abstractly), out of",  
		        int nd_rd, text "read"],
		 hsep [int sd_sp, text "type synonym decls imported, out of",  
		        int sd_rd, text "read"],
		 hsep [int vd_sp, text "value signatures imported, out of",  
		        int vd_rd, text "read"],
		 hsep [int id_sp, text "instance decls imported, out of",  
		        int inst_decls_read, text "read"]
		]
    in
    returnRn (hcat [text "Renamer stats: ", stats])

is_imported_decl (DefD _) = False
is_imported_decl (ValD _) = False
is_imported_decl decl     = not (isLocallyDefined (hsDeclName decl))

count_decls decls
127
  = -- pprTrace "count_decls" (ppr  decls
sof's avatar
sof committed
128
129
130
131
    --
    --			    $$
    --			    text "========="
    --			    $$
132
    --			    ppr imported_decls
sof's avatar
sof committed
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
    --	) $
    (class_decls, 
     data_decls,    abstract_data_decls,
     newtype_decls, abstract_newtype_decls,
     syn_decls, 
     val_decls, 
     inst_decls)
  where
    class_decls   = length [() | ClD _		     	    <- decls]
    data_decls    = length [() | TyD (TyData DataType _ _ _ _ _ _ _) <- decls]
    newtype_decls = length [() | TyD (TyData NewType  _ _ _ _ _ _ _) <- decls]
    abstract_data_decls    = length [() | TyD (TyData DataType _ _ _ [] _ _ _) <- decls]
    abstract_newtype_decls = length [() | TyD (TyData NewType  _ _ _ [] _ _ _) <- decls]
    syn_decls     = length [() | TyD (TySynonym _ _ _ _)    <- decls]
    val_decls     = length [() | SigD _		    	    <- decls]
    inst_decls    = length [() | InstD _		    <- decls]

\end{code}    

152
153
154
155
156
%*********************************************************
%*							*
\subsection{Loading a new interface file}
%*							*
%*********************************************************
157

158
\begin{code}
159
loadInterface :: SDoc -> Module -> IfaceFlavour -> RnMG Ifaces
sof's avatar
sof committed
160
loadInterface doc_str load_mod as_source
161
  = getIfacesRn 		`thenRn` \ ifaces ->
162
    let
sof's avatar
sof committed
163
	Ifaces this_mod mod_map decls 
sof's avatar
sof committed
164
165
	       all_names imp_names (insts, tycls_names) 
	       deferred_data_decls inst_mods = ifaces
166
    in
167
	-- CHECK WHETHER WE HAVE IT ALREADY
sof's avatar
sof committed
168
169
170
171
172
    case lookupFM mod_map load_mod of {
	Just (hif, _, _, _) | hif `as_good_as` as_source
			    -> 	-- Already in the cache; don't re-read it
				returnRn ifaces ;
	other ->
173
174

	-- READ THE MODULE IN
sof's avatar
sof committed
175
    findAndReadIface doc_str load_mod as_source	`thenRn` \ read_result ->
176
177
178
179
180
    case read_result of {
	-- Check for not found
	Nothing -> 	-- Not found, so add an empty export env to the Ifaces map
			-- so that we don't look again
		   let
sof's avatar
sof committed
181
182
183
184
			new_mod_map = addToFM mod_map load_mod (HiFile, 0, [],[])
			new_ifaces = Ifaces this_mod new_mod_map
					    decls all_names imp_names (insts, tycls_names) 
					    deferred_data_decls inst_mods
185
186
187
188
189
		   in
		   setIfacesRn new_ifaces		`thenRn_`
		   failWithRn new_ifaces (noIfaceErr load_mod) ;

	-- Found and parsed!
190
	Just (ParsedIface _ mod_vers usages exports rd_inst_mods fixs rd_decls rd_insts) ->
191
192

	-- LOAD IT INTO Ifaces
sof's avatar
sof committed
193
194
195
196
	-- 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)
sof's avatar
sof committed
197
    foldlRn (loadDecl load_mod as_source) decls rd_decls `thenRn` \ new_decls ->
sof's avatar
sof committed
198
    mapRn loadExport exports				 `thenRn` \ avails_s ->
sof's avatar
sof committed
199
    foldlRn (loadInstDecl load_mod) insts rd_insts	 `thenRn` \ new_insts ->
200
    let
sof's avatar
sof committed
201
	 mod_details = (as_source, mod_vers, concat avails_s, fixs)
202
203
204
205
206

			-- Exclude this module from the "special-inst" modules
	 new_inst_mods = inst_mods `unionLists` (filter (/= this_mod) rd_inst_mods)

	 new_ifaces = Ifaces this_mod
sof's avatar
sof committed
207
			     (addToFM mod_map load_mod mod_details)
208
209
			     new_decls
			     all_names imp_names
sof's avatar
sof committed
210
			     (new_insts, tycls_names)
sof's avatar
sof committed
211
			     deferred_data_decls 
212
			     new_inst_mods 
213
    in
214
215
    setIfacesRn new_ifaces		`thenRn_`
    returnRn new_ifaces
sof's avatar
sof committed
216
217
218
219
220
221
    }}

as_good_as HiFile any        = True
as_good_as any    HiBootFile = True
as_good_as _      _	     = False

222

sof's avatar
sof committed
223
224
loadExport :: ExportItem -> RnMG [AvailInfo]
loadExport (mod, hif, entities)
225
  = mapRn load_entity entities
226
  where
227
    new_name occ = newImportedGlobalName mod occ hif
228

sof's avatar
sof committed
229
230
231
232
    load_entity (Avail occ)
      =	new_name occ 		`thenRn` \ name ->
	returnRn (Avail name)
    load_entity (AvailTC occ occs)
233
      =	new_name occ 		`thenRn` \ name ->
sof's avatar
sof committed
234
235
        mapRn new_name occs 	`thenRn` \ names ->
        returnRn (AvailTC name names)
236

sof's avatar
sof committed
237
loadDecl :: Module 
sof's avatar
sof committed
238
         -> IfaceFlavour
sof's avatar
sof committed
239
	 -> DeclsMap
240
	 -> (Version, RdrNameHsDecl)
241
	 -> RnMG DeclsMap
sof's avatar
sof committed
242
loadDecl mod as_source decls_map (version, decl)
243
  = getDeclBinders new_implicit_name decl	`thenRn` \ avail ->
244
    returnRn (addListToFM decls_map
sof's avatar
sof committed
245
			  [(name,(version,avail,decl')) | name <- availNames avail]
246
    )
247
  where
sof's avatar
sof committed
248
249
250
251
252
253
254
255
256
257
258
259
260
261
    {-
      If a signature decl is being loaded and we're ignoring interface pragmas,
      toss away unfolding information.

      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
      it's interface file. Hence, B is recompiled, maybe changing it's interface file,
      which will the ufolding info used in A to become invalid. Simple way out is to
      just ignore unfolding info.
    -}
    decl' = 
     case decl of
sof's avatar
sof committed
262
       SigD (IfaceSig name tp ls loc) | from_hi_boot || opt_IgnoreIfacePragmas -> 
sof's avatar
sof committed
263
264
265
	    SigD (IfaceSig name tp [] loc)
       _ -> decl

266
267
    new_implicit_name rdr_name loc = newImportedGlobalName mod (rdrNameOcc rdr_name) as_source

sof's avatar
sof committed
268
269
270
    from_hi_boot = case as_source of
			HiBootFile -> True
			other	   -> False
271

272
273
274
275
loadInstDecl :: Module
	     -> Bag IfaceInst
	     -> RdrNameInstDecl
	     -> RnMG (Bag IfaceInst)
276
loadInstDecl mod_name insts decl@(InstDecl inst_ty binds uprags dfun_name src_loc)
277
278
279
280
281
282
283
284
  = 
	-- 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 ...
285
	--
286
287
288
289
290
291
292
293
294
	-- Here the gates are Baz and T, but *not* Foo.
    let 
	munged_inst_ty = case inst_ty of
				HsForAllTy tvs cxt ty -> HsForAllTy tvs [] ty
				HsPreForAllTy cxt ty  -> HsPreForAllTy [] ty
				other		      -> inst_ty
    in
	-- We find the gates by renaming the instance type with in a 
	-- and returning the occurrence pool.
295
296
    initRnMS emptyRnEnv mod_name vanillaInterfaceMode (
        findOccurrencesRn (rnHsSigType (text "an instance decl") munged_inst_ty)	
297
298
    )						`thenRn` \ gate_names ->
    returnRn (((mod_name, decl), gate_names) `consBag` insts)
299
300

vanillaInterfaceMode = InterfaceMode Compulsory (\_ -> False)
301
\end{code}
302

303

304
305
306
307
308
309
310
311
312
%********************************************************
%*							*
\subsection{Loading usage information}
%*							*
%********************************************************

\begin{code}
checkUpToDate :: Module -> RnMG Bool		-- True <=> no need to recompile
checkUpToDate mod_name
sof's avatar
sof committed
313
314
315
  = findAndReadIface doc_str mod_name HiFile	`thenRn` \ read_result ->

	-- CHECK WHETHER WE HAVE IT ALREADY
316
    case read_result of
317
	Nothing -> 	-- Old interface file not found, so we'd better bail out
sof's avatar
sof committed
318
		    traceRn (sep [ptext SLIT("Didnt find old iface"), 
319
				    pprModule mod_name])	`thenRn_`
320
321
322
323
324
		    returnRn False

	Just (ParsedIface _ _ usages _ _ _ _ _) 
		-> 	-- Found it, so now check it
		    checkModUsage usages
325
  where
326
	-- Only look in current directory, with suffix .hi
327
    doc_str = sep [ptext SLIT("need usage info from"), pprModule mod_name]
328

329
checkModUsage [] = returnRn True		-- Yes!  Everything is up to date!
330

331
checkModUsage ((mod, hif, old_mod_vers, whats_imported) : rest)
sof's avatar
sof committed
332
  = loadInterface doc_str mod hif	`thenRn` \ ifaces ->
333
    let
sof's avatar
sof committed
334
335
336
	Ifaces _ mod_map decls _ _ _ _ _ = ifaces
	maybe_new_mod_vers	         = lookupFM mod_map mod
	Just (_, new_mod_vers, _, _)     = maybe_new_mod_vers
337
    in
338
	-- If we can't find a version number for the old module then
339
	-- bail out saying things aren't up to date
340
    if not (maybeToBool maybe_new_mod_vers) then
341
	traceRn (sep [ptext SLIT("Can't find version number for module"), pprModule mod]) `thenRn_`
342
343
344
345
346
	returnRn False
    else

	-- If the module version hasn't changed, just move on
    if new_mod_vers == old_mod_vers then
347
	traceRn (sep [ptext SLIT("Module version unchanged:"), pprModule mod])	`thenRn_`
348
349
	checkModUsage rest
    else
350
351
352
353
354
355
356
357
358
359
360
361
    traceRn (sep [ptext SLIT("Module version has changed:"), pprModule mod])	`thenRn_`

	-- 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
    case whats_imported of {
      Everything -> traceRn (ptext SLIT("...and I needed the whole module"))	`thenRn_`
		    returnRn False;		   -- Bale out

      Specifically old_local_vers ->
362

363
	-- Non-empty usage list, so check item by item
364
    checkEntityUsage mod decls old_local_vers	`thenRn` \ up_to_date ->
365
    if up_to_date then
sof's avatar
sof committed
366
	traceRn (ptext SLIT("...but the bits I use haven't."))	`thenRn_`
367
368
369
	checkModUsage rest	-- This one's ok, so check the rest
    else
	returnRn False		-- This one failed, so just bail out now
370
    }
371
  where
372
    doc_str = sep [ptext SLIT("need version info for"), pprModule mod]
373
374


375
checkEntityUsage mod decls [] 
376
377
  = returnRn True	-- Yes!  All up to date!

378
checkEntityUsage mod decls ((occ_name,old_vers) : rest)
379
  = newImportedGlobalName mod occ_name HiFile	`thenRn` \ name ->
380
    case lookupFM decls name of
381
382

	Nothing       -> 	-- We used it before, but it ain't there now
383
			  putDocRn (sep [ptext SLIT("No longer exported:"), ppr name])	`thenRn_`
384
385
			  returnRn False

386
387
388
389
390
391
392
	Just (new_vers,_,_) 	-- It's there, but is it up to date?
		| new_vers == old_vers
			-- Up to date, so check the rest
		-> checkEntityUsage mod decls rest

		| otherwise
			-- Out of date, so bale out
393
		-> putDocRn (sep [ptext SLIT("Out of date:"), ppr name])  `thenRn_`
394
		   returnRn False
395
396
397
\end{code}


398
399
400
401
402
%*********************************************************
%*							*
\subsection{Getting in a declaration}
%*							*
%*********************************************************
403

404
\begin{code}
405
importDecl :: Occurrence -> RnSMode -> RnMG (Maybe RdrNameHsDecl)
406
407
	-- Returns Nothing for a wired-in or already-slurped decl

408
importDecl (name, loc) mode
409
410
  = checkSlurped name			`thenRn` \ already_slurped ->
    if already_slurped then
411
--	traceRn (sep [text "Already slurped:", ppr name])	`thenRn_`
412
413
414
	returnRn Nothing	-- Already dealt with
    else
    if isWiredInName name then
415
	getWiredInDecl name mode
416
417
418
    else 
       getIfacesRn 		`thenRn` \ ifaces ->
       let
sof's avatar
sof committed
419
         Ifaces this_mod _ _ _ _ _ _ _ = ifaces
sof's avatar
sof committed
420
         mod = nameModule name
421
422
       in
       if mod == this_mod  then    -- Don't bring in decls from
423
	  pprTrace "importDecl wierdness:" (ppr name) $
424
425
426
	  returnRn Nothing         -- the renamed module's own interface file
			           -- 
       else
427
       getNonWiredInDecl name loc mode
428
\end{code}
429

430
\begin{code}
431
432
getNonWiredInDecl :: Name -> SrcLoc -> RnSMode -> RnMG (Maybe RdrNameHsDecl)
getNonWiredInDecl needed_name loc mode
sof's avatar
sof committed
433
434
  = traceRn doc_str					 `thenRn_`
    loadInterface doc_str mod (ifaceFlavour needed_name) `thenRn` \ (Ifaces _ _ decls _ _ _ _ _) ->
sof's avatar
sof committed
435
436
437
438
439
    case lookupFM decls needed_name of

	-- Special case for data/newtype type declarations
      Just (version, avail, TyD ty_decl) | is_data_or_newtype ty_decl
	      -> getNonWiredDataDecl needed_name version avail ty_decl	`thenRn` \ (avail', maybe_decl) ->
sof's avatar
sof committed
440
		 recordSlurp (Just version) necessity avail'	`thenRn_`
sof's avatar
sof committed
441
		 returnRn maybe_decl
442

sof's avatar
sof committed
443
      Just (version,avail,decl)
sof's avatar
sof committed
444
	      -> recordSlurp (Just version) necessity avail	`thenRn_`
sof's avatar
sof committed
445
		 returnRn (Just decl)
446
447
448

      Nothing -> 	-- Can happen legitimately for "Optional" occurrences
		   case necessity of { 
449
450
				Optional -> addWarnRn (getDeclWarn needed_name loc);
				other	 -> addErrRn  (getDeclErr  needed_name loc)
451
452
		   }						`thenRn_` 
		   returnRn Nothing
453
  where
454
455
     necessity = modeToNecessity mode
     doc_str = sep [ptext SLIT("need decl for"), ppr needed_name, ptext SLIT("needed at"), ppr loc]
sof's avatar
sof committed
456
     mod = nameModule needed_name
sof's avatar
sof committed
457
458
459

     is_data_or_newtype (TyData _ _ _ _ _ _ _ _) = True
     is_data_or_newtype other		         = False
sof's avatar
sof committed
460

461
462
\end{code}

463
464
465
@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,
466

467
468
469
  *	if the wired-in name is a data type constructor or a data constructor, 
	it brings in the type constructor and all the data constructors; and
	marks as "occurrences" any free vars of the data con.
470

471
  * 	similarly for synonum type constructor
472

473
474
  * 	if the wired-in name is another wired-in Id, it marks as "occurrences"
	the free vars of the Id's type.
475

476
477
  *	it loads the interface file for the wired-in thing for the
	sole purpose of making sure that its instance declarations are available
478

479
480
481
482
All this is necessary so that we know all types that are "in play", so
that we know just what instances to bring into scope.
	
\begin{code}
483
484
getWiredInDecl name mode
  = initRnMS emptyRnEnv mod_name new_mode
sof's avatar
sof committed
485
486
	     get_wired				`thenRn` \ avail ->
    recordSlurp Nothing necessity avail		`thenRn_`
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508

   	-- Force in the home module in case it has instance decls for
	-- the thing we are interested in.
	--
	-- Mini hack 1: no point for non-tycons/class; and if we
	-- do this we find PrelNum trying to import PackedString,
	-- because PrelBase's .hi file mentions PackedString.unpackString
	-- But PackedString.hi isn't built by that point!
	--
	-- Mini hack 2; GHC is guaranteed not to have
	-- instance decls, so it's a waste of time to read it
	--
	-- NB: We *must* look at the availName of the slurped avail, 
	-- not the name passed to getWiredInDecl!  Why?  Because if a data constructor 
	-- or class op is passed to getWiredInDecl we'll pull in the whole data/class
	-- decl, and recordSlurp will record that fact.  But since the data constructor
	-- isn't a tycon/class we won't force in the home module.  And even if the
	-- type constructor/class comes along later, loadDecl will say that it's already
	-- been slurped, so getWiredInDecl won't even be called.  Pretty obscure bug, this was.
    let
	main_name  = availName avail
	main_is_tc = case avail of { AvailTC _ _ -> True; Avail _ -> False }
sof's avatar
sof committed
509
	mod        = nameModule main_name
510
	doc_str    = sep [ptext SLIT("need home module for wired in thing"), ppr name]
511
512
513
    in
    (if not main_is_tc || mod == gHC__ then
	returnRn ()		
514
    else
sof's avatar
sof committed
515
	loadInterface doc_str mod (ifaceFlavour main_name)	`thenRn_`
516
	returnRn ()
sof's avatar
sof committed
517
    )								`thenRn_`
518
519

    returnRn Nothing		-- No declaration to process further
520
  where
521
522
523
524
    necessity = modeToNecessity mode
    new_mode = case mode of 
			InterfaceMode _ _ -> mode
			SourceMode	  -> vanillaInterfaceMode
525

526
527
528
    get_wired | is_tycon			-- ... a type constructor
	      = get_wired_tycon the_tycon

sof's avatar
sof committed
529
	      | (isAlgCon the_id) 		-- ... a wired-in data constructor
530
531
532
533
534
	      = get_wired_tycon (dataConTyCon the_id)

	      | otherwise			-- ... a wired-in non data-constructor
	      = get_wired_id the_id

sof's avatar
sof committed
535
    mod_name		 = nameModule name
536
537
538
539
540
541
    maybe_wired_in_tycon = maybeWiredInTyConName name
    is_tycon		 = maybeToBool maybe_wired_in_tycon
    maybe_wired_in_id    = maybeWiredInIdName    name
    Just the_tycon	 = maybe_wired_in_tycon
    Just the_id 	 = maybe_wired_in_id

542

543
get_wired_id id
sof's avatar
sof committed
544
  = addImplicitOccsRn id_mentions 	`thenRn_`
545
    returnRn (Avail (getName id))
546
  where
sof's avatar
sof committed
547
548
    id_mentions = nameSetToList (namesOfType ty)
    ty = idType id
549

550
551
552
get_wired_tycon tycon 
  | isSynTyCon tycon
  = addImplicitOccsRn (nameSetToList mentioned)		`thenRn_`
sof's avatar
sof committed
553
    returnRn (AvailTC tc_name [tc_name])
554
  where
sof's avatar
sof committed
555
    tc_name     = getName tycon
556
    (tyvars,ty) = getSynTyConDefn tycon
sof's avatar
sof committed
557
    mentioned   = namesOfType ty `minusNameSet` mkNameSet (map getName tyvars)
558

559
560
561
get_wired_tycon tycon 
  | otherwise		-- data or newtype
  = addImplicitOccsRn (nameSetToList mentioned)		`thenRn_`
562
    returnRn (AvailTC tycon_name (tycon_name : map getName data_cons))
563
  where
564
565
566
    tycon_name = getName tycon
    data_cons  = tyConDataCons tycon
    mentioned  = foldr (unionNameSets . namesOfType . idType) emptyNameSet data_cons
567
568
569
\end{code}


570
    
571
572
%*********************************************************
%*							*
sof's avatar
sof committed
573
\subsection{Getting what a module exports}
574
575
%*							*
%*********************************************************
576
577

\begin{code}
sof's avatar
sof committed
578
getInterfaceExports :: Module -> IfaceFlavour -> RnMG (Avails, [(OccName,Fixity)])
sof's avatar
sof committed
579
getInterfaceExports mod as_source
sof's avatar
sof committed
580
581
  = loadInterface doc_str mod as_source	`thenRn` \ (Ifaces _ mod_map _ _ _ _ _ _) ->
    case lookupFM mod_map mod of
582
583
584
585
586
587
	Nothing ->	-- Not there; it must be that the interface file wasn't found;
			-- the error will have been reported already.
			-- (Actually loadInterface should put the empty export env in there
			--  anyway, but this does no harm.)
		      returnRn ([],[])

sof's avatar
sof committed
588
	Just (_, _, avails, fixities) -> returnRn (avails, fixities)
589
  where
590
    doc_str = sep [pprModule mod, ptext SLIT("is directly imported")]
sof's avatar
sof committed
591
592
593
594
595
596
597
598
599
600
601
602
603
604
\end{code}


%*********************************************************
%*							*
\subsection{Data type declarations are handled specially}
%*							*
%*********************************************************

Data type declarations get special treatment.  If we import a data type decl
with all its constructors, we end up importing all the types mentioned in 
the constructors' signatures, and hence {\em their} data type decls, and so on.
In effect, we get the transitive closure of data type decls.  Worse, this drags
in tons on instance decls, and their unfoldings, and so on.
605

sof's avatar
sof committed
606
607
608
If only the type constructor is mentioned, then all this is a waste of time.
If any of the data constructors are mentioned then we really have to 
drag in the whole declaration.
609

sof's avatar
sof committed
610
611
612
613
614
615
616
617
618
619
620
So when we import the type constructor for a @data@ or @newtype@ decl, we
put it in the "deferred data/newtype decl" pile in Ifaces.  Right at the end
we slurp these decls, if they havn't already been dragged in by an occurrence
of a constructor.

\begin{code}
getNonWiredDataDecl needed_name 
		    version
	 	    avail@(AvailTC tycon_name _) 
		    ty_decl@(TyData new_or_data context tycon tyvars condecls derivings pragmas src_loc)
  |  needed_name == tycon_name
sof's avatar
sof committed
621
  && opt_PruneTyDecls
622
623
624
625
626
  && not (nameUnique needed_name `elem` cCallishTyKeys)		
	-- Hack!  Don't prune these tycons whose constructors
	-- the desugarer must be able to see when desugaring
	-- a CCall.  Ugh!

sof's avatar
sof committed
627
628
629
  = 	-- Need the type constructor; so put it in the deferred set for now
    getIfacesRn 		`thenRn` \ ifaces ->
    let
630
631
632
633
634
	Ifaces this_mod mod_map decls_fm slurped_names imp_names 
	       unslurped_insts deferred_data_decls inst_mods = ifaces

	new_ifaces = Ifaces this_mod mod_map decls_fm slurped_names imp_names
			    unslurped_insts new_deferred_data_decls inst_mods
sof's avatar
sof committed
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650

	no_constr_ty_decl       = TyData new_or_data [] tycon tyvars [] derivings pragmas src_loc
	new_deferred_data_decls = addToFM deferred_data_decls tycon_name no_constr_ty_decl
		-- Nota bene: we nuke both the constructors and the context in the deferred decl.
		-- If we don't nuke the context then renaming the deferred data decls can give
		-- new unresolved names (for the classes).  This could be handled, but there's
		-- no point.  If the data type is completely abstract then we aren't interested
		-- its context.
    in
    setIfacesRn new_ifaces	`thenRn_`
    returnRn (AvailTC tycon_name [tycon_name], Nothing)

  | otherwise
  = 	-- Need a data constructor, so delete the data decl from the deferred set if it's there
    getIfacesRn 		`thenRn` \ ifaces ->
    let
651
652
653
654
655
	Ifaces this_mod mod_map decls_fm slurped_names imp_names 
	       unslurped_insts deferred_data_decls inst_mods = ifaces

	new_ifaces = Ifaces this_mod mod_map decls_fm slurped_names imp_names 
			    unslurped_insts new_deferred_data_decls inst_mods
sof's avatar
sof committed
656
657
658
659
660
661
662
663
664
665

	new_deferred_data_decls = delFromFM deferred_data_decls tycon_name
    in
    setIfacesRn new_ifaces	`thenRn_`
    returnRn (avail, Just (TyD ty_decl))
\end{code}

\begin{code}
getDeferredDataDecls :: RnMG [(Name, RdrNameTyDecl)]
getDeferredDataDecls 
sof's avatar
sof committed
666
  = getIfacesRn 		`thenRn` \ (Ifaces _ _ _ _ _ _ deferred_data_decls _) ->
sof's avatar
sof committed
667
668
669
    let
	deferred_list = fmToList deferred_data_decls
	trace_msg = hang (text "Slurping abstract data/newtype decls for: ")
670
			4 (ppr (map fst deferred_list))
sof's avatar
sof committed
671
672
673
674
675
676
677
678
679
680
681
682
683
    in
    traceRn trace_msg			`thenRn_`
    returnRn deferred_list
\end{code}


%*********************************************************
%*							*
\subsection{Instance declarations are handled specially}
%*							*
%*********************************************************

\begin{code}
684
getImportedInstDecls :: RnMG [(Module,RdrNameInstDecl)]
685
686
687
688
getImportedInstDecls
  = 	-- First load any special-instance modules that aren't aready loaded
    getSpecialInstModules 			`thenRn` \ inst_mods ->
    mapRn load_it inst_mods			`thenRn_`
689

690
	-- Now we're ready to grab the instance declarations
691
692
693
	-- Find the un-gated ones and return them, 
	-- removing them from the bag kept in Ifaces
    getIfacesRn 	`thenRn` \ ifaces ->
694
    let
sof's avatar
sof committed
695
	Ifaces this_mod mod_map decls slurped_names imp_names (insts, tycls_names) deferred_data_decls inst_mods = ifaces
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710

		-- An instance decl is ungated if all its gates have been slurped
        select_ungated :: IfaceInst					-- A gated inst decl

		       -> ([(Module, RdrNameInstDecl)], [IfaceInst])	-- Accumulator

		       -> ([(Module, RdrNameInstDecl)], 		-- The ungated ones
			   [IfaceInst]) 				-- Still gated, but with
									-- depeleted gates
	select_ungated (decl,gates) (ungated_decls, gated_decls)
	  | null remaining_gates
	  = (decl : ungated_decls, gated_decls)
	  | otherwise
	  = (ungated_decls, (decl, remaining_gates) : gated_decls)
	  where
sof's avatar
sof committed
711
	    remaining_gates = filter (not . (`elemNameSet` tycls_names)) gates
712
713
714

	(un_gated_insts, still_gated_insts) = foldrBag select_ungated ([], []) insts
	
sof's avatar
sof committed
715
	new_ifaces = Ifaces this_mod mod_map decls slurped_names imp_names
sof's avatar
sof committed
716
717
			    ((listToBag still_gated_insts), tycls_names)
				-- NB: don't throw away tycls_names; we may comre across more instance decls
sof's avatar
sof committed
718
			    deferred_data_decls 
719
			    inst_mods
720
    in
721
    traceRn (sep [text "getInstDecls:", fsep (map ppr (nameSetToList tycls_names))])	`thenRn_`
722
723
    setIfacesRn new_ifaces	`thenRn_`
    returnRn un_gated_insts
724
  where
sof's avatar
sof committed
725
    load_it mod = loadInterface (doc_str mod) mod HiFile
726
    doc_str mod = sep [pprModule mod, ptext SLIT("is a special-instance module")]
727

728
729
730
731
732

getSpecialInstModules :: RnMG [Module]
getSpecialInstModules 
  = getIfacesRn						`thenRn` \ ifaces ->
    let
sof's avatar
sof committed
733
	 Ifaces _ _ _ _ _ _ _ inst_mods = ifaces
734
735
    in
    returnRn inst_mods
736
737
\end{code}

sof's avatar
sof committed
738
739
740
741
742
743
744

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

745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
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:
	- anything reachable from its body code
	- any module exported with a "module Foo".

Why the latter?  Because if Foo changes then this module's export list
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.

What about this? 
	module A( f, g ) where		module B( f ) where
	  import B( f )			  f = h 3
	  g = ...			  h = ...

Should we record B.f in A's usages?  In fact we don't.  Certainly, if
anything about B.f changes than anyone who imports A should be recompiled;
they'll get an early exit if they don't use B.f.  However, 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.  So there are two things going on when compiling module A:

1.  Are A.o and A.hi correct?  Then we can bale out early.
2.  Should modules that import A be recompiled?

For (1) it is slightly harmful to record B.f in A's usages, because a change in
B.f's version will provoke full recompilation of A, producing an identical A.o,
and A.hi differing only in its usage-version of B.f (which isn't used by any importer).

For (2), because of the tricky B.h question above, we ensure that A.hi is touched
(even if identical to its previous version) if A's recompilation was triggered by
an imported .hi file date change.  Given that, there's no need to record B.f in
A's usages.

On the other hand, if A exports "module B" then we *do* count module B among
A's usages, because we must recompile A to ensure that A.hi changes appropriately.

782
\begin{code}
783
784
getImportVersions :: Module			-- Name of this module
		  -> Maybe [IE any]		-- Export list for this module
785
		  -> RnMG (VersionInfo Name)	-- Version info for these names
786

787
getImportVersions this_mod exports
788
789
  = getIfacesRn					`thenRn` \ ifaces ->
    let
sof's avatar
sof committed
790
	 Ifaces _ mod_map _ _ imp_names _ _ _ = ifaces
791
792

	 -- mv_map groups together all the things imported from a particular module.
793
	 mv_map, mv_map_mod :: FiniteMap Module (WhatsImported Name)
794
795
796

	 mv_map_mod = foldl add_mod emptyFM export_mods
		-- mv_map_mod records all the modules that have a "module M"
797
		-- in this module's export list with an "Everything" 
798
799
800
801

	 mv_map = foldl add_mv mv_map_mod imp_names
		-- mv_map adds the version numbers of things exported individually

sof's avatar
sof committed
802
803
804
805
806
	 mk_version_info (mod, local_versions)
	   = case lookupFM mod_map mod of
		Just (hif, version, _, _) -> (mod, hif, version, local_versions)
    in
    returnRn (map mk_version_info (fmToList mv_map))
807
808
809
810
811
812
  where
     export_mods = case exports of
			Nothing -> []
			Just es -> [mod | IEModuleContents mod <- es, mod /= this_mod]

     add_mv mv_map v@(name, version) 
813
      = addToFM_C add_item mv_map mod (Specifically [v]) 
814
	where
sof's avatar
sof committed
815
	 mod = nameModule name
816

817
818
819
820
         add_item Everything        _ = Everything
         add_item (Specifically xs) _ = Specifically (v:xs)

     add_mod mv_map mod = addToFM mv_map mod Everything
821
\end{code}
822

sof's avatar
sof committed
823
824
\begin{code}
checkSlurped name
sof's avatar
sof committed
825
  = getIfacesRn 	`thenRn` \ (Ifaces _ _ _ slurped_names _ _ _ _) ->
sof's avatar
sof committed
826
827
828
829
830
831
    returnRn (name `elemNameSet` slurped_names)

getSlurpedNames :: RnMG NameSet
getSlurpedNames
  = getIfacesRn 	`thenRn` \ ifaces ->
    let
sof's avatar
sof committed
832
	 Ifaces _ _ _ slurped_names _ _ _ _ = ifaces
sof's avatar
sof committed
833
834
835
    in
    returnRn slurped_names

sof's avatar
sof committed
836
recordSlurp maybe_version necessity avail
837
  = {- traceRn (hsep [text "Record slurp:", pprAvail avail, 
sof's avatar
sof committed
838
839
					-- NB PprForDebug prints export flag, which is too
					-- strict; it's a knot-tied thing in RnNames
sof's avatar
sof committed
840
841
		  case necessity of {Compulsory -> text "comp"; Optional -> text "opt" } ])	`thenRn_` 
    -}
sof's avatar
sof committed
842
843
    getIfacesRn 	`thenRn` \ ifaces ->
    let
844
845
846
	Ifaces this_mod mod_map decls slurped_names imp_names 
	       (insts, tycls_names) deferred_data_decls inst_mods = ifaces

sof's avatar
sof committed
847
848
849
	new_slurped_names = addAvailToNameSet slurped_names avail

	new_imp_names = case maybe_version of
sof's avatar
sof committed
850
			   Just version	-> (availName avail, version) : imp_names
sof's avatar
sof committed
851
852
			   Nothing      -> imp_names

sof's avatar
sof committed
853
854
855
856
857
858
859
860
861
		-- Add to the names that will let in instance declarations;
		-- but only (a) if it's a type/class
		--	    (b) if it's compulsory (unless the test flag opt_PruneInstDecls is off)
	new_tycls_names = case avail of
				AvailTC tc _  | not opt_PruneInstDecls || 
						case necessity of {Optional -> False; Compulsory -> True }
					      -> tycls_names `addOneToNameSet` tc
				otherwise     -> tycls_names

sof's avatar
sof committed
862
	new_ifaces = Ifaces this_mod mod_map decls 
sof's avatar
sof committed
863
864
			    new_slurped_names 
			    new_imp_names
sof's avatar
sof committed
865
			    (insts, new_tycls_names)
sof's avatar
sof committed
866
867
868
869
870
871
872
			    deferred_data_decls 
			    inst_mods
    in
    setIfacesRn new_ifaces
\end{code}


873
874
875
876
877
878
879
880
881
882
883
884
885
%*********************************************************
%*							*
\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@).

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

886
\begin{code}
sof's avatar
sof committed
887
getDeclBinders :: (RdrName -> SrcLoc -> RnMG Name)	-- New-name function
888
889
		-> RdrNameHsDecl
		-> RnMG AvailInfo
890

sof's avatar
sof committed
891
getDeclBinders new_name (TyD (TyData _ _ tycon _ condecls _ _ src_loc))
892
893
  = new_name tycon src_loc			`thenRn` \ tycon_name ->
    getConFieldNames new_name condecls		`thenRn` \ sub_names ->
sof's avatar
sof committed
894
895
896
    returnRn (AvailTC tycon_name (tycon_name : nub sub_names))
	-- The "nub" is because getConFieldNames can legitimately return duplicates,
	-- when a record declaration has the same field in multiple constructors
897

898
899
getDeclBinders new_name (TyD (TySynonym tycon _ _ src_loc))
  = new_name tycon src_loc		`thenRn` \ tycon_name ->
sof's avatar
sof committed
900
    returnRn (AvailTC tycon_name [tycon_name])
901

902
getDeclBinders new_name (ClD (ClassDecl _ cname _ sigs _ _ tname dname src_loc))
903
  = new_name cname src_loc			`thenRn` \ class_name ->
904
905
906
907
    new_name dname src_loc		        `thenRn` \ datacon_name ->
    new_name tname src_loc		        `thenRn` \ tycon_name ->

	-- Record the names for the class ops
908
    mapRn (getClassOpNames new_name) sigs	`thenRn` \ sub_names ->
909
910

    returnRn (AvailTC class_name (class_name : datacon_name : tycon_name : sub_names))
911
912
913

getDeclBinders new_name (SigD (IfaceSig var ty prags src_loc))
  = new_name var src_loc			`thenRn` \ var_name ->
914
    returnRn (Avail var_name)
915
916
917
918
919

getDeclBinders new_name (DefD _)  = returnRn NotAvailable
getDeclBinders new_name (InstD _) = returnRn NotAvailable

----------------
sof's avatar
sof committed
920
getConFieldNames new_name (ConDecl con _ (RecCon fielddecls) src_loc : rest)
921
922
923
  = mapRn (\n -> new_name n src_loc) (con:fields)	`thenRn` \ cfs ->
    getConFieldNames new_name rest			`thenRn` \ ns  -> 
    returnRn (cfs ++ ns)
924
  where
925
926
    fields = concat (map fst fielddecls)

sof's avatar
sof committed
927
928
929
930
931
getConFieldNames new_name (ConDecl con _ _ src_loc : rest)
  = new_name con src_loc		`thenRn` \ n ->
    getConFieldNames new_name rest	`thenRn` \ ns -> 
    returnRn (n:ns)

932
getConFieldNames new_name [] = returnRn []
933

934
getClassOpNames new_name (ClassOpSig op _ _ src_loc) = new_name op src_loc
935
936
937
\end{code}


938
939
940
941
942
943
%*********************************************************
%*							*
\subsection{Reading an interface file}
%*							*
%*********************************************************

944
\begin{code}
945
findAndReadIface :: SDoc -> Module 
sof's avatar
sof committed
946
947
	  	 -> IfaceFlavour 
		 -> RnMG (Maybe ParsedIface)
948
949
	-- Nothing <=> file not found, or unreadable, or illegible
	-- Just x  <=> successfully found and parsed 
sof's avatar
sof committed
950
findAndReadIface doc_str mod_name as_source
951
952
953
954
  = traceRn trace_msg			`thenRn_`
    getSearchPathRn			`thenRn` \ dirs ->
    try dirs dirs
  where
sof's avatar
sof committed
955
956
957
    trace_msg = sep [hsep [ptext SLIT("Reading"), 
			   case as_source of { HiBootFile -> ptext SLIT("[boot]"); other -> empty},
			   ptext SLIT("interface for"), 
sof's avatar
sof committed
958
959
			   ptext mod_name <> semi],
		     nest 4 (ptext SLIT("reason:") <+> doc_str)]
sof's avatar
sof committed
960
961
962
963

	-- For import {-# SOURCE #-} Foo, "as_source" will be True
	-- and we read Foo.hi-boot, not Foo.hi.  This is used to break
	-- loops among modules.
sof's avatar
sof committed
964
965
966
    mod_suffix hi = case as_source of
			HiBootFile -> ".hi-boot" -- Ignore `ways' for boot files.
			HiFile     -> hi
sof's avatar
sof committed
967
968

    try all_dirs [] = traceRn (ptext SLIT("...failed"))	`thenRn_`
969
970
		      returnRn Nothing

sof's avatar
sof committed
971
    try all_dirs ((dir,hisuf):dirs)
972
973
	= readIface file_path	`thenRn` \ read_result ->
	  case read_result of
sof's avatar
sof committed
974
975
976
	      Nothing    -> try all_dirs dirs
	      Just iface -> traceRn (ptext SLIT("...done"))	`thenRn_`
			    returnRn (Just iface)
977
	where
sof's avatar
sof committed
978
	  file_path = dir ++ '/' : moduleString mod_name ++ (mod_suffix hisuf)
979
\end{code}
980

981
@readIface@ trys just one file.
982

983
984
985
986
987
\begin{code}
readIface :: String -> RnMG (Maybe ParsedIface)	
	-- Nothing <=> file not found, or unreadable, or illegible
	-- Just x  <=> successfully found and parsed 
readIface file_path
sof's avatar
sof committed
988
989
  = ioToRnMG (hGetStringBuffer file_path)                       `thenRn` \ read_result ->
    --traceRn (hcat[ptext SLIT("Opening...."), text file_path])   `thenRn_`
990
    case read_result of
sof's avatar
sof committed
991
	Right contents	  -> 
992
             case parseIface contents (mkSrcLoc (mkFastString file_path) 1) of
sof's avatar
sof committed
993
994
	          Failed err      ->
		     failWithRn Nothing err 
995
		  Succeeded (PIface iface) -> 
sof's avatar
sof committed
996
		     returnRn (Just iface)
997

sof's avatar
sof committed
998
999
1000
1001
1002
        Left err ->
	  if isDoesNotExistError err then
	     returnRn Nothing
	  else
	     failWithRn Nothing (cannaeReadFile file_path err)
1003
1004
\end{code}

sof's avatar
sof committed
1005
1006
1007
mkSearchPath takes a string consisting of a colon-separated list
of directories and corresponding suffixes, and turns it into a list
of (directory, suffix) pairs.  For example:
1008

sof's avatar
sof committed
1009
\begin{verbatim}
sof's avatar
sof committed
1010
1011
 mkSearchPath "foo%.hi:.%.p_hi:baz%.mc_hi"
   = [("foo",".hi"),( ".", ".p_hi"), ("baz",".mc_hi")]
sof's avatar
sof committed
1012
\begin{verbatim}
1013
1014
1015

\begin{code}
mkSearchPath :: Maybe String -> SearchPath
sof's avatar
sof committed
1016
mkSearchPath Nothing = [(".",".hi")]
1017
1018
1019
mkSearchPath (Just s)
  = go s
  where
sof's avatar
sof committed
1020
    go "" = []
sof's avatar
sof committed
1021
1022
1023
1024
1025
1026
    go s  = 
      case span (/= '%') s of
       (dir,'%':rs) ->
         case span (/= ':') rs of
          (hisuf,_:rest) -> (dir,hisuf):go rest
          (hisuf,[])     -> [(dir,hisuf)]
1027
\end{code}
1028

1029
%*********************************************************
sof's avatar
sof committed
1030
%*						 	 *
1031
\subsection{Errors}
sof's avatar
sof committed
1032
%*							 *
1033
%*********************************************************
1034

1035
\begin{code}
1036
noIfaceErr filename
sof's avatar
sof committed
1037
  = hcat [ptext SLIT("Could not find valid interface file "), 
1038
          quotes (pprModule filename)]
1039

1040
cannaeReadFile file err
sof's avatar
sof committed
1041
1042
1043
1044
  = hcat [ptext SLIT("Failed in reading file: "), 
           text file, 
	  ptext SLIT("; error="), 
	   text (show err)]
1045

1046
getDeclErr name loc
sof's avatar
sof committed
1047
  = sep [ptext SLIT("Failed to find interface decl for"), 
1048
         quotes (ppr name), ptext SLIT("needed at"), ppr loc]
1049

1050
getDeclWarn name loc
sof's avatar
sof committed
1051
  = sep [ptext SLIT("Warning: failed to find (optional) interface decl for"), 
1052
         quotes (ppr name), ptext SLIT("desired at"), ppr loc]
1053
\end{code}