HscTypes.lhs 37.4 KB
Newer Older
1

2
3
4
5
6
% (c) The University of Glasgow, 2000
%
\section[HscTypes]{Types for the per-module compiler}

\begin{code}
7
module HscTypes ( 
8
9
10
11
12
	-- * Sessions and compilation state
	Session(..), HscEnv(..), hscEPS,
	FinderCache, FinderCacheEntry,
	Target(..), TargetId(..), pprTarget, pprTargetId,
	ModuleGraph, emptyMG,
13

14
	ModDetails(..),	emptyModDetails,
15
	ModGuts(..), CgGuts(..), ModImports(..), ForeignStubs(..),
16

17
	ModSummary(..), showModMsg, isBootSummary,
18
19
20
21
	msHsFilePath, msHiFilePath, msObjFilePath, 

	HscSource(..), isHsBoot, hscSourceString,	-- Re-exported from DriverPhases
	
22
	HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
23
	hptInstances, hptRules,
24

25
	ExternalPackageState(..), EpsStats(..), addEpsInStats,
26
	PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
27
	lookupIface, lookupIfaceByModule, emptyModIface,
28

29
30
31
32
	InteractiveContext(..), emptyInteractiveContext, 
	icPrintUnqual, unQualInScope,

	ModIface(..), mkIfaceDepCache, mkIfaceVerCache, mkIfaceFixCache,
33
	emptyIfaceDepCache, 
34

35
	Deprecs(..), IfaceDeprecs,
36

37
	FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,
38

39
	implicitTyThings, 
40

41
	TyThing(..), tyThingClass, tyThingTyCon, tyThingDataCon, tyThingId,
42
	TypeEnv, lookupType, mkTypeEnv, emptyTypeEnv,
43
	extendTypeEnv, extendTypeEnvList, extendTypeEnvWithIds, lookupTypeEnv,
44
	typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
45

46
	WhetherHasOrphans, IsBootInterface, Usage(..), 
47
	Dependencies(..), noDependencies,
48
49
	NameCache(..), OrigNameCache, OrigIParamCache,
	Avails, availsToNameSet, availName, availNames,
50
	GenAvailInfo(..), AvailInfo, RdrAvailInfo, 
51
	IfaceExport,
52

53
	Deprecations, DeprecTxt, lookupDeprec, plusDeprecs,
54

55
	PackageInstEnv, PackageRuleBase,
56

57
58
59
	-- Linker stuff
	Linkable(..), isObjectLinkable,
	Unlinked(..), CompiledByteCode,
60
	isObject, nameOfObject, isInterpretable, byteCodeOfObject
61
    ) where
62
63
64

#include "HsVersions.h"

65
66
67
68
#ifdef GHCI
import ByteCodeAsm	( CompiledByteCode )
#endif

69
70
import RdrName		( GlobalRdrEnv, emptyGlobalRdrEnv,
			  LocalRdrEnv, emptyLocalRdrEnv,
71
			  GlobalRdrElt(..), mkRdrUnqual, lookupGRE_RdrName )
72
import Name		( Name, NamedThing, getName, nameOccName, nameModule )
73
import NameEnv
74
import NameSet	
75
import OccName		( OccName, OccEnv, lookupOccEnv, mkOccEnv, emptyOccEnv, 
76
			  extendOccEnv )
77
import Module
78
import InstEnv		( InstEnv, Instance )
79
import Rules		( RuleBase )
80
import CoreSyn		( CoreBind )
81
import Id		( Id )
82
83
import Type		( TyThing(..) )

84
import Class		( Class, classSelIds, classTyCon )
85
import TyCon		( TyCon, tyConSelIds, tyConDataCons )
86
import DataCon		( dataConImplicitIds )
87
import PrelNames	( gHC_PRIM )
88
import Packages		( PackageIdH, PackageId, PackageConfig, HomeModules )
89
import DynFlags		( DynFlags(..), isOneShot, HscTarget (..) )
90
import DriverPhases	( HscSource(..), isHsBoot, hscSourceString, Phase )
91
92
import BasicTypes	( Version, initialVersion, IPName, 
			  Fixity, defaultFixity, DeprecTxt )
93

94
import IfaceSyn		( IfaceInst, IfaceRule, IfaceDecl(ifName) )
95

96
import FiniteMap	( FiniteMap )
97
import CoreSyn		( CoreRule )
Simon Marlow's avatar
Simon Marlow committed
98
import Maybes		( orElse, expectJust )
99
import Outputable
100
import SrcLoc		( SrcSpan, Located )
101
import UniqSupply	( UniqSupply )
102
103
import FastString	( FastString )

104
import DATA_IOREF	( IORef, readIORef )
105
import StringBuffer	( StringBuffer )
106
import Time		( ClockTime )
107
108
\end{code}

109

110
111
%************************************************************************
%*									*
112
\subsection{Compilation environment}
113
114
115
%*									*
%************************************************************************

116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

\begin{code}
-- | The Session is a handle to the complete state of a compilation
-- session.  A compilation session consists of a set of modules
-- constituting the current program or library, the context for
-- interactive evaluation, and various caches.
newtype Session = Session (IORef HscEnv)
\end{code}

HscEnv is like Session, except that some of the fields are immutable.
An HscEnv is used to compile a single module from plain Haskell source
code (after preprocessing) to either C, assembly or C--.  Things like
the module graph don't change during a single compilation.

Historical note: "hsc" used to be the name of the compiler binary,
when there was a separate driver and compiler.  To compile a single
module, the driver would invoke hsc on the source code... so nowadays
we think of hsc as the layer of the compiler that deals with compiling
a single module.
135

136
\begin{code}
137
data HscEnv 
138
139
140
141
142
143
  = HscEnv { 
	hsc_dflags :: DynFlags,
		-- The dynamic flag settings

	hsc_targets :: [Target],
		-- The targets (or roots) of the current session
144

145
146
147
148
149
150
151
	hsc_mod_graph :: ModuleGraph,
		-- The module graph of the current session

	hsc_IC :: InteractiveContext,
		-- The context for evaluating interactive statements

	hsc_HPT    :: HomePackageTable,
152
153
154
155
156
		-- The home package table describes already-compiled
		-- home-packge modules, *excluding* the module we 
		-- are compiling right now.
		-- (In one-shot mode the current module is the only
		--  home-package module, so hsc_HPT is empty.  All other
157
158
159
160
		--  modules count as "external-package" modules.
		--  However, even in GHCi mode, hi-boot interfaces are
		--  demand-loadeded into the external-package table.)
		--
161
162
		-- hsc_HPT is not mutable because we only demand-load 
		-- external packages; the home package is eagerly 
163
		-- loaded, module by module, by the compilation manager.
164
165
166
167
		--	
		-- The HPT may contain modules compiled earlier by --make
		-- but not actually below the current module in the dependency
		-- graph.  (This changes a previous invariant: changed Jan 05.)
168
	
169
170
171
172
173
174
	hsc_EPS	:: {-# UNPACK #-} !(IORef ExternalPackageState),
	hsc_NC	:: {-# UNPACK #-} !(IORef NameCache),
		-- These are side-effected by compiling to reflect
		-- sucking in interface files.  They cache the state of
		-- external interface files, in effect.

175
	hsc_FC  :: {-# UNPACK #-} !(IORef FinderCache),
176
177
		-- The finder's cache.  This caches the location of modules,
		-- so we don't have to search the filesystem multiple times.
178
179
        hsc_global_rdr_env :: GlobalRdrEnv,
        hsc_global_type_env :: TypeEnv
180
 }
181
182
183

hscEPS :: HscEnv -> IO ExternalPackageState
hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
184

185
186
187
188
189
190
-- | A compilation target.
--
-- A target may be supplied with the actual text of the
-- module.  If so, use this instead of the file contents (this
-- is for use in an IDE where the file hasn't been saved by
-- the user yet).
191
data Target = Target TargetId (Maybe (StringBuffer,ClockTime))
192
193

data TargetId
194
195
196
197
198
199
200
  = TargetModule Module
	-- ^ A module name: search for the file
  | TargetFile FilePath (Maybe Phase)
	-- ^ A filename: preprocess & parse it to find the module name.
	-- If specified, the Phase indicates how to compile this file
	-- (which phase to start from).  Nothing indicates the starting phase
	-- should be determined from the suffix of the filename.
201
  deriving Eq
202
203
204
205
206

pprTarget :: Target -> SDoc
pprTarget (Target id _) = pprTargetId id

pprTargetId (TargetModule m) = ppr m
207
pprTargetId (TargetFile f _) = text f
208
209
210
211
212
213
214
215
216

type FinderCache = ModuleEnv FinderCacheEntry
type FinderCacheEntry = (ModLocation, Maybe (PackageConfig,Bool))
	-- The finder's cache (see module Finder)

type HomePackageTable  = ModuleEnv HomeModInfo
	-- Domain = modules in the home package
type PackageIfaceTable = ModuleEnv ModIface
	-- Domain = modules in the imported packages
217
218
219
220

emptyHomePackageTable  = emptyModuleEnv
emptyPackageIfaceTable = emptyModuleEnv

221
data HomeModInfo 
222
223
224
225
226
227
228
229
230
  = HomeModInfo { hm_iface    :: !ModIface,
		  hm_details  :: !ModDetails,
		  hm_linkable :: !(Maybe Linkable) }
		-- hm_linkable might be Nothing if:
		--   a) this is an .hs-boot module
		--   b) temporarily during compilation if we pruned away
		--      the old linkable because it was out of date.
		-- after a complete compilation (GHC.load), all hm_linkable
		-- fields in the HPT will be Just.
231
232
233
234
		--
		-- When re-linking a module (hscNoRecomp), we construct
		-- the HomModInfo by building a new ModDetails from the
		-- old ModIface (only).
235
236
\end{code}

237
Simple lookups in the symbol table.
238

239
\begin{code}
240
lookupIface :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
241
-- We often have two IfaceTables, and want to do a lookup
242
lookupIface hpt pit mod
243
244
245
246
  = case lookupModuleEnv hpt mod of
	Just mod_info -> Just (hm_iface mod_info)
	Nothing       -> lookupModuleEnv pit mod

247
lookupIfaceByModule :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface
248
-- We often have two IfaceTables, and want to do a lookup
249
250
lookupIfaceByModule hpt pit mod
  = case lookupModuleEnv hpt mod of
251
	Just mod_info -> Just (hm_iface mod_info)
252
	Nothing       -> lookupModuleEnv pit mod
253
\end{code}
254

255
256

\begin{code}
257
hptInstances :: HscEnv -> (Module -> Bool) -> [Instance]
258
259
260
261
-- Find all the instance declarations that are in modules imported 
-- by this one, directly or indirectly, and are in the Home Package Table
-- This ensures that we don't see instances from modules --make compiled 
-- before this one, but which are not below this one
262
hptInstances hsc_env want_this_module
263
  = [ ispec 
264
265
    | mod_info <- moduleEnvElts (hsc_HPT hsc_env)
    , want_this_module (mi_module (hm_iface mod_info))
266
    , ispec <- md_insts (hm_details mod_info) ]
267

268
hptRules :: HscEnv -> [(Module, IsBootInterface)] -> [CoreRule]
269
270
271
-- Get rules from modules "below" this one (in the dependency sense)
-- C.f Inst.hptInstances
hptRules hsc_env deps
272
  | isOneShot (ghcMode (hsc_dflags hsc_env)) = []
273
274
275
276
277
278
279
280
  | otherwise
  = let 
	hpt = hsc_HPT hsc_env
    in
    [ rule
    |	-- Find each non-hi-boot module below me
      (mod, False) <- deps

281
282
283
284
285
286
287
	-- unsavoury: when compiling the base package with --make, we
	-- sometimes try to look up RULES for GHC.Prim.  GHC.Prim won't
	-- be in the HPT, because we never compile it; it's in the EPT
	-- instead.  ToDo: clean up, and remove this slightly bogus
	-- filter:
    , mod /= gHC_PRIM

288
	-- Look it up in the HPT
289
290
291
    , let mod_info = case lookupModuleEnv hpt mod of
		  	Nothing -> pprPanic "hptRules" (ppr mod <+> ppr deps)
		  	Just x  -> x
292
293
294
295
296
297

	-- And get its dfuns
    , rule <- md_rules (hm_details mod_info) ]
\end{code}


298
299
%************************************************************************
%*									*
300
\subsection{Symbol tables and Module details}
301
302
303
%*									*
%************************************************************************

304
305
A @ModIface@ plus a @ModDetails@ summarises everything we know 
about a compiled module.  The @ModIface@ is the stuff *before* linking,
306
307
308
309
310
311
and can be written out to an interface file.  (The @ModDetails@ is after 
linking; it is the "linked" form of the mi_decls field.)

When we *read* an interface file, we also construct a @ModIface@ from it,
except that the mi_decls part is empty; when reading we consolidate
the declarations into a single indexed map in the @PersistentRenamerState@.
312
313

\begin{code}
314
315
data ModIface 
   = ModIface {
316
	mi_package  :: !PackageIdH,	    -- Which package the module comes from
317
318
319
        mi_module   :: !Module,
        mi_mod_vers :: !Version,	    -- Module version: changes when anything changes

320
321
        mi_orphan   :: !WhetherHasOrphans,  -- Whether this module has orphans
	mi_boot	    :: !IsBootInterface,    -- Read from an hi-boot file?
322

323
	mi_deps	    :: Dependencies,
324
325
		-- This is consulted for directly-imported modules,
		-- but not for anything else (hence lazy)
326

327
328
329
		-- Usages; kept sorted so that it's easy to decide
		-- whether to write a new iface file (changing usages
		-- doesn't affect the version of this module)
330
        mi_usages   :: [Usage],
331
		-- NOT STRICT!  we read this field lazily from the interface file
332
		-- It is *only* consulted by the recompilation checker
333

334
335
336
337
		-- Exports
		-- Kept sorted by (mod,occ), to make version comparisons easier
        mi_exports  :: ![IfaceExport],
        mi_exp_vers :: !Version,	-- Version number of export list
338

339
340
341
		-- Fixities
        mi_fixities :: [(OccName,Fixity)],
		-- NOT STRICT!  we read this field lazily from the interface file
342

343
		-- Deprecations
344
	mi_deprecs  :: IfaceDeprecs,
345
		-- NOT STRICT!  we read this field lazily from the interface file
346

347
348
349
350
351
352
353
		-- Type, class and variable declarations
		-- The version of an Id changes if its fixity or deprecations change
		--	(as well as its type of course)
		-- Ditto data constructors, class operations, except that 
		-- the version of the parent class/tycon changes
	mi_decls :: [(Version,IfaceDecl)],	-- Sorted

354
        mi_globals  :: !(Maybe GlobalRdrEnv),
355
356
357
358
359
360
361
362
363
364
		-- Binds all the things defined at the top level in
		-- the *original source* code for this module. which
		-- is NOT the same as mi_exports, nor mi_decls (which
		-- may contains declarations for things not actually
		-- defined by the user).  Used for GHCi and for inspecting
		-- the contents of modules via the GHC API only.
		--
		-- (We need the source file to figure out the
		-- top-level environment, if we didn't compile this module
		-- from source then this field contains Nothing).
365
366
367
		--
		-- Strictly speaking this field should live in the
		-- HomeModInfo, but that leads to more plumbing.
368

369
370
371
372
373
374
375
376
377
378
379
380
381
382
		-- Instance declarations and rules
	mi_insts     :: [IfaceInst],	-- Sorted
	mi_rules     :: [IfaceRule],	-- Sorted
	mi_rule_vers :: !Version,	-- Version number for rules and instances combined

		-- Cached environments for easy lookup
		-- These are computed (lazily) from other fields
		-- and are not put into the interface file
	mi_dep_fn  :: Name -> Maybe DeprecTxt,	-- Cached lookup for mi_deprecs
	mi_fix_fn  :: OccName -> Fixity,	-- Cached lookup for mi_fixities
	mi_ver_fn  :: OccName -> Maybe Version	-- Cached lookup for mi_decls
			-- The Nothing in mi_ver_fn means that the thing
			-- isn't in decls. It's useful to know that when
			-- seeing if we are up to date wrt the old interface
383
     }
384

385
386
387
-- Should be able to construct ModDetails from mi_decls in ModIface
data ModDetails
   = ModDetails {
388
	-- The next three fields are created by the typechecker
389
	md_exports  :: NameSet,
390
391
392
        md_types    :: !TypeEnv,
        md_insts    :: ![Instance],	-- Dfun-ids for the instances in this module
        md_rules    :: ![CoreRule]	-- Domain may include Ids from other modules
393
     }
394

395
emptyModDetails = ModDetails { md_types = emptyTypeEnv,
396
			       md_exports = emptyNameSet,
397
398
399
			       md_insts = [],
			       md_rules = [] }

400
401
402
403
404
405
406
407
-- A ModGuts is carried through the compiler, accumulating stuff as it goes
-- There is only one ModGuts at any time, the one for the module
-- being compiled right now.  Once it is compiled, a ModIface and 
-- ModDetails are extracted and the ModGuts is dicarded.

data ModGuts
  = ModGuts {
        mg_module   :: !Module,
408
	mg_boot     :: IsBootInterface, -- Whether it's an hs-boot module
409
	mg_exports  :: !NameSet,	-- What it exports
410
	mg_deps	    :: !Dependencies,	-- What is below it, directly or otherwise
411
	mg_home_mods :: !HomeModules,	-- For calling isHomeModule etc.
412
413
	mg_dir_imps :: ![Module],	-- Directly-imported modules; used to
					--	generate initialisation code
414
	mg_usages   :: ![Usage],	-- Version info for what it needed
415
416
417
418
419
420

        mg_rdr_env  :: !GlobalRdrEnv,	-- Top-level lexical environment
	mg_fix_env  :: !FixityEnv,	-- Fixity env, for things declared in this module
	mg_deprecs  :: !Deprecations,	-- Deprecations declared in the module

	mg_types    :: !TypeEnv,
421
422
	mg_insts    :: ![Instance],	-- Instances 
        mg_rules    :: ![CoreRule],	-- Rules from this module
423
424
425
426
427
	mg_binds    :: ![CoreBind],	-- Bindings for this module
	mg_foreign  :: !ForeignStubs
    }

-- The ModGuts takes on several slightly different forms:
428
--
429
430
431
432
433
-- After simplification, the following fields change slightly:
--	mg_rules	Orphan rules only (local ones now attached to binds)
--	mg_binds	With rules attached


434
435
436
437
438
439
440
441
442
---------------------------------------------------------
-- The Tidy pass forks the information about this module: 
--	* one lot goes to interface file generation (ModIface)
--	  and later compilations (ModDetails)
--	* the other lot goes to code generation (CgGuts)
data CgGuts 
  = CgGuts {
	cg_module   :: !Module,

443
444
445
446
447
	cg_tycons   :: [TyCon],
		-- Algebraic data types (including ones that started
		-- life as classes); generate constructors and info
		-- tables Includes newtypes, just for the benefit of
		-- External Core
448

449
450
451
452
453
454
	cg_binds    :: [CoreBind],
		-- The tidied main bindings, including
		-- previously-implicit bindings for record and class
		-- selectors, and data construtor wrappers.  But *not*
		-- data constructor workers; reason: we we regard them
		-- as part of the code-gen of tycons
455

456
457
458
	cg_dir_imps :: ![Module],
		-- Directly-imported modules; used to generate
		-- initialisation code
459
460

	cg_foreign  :: !ForeignStubs,	
461
	cg_home_mods :: !HomeModules,	-- for calling isHomeModule etc.
462
463
	cg_dep_pkgs :: ![PackageId]	-- Used to generate #includes for C code gen
    }
464

465
-----------------------------------
466
467
468
469
470
471
472
473
474
475
476
data ModImports
  = ModImports {
	imp_direct     :: ![(Module,Bool)],	-- Explicitly-imported modules
						-- Boolean is true if we imported the whole
						--	module (apart, perhaps, from hiding some)
	imp_pkg_mods   :: !ModuleSet,		-- Non-home-package modules on which we depend,
						--	directly or indirectly
	imp_home_names :: !NameSet		-- Home package things on which we depend,
						--	directly or indirectly
    }

477
-----------------------------------
478
479
480
481
482
483
484
485
486
487
488
data ForeignStubs = NoStubs
		  | ForeignStubs
			SDoc 		-- Header file prototypes for
                                      	-- 	"foreign exported" functions
			SDoc 		-- C stubs to use when calling
                                        -- 	"foreign exported" functions
			[FastString] 	-- Headers that need to be included
				        -- 	into C code generated for this module
			[Id]		-- Foreign-exported binders
					-- 	we have to generate code to register these

489
490
491
\end{code}

\begin{code}
492
emptyModIface :: PackageIdH -> Module -> ModIface
493
494
emptyModIface pkg mod
  = ModIface { mi_package  = pkg,
495
	       mi_module   = mod,
496
	       mi_mod_vers = initialVersion,
497
498
	       mi_orphan   = False,
	       mi_boot	   = False,
499
500
	       mi_deps     = noDependencies,
	       mi_usages   = [],
501
	       mi_exports  = [],
502
503
	       mi_exp_vers = initialVersion,
	       mi_fixities = [],
504
	       mi_deprecs  = NoDeprecs,
505
506
507
	       mi_insts = [],
	       mi_rules = [],
	       mi_decls = [],
508
	       mi_globals  = Nothing,
509
510
511
512
	       mi_rule_vers = initialVersion,
	       mi_dep_fn = emptyIfaceDepCache,
	       mi_fix_fn = emptyIfaceFixCache,
	       mi_ver_fn = emptyIfaceVerCache
513
    }		
514
515
\end{code}

516

517
518
519
520
521
522
523
524
525
%************************************************************************
%*									*
\subsection{The interactive context}
%*									*
%************************************************************************

\begin{code}
data InteractiveContext 
  = InteractiveContext { 
526
	ic_toplev_scope :: [Module],	-- Include the "top-level" scope of
527
					-- these modules
528

529
	ic_exports :: [Module],		-- Include just the exports of these
530
531
532
533
534
535
					-- modules

	ic_rn_gbl_env :: GlobalRdrEnv,	-- The cached GlobalRdrEnv, built from
					-- ic_toplev_scope and ic_exports

	ic_rn_local_env :: LocalRdrEnv,	-- Lexical context for variables bound
536
537
538
539
					-- during interaction

	ic_type_env :: TypeEnv		-- Ditto for types
    }
540
541
542
543

emptyInteractiveContext
  = InteractiveContext { ic_toplev_scope = [],
			 ic_exports = [],
544
545
			 ic_rn_gbl_env = emptyGlobalRdrEnv,
			 ic_rn_local_env = emptyLocalRdrEnv,
546
547
548
549
			 ic_type_env = emptyTypeEnv }

icPrintUnqual :: InteractiveContext -> PrintUnqualified
icPrintUnqual ictxt = unQualInScope (ic_rn_gbl_env ictxt)
550
551
\end{code}

552
553
554
555
556
557
@unQualInScope@ returns a function that takes a @Name@ and tells whether
its unqualified name is in scope.  This is put as a boolean flag in
the @Name@'s provenance to guide whether or not to print the name qualified
in error messages.

\begin{code}
558
unQualInScope :: GlobalRdrEnv -> PrintUnqualified
559
560
561
562
-- True if 'f' is in scope, and has only one binding,
-- and the thing it is bound to is the name we are looking for
-- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
--
563
564
565
-- [Out of date] Also checks for built-in syntax, which is always 'in scope'
unQualInScope env mod occ
  = case lookupGRE_RdrName (mkRdrUnqual occ) env of
566
	[gre] -> nameModule (gre_name gre) == mod
567
	other -> False
568
569
\end{code}

570

571
572
%************************************************************************
%*									*
573
		TyThing
574
575
576
577
%*									*
%************************************************************************

\begin{code}
578
579
580
581
582
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
610
611
612
613
implicitTyThings :: TyThing -> [TyThing]
implicitTyThings (AnId id)   = []

	-- For type constructors, add the data cons (and their extras),
	-- and the selectors and generic-programming Ids too
	--
	-- Newtypes don't have a worker Id, so don't generate that?
implicitTyThings (ATyCon tc) = map AnId (tyConSelIds tc) ++ 
			       concatMap (extras_plus . ADataCon) (tyConDataCons tc)
		     
	-- For classes, add the class TyCon too (and its extras)
	-- and the class selector Ids
implicitTyThings (AClass cl) = map AnId (classSelIds cl) ++
			       extras_plus (ATyCon (classTyCon cl))
			 

	-- For data cons add the worker and wrapper (if any)
implicitTyThings (ADataCon dc) = map AnId (dataConImplicitIds dc)

extras_plus thing = thing : implicitTyThings thing

extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv
extendTypeEnvWithIds env ids
  = extendNameEnvList env [(getName id, AnId id) | id <- ids]
\end{code}

%************************************************************************
%*									*
		TypeEnv
%*									*
%************************************************************************

\begin{code}
type TypeEnv = NameEnv TyThing

emptyTypeEnv   :: TypeEnv
614
615
616
617
typeEnvElts    :: TypeEnv -> [TyThing]
typeEnvClasses :: TypeEnv -> [Class]
typeEnvTyCons  :: TypeEnv -> [TyCon]
typeEnvIds     :: TypeEnv -> [Id]
618
lookupTypeEnv  :: TypeEnv -> Name -> Maybe TyThing
619

620
emptyTypeEnv 	   = emptyNameEnv
621
622
623
624
typeEnvElts    env = nameEnvElts env
typeEnvClasses env = [cl | AClass cl <- typeEnvElts env]
typeEnvTyCons  env = [tc | ATyCon tc <- typeEnvElts env] 
typeEnvIds     env = [id | AnId id   <- typeEnvElts env] 
625

626
627
mkTypeEnv :: [TyThing] -> TypeEnv
mkTypeEnv things = extendTypeEnvList emptyTypeEnv things
628
		
629
630
lookupTypeEnv = lookupNameEnv

631
-- Extend the type environment
632
633
634
635
636
extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv
extendTypeEnv env thing = extendNameEnv env (getName thing) thing 

extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv
extendTypeEnvList env things = foldl extendTypeEnv env things
637
638
\end{code}

639
\begin{code}
640
641
642
643
lookupType :: HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing
lookupType hpt pte name
  = case lookupModuleEnv hpt (nameModule name) of
	Just details -> lookupNameEnv (md_types (hm_details details)) name
644
645
	Nothing	     -> lookupNameEnv pte name
\end{code}
646

647
648
649
650
651
652
653
654
655
656
657
658
659
660
661

\begin{code}
tyThingTyCon (ATyCon tc) = tc
tyThingTyCon other	 = pprPanic "tyThingTyCon" (ppr other)

tyThingClass (AClass cls) = cls
tyThingClass other	  = pprPanic "tyThingClass" (ppr other)

tyThingDataCon (ADataCon dc) = dc
tyThingDataCon other	     = pprPanic "tyThingDataCon" (ppr other)

tyThingId (AnId id) = id
tyThingId other     = pprPanic "tyThingId" (ppr other)
\end{code}

662
663
664
665
666
667
668
669
%************************************************************************
%*									*
\subsection{Auxiliary types}
%*									*
%************************************************************************

These types are defined here because they are mentioned in ModDetails,
but they are mostly elaborated elsewhere
670
671

\begin{code}
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
mkIfaceVerCache :: [(Version,IfaceDecl)] -> OccName -> Maybe Version
mkIfaceVerCache pairs 
  = \occ -> lookupOccEnv env occ
  where
    env = foldl add emptyOccEnv pairs
    add env (v,d) = extendOccEnv env (ifName d) v

emptyIfaceVerCache :: OccName -> Maybe Version
emptyIfaceVerCache occ = Nothing

------------------ Deprecations -------------------------
data Deprecs a
  = NoDeprecs
  | DeprecAll DeprecTxt	-- Whole module deprecated
  | DeprecSome a	-- Some specific things deprecated
  deriving( Eq )
688

689
690
type IfaceDeprecs = Deprecs [(OccName,DeprecTxt)]
type Deprecations = Deprecs (NameEnv (OccName,DeprecTxt))
691
692
693
694
695
	-- Keep the OccName so we can flatten the NameEnv to
	-- get an IfaceDeprecs from a Deprecations
	-- Only an OccName is needed, because a deprecation always
	-- applies to things defined in the module in which the
	-- deprecation appears.
696

697
698
699
700
mkIfaceDepCache:: IfaceDeprecs -> Name -> Maybe DeprecTxt
mkIfaceDepCache NoDeprecs     	  = \n -> Nothing
mkIfaceDepCache (DeprecAll t) 	  = \n -> Just t
mkIfaceDepCache (DeprecSome pairs) = lookupOccEnv (mkOccEnv pairs) . nameOccName
701

702
703
emptyIfaceDepCache :: Name -> Maybe DeprecTxt
emptyIfaceDepCache n = Nothing
704

705
706
707
708
709
710
lookupDeprec :: Deprecations -> Name -> Maybe DeprecTxt
lookupDeprec NoDeprecs        name = Nothing
lookupDeprec (DeprecAll  txt) name = Just txt
lookupDeprec (DeprecSome env) name = case lookupNameEnv env name of
					    Just (_, txt) -> Just txt
					    Nothing	  -> Nothing
711

712
713
714
715
716
717
plusDeprecs :: Deprecations -> Deprecations -> Deprecations
plusDeprecs d NoDeprecs = d
plusDeprecs NoDeprecs d = d
plusDeprecs d (DeprecAll t) = DeprecAll t
plusDeprecs (DeprecAll t) d = DeprecAll t
plusDeprecs (DeprecSome v1) (DeprecSome v2) = DeprecSome (v1 `plusNameEnv` v2)
718
719
720
721
722
723
724
725
\end{code}


\begin{code}
type Avails	  = [AvailInfo]
type AvailInfo    = GenAvailInfo Name
type RdrAvailInfo = GenAvailInfo OccName

726
727
728
729
730
731
732
733
734
data GenAvailInfo name	= Avail name	 -- An ordinary identifier
			| AvailTC name 	 -- The name of the type or class
				  [name] -- The available pieces of type/class.
					 -- NB: If the type or class is itself
					 -- to be in scope, it must be in this list.
					 -- Thus, typically: AvailTC Eq [Eq, ==, /=]
			deriving( Eq )
			-- Equality used when deciding if the interface has changed

735
type IfaceExport = (Module, [GenAvailInfo OccName])
736

737
738
739
740
741
742
743
744
availsToNameSet :: [AvailInfo] -> NameSet
availsToNameSet avails = foldl add emptyNameSet avails
		       where
			 add set avail = addListToNameSet set (availNames avail)

availName :: GenAvailInfo name -> name
availName (Avail n)     = n
availName (AvailTC n _) = n
745

746
747
748
availNames :: GenAvailInfo name -> [name]
availNames (Avail n)      = [n]
availNames (AvailTC n ns) = ns
749

750
751
752
753
754
755
756
757
758
instance Outputable n => Outputable (GenAvailInfo n) where
   ppr = pprAvail

pprAvail :: Outputable n => GenAvailInfo n -> SDoc
pprAvail (AvailTC n ns) = ppr n <> case {- filter (/= n) -} ns of
					[]  -> empty
					ns' -> braces (hsep (punctuate comma (map ppr ns')))

pprAvail (Avail n) = ppr n
759
760
\end{code}

761
\begin{code}
762
763
764
765
766
767
768
769
770
771
772
773
774
mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Fixity
mkIfaceFixCache pairs 
  = \n -> lookupOccEnv env n `orElse` defaultFixity
  where
   env = mkOccEnv pairs

emptyIfaceFixCache :: OccName -> Fixity
emptyIfaceFixCache n = defaultFixity

-- This fixity environment is for source code only
type FixityEnv = NameEnv FixItem

-- We keep the OccName in the range so that we can generate an interface from it
775
data FixItem = FixItem OccName Fixity SrcSpan
776
777
778

instance Outputable FixItem where
  ppr (FixItem occ fix loc) = ppr fix <+> ppr occ <+> parens (ppr loc)
779
780
781

emptyFixityEnv :: FixityEnv
emptyFixityEnv = emptyNameEnv
782
783

lookupFixity :: FixityEnv -> Name -> Fixity
784
lookupFixity env n = case lookupNameEnv env n of
785
786
			Just (FixItem _ fix _) -> fix
			Nothing	      	       -> defaultFixity
787
788
\end{code}

789
790
791

%************************************************************************
%*									*
792
\subsection{WhatsImported}
793
794
795
796
%*									*
%************************************************************************

\begin{code}
797
798
799
800
801
802
803
type WhetherHasOrphans   = Bool
	-- An "orphan" is 
	-- 	* an instance decl in a module other than the defn module for 
	--		one of the tycons or classes in the instance head
	--	* a transformation rule in a module other than the one defining
	--		the function in the head of the rule.

804
type IsBootInterface = Bool
805

806
807
808
809
-- Dependency info about modules and packages below this one
-- in the import hierarchy.  See TcRnTypes.ImportAvails for details.
--
-- Invariant: the dependencies of a module M never includes M
810
-- Invariant: the lists are unordered, with no duplicates
811
data Dependencies
812
813
814
  = Deps { dep_mods  :: [(Module,IsBootInterface)],	-- Home-package module dependencies
	   dep_pkgs  :: [PackageId], 			-- External package dependencies
	   dep_orphs :: [Module] }			-- Orphan modules (whether home or external pkg)
815
816
  deriving( Eq )
	-- Equality used only for old/new comparison in MkIface.addVersionInfo
817
818
819
820

noDependencies :: Dependencies
noDependencies = Deps [] [] []
 	  
821
data Usage
822
  = Usage { usg_name     :: Module,			-- Name of the module
823
824
825
826
827
	    usg_mod      :: Version,			-- Module version
	    usg_entities :: [(OccName,Version)],	-- Sorted by occurrence name
	    usg_exports  :: Maybe Version,		-- Export-list version, if we depend on it
	    usg_rules    :: Version 			-- Orphan-rules version (for non-orphan
							-- modules this will always be initialVersion)
828
829
    }	    deriving( Eq )
	-- This type doesn't let you say "I imported f but none of the rules in
830
831
	-- the module". If you use anything in the module you get its rule version
	-- So if the rules change, you'll recompile, even if you don't use them.
832
833
834
	-- This is easy to implement, and it's safer: you might not have used the rules last
	-- time round, but if someone has added a new rule you might need it this time

835
	-- The export list field is (Just v) if we depend on the export list:
836
837
838
839
840
841
842
843
844
845
	--	i.e. we imported the module directly, whether or not we
	--	     enumerated the things we imported, or just imported everything
	-- We need to recompile if M's exports change, because 
	-- if the import was	import M, 	we might now have a name clash in the 
	--					importing module.
	-- if the import was	import M(x)	M might no longer export x
	-- The only way we don't depend on the export list is if we have
	--			import M()
	-- And of course, for modules that aren't imported directly we don't
	-- depend on their export lists
846
847
\end{code}

848

849
850
%************************************************************************
%*									*
851
		The External Package State
852
853
854
%*									*
%************************************************************************

855
\begin{code}
856
type PackageTypeEnv  = TypeEnv
857
858
859
type PackageRuleBase = RuleBase
type PackageInstEnv  = InstEnv

860
861
data ExternalPackageState
  = EPS {
862
	eps_is_boot :: !(ModuleEnv (Module, IsBootInterface)),
863
864
865
866
867
868
		-- In OneShot mode (only), home-package modules accumulate in the
		-- external package state, and are sucked in lazily.
		-- For these home-pkg modules (only) we need to record which are
		-- boot modules.  We set this field after loading all the 
		-- explicitly-imported interfaces, but before doing anything else
		--
869
		-- The Module part is not necessary, but it's useful for
870
871
872
		-- debug prints, and it's convenient because this field comes
		-- direct from TcRnTypes.ImportAvails.imp_dep_mods

873
874
875
876
	eps_PIT :: !PackageIfaceTable,
		-- The ModuleIFaces for modules in external packages
		-- whose interfaces we have opened
		-- The declarations in these interface files are held in
877
		-- eps_decls, eps_inst_env, eps_rules (below), not in the 
878
879
880
881
882
883
884
885
886
887
888
889
890
891
		-- mi_decls fields of the iPIT.  
		-- What _is_ in the iPIT is:
		--	* The Module 
		--	* Version info
		--	* Its exports
		--	* Fixities
		--	* Deprecations

	eps_PTE :: !PackageTypeEnv,		-- Domain = external-package modules

	eps_inst_env :: !PackageInstEnv,	-- The total InstEnv accumulated from
						--   all the external-package modules
	eps_rule_base :: !PackageRuleBase,	-- Ditto RuleEnv

892
	eps_stats :: !EpsStats
893
  }
894
895
896
897
898
899
900

-- "In" means read from iface files
-- "Out" means actually sucked in and type-checked
data EpsStats = EpsStats { n_ifaces_in
			 , n_decls_in, n_decls_out 
			 , n_rules_in, n_rules_out
			 , n_insts_in, n_insts_out :: !Int }
901
902
903
904
905
906
907
908

addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats
-- Add stats for one newly-read interface
addEpsInStats stats n_decls n_insts n_rules
  = stats { n_ifaces_in = n_ifaces_in stats + 1
	  , n_decls_in  = n_decls_in stats + n_decls
	  , n_insts_in  = n_insts_in stats + n_insts
	  , n_rules_in  = n_rules_in stats + n_rules }
909
910
\end{code}

911
The NameCache makes sure that there is just one Unique assigned for
912
913
914
915
916
917
918
919
each original name; i.e. (module-name, occ-name) pair.  The Name is
always stored as a Global, and has the SrcLoc of its binding location.
Actually that's not quite right.  When we first encounter the original
name, we might not be at its binding site (e.g. we are reading an
interface file); so we give it 'noSrcLoc' then.  Later, when we find
its binding site, we fix it up.

\begin{code}
920
921
data NameCache
 = NameCache {  nsUniqs :: UniqSupply,
922
		-- Supply of uniques
923
		nsNames :: OrigNameCache,
924
		-- Ensures that one original name gets one unique
925
		nsIPs   :: OrigIParamCache
926
		-- Ensures that one implicit parameter name gets one unique
927
   }
928

929
930
type OrigNameCache   = ModuleEnv (OccEnv Name)
type OrigIParamCache = FiniteMap (IPName OccName) (IPName Name)
931
\end{code}
932

933

934

935
936
%************************************************************************
%*									*
937
		The module graph and ModSummary type
938
939
940
941
942
	A ModSummary is a node in the compilation manager's
	dependency graph, and it's also passed to hscMain
%*									*
%************************************************************************

943
944
945
A ModuleGraph contains all the nodes from the home package (only).  
There will be a node for each source module, plus a node for each hi-boot
module.
946
947

\begin{code}
948
949
950
951
952
953
954
955
956
957
type ModuleGraph = [ModSummary]  -- The module graph, 
				 -- NOT NECESSARILY IN TOPOLOGICAL ORDER

emptyMG :: ModuleGraph
emptyMG = []

-- The nodes of the module graph are
-- 	EITHER a regular Haskell source module
-- 	OR     a hi-boot source module

958
959
960
961
962
data ModSummary
   = ModSummary {
        ms_mod       :: Module,			-- Name of the module
	ms_hsc_src   :: HscSource,		-- Source is Haskell, hs-boot, external core
        ms_location  :: ModLocation,		-- Location
963
964
        ms_hs_date   :: ClockTime,		-- Timestamp of source file
	ms_obj_date  :: Maybe ClockTime,	-- Timestamp of object, maybe
965
966
        ms_srcimps   :: [Located Module],	-- Source imports
        ms_imps      :: [Located Module],	-- Non-source imports
967
968
969
970
        ms_hspp_file :: FilePath,		-- Filename of preprocessed source.
        ms_hspp_opts :: DynFlags,               -- Cached flags from OPTIONS, INCLUDE
                                                -- and LANGUAGE pragmas.
	ms_hspp_buf  :: Maybe StringBuffer    	-- The actual preprocessed source, maybe.
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
     }

-- The ModLocation contains both the original source filename and the
-- filename of the cleaned-up source file after all preprocessing has been
-- done.  The point is that the summariser will have to cpp/unlit/whatever
-- all files anyway, and there's no point in doing this twice -- just 
-- park the result in a temp file, put the name of it in the location,
-- and let @compile@ read from that file on the way back up.

-- The ModLocation is stable over successive up-sweeps in GHCi, wheres
-- the ms_hs_date and imports can, of course, change

msHsFilePath, msHiFilePath, msObjFilePath :: ModSummary -> FilePath
msHsFilePath  ms = expectJust "msHsFilePath" (ml_hs_file  (ms_location ms))
msHiFilePath  ms = ml_hi_file  (ms_location ms)
msObjFilePath ms = ml_obj_file (ms_location ms)

988
989
isBootSummary :: ModSummary -> Bool
isBootSummary ms = isHsBoot (ms_hsc_src ms)
990
991
992
993
994
995
996
997
998
999
1000
1001

instance Outputable ModSummary where
   ppr ms
      = sep [text "ModSummary {",
             nest 3 (sep [text "ms_hs_date = " <> text (show (ms_hs_date ms)),
                          text "ms_mod =" <+> ppr (ms_mod ms) 
				<> text (hscSourceString (ms_hsc_src ms)) <> comma,
                          text "ms_imps =" <+> ppr (ms_imps ms),
                          text "ms_srcimps =" <+> ppr (ms_srcimps ms)]),
             char '}'
            ]

1002
1003
showModMsg :: HscTarget -> Bool -> ModSummary -> String
showModMsg target recomp mod_summary
1004
1005
  = showSDoc (hsep [text (mod_str ++ replicate (max 0 (16 - length mod_str)) ' '),
	            char '(', text (msHsFilePath mod_summary) <> comma,
1006
1007
1008
1009
1010
		    case target of
                      HscInterpreted | recomp
                                 -> text "interpreted"
                      HscNothing -> text "nothing"
                      _other     -> text (msObjFilePath mod_summary),
1011
1012
1013
		    char ')'])
 where 
    mod     = ms_mod mod_summary 
1014
    mod_str = moduleString mod ++ hscSourceString (ms_hsc_src mod_summary)
1015
1016
1017
\end{code}


1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
%************************************************************************
%*									*
\subsection{Linkable stuff}
%*									*
%************************************************************************

This stuff is in here, rather than (say) in Linker.lhs, because the Linker.lhs
stuff is the *dynamic* linker, and isn't present in a stage-1 compiler

\begin{code}
data Linkable = LM {
  linkableTime     :: ClockTime,	-- Time at which this linkable was built
					-- (i.e. when the bytecodes were produced,
					--	 or the mod date on the files)
1032
  linkableModule   :: Module,		-- Should be Module, but see below
1033
1034
1035
1036
  linkableUnlinked :: [Unlinked]
 }

isObjectLinkable :: Linkable -> Bool
1037
1038
1039
1040
1041
1042
isObjectLinkable l = not (null unlinked) && all isObject unlinked
  where unlinked = linkableUnlinked l
	-- A linkable with no Unlinked's is treated as a BCO.  We can
	-- generate a linkable with no Unlinked's as a result of
	-- compiling a module in HscNothing mode, and this choice
	-- happens to work well with checkStability in module GHC.
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085

instance Outputable Linkable where
   ppr (LM when_made mod unlinkeds)
      = (text "LinkableM" <+> parens (text (show when_made)) <+> ppr mod)
        $$ nest 3 (ppr unlinkeds)

-------------------------------------------
data Unlinked
   = DotO FilePath
   | DotA FilePath
   | DotDLL FilePath
   | BCOs CompiledByteCode

#ifndef GHCI
data CompiledByteCode = NoByteCode
#endif

instance Outputable Unlinked where
   ppr (DotO path)   = text "DotO" <+> text path
   ppr (DotA path)   = text "DotA" <+> text path
   ppr (DotDLL path) = text "DotDLL" <+> text path
#ifdef GHCI
   ppr (BCOs bcos)   = text "BCOs" <+> ppr bcos
#else
   ppr (BCOs bcos)   = text "No byte code"
#endif

isObject (DotO _)   = True
isObject (DotA _)   = True
isObject (DotDLL _) = True
isObject _          = False

isInterpretable = not . isObject

nameOfObject (DotO fn)   = fn
nameOfObject (DotA fn)   = fn
nameOfObject (DotDLL fn) = fn

byteCodeOfObject (BCOs bc) = bc
\end{code}