TcIface.lhs 47.7 KB
Newer Older
1
%
Simon Marlow's avatar
Simon Marlow committed
2
% (c) The University of Glasgow 2006
3
4
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
Simon Marlow's avatar
Simon Marlow committed
5
6

Type checking of type signatures in interface files
7
8
9

\begin{code}
module TcIface ( 
10
	tcImportDecl, checkWiredInTyCon, tcHiBootIface, typecheckIface, 
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
11
	tcIfaceDecl, tcIfaceInst, tcIfaceFamInst, tcIfaceRules,
12
	tcIfaceVectInfo, tcIfaceAnnotations, tcIfaceGlobal, tcExtCoreBindings
13
 ) where
14

15
16
17
#include "HsVersions.h"

import IfaceSyn
Simon Marlow's avatar
Simon Marlow committed
18
19
20
import LoadIface
import IfaceEnv
import BuildTyCl
21
import TcRnMonad
22
import TcType
Simon Marlow's avatar
Simon Marlow committed
23
24
25
import Type
import TypeRep
import HscTypes
26
import Annotations
Simon Marlow's avatar
Simon Marlow committed
27
28
import InstEnv
import FamInstEnv
29
import CoreSyn
Simon Marlow's avatar
Simon Marlow committed
30
import CoreUtils
31
import CoreUnfold
Simon Marlow's avatar
Simon Marlow committed
32
33
34
35
36
37
38
39
40
import CoreLint
import WorkWrap
import Id
import MkId
import IdInfo
import Class
import TyCon
import DataCon
import TysWiredIn
41
import TysPrim		( anyTyConOfKind )
Simon Marlow's avatar
Simon Marlow committed
42
import Var              ( TyVar )
43
import BasicTypes	( nonRuleLoopBreaker )
Simon Marlow's avatar
Simon Marlow committed
44
import qualified Var
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
45
import VarEnv
Simon Marlow's avatar
Simon Marlow committed
46
import Name
47
import NameEnv
48
import OccurAnal	( occurAnalyseExpr )
49
import Demand		( isBottomingSig )
Simon Marlow's avatar
Simon Marlow committed
50
import Module
51
import UniqFM
Simon Marlow's avatar
Simon Marlow committed
52
import UniqSupply
53
import Outputable	
Simon Marlow's avatar
Simon Marlow committed
54
55
56
57
import ErrUtils
import Maybes
import SrcLoc
import DynFlags
Ian Lynagh's avatar
Ian Lynagh committed
58
import Util
59
import FastString
Simon Marlow's avatar
Simon Marlow committed
60

61
import Control.Monad
Simon Marlow's avatar
Simon Marlow committed
62
import Data.List
63
64
65
66
67
68
69
70
71
72
73
\end{code}

This module takes

	IfaceDecl -> TyThing
	IfaceType -> Type
	etc

An IfaceDecl is populated with RdrNames, and these are not renamed to
Names before typechecking, because there should be no scope errors etc.

74
	-- For (b) consider: f = \$(...h....)
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
	-- where h is imported, and calls f via an hi-boot file.  
	-- This is bad!  But it is not seen as a staging error, because h
	-- is indeed imported.  We don't want the type-checker to black-hole 
	-- when simplifying and compiling the splice!
	--
	-- Simple solution: discard any unfolding that mentions a variable
	-- bound in this module (and hence not yet processed).
	-- The discarding happens when forkM finds a type error.

%************************************************************************
%*									*
%*	tcImportDecl is the key function for "faulting in" 		*
%*	imported things
%*									*
%************************************************************************

The main idea is this.  We are chugging along type-checking source code, and
find a reference to GHC.Base.map.  We call tcLookupGlobal, which doesn't find
it in the EPS type envt.  So it 
	1 loads GHC.Base.hi
	2 gets the decl for GHC.Base.map
	3 typechecks it via tcIfaceDecl
	4 and adds it to the type env in the EPS

Note that DURING STEP 4, we may find that map's type mentions a type 
constructor that also 

Notice that for imported things we read the current version from the EPS
mutable variable.  This is important in situations like
	...$(e1)...$(e2)...
where the code that e1 expands to might import some defns that 
also turn out to be needed by the code that e2 expands to.

\begin{code}
109
tcImportDecl :: Name -> TcM TyThing
110
-- Entry point for *source-code* uses of importDecl
111
tcImportDecl name 
112
  | Just thing <- wiredInNameTyThing_maybe name
113
114
115
  = do	{ when (needWiredInHomeIface thing)
    	       (initIfaceTcRn (loadWiredInHomeIface name))
		-- See Note [Loading instances for wired-in things]
116
	; return thing }
117
  | otherwise
118
  = do 	{ traceIf (text "tcImportDecl" <+> ppr name)
119
120
121
122
123
124
	; mb_thing <- initIfaceTcRn (importDecl name)
	; case mb_thing of
	    Succeeded thing -> return thing
	    Failed err      -> failWithTc err }

importDecl :: Name -> IfM lcl (MaybeErr Message TyThing)
125
-- Get the TyThing for this Name from an interface file
126
127
128
129
-- It's not a wired-in thing -- the caller caught that
importDecl name
  = ASSERT( not (isWiredInName name) )
    do	{ traceIf nd_doc
130
131

	-- Load the interface, which should populate the PTE
132
133
	; mb_iface <- ASSERT2( isExternalName name, ppr name ) 
	  	      loadInterface nd_doc (nameModule name) ImportBySystem
134
135
	; case mb_iface of {
		Failed err_msg  -> return (Failed err_msg) ;
Ian Lynagh's avatar
Ian Lynagh committed
136
		Succeeded _ -> do
137
138

	-- Now look it up again; this time we should find it
139
	{ eps <- getEps	
140
	; case lookupTypeEnv (eps_PTE eps) name of
141
142
143
	    Just thing -> return (Succeeded thing)
	    Nothing    -> return (Failed not_found_msg)
    }}}
144
  where
Ian Lynagh's avatar
Ian Lynagh committed
145
146
    nd_doc = ptext (sLit "Need decl for") <+> ppr name
    not_found_msg = hang (ptext (sLit "Can't find interface-file declaration for") <+>
147
				pprNameSpace (occNameSpace (nameOccName name)) <+> ppr name)
Ian Lynagh's avatar
Ian Lynagh committed
148
149
	  	       2 (vcat [ptext (sLit "Probable cause: bug in .hi-boot file, or inconsistent .hi file"),
		                ptext (sLit "Use -ddump-if-trace to get an idea of which file caused the error")])
150
151
\end{code}

152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
%************************************************************************
%*									*
           Checks for wired-in things
%*									*
%************************************************************************

Note [Loading instances for wired-in things]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We need to make sure that we have at least *read* the interface files
for any module with an instance decl or RULE that we might want.  

* If the instance decl is an orphan, we have a whole separate mechanism
  (loadOprhanModules)

* If the instance decl not an orphan, then the act of looking at the
  TyCon or Class will force in the defining module for the
  TyCon/Class, and hence the instance decl

* BUT, if the TyCon is a wired-in TyCon, we don't really need its interface;
  but we must make sure we read its interface in case it has instances or
  rules.  That is what LoadIface.loadWiredInHomeInterface does.  It's called
  from TcIface.{tcImportDecl, checkWiredInTyCon, ifCheckWiredInThing}

* HOWEVER, only do this for TyCons.  There are no wired-in Classes.  There
  are some wired-in Ids, but we don't want to load their interfaces. For
  example, Control.Exception.Base.recSelError is wired in, but that module
  is compiled late in the base library, and we don't want to force it to
  load before it's been compiled!

All of this is done by the type checker. The renamer plays no role.
(It used to, but no longer.)


\begin{code}
checkWiredInTyCon :: TyCon -> TcM ()
-- Ensure that the home module of the TyCon (and hence its instances)
-- are loaded. See Note [Loading instances for wired-in things]
-- It might not be a wired-in tycon (see the calls in TcUnify),
-- in which case this is a no-op.
checkWiredInTyCon tc	
  | not (isWiredInName tc_name) 
  = return ()
  | otherwise
  = do	{ mod <- getModule
	; ASSERT( isExternalName tc_name ) 
	  when (mod /= nameModule tc_name)
	       (initIfaceTcRn (loadWiredInHomeIface tc_name))
		-- Don't look for (non-existent) Float.hi when
		-- compiling Float.lhs, which mentions Float of course
	  	-- A bit yukky to call initIfaceTcRn here
	}
  where
    tc_name = tyConName tc

ifCheckWiredInThing :: TyThing -> IfL ()
-- Even though we are in an interface file, we want to make
-- sure the instances of a wired-in thing are loaded (imagine f :: Double -> Double)
-- Ditto want to ensure that RULES are loaded too
-- See Note [Loading instances for wired-in things]
ifCheckWiredInThing thing
  = do	{ mod <- getIfModule
		-- Check whether we are typechecking the interface for this
		-- very module.  E.g when compiling the base library in --make mode
		-- we may typecheck GHC.Base.hi. At that point, GHC.Base is not in
		-- the HPT, so without the test we'll demand-load it into the PIT!
		-- C.f. the same test in checkWiredInTyCon above
        ; let name = getName thing
	; ASSERT2( isExternalName name, ppr name ) 
	  when (needWiredInHomeIface thing && mod /= nameModule name)
	       (loadWiredInHomeIface name) }

needWiredInHomeIface :: TyThing -> Bool
-- Only for TyCons; see Note [Loading instances for wired-in things]
needWiredInHomeIface (ATyCon {}) = True
needWiredInHomeIface _           = False
\end{code}

229
230
%************************************************************************
%*									*
231
		Type-checking a complete interface
232
233
234
%*									*
%************************************************************************

235
236
237
238
239
240
241
242
Suppose we discover we don't need to recompile.  Then we must type
check the old interface file.  This is a bit different to the
incremental type checking we do as we suck in interface files.  Instead
we do things similarly as when we are typechecking source decls: we
bring into scope the type envt for the interface all at once, using a
knot.  Remember, the decls aren't necessarily in dependency order --
and even if they were, the type decls might be mutually recursive.

243
\begin{code}
244
245
246
247
248
249
typecheckIface :: ModIface 	-- Get the decls from here
	       -> TcRnIf gbl lcl ModDetails
typecheckIface iface
  = initIfaceTc iface $ \ tc_env_var -> do
	-- The tc_env_var is freshly allocated, private to 
	-- type-checking this particular interface
250
251
252
253
254
255
	{ 	-- Get the right set of decls and rules.  If we are compiling without -O
		-- we discard pragmas before typechecking, so that we don't "see"
		-- information that we shouldn't.  From a versioning point of view
		-- It's not actually *wrong* to do so, but in fact GHCi is unable 
		-- to handle unboxed tuples, so it must not see unfoldings.
	  ignore_prags <- doptM Opt_IgnoreInterfacePragmas
256

257
258
259
260
261
262
		-- Typecheck the decls.  This is done lazily, so that the knot-tying
		-- within this single module work out right.  In the If monad there is
		-- no global envt for the current interface; instead, the knot is tied
		-- through the if_rec_types field of IfGblEnv
	; names_w_things <- loadDecls ignore_prags (mi_decls iface)
	; let type_env = mkNameEnv names_w_things
263
264
	; writeMutVar tc_env_var type_env

265
		-- Now do those rules, instances and annotations
266
267
268
	; insts     <- mapM tcIfaceInst    (mi_insts     iface)
	; fam_insts <- mapM tcIfaceFamInst (mi_fam_insts iface)
	; rules     <- tcIfaceRules ignore_prags (mi_rules iface)
269
	; anns      <- tcIfaceAnnotations  (mi_anns iface)
270

chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
271
                -- Vectorisation information
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
272
273
        ; vect_info <- tcIfaceVectInfo (mi_module iface) type_env 
                                       (mi_vect_info iface)
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
274

275
		-- Exports
276
	; exports <- ifaceExportNames (mi_exports iface)
277

278
		-- Finished
279
280
	; traceIf (vcat [text "Finished typechecking interface for" <+> ppr (mi_module iface),
			 text "Type envt:" <+> ppr type_env])
281
	; return $ ModDetails { md_types     = type_env
282
283
			      , md_insts     = insts
			      , md_fam_insts = fam_insts
284
			      , md_rules     = rules
285
			      , md_anns      = anns
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
286
                              , md_vect_info = vect_info
mnislaih's avatar
mnislaih committed
287
			      , md_exports   = exports
288
			      }
289
    }
290
291
292
\end{code}


293
294
295
296
297
298
299
%************************************************************************
%*									*
		Type and class declarations
%*									*
%************************************************************************

\begin{code}
300
tcHiBootIface :: HscSource -> Module -> TcRn ModDetails
301
302
303
-- Load the hi-boot iface for the module being compiled,
-- if it indeed exists in the transitive closure of imports
-- Return the ModDetails, empty if no hi-boot iface
304
305
306
307
tcHiBootIface hsc_src mod
  | isHsBoot hsc_src		-- Already compiling a hs-boot file
  = return emptyModDetails
  | otherwise
308
309
  = do 	{ traceIf (text "loadHiBootInterface" <+> ppr mod)

310
	; mode <- getGhcMode
311
312
313
	; if not (isOneShot mode)
		-- In --make and interactive mode, if this module has an hs-boot file
		-- we'll have compiled it already, and it'll be in the HPT
314
315
316
317
318
319
320
321
		-- 
		-- We check wheher the interface is a *boot* interface.
		-- It can happen (when using GHC from Visual Studio) that we
		-- compile a module in TypecheckOnly mode, with a stable, 
		-- fully-populated HPT.  In that case the boot interface isn't there
		-- (it's been replaced by the mother module) so we can't check it.
		-- And that's fine, because if M's ModInfo is in the HPT, then 
		-- it's been compiled once, and we don't need to check the boot iface
322
	  then do { hpt <- getHpt
Simon Marlow's avatar
Simon Marlow committed
323
		  ; case lookupUFM hpt (moduleName mod) of
324
325
		      Just info | mi_boot (hm_iface info) 
				-> return (hm_details info)
Ian Lynagh's avatar
Ian Lynagh committed
326
		      _ -> return emptyModDetails }
327
328
329
330
331
332
333
	  else do

	-- OK, so we're in one-shot mode.  
	-- In that case, we're read all the direct imports by now, 
	-- so eps_is_boot will record if any of our imports mention us by 
	-- way of hi-boot file
	{ eps <- getEps
Simon Marlow's avatar
Simon Marlow committed
334
	; case lookupUFM (eps_is_boot eps) (moduleName mod) of {
335
336
337
338
339
340
	    Nothing -> return emptyModDetails ;	-- The typical case

	    Just (_, False) -> failWithTc moduleLoop ;
 		-- Someone below us imported us!
		-- This is a loop with no hi-boot in the way
		
Simon Marlow's avatar
Simon Marlow committed
341
	    Just (_mod, True) -> 	-- There's a hi-boot interface below us
342
343
344
345
346
347
348
349
		
    do	{ read_result <- findAndReadIface 
				need mod
				True	-- Hi-boot file

	; case read_result of
		Failed err               -> failWithTc (elaborate err)
		Succeeded (iface, _path) -> typecheckIface iface
350
    }}}}
351
  where
Ian Lynagh's avatar
Ian Lynagh committed
352
353
    need = ptext (sLit "Need the hi-boot interface for") <+> ppr mod
		 <+> ptext (sLit "to compare against the Real Thing")
354

Ian Lynagh's avatar
Ian Lynagh committed
355
356
    moduleLoop = ptext (sLit "Circular imports: module") <+> quotes (ppr mod) 
		     <+> ptext (sLit "depends on itself")
357

Ian Lynagh's avatar
Ian Lynagh committed
358
    elaborate err = hang (ptext (sLit "Could not find hi-boot interface for") <+> 
359
360
361
362
		          quotes (ppr mod) <> colon) 4 err
\end{code}


363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
%************************************************************************
%*									*
		Type and class declarations
%*									*
%************************************************************************

When typechecking a data type decl, we *lazily* (via forkM) typecheck
the constructor argument types.  This is in the hope that we may never
poke on those argument types, and hence may never need to load the
interface files for types mentioned in the arg types.

E.g.	
	data Foo.S = MkS Baz.T
Mabye we can get away without even loading the interface for Baz!

This is not just a performance thing.  Suppose we have
	data Foo.S = MkS Baz.T
	data Baz.T = MkT Foo.S
(in different interface files, of course).
Now, first we load and typecheck Foo.S, and add it to the type envt.  
If we do explore MkS's argument, we'll load and typecheck Baz.T.
If we explore MkT's argument we'll find Foo.S already in the envt.  

If we typechecked constructor args eagerly, when loading Foo.S we'd try to
typecheck the type Baz.T.  So we'd fault in Baz.T... and then need Foo.S...
which isn't done yet.

All very cunning. However, there is a rather subtle gotcha which bit
me when developing this stuff.  When we typecheck the decl for S, we
extend the type envt with S, MkS, and all its implicit Ids.  Suppose
(a bug, but it happened) that the list of implicit Ids depended in
turn on the constructor arg types.  Then the following sequence of
events takes place:
	* we build a thunk <t> for the constructor arg tys
	* we build a thunk for the extended type environment (depends on <t>)
	* we write the extended type envt into the global EPS mutvar
	
Now we look something up in the type envt
	* that pulls on <t>
	* which reads the global type envt out of the global EPS mutvar
	* but that depends in turn on <t>

It's subtle, because, it'd work fine if we typechecked the constructor args 
eagerly -- they don't need the extended type envt.  They just get the extended
type envt by accident, because they look at it later.

What this means is that the implicitTyThings MUST NOT DEPEND on any of
the forkM stuff.


\begin{code}
414
415
416
tcIfaceDecl :: Bool	-- True <=> discard IdInfo on IfaceId bindings
	    -> IfaceDecl
	    -> IfL TyThing
417
418
419
420
421
422
423
424
tcIfaceDecl = tc_iface_decl NoParentTyCon

tc_iface_decl :: TyConParent	-- For nested declarations
              -> Bool	-- True <=> discard IdInfo on IfaceId bindings
	      -> IfaceDecl
	      -> IfL TyThing
tc_iface_decl _ ignore_prags (IfaceId {ifName = occ_name, ifType = iface_type, 
 	                               ifIdDetails = details, ifIdInfo = info})
425
426
  = do	{ name <- lookupIfaceTop occ_name
	; ty <- tcIfaceType iface_type
427
	; details <- tcIdDetails ty details
428
	; info <- tcIdInfo ignore_prags name ty info
429
	; return (AnId (mkGlobalId details name ty info)) }
430

431
tc_iface_decl parent _ (IfaceData {ifName = occ_name, 
432
433
434
435
436
437
			  ifTyVars = tv_bndrs, 
			  ifCtxt = ctxt, ifGadtSyntax = gadt_syn,
			  ifCons = rdr_cons, 
			  ifRec = is_rec, 
			  ifGeneric = want_generic,
			  ifFamInst = mb_family })
438
439
440
  = bindIfaceTyVars_AT tv_bndrs $ \ tyvars -> do
    { tc_name <- lookupIfaceTop occ_name
    ; tycon <- fixM ( \ tycon -> do
441
	    { stupid_theta <- tcIfaceCtxt ctxt
442
	    ; cons <- tcIfaceDataCons tc_name tycon tyvars rdr_cons
443
444
445
	    ; mb_fam_inst  <- tcFamInst mb_family
	    ; buildAlgTyCon tc_name tyvars stupid_theta cons is_rec
			    want_generic gadt_syn parent mb_fam_inst
446
	    })
447
448
    ; traceIf (text "tcIfaceDecl4" <+> ppr tycon)
    ; return (ATyCon tycon) }
449

450
451
452
tc_iface_decl parent _ (IfaceSyn {ifName = occ_name, ifTyVars = tv_bndrs, 
		         	  ifSynRhs = mb_rhs_ty,
		         	  ifSynKind = kind, ifFamInst = mb_family})
453
   = bindIfaceTyVars_AT tv_bndrs $ \ tyvars -> do
454
     { tc_name  <- lookupIfaceTop occ_name
455
     ; rhs_kind <- tcIfaceType kind	-- Note [Synonym kind loop]
456
457
458
459
460
     ; rhs      <- forkM (mk_doc tc_name) $ 
       	      	   tc_syn_rhs mb_rhs_ty
     ; fam_info <- tcFamInst mb_family
     ; tycon <- buildSynTyCon tc_name tyvars rhs rhs_kind parent fam_info
     ; return (ATyCon tycon)
461
     }
462
463
   where
     mk_doc n = ptext (sLit "Type syonym") <+> ppr n
464
465
466
     tc_syn_rhs Nothing   = return SynFamilyTyCon
     tc_syn_rhs (Just ty) = do { rhs_ty <- tcIfaceType ty
		               ; return (SynonymTyCon rhs_ty) }
467

468
tc_iface_decl _parent ignore_prags
469
	    (IfaceClass {ifCtxt = rdr_ctxt, ifName = occ_name, 
470
471
			 ifTyVars = tv_bndrs, ifFDs = rdr_fds, 
			 ifATs = rdr_ats, ifSigs = rdr_sigs, 
472
			 ifRec = tc_isrec })
473
474
-- ToDo: in hs-boot files we should really treat abstract classes specially,
--	 as we do abstract tycons
475
476
477
  = bindIfaceTyVars tv_bndrs $ \ tyvars -> do
    { cls_name <- lookupIfaceTop occ_name
    ; ctxt <- tcIfaceCtxt rdr_ctxt
478
479
    ; sigs <- mapM tc_sig rdr_sigs
    ; fds  <- mapM tc_fd rdr_fds
480
481
482
    ; cls  <- fixM $ \ cls -> do
              { ats  <- mapM (tc_iface_decl (AssocFamilyTyCon cls) ignore_prags) rdr_ats
              ; buildClass ignore_prags cls_name tyvars ctxt fds ats sigs tc_isrec }
483
484
485
486
487
488
    ; return (AClass cls) }
  where
   tc_sig (IfaceClassOp occ dm rdr_ty)
     = do { op_name <- lookupIfaceTop occ
	  ; op_ty   <- forkM (mk_doc op_name rdr_ty) (tcIfaceType rdr_ty)
		-- Must be done lazily for just the same reason as the 
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
489
490
		-- type of a data con; to avoid sucking in types that
		-- it mentions unless it's necessray to do so
491
492
	  ; return (op_name, dm, op_ty) }

Ian Lynagh's avatar
Ian Lynagh committed
493
   mk_doc op_name op_ty = ptext (sLit "Class op") <+> sep [ppr op_name, ppr op_ty]
494

495
496
   tc_fd (tvs1, tvs2) = do { tvs1' <- mapM tcIfaceTyVar tvs1
			   ; tvs2' <- mapM tcIfaceTyVar tvs2
497
498
			   ; return (tvs1', tvs2') }

499
tc_iface_decl _ _ (IfaceForeign {ifName = rdr_name, ifExtName = ext_name})
500
501
  = do	{ name <- lookupIfaceTop rdr_name
	; return (ATyCon (mkForeignTyCon name ext_name 
502
					 liftedTypeKind 0)) }
503

504
505
506
507
508
509
tcFamInst :: Maybe (IfaceTyCon, [IfaceType]) -> IfL (Maybe (TyCon, [Type]))
tcFamInst Nothing           = return Nothing
tcFamInst (Just (fam, tys)) = do { famTyCon <- tcIfaceTyCon fam
      	    			 ; insttys <- mapM tcIfaceType tys
       	    			 ; return $ Just (famTyCon, insttys) }

Ian Lynagh's avatar
Ian Lynagh committed
510
511
tcIfaceDataCons :: Name -> TyCon -> [TyVar] -> IfaceConDecls -> IfL AlgTyConRhs
tcIfaceDataCons tycon_name tycon _ if_cons
512
  = case if_cons of
513
	IfAbstractTyCon	 -> return mkAbstractTyConRhs
514
	IfOpenDataTyCon	 -> return DataFamilyTyCon
515
	IfDataTyCon cons -> do 	{ data_cons <- mapM tc_con_decl cons
516
517
				; return (mkDataTyConRhs data_cons) }
	IfNewTyCon con	 -> do 	{ data_con <- tc_con_decl con
518
				; mkNewTyConRhs tycon_name tycon data_con }
519
  where
520
521
522
523
    tc_con_decl (IfCon { ifConInfix = is_infix, 
			 ifConUnivTvs = univ_tvs, ifConExTvs = ex_tvs,
			 ifConOcc = occ, ifConCtxt = ctxt, ifConEqSpec = spec,
			 ifConArgTys = args, ifConFields = field_lbls,
524
			 ifConStricts = stricts})
525
526
     = bindIfaceTyVars univ_tvs $ \ univ_tyvars -> do
       bindIfaceTyVars ex_tvs	 $ \ ex_tyvars -> do
527
	{ name  <- lookupIfaceTop occ
528
        ; eq_spec <- tcIfaceEqSpec spec
529
530
531
532
533
534
535
536
537
	; theta <- tcIfaceCtxt ctxt	-- Laziness seems not worth the bother here
	 	-- At one stage I thought that this context checking *had*
		-- to be lazy, because of possible mutual recursion between the
		-- type and the classe: 
		-- E.g. 
		--	class Real a where { toRat :: a -> Ratio Integer }
		--	data (Real a) => Ratio a = ...
		-- But now I think that the laziness in checking class ops breaks 
		-- the loop, so no laziness needed
538
539
540

	-- Read the argument types, but lazily to avoid faulting in
	-- the component types unless they are really needed
541
542
 	; arg_tys <- forkM (mk_doc name) (mapM tcIfaceType args)
	; lbl_names <- mapM lookupIfaceTop field_lbls
543

544
545
546
547
	-- Remember, tycon is the representation tycon
	; let orig_res_ty = mkFamilyTyConApp tycon 
				(substTyVars (mkTopTvSubst eq_spec) univ_tyvars)

548
549
550
551
	; buildDataCon name is_infix {- Not infix -}
		       stricts lbl_names
		       univ_tyvars ex_tyvars 
                       eq_spec theta 
552
		       arg_tys orig_res_ty tycon
553
	}
Ian Lynagh's avatar
Ian Lynagh committed
554
    mk_doc con_name = ptext (sLit "Constructor") <+> ppr con_name
555

Ian Lynagh's avatar
Ian Lynagh committed
556
tcIfaceEqSpec :: [(OccName, IfaceType)] -> IfL [(TyVar, Type)]
557
558
559
tcIfaceEqSpec spec
  = mapM do_item spec
  where
560
    do_item (occ, if_ty) = do { tv <- tcIfaceTyVar (occNameFS occ)
561
562
                              ; ty <- tcIfaceType if_ty
                              ; return (tv,ty) }
563
\end{code}
564

565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
Note [Synonym kind loop]
~~~~~~~~~~~~~~~~~~~~~~~~
Notice that we eagerly grab the *kind* from the interface file, but
build a forkM thunk for the *rhs* (and family stuff).  To see why, 
consider this (Trac #2412)

M.hs:       module M where { import X; data T = MkT S }
X.hs:       module X where { import {-# SOURCE #-} M; type S = T }
M.hs-boot:  module M where { data T }

When kind-checking M.hs we need S's kind.  But we do not want to
find S's kind from (typeKind S-rhs), because we don't want to look at
S-rhs yet!  Since S is imported from X.hi, S gets just one chance to
be defined, and we must not do that until we've finished with M.T.

Solution: record S's kind in the interface file; now we can safely
look at it.
582
583
584
585
586
587
588
589

%************************************************************************
%*									*
		Instances
%*									*
%************************************************************************

\begin{code}
590
591
tcIfaceInst :: IfaceInst -> IfL Instance
tcIfaceInst (IfaceInst { ifDFun = dfun_occ, ifOFlag = oflag,
Ian Lynagh's avatar
Ian Lynagh committed
592
			 ifInstCls = cls, ifInstTys = mb_tcs })
Ian Lynagh's avatar
Ian Lynagh committed
593
  = do	{ dfun    <- forkM (ptext (sLit "Dict fun") <+> ppr dfun_occ) $
594
595
		     tcIfaceExtId dfun_occ
        ; let mb_tcs' = map (fmap ifaceTyConName) mb_tcs
596
	; return (mkImportedInstance cls mb_tcs' dfun oflag) }
597
598
599
600

tcIfaceFamInst :: IfaceFamInst -> IfL FamInst
tcIfaceFamInst (IfaceFamInst { ifFamInstTyCon = tycon, 
			       ifFamInstFam = fam, ifFamInstTys = mb_tcs })
Ian Lynagh's avatar
Ian Lynagh committed
601
--	{ tycon'  <- forkM (ptext (sLit "Inst tycon") <+> ppr tycon) $
Thomas Schilling's avatar
Thomas Schilling committed
602
-- the above line doesn't work, but this below does => CPP in Haskell = evil!
603
604
605
606
    = do tycon'  <- forkM (text ("Inst tycon") <+> ppr tycon) $
                    tcIfaceTyCon tycon
         let mb_tcs' = map (fmap ifaceTyConName) mb_tcs
         return (mkImportedFamInst fam mb_tcs' tycon')
607
608
\end{code}

609

610
611
612
613
614
615
616
617
618
619
620
%************************************************************************
%*									*
		Rules
%*									*
%************************************************************************

We move a IfaceRule from eps_rules to eps_rule_base when all its LHS free vars
are in the type environment.  However, remember that typechecking a Rule may 
(as a side effect) augment the type envt, and so we may need to iterate the process.

\begin{code}
621
622
623
624
625
626
627
tcIfaceRules :: Bool 		-- True <=> ignore rules
	     -> [IfaceRule]
	     -> IfL [CoreRule]
tcIfaceRules ignore_prags if_rules
  | ignore_prags = return []
  | otherwise    = mapM tcIfaceRule if_rules

628
629
tcIfaceRule :: IfaceRule -> IfL CoreRule
tcIfaceRule (IfaceRule {ifRuleName = name, ifActivation = act, ifRuleBndrs = bndrs,
Ian Lynagh's avatar
Ian Lynagh committed
630
			ifRuleHead = fn, ifRuleArgs = args, ifRuleRhs = rhs })
631
  = do	{ ~(bndrs', args', rhs') <- 
632
		-- Typecheck the payload lazily, in the hope it'll never be looked at
Ian Lynagh's avatar
Ian Lynagh committed
633
		forkM (ptext (sLit "Rule") <+> ftext name) $
634
		bindIfaceBndrs bndrs 			  $ \ bndrs' ->
635
		do { args' <- mapM tcIfaceExpr args
636
637
		   ; rhs'  <- tcIfaceExpr rhs
		   ; return (bndrs', args', rhs') }
638
	; let mb_tcs = map ifTopFreeName args
639
	; return (Rule { ru_name = name, ru_fn = fn, ru_act = act, 
640
			  ru_bndrs = bndrs', ru_args = args', 
641
			  ru_rhs = occurAnalyseExpr rhs', 
642
			  ru_rough = mb_tcs,
643
644
645
			  ru_local = False }) }	-- An imported RULE is never for a local Id
						-- or, even if it is (module loop, perhaps)
						-- we'll just leave it in the non-local set
646
  where
647
648
649
650
651
652
653
	-- This function *must* mirror exactly what Rules.topFreeName does
	-- We could have stored the ru_rough field in the iface file
	-- but that would be redundant, I think.
	-- The only wrinkle is that we must not be deceived by
	-- type syononyms at the top of a type arg.  Since
	-- we can't tell at this point, we are careful not
	-- to write them out in coreRuleToIfaceRule
654
655
    ifTopFreeName :: IfaceExpr -> Maybe Name
    ifTopFreeName (IfaceType (IfaceTyConApp tc _ )) = Just (ifaceTyConName tc)
Ian Lynagh's avatar
Ian Lynagh committed
656
    ifTopFreeName (IfaceApp f _)                    = ifTopFreeName f
657
    ifTopFreeName (IfaceExt n)                      = Just n
Ian Lynagh's avatar
Ian Lynagh committed
658
    ifTopFreeName _                                 = Nothing
659
660
661
\end{code}


662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
%************************************************************************
%*									*
		Annotations
%*									*
%************************************************************************

\begin{code}
tcIfaceAnnotations :: [IfaceAnnotation] -> IfL [Annotation]
tcIfaceAnnotations = mapM tcIfaceAnnotation

tcIfaceAnnotation :: IfaceAnnotation -> IfL Annotation
tcIfaceAnnotation (IfaceAnnotation target serialized) = do
    target' <- tcIfaceAnnTarget target
    return $ Annotation {
        ann_target = target',
        ann_value = serialized
    }

tcIfaceAnnTarget :: IfaceAnnTarget -> IfL (AnnTarget Name)
tcIfaceAnnTarget (NamedTarget occ) = do
    name <- lookupIfaceTop occ
    return $ NamedTarget name
tcIfaceAnnTarget (ModuleTarget mod) = do
    return $ ModuleTarget mod

\end{code}


chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
690
691
692
693
694
695
696
697
%************************************************************************
%*									*
		Vectorisation information
%*									*
%************************************************************************

\begin{code}
tcIfaceVectInfo :: Module -> TypeEnv  -> IfaceVectInfo -> IfL VectInfo
698
tcIfaceVectInfo mod typeEnv (IfaceVectInfo 
699
700
701
                             { ifaceVectInfoVar        = vars
                             , ifaceVectInfoTyCon      = tycons
                             , ifaceVectInfoTyConReuse = tyconsReuse
702
                             })
703
704
  = do { vVars     <- mapM vectVarMapping vars
       ; tyConRes1 <- mapM vectTyConMapping      tycons
705
       ; tyConRes2 <- mapM vectTyConReuseMapping tyconsReuse
rl@cse.unsw.edu.au's avatar
rl@cse.unsw.edu.au committed
706
       ; let (vTyCons, vDataCons, vPAs, vIsos) = unzip4 (tyConRes1 ++ tyConRes2)
707
       ; return $ VectInfo 
708
709
710
                  { vectInfoVar     = mkVarEnv  vVars
                  , vectInfoTyCon   = mkNameEnv vTyCons
                  , vectInfoDataCon = mkNameEnv (concat vDataCons)
rl@cse.unsw.edu.au's avatar
rl@cse.unsw.edu.au committed
711
                  , vectInfoPADFun  = mkNameEnv vPAs
712
                  , vectInfoIso     = mkNameEnv vIsos
713
                  }
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
714
715
       }
  where
716
717
718
719
    vectVarMapping name 
      = do { vName <- lookupOrig mod (mkVectOcc (nameOccName name))
           ; let { var  = lookupVar name
                 ; vVar = lookupVar vName
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
720
                 }
721
           ; return (var, (var, vVar))
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
722
           }
723
724
    vectTyConMapping name 
      = do { vName   <- lookupOrig mod (mkVectTyConOcc (nameOccName name))
rl@cse.unsw.edu.au's avatar
rl@cse.unsw.edu.au committed
725
           ; paName  <- lookupOrig mod (mkPADFunOcc    (nameOccName name))
726
           ; isoName <- lookupOrig mod (mkVectIsoOcc   (nameOccName name))
727
           ; let { tycon    = lookupTyCon name
728
                 ; vTycon   = lookupTyCon vName
rl@cse.unsw.edu.au's avatar
rl@cse.unsw.edu.au committed
729
                 ; paTycon  = lookupVar paName
730
731
                 ; isoTycon = lookupVar isoName
                 }
732
733
734
           ; vDataCons <- mapM vectDataConMapping (tyConDataCons tycon)
           ; return ((name, (tycon, vTycon)),    -- (T, T_v)
                     vDataCons,                  -- list of (Ci, Ci_v)
735
                     (vName, (vTycon, paTycon)), -- (T_v, paT)
736
737
                     (name, (tycon, isoTycon)))  -- (T, isoT)
           }
738
    vectTyConReuseMapping name 
rl@cse.unsw.edu.au's avatar
rl@cse.unsw.edu.au committed
739
740
      = do { paName  <- lookupOrig mod (mkPADFunOcc    (nameOccName name))
           ; isoName <- lookupOrig mod (mkVectIsoOcc   (nameOccName name))
741
           ; let { tycon      = lookupTyCon name
rl@cse.unsw.edu.au's avatar
rl@cse.unsw.edu.au committed
742
                 ; paTycon    = lookupVar paName
743
                 ; isoTycon   = lookupVar isoName
744
                 ; vDataCons  = [ (dataConName dc, (dc, dc)) 
745
746
747
                                | dc <- tyConDataCons tycon]
                 }
           ; return ((name, (tycon, tycon)),     -- (T, T)
748
                     vDataCons,                  -- list of (Ci, Ci)
rl@cse.unsw.edu.au's avatar
rl@cse.unsw.edu.au committed
749
                     (name, (tycon, paTycon)),   -- (T, paT)
750
751
                     (name, (tycon, isoTycon)))  -- (T, isoT)
           }
752
    vectDataConMapping datacon
753
      = do { let name = dataConName datacon
754
755
756
           ; vName <- lookupOrig mod (mkVectDataConOcc (nameOccName name))
           ; let vDataCon = lookupDataCon vName
           ; return (name, (datacon, vDataCon))
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
           }
    --
    lookupVar name = case lookupTypeEnv typeEnv name of
                       Just (AnId var) -> var
                       Just _         -> 
                         panic "TcIface.tcIfaceVectInfo: not an id"
                       Nothing        ->
                         panic "TcIface.tcIfaceVectInfo: unknown name"
    lookupTyCon name = case lookupTypeEnv typeEnv name of
                         Just (ATyCon tc) -> tc
                         Just _         -> 
                           panic "TcIface.tcIfaceVectInfo: not a tycon"
                         Nothing        ->
                           panic "TcIface.tcIfaceVectInfo: unknown name"
    lookupDataCon name = case lookupTypeEnv typeEnv name of
                           Just (ADataCon dc) -> dc
                           Just _         -> 
                             panic "TcIface.tcIfaceVectInfo: not a datacon"
                           Nothing        ->
                             panic "TcIface.tcIfaceVectInfo: unknown name"
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
777
778
\end{code}

779
780
781
782
783
784
785
786
787
788
789
%************************************************************************
%*									*
			Types
%*									*
%************************************************************************

\begin{code}
tcIfaceType :: IfaceType -> IfL Type
tcIfaceType (IfaceTyVar n)        = do { tv <- tcIfaceTyVar n; return (TyVarTy tv) }
tcIfaceType (IfaceAppTy t1 t2)    = do { t1' <- tcIfaceType t1; t2' <- tcIfaceType t2; return (AppTy t1' t2') }
tcIfaceType (IfaceFunTy t1 t2)    = do { t1' <- tcIfaceType t1; t2' <- tcIfaceType t2; return (FunTy t1' t2') }
790
tcIfaceType (IfaceTyConApp tc ts) = do { tc' <- tcIfaceTyCon tc; ts' <- tcIfaceTypes ts; return (mkTyConApp tc' ts') }
791
792
793
tcIfaceType (IfaceForAllTy tv t)  = bindIfaceTyVar tv $ \ tv' -> do { t' <- tcIfaceType t; return (ForAllTy tv' t') }
tcIfaceType (IfacePredTy st)      = do { st' <- tcIfacePredType st; return (PredTy st') }

Ian Lynagh's avatar
Ian Lynagh committed
794
tcIfaceTypes :: [IfaceType] -> IfL [Type]
795
796
797
798
799
800
tcIfaceTypes tys = mapM tcIfaceType tys

-----------------------------------------
tcIfacePredType :: IfacePredType -> IfL PredType
tcIfacePredType (IfaceClassP cls ts) = do { cls' <- tcIfaceClass cls; ts' <- tcIfaceTypes ts; return (ClassP cls' ts') }
tcIfacePredType (IfaceIParam ip t)   = do { ip' <- newIPName ip; t' <- tcIfaceType t; return (IParam ip' t') }
801
tcIfacePredType (IfaceEqPred t1 t2)  = do { t1' <- tcIfaceType t1; t2' <- tcIfaceType t2; return (EqPred t1' t2') }
802
803
804

-----------------------------------------
tcIfaceCtxt :: IfaceContext -> IfL ThetaType
805
tcIfaceCtxt sts = mapM tcIfacePredType sts
806
807
808
809
810
811
812
813
814
815
816
817
\end{code}


%************************************************************************
%*									*
			Core
%*									*
%************************************************************************

\begin{code}
tcIfaceExpr :: IfaceExpr -> IfL CoreExpr
tcIfaceExpr (IfaceType ty)
818
  = Type <$> tcIfaceType ty
819
820

tcIfaceExpr (IfaceLcl name)
821
  = Var <$> tcIfaceLclId name
822

823
tcIfaceExpr (IfaceTick modName tickNo)
824
  = Var <$> tcIfaceTick modName tickNo
825

826
tcIfaceExpr (IfaceExt gbl)
827
  = Var <$> tcIfaceExtId gbl
828
829

tcIfaceExpr (IfaceLit lit)
830
831
832
833
834
835
836
837
838
839
840
841
  = return (Lit lit)

tcIfaceExpr (IfaceFCall cc ty) = do
    ty' <- tcIfaceType ty
    u <- newUnique
    return (Var (mkFCallId u cc ty'))

tcIfaceExpr (IfaceTuple boxity args)  = do
    args' <- mapM tcIfaceExpr args
    -- Put the missing type arguments back in
    let con_args = map (Type . exprType) args' ++ args'
    return (mkApps (Var con_id) con_args)
842
843
844
845
846
847
  where
    arity = length args
    con_id = dataConWorkId (tupleCon boxity arity)
    

tcIfaceExpr (IfaceLam bndr body)
848
849
  = bindIfaceBndr bndr $ \bndr' ->
    Lam bndr' <$> tcIfaceExpr body
850
851

tcIfaceExpr (IfaceApp fun arg)
852
  = App <$> tcIfaceExpr fun <*> tcIfaceExpr arg
853

854
855
856
tcIfaceExpr (IfaceCase scrut case_bndr ty alts)  = do
    scrut' <- tcIfaceExpr scrut
    case_bndr_name <- newIfaceName (mkVarOccFS case_bndr)
857
858
859
860
861
862
863
864
865
866
    let
	scrut_ty   = exprType scrut'
	case_bndr' = mkLocalId case_bndr_name scrut_ty
	tc_app     = splitTyConApp scrut_ty
		-- NB: Won't always succeed (polymoprhic case)
		--     but won't be demanded in those cases
		-- NB: not tcSplitTyConApp; we are looking at Core here
		--     look through non-rec newtypes to find the tycon that
		--     corresponds to the datacon in this case alternative

867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
    extendIfaceIdEnv [case_bndr'] $ do
     alts' <- mapM (tcIfaceAlt scrut' tc_app) alts
     ty' <- tcIfaceType ty
     return (Case scrut' case_bndr' ty' alts')

tcIfaceExpr (IfaceLet (IfaceNonRec bndr rhs) body) = do
    rhs' <- tcIfaceExpr rhs
    id   <- tcIfaceLetBndr bndr
    body' <- extendIfaceIdEnv [id] (tcIfaceExpr body)
    return (Let (NonRec id rhs') body')

tcIfaceExpr (IfaceLet (IfaceRec pairs) body) = do
    ids <- mapM tcIfaceLetBndr bndrs
    extendIfaceIdEnv ids $ do
     rhss' <- mapM tcIfaceExpr rhss
     body' <- tcIfaceExpr body
     return (Let (Rec (ids `zip` rhss')) body')
884
885
886
  where
    (bndrs, rhss) = unzip pairs

887
tcIfaceExpr (IfaceCast expr co) = do
888
889
890
    expr' <- tcIfaceExpr expr
    co' <- tcIfaceType co
    return (Cast expr' co')
891

892
893
tcIfaceExpr (IfaceNote note expr) = do
    expr' <- tcIfaceExpr expr
894
    case note of
895
896
        IfaceSCC cc       -> return (Note (SCC cc)   expr')
        IfaceCoreNote n   -> return (Note (CoreNote n) expr')
897
898

-------------------------
Ian Lynagh's avatar
Ian Lynagh committed
899
900
901
tcIfaceAlt :: CoreExpr -> (TyCon, [Type])
           -> (IfaceConAlt, [FastString], IfaceExpr)
           -> IfL (AltCon, [TyVar], CoreExpr)
902
tcIfaceAlt _ _ (IfaceDefault, names, rhs)
903
904
905
  = ASSERT( null names ) do
    rhs' <- tcIfaceExpr rhs
    return (DEFAULT, [], rhs')
906
  
907
tcIfaceAlt _ _ (IfaceLitAlt lit, names, rhs)
908
909
910
  = ASSERT( null names ) do
    rhs' <- tcIfaceExpr rhs
    return (LitAlt lit, [], rhs')
911
912
913
914

-- A case alternative is made quite a bit more complicated
-- by the fact that we omit type annotations because we can
-- work them out.  True enough, but its not that easy!
915
tcIfaceAlt scrut (tycon, inst_tys) (IfaceDataAlt data_occ, arg_strs, rhs)
916
  = do	{ con <- tcIfaceDataCon data_occ
Ian Lynagh's avatar
Ian Lynagh committed
917
	; when (debugIsOn && not (con `elem` tyConDataCons tycon))
918
	       (failIfM (ppr scrut $$ ppr con $$ ppr tycon $$ ppr (tyConDataCons tycon)))
919
	; tcIfaceDataAlt con inst_tys arg_strs rhs }
920
		  
Ian Lynagh's avatar
Ian Lynagh committed
921
tcIfaceAlt _ (tycon, inst_tys) (IfaceTupleAlt _boxity, arg_occs, rhs)
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
922
  = ASSERT2( isTupleTyCon tycon, ppr tycon )
923
924
925
    do	{ let [data_con] = tyConDataCons tycon
	; tcIfaceDataAlt data_con inst_tys arg_occs rhs }

Ian Lynagh's avatar
Ian Lynagh committed
926
927
tcIfaceDataAlt :: DataCon -> [Type] -> [FastString] -> IfaceExpr
               -> IfL (AltCon, [TyVar], CoreExpr)
928
tcIfaceDataAlt con inst_tys arg_strs rhs
929
930
  = do	{ us <- newUniqueSupply
	; let uniqs = uniqsFromSupply us
931
932
933
	; let (ex_tvs, co_tvs, arg_ids)
	              = dataConRepFSInstPat arg_strs uniqs con inst_tys
              all_tvs = ex_tvs ++ co_tvs
934
935

	; rhs' <- extendIfaceTyVarEnv all_tvs	$
936
937
		  extendIfaceIdEnv arg_ids	$
		  tcIfaceExpr rhs
938
	; return (DataAlt con, all_tvs ++ arg_ids, rhs') }
939
940
941
942
\end{code}


\begin{code}
943
944
945
tcExtCoreBindings :: [IfaceBinding] -> IfL [CoreBind]	-- Used for external core
tcExtCoreBindings []     = return []
tcExtCoreBindings (b:bs) = do_one b (tcExtCoreBindings bs)
946

947
948
do_one :: IfaceBinding -> IfL [CoreBind] -> IfL [CoreBind]
do_one (IfaceNonRec bndr rhs) thing_inside
949
  = do	{ rhs' <- tcIfaceExpr rhs
950
	; bndr' <- newExtCoreBndr bndr
951
952
953
954
	; extendIfaceIdEnv [bndr'] $ do 
	{ core_binds <- thing_inside
	; return (NonRec bndr' rhs' : core_binds) }}

955
do_one (IfaceRec pairs) thing_inside
956
  = do	{ bndrs' <- mapM newExtCoreBndr bndrs
957
	; extendIfaceIdEnv bndrs' $ do
958
 	{ rhss' <- mapM tcIfaceExpr rhss
959
960
961
962
963
964
965
966
967
968
969
970
971
972
	; core_binds <- thing_inside
	; return (Rec (bndrs' `zip` rhss') : core_binds) }}
  where
    (bndrs,rhss) = unzip pairs
\end{code}


%************************************************************************
%*									*
		IdInfo
%*									*
%************************************************************************

\begin{code}
973
974
975
976
977
978
979
980
tcIdDetails :: Type -> IfaceIdDetails -> IfL IdDetails
tcIdDetails _  IfVanillaId = return VanillaId
tcIdDetails ty IfDFunId
  = return (DFunId (isNewTyCon (classTyCon cls)))
  where
    (_, cls, _) = tcSplitDFunTy ty

tcIdDetails _ (IfRecSelId tc naughty)
981
982
  = do { tc' <- tcIfaceTyCon tc
       ; return (RecSelId { sel_tycon = tc', sel_naughty = naughty }) }
983

984
985
986
987
988
989
tcIdInfo :: Bool -> Name -> Type -> IfaceIdInfo -> IfL IdInfo
tcIdInfo ignore_prags name ty info 
  | ignore_prags = return vanillaIdInfo
  | otherwise    = case info of
			NoInfo       -> return vanillaIdInfo
			HasInfo info -> foldlM tcPrag init_info info
990
991
992
993
994
  where
    -- Set the CgInfo to something sensible but uninformative before
    -- we start; default assumption is that it has CAFs
    init_info = vanillaIdInfo

995
    tcPrag :: IdInfo -> IfaceInfoItem -> IfL IdInfo
996
997
    tcPrag info HsNoCafRefs        = return (info `setCafInfo`   NoCafRefs)
    tcPrag info (HsArity arity)    = return (info `setArityInfo` arity)
998
    tcPrag info (HsStrictness str) = return (info `setStrictnessInfo` Just str)
999
    tcPrag info (HsInline prag)    = return (info `setInlinePragInfo` prag)
1000
1001

	-- The next two are lazy, so they don't transitively suck stuff in
1002
1003
1004
1005
1006
    tcPrag info (HsUnfold lb if_unf) 
      = do { unf <- tcUnfolding name ty info if_unf
    	   ; let info1 | lb        = info `setOccInfo` nonRuleLoopBreaker
	     	       | otherwise = info
	   ; return (info1 `setUnfoldingInfoLazily` unf) }
1007
1008
1009
\end{code}

\begin{code}
1010
tcUnfolding :: Name -> Type -> IdInfo -> IfaceUnfolding -> IfL Unfolding
1011
tcUnfolding name _ info (IfCoreUnfold if_expr)
1012
1013
1014
  = do 	{ mb_expr <- tcPragExpr name if_expr
	; return (case mb_expr of
		    Nothing -> NoUnfolding
1015
1016
1017
1018
1019
1020
		    Just expr -> mkTopUnfolding is_bottoming expr) }
  where
     -- Strictness should occur before unfolding!
    is_bottoming = case strictnessInfo info of
    		     Just sig -> isBottomingSig sig
 		     Nothing  -> False
1021

1022
tcUnfolding name _ _ (IfCompulsory if_expr)
1023
1024
1025
  = do 	{ mb_expr <- tcPragExpr name if_expr
	; return (case mb_expr of
		    Nothing   -> NoUnfolding
1026
1027
1028
1029
1030
1031
1032
1033
1034
		    Just expr -> mkCompulsoryUnfolding expr) }

tcUnfolding name _ _ (IfInlineRule arity unsat_ok boring_ok if_expr)
  = do 	{ mb_expr <- tcPragExpr name if_expr
	; return (case mb_expr of
		    Nothing   -> NoUnfolding
		    Just expr -> mkCoreUnfolding True InlineRule expr arity 
                                                 (UnfWhen unsat_ok boring_ok))
    }
Simon Marlow's avatar
Simon Marlow committed
1035

1036
1037
tcUnfolding name ty info (IfWrapper arity wkr)
  = do 	{ mb_wkr_id <- forkM_maybe doc (tcIfaceExtId wkr)
1038
	; us <- newUniqueSupply
1039
	; return (case mb_wkr_id of
1040
1041
		     Nothing     -> noUnfolding
		     Just wkr_id -> make_inline_rule wkr_id us) }
1042
  where
1043
    doc = text "Worker for" <+> ppr name
1044

1045
1046
1047
1048
    make_inline_rule wkr_id us 
	= mkWwInlineRule wkr_id
	  		 (initUs_ us (mkWrapper ty strict_sig) wkr_id) 
		         arity
1049

1050
1051
    	-- Again we rely here on strictness info always appearing 
	-- before unfolding
1052
    strict_sig = case strictnessInfo info of
1053
		   Just sig -> sig
1054
		   Nothing  -> pprPanic "Worker info but no strictness for" (ppr wkr)
1055
1056
1057
1058
1059

tcUnfolding name dfun_ty _ (IfDFunUnfold ops)
  = do { mb_ops1 <- forkM_maybe doc $ mapM tcIfaceExpr ops
       ; return (case mb_ops1 of
       	 	    Nothing   -> noUnfolding
1060
                    Just ops1 -> mkDFunUnfolding dfun_ty ops1) }
1061
1062
  where
    doc = text "Class ops for dfun" <+> ppr name
1063
1064
1065
1066
1067
1068
1069
1070
\end{code}

For unfoldings we try to do the job lazily, so that we never type check
an unfolding that isn't going to be looked at.

\begin{code}
tcPragExpr :: Name -> IfaceExpr -> IfL (Maybe CoreExpr)
tcPragExpr name expr
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
  = forkM_maybe doc $ do
    core_expr' <- tcIfaceExpr expr

                -- Check for type consistency in the unfolding
    ifOptM Opt_DoCoreLinting $ do
        in_scope <- get_in_scope_ids
        case lintUnfolding noSrcLoc in_scope core_expr' of
          Nothing       -> return ()
          Just fail_msg -> pprPanic "Iface Lint failure" (hang doc 2 fail_msg)

    return core_expr'
1082
1083
  where
    doc = text "Unfolding of" <+> ppr name
1084
1085
1086
1087
1088
1089
1090
1091
    get_in_scope_ids 	-- Urgh; but just for linting
	= setLclEnv () $ 
	  do	{ env <- getGblEnv 
		; case if_rec_types env of {
			  Nothing -> return [] ;
			  Just (_, get_env) -> do
		{ type_env <- get_env
		; return (typeEnvIds type_env) }}}
1092
1093
1094
1095
\end{code}



1096
1097
1098
1099
1100
1101
1102
%************************************************************************
%*									*
		Getting from Names to TyThings
%*									*
%************************************************************************

\begin{code}
1103
tcIfaceGlobal :: Name -> IfL TyThing
1104
tcIfaceGlobal name
1105
  | Just thing <- wiredInNameTyThing_maybe name
1106
	-- Wired-in things include TyCons, DataCons, and Ids
1107
  = do { ifCheckWiredInThing thing; return thing }
1108
  | otherwise
1109
1110
  = do	{ env <- getGblEnv
	; case if_rec_types env of {	-- Note [Tying the knot]
1111
1112
1113
	    Just (mod, get_type_env) 
		| nameIsLocalOrFrom mod name
		-> do 		-- It's defined in the module being compiled
1114
	  	{ type_env <- setLclEnv () get_type_env		-- yuk
1115
1116
		; case lookupNameEnv type_env name of
			Just thing -> return thing
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
1117
			Nothing	  -> pprPanic "tcIfaceGlobal (local): not found:"  
1118
1119
						(ppr name $$ ppr type_env) }

Ian Lynagh's avatar
Ian Lynagh committed
1120
	  ; _ -> do
1121

1122
1123
1124
	{ hsc_env <- getTopEnv
        ; mb_thing <- liftIO (lookupTypeHscEnv hsc_env name)
	; case mb_thing of {
1125
1126
1127
	    Just thing -> return thing ;
	    Nothing    -> do

1128
1129
1130
1131
	{ mb_thing <- importDecl name 	-- It's imported; go get it
	; case mb_thing of
	    Failed err      -> failIfM err
	    Succeeded thing -> return thing
1132
    }}}}}
1133

1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
-- Note [Tying the knot]
-- ~~~~~~~~~~~~~~~~~~~~~
-- The if_rec_types field is used in two situations:
--
-- a) Compiling M.hs, which indiretly imports Foo.hi, which mentions M.T
--    Then we look up M.T in M's type environment, which is splatted into if_rec_types
--    after we've built M's type envt.
--
-- b) In ghc --make, during the upsweep, we encounter M.hs, whose interface M.hi
--    is up to date.  So we call typecheckIface on M.hi.  This splats M.T into 
--    if_rec_types so that the (lazily typechecked) decls see all the other decls
--
-- In case (b) it's important to do the if_rec_types check *before* looking in the HPT
-- Because if M.hs also has M.hs-boot, M.T will *already be* in the HPT, but in its
-- emasculated form (e.g. lacking data constructors).

1150
tcIfaceTyCon :: IfaceTyCon -> IfL TyCon
1151
1152
1153
1154
1155
1156
tcIfaceTyCon IfaceIntTc       	= tcWiredInTyCon intTyCon
tcIfaceTyCon IfaceBoolTc      	= tcWiredInTyCon boolTyCon
tcIfaceTyCon IfaceCharTc      	= tcWiredInTyCon charTyCon
tcIfaceTyCon IfaceListTc      	= tcWiredInTyCon listTyCon
tcIfaceTyCon IfacePArrTc      	= tcWiredInTyCon parrTyCon
tcIfaceTyCon (IfaceTupTc bx ar) = tcWiredInTyCon (tupleTyCon bx ar)
1157
1158
tcIfaceTyCon (IfaceAnyTc kind)  = do { tc_kind <- tcIfaceType kind
                                     ; tcWiredInTyCon (anyTyConOfKind tc_kind) }
1159
tcIfaceTyCon (IfaceTc name)     = do { thing <- tcIfaceGlobal name 
1160
1161
				     ; return (check_tc (tyThingTyCon thing)) }
  where
Ian Lynagh's avatar
Ian Lynagh committed
1162
1163
1164
    check_tc tc
     | debugIsOn = case toIfaceTyCon tc of
                   IfaceTc _ -> tc
Ian Lynagh's avatar
Ian Lynagh committed
1165
                   _         -> pprTrace "check_tc" (ppr tc) tc
Ian Lynagh's avatar
Ian Lynagh committed
1166
     | otherwise = tc
1167
1168
1169
1170
1171
1172
-- we should be okay just returning Kind constructors without extra loading
tcIfaceTyCon IfaceLiftedTypeKindTc   = return liftedTypeKindTyCon
tcIfaceTyCon IfaceOpenTypeKindTc     = return openTypeKindTyCon
tcIfaceTyCon IfaceUnliftedTypeKindTc = return unliftedTypeKindTyCon
tcIfaceTyCon IfaceArgTypeKindTc      = return argTypeKindTyCon
tcIfaceTyCon IfaceUbxTupleKindTc     = return ubxTupleKindTyCon
1173
1174
1175
1176
1177

-- Even though we are in an interface file, we want to make
-- sure the instances and RULES of this tycon are loaded 
-- Imagine: f :: Double -> Double
tcWiredInTyCon :: TyCon -> IfL TyCon
1178
tcWiredInTyCon tc = do { ifCheckWiredInThing (ATyCon tc)
1179
		       ; return tc }
1180

1181
1182
1183
tcIfaceClass :: Name -> IfL Class
tcIfaceClass name = do { thing <- tcIfaceGlobal name
		       ; return (tyThingClass thing) }
1184

1185
1186
1187
tcIfaceDataCon :: Name -> IfL DataCon
tcIfaceDataCon name = do { thing <- tcIfaceGlobal name
		 	 ; case thing of
1188
				ADataCon dc -> return dc
Ian Lynagh's avatar
Ian Lynagh committed
1189
				_       -> pprPanic "tcIfaceExtDC" (ppr name$$ ppr thing) }
1190

1191
1192
1193
tcIfaceExtId :: Name -> IfL Id
tcIfaceExtId name = do { thing <- tcIfaceGlobal name
		       ; case thing of
1194
			  AnId id -> return id
Ian Lynagh's avatar
Ian Lynagh committed
1195
			  _       -> pprPanic "tcIfaceExtId" (ppr name$$ ppr thing) }
1196
1197
\end{code}

1198
1199
1200
1201
1202
1203
1204
1205
%************************************************************************
%*									*
		Bindings
%*									*
%************************************************************************

\begin{code}
bindIfaceBndr :: IfaceBndr -> (CoreBndr -> IfL a) -> IfL a
1206
1207
1208
1209
1210
bindIfaceBndr (IfaceIdBndr (fs, ty)) thing_inside
  = do	{ name <- newIfaceName (mkVarOccFS fs)
	; ty' <- tcIfaceType ty
	; let id = mkLocalId name ty'
	; extendIfaceIdEnv [id] (thing_inside id) }
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
bindIfaceBndr (IfaceTvBndr bndr) thing_inside
  = bindIfaceTyVar bndr thing_inside
    
bindIfaceBndrs :: [IfaceBndr] -> ([CoreBndr] -> IfL a) -> IfL a
bindIfaceBndrs []     thing_inside = thing_inside []
bindIfaceBndrs (b:bs) thing_inside
  = bindIfaceBndr b	$ \ b' ->
    bindIfaceBndrs bs	$ \ bs' ->
    thing_inside (b':bs')

1221

1222
-----------------------
Ian Lynagh's avatar
Ian Lynagh committed
1223
tcIfaceLetBndr :: IfaceLetBndr -> IfL Id
1224
1225
tcIfaceLetBndr (IfLetBndr fs ty info)
  = do	{ name <- newIfaceName (mkVarOccFS fs)
1226
	; ty' <- tcIfaceType ty
1227
1228
1229
	; case info of
		NoInfo    -> return (mkLocalId name ty')
		HasInfo i -> return (mkLocalIdWithInfo name ty' (tc_info i)) } 
1230
  where
1231
1232
1233
1234
	-- Similar to tcIdInfo, but much simpler
    tc_info [] = vanillaIdInfo
    tc_info (HsInline p     : i) = tc_info i `setInlinePragInfo` p 
    tc_info (HsArity a      : i) = tc_info i `setArityInfo` a 
1235
    tc_info (HsStrictness s : i) = tc_info i `setStrictnessInfo` Just s 
1236
1237
    tc_info (other          : i) = pprTrace "tcIfaceLetBndr: discarding unexpected IdInfo" 
					    (ppr other) (tc_info i)
1238
1239

-----------------------
1240
newExtCoreBndr :: IfaceLetBndr -> IfL Id
1241
newExtCoreBndr (IfLetBndr var ty _)    -- Ignoring IdInfo for now
1242
  = do	{ mod <- getIfModule
Simon Marlow's avatar