TcRnTypes.lhs 56.3 KB
Newer Older
1

2
% (c) The University of Glasgow 2006
3
4
% (c) The GRASP Project, Glasgow University, 1992-2002
%
5
6
7
8
9
10
11
12
13
14
15
16
17

Various types used during typechecking, please see TcRnMonad as well for
operations on these types. You probably want to import it, instead of this
module.

All the monads exported here are built on top of the same IOEnv monad. The
monad functions like a Reader monad in the way it passes the environment
around. This is done to allow the environment to be manipulated in a stack
like fashion when entering expressions... ect.

For state that is global and should be returned at the end (e.g not part
of the stack mechanism), you should use an TcRef (= IORef) to store them.

18
\begin{code}
Ian Lynagh's avatar
Ian Lynagh committed
19
20
21
22
23
24
25
{-# OPTIONS -fno-warn-tabs #-}
-- The above warning supression flag is a temporary kludge.
-- While working on this module you are encouraged to remove it and
-- detab the module (please do the detabbing in a separate patch). See
--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
-- for details

26
module TcRnTypes(
27
28
	TcRnIf, TcRn, TcM, RnM,	IfM, IfL, IfG, -- The monad is opaque outside this module
	TcRef,
29
30

	-- The environment types
31
32
	Env(..), 
	TcGblEnv(..), TcLclEnv(..), 
33
	IfGblEnv(..), IfLclEnv(..), 
34
35

	-- Ranamer types
36
	ErrCtxt, RecFieldEnv(..),
37
	ImportAvails(..), emptyImportAvails, plusImportAvails, 
38
	WhereFrom(..), mkModDeps,
39
40

	-- Typechecker types
41
42
	TcTypeEnv, TcTyThing(..), PromotionErr(..), 
        pprTcTyThingCategory, pprPECategory,
43
44

	-- Template Haskell
45
	ThStage(..), topStage, topAnnStage, topSpliceStage,
46
	ThLevel, impLevel, outerLevel, thLevel,
47

ross's avatar
ross committed
48
	-- Arrows
ross's avatar
ross committed
49
	ArrowCtxt(NoArrowCtxt), newArrowScope, escapeArrowScope,
ross's avatar
ross committed
50

51
	-- Constraints
52
        Untouchables(..), inTouchableRange, isNoUntouchables,
53

54
       -- Canonical constraints
55
        Xi, Ct(..), Cts, emptyCts, andCts, andManyCts, keepWanted,
56
        singleCt, extendCts, isEmptyCts, isCTyEqCan, isCFunEqCan,
57
        isCDictCan_Maybe, isCFunEqCan_Maybe,
58
        isCIrredEvCan, isCNonCanonical, isWantedCt, isDerivedCt, 
59
60
61
        isGivenCt, 
        ctWantedLoc, ctEvidence,
        SubGoalDepth, mkNonCanonical, ctPred, ctEvPred, ctEvTerm, ctEvId,
62

63
64
65
66
        WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC,
        andWC, addFlats, addImplics, mkFlatWC,

        Implication(..),
67
68
        CtLoc(..), ctLocSpan, ctLocOrigin, setCtLocOrigin,
	CtOrigin(..), EqOrigin(..), 
dimitris's avatar
dimitris committed
69
        WantedLoc, GivenLoc, pushErrCtxt, 
70
        pushErrCtxtSameOrigin,
71

72
	SkolemInfo(..),
73

74
75
76
        CtEvidence(..), pprFlavorArising,
        mkGivenLoc,
        isWanted, isGiven,
dimitris's avatar
dimitris committed
77
        isDerived, getWantedLoc, getGivenLoc, canSolve, canRewrite,
78
79

	-- Pretty printing
80
81
        pprEvVarTheta, pprWantedsWithLocs,
	pprEvVars, pprEvVarWithType, 
82
        pprArising, pprArisingAt,
83
84

	-- Misc other types
85
	TcId, TcIdSet, TcTyVarBind(..), TcTyVarBinds
86
	
87
88
89
90
  ) where

#include "HsVersions.h"

91
import HsSyn
92
import HscTypes
93
import TcEvidence
94
import Type
95
import Class    ( Class )
96
import TyCon    ( TyCon )
97
import DataCon  ( DataCon, dataConUserType )
98
import TcType
99
import Annotations
100
101
import InstEnv
import FamInstEnv
102
import IOEnv
103
104
import RdrName
import Name
105
import NameEnv
106
import NameSet
107
import Avail
108
109
import Var
import VarEnv
110
import Module
111
112
113
import SrcLoc
import VarSet
import ErrUtils
114
import UniqFM
115
import UniqSupply
116
import Unique
117
import BasicTypes
118
import Bag
Ian Lynagh's avatar
Ian Lynagh committed
119
import DynFlags
120
import Outputable
121
import ListSetOps
122
import FastString
123
import Util
124

125
import Data.Set (Set)
126

127
128
129
130
131
132
133
134
135
136
\end{code}


%************************************************************************
%*									*
	       Standard monad definition for TcRn
    All the combinators for the monad can be found in TcRnMonad
%*									*
%************************************************************************

137
The monad itself has to be defined here, because it is mentioned by ErrCtxt
138
139

\begin{code}
140
type TcRef a 	 = IORef a
141
type TcId    	 = Id 			
142
type TcIdSet 	 = IdSet
143

144

145
146
type TcRnIf a b c = IOEnv (Env a b) c
type IfM lcl a  = TcRnIf IfGblEnv lcl a		-- Iface stuff
Simon Marlow's avatar
Simon Marlow committed
147

148
149
150
151
152
type IfG a  = IfM () a				-- Top level
type IfL a  = IfM IfLclEnv a			-- Nested
type TcRn a = TcRnIf TcGblEnv TcLclEnv a
type RnM  a = TcRn a		-- Historical
type TcM  a = TcRn a		-- Historical
153
154
\end{code}

155
156
157
158
159
160
161
162
163
164
165
166
Representation of type bindings to uninstantiated meta variables used during
constraint solving.

\begin{code}
data TcTyVarBind = TcTyVarBind TcTyVar TcType

type TcTyVarBinds = Bag TcTyVarBind

instance Outputable TcTyVarBind where
  ppr (TcTyVarBind tv ty) = ppr tv <+> text ":=" <+> ppr ty
\end{code}

167
168

%************************************************************************
169
170
171
%*                                                                      *
                The main environment types
%*                                                                      *
172
173
174
%************************************************************************

\begin{code}
175
176
177
178
-- We 'stack' these envs through the Reader like monad infastructure
-- as we move into an expression (although the change is focused in
-- the lcl type).
data Env gbl lcl
179
  = Env {
180
181
        env_top  :: HscEnv,  -- Top-level stuff that never changes
                             -- Includes all info about imported things
182

183
184
        env_us   :: {-# UNPACK #-} !(IORef UniqSupply),
                             -- Unique supply for local varibles
185

186
187
        env_gbl  :: gbl,     -- Info about things defined at the top level
                             -- of the module being compiled
188

189
        env_lcl  :: lcl      -- Nested stuff; changes as we go into 
190
    }
191

Ian Lynagh's avatar
Ian Lynagh committed
192
193
194
instance ContainsDynFlags (Env gbl lcl) where
    extractDynFlags env = hsc_dflags (env_top env)

195
196
197
-- TcGblEnv describes the top-level of the module at the 
-- point at which the typechecker is finished work.
-- It is this structure that is handed on to the desugarer
198
199
-- For state that needs to be updated during the typechecking
-- phase and returned at end, use a TcRef (= IORef).
200
201
202

data TcGblEnv
  = TcGblEnv {
203
204
205
	tcg_mod     :: Module,         -- ^ Module being compiled
	tcg_src     :: HscSource,
          -- ^ What kind of module (regular Haskell, hs-boot, ext-core)
206

207
208
209
	tcg_rdr_env :: GlobalRdrEnv,   -- ^ Top level envt; used during renaming
	tcg_default :: Maybe [Type],
          -- ^ Types used for defaulting. @Nothing@ => no @default@ decl
210

211
212
	tcg_fix_env   :: FixityEnv,	-- ^ Just for things in this module
	tcg_field_env :: RecFieldEnv,	-- ^ Just for things in this module
213

214
215
216
217
218
219
220
	tcg_type_env :: TypeEnv,
          -- ^ Global type env for the module we are compiling now.  All
	  -- TyCons and Classes (for this module) end up in here right away,
	  -- along with their derived constructors, selectors.
	  --
	  -- (Ids defined in this module start in the local envt, though they
	  --  move to the global envt during zonking)
221

222
	tcg_type_env_var :: TcRef TypeEnv,
223
224
225
226
		-- Used only to initialise the interface-file
		-- typechecker in initIfaceTcRn, so that it can see stuff
		-- bound in this module when dealing with hi-boot recursions
		-- Updated at intervals (e.g. after dealing with types and classes)
227
	
228
	tcg_inst_env     :: InstEnv,
229
230
          -- ^ Instance envt for all /home-package/ modules; 
          -- Includes the dfuns in tcg_insts
231
	tcg_fam_inst_env :: FamInstEnv,	-- ^ Ditto for family instances
232

233
234
235
236
		-- Now a bunch of things about this module that are simply 
		-- accumulated, but never consulted until the end.  
		-- Nevertheless, it's convenient to accumulate them along 
		-- with the rest of the info from this module.
237
238
239
	tcg_exports :: [AvailInfo],	-- ^ What is exported
	tcg_imports :: ImportAvails,
          -- ^ Information about what was imported from where, including
240
241
	  -- things bound in this module. Also store Safe Haskell info
          -- here about transative trusted packaage requirements.
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270

	tcg_dus :: DefUses,
          -- ^ What is defined in this module and what is used.
          -- The latter is used to generate
          --
          --  (a) version tracking; no need to recompile if these things have
          --      not changed version stamp
          --
          --  (b) unused-import info

	tcg_keep :: TcRef NameSet,
          -- ^ Locally-defined top-level names to keep alive.
          --
          -- "Keep alive" means give them an Exported flag, so that the
          -- simplifier does not discard them as dead code, and so that they
          -- are exposed in the interface file (but not to export to the
          -- user).
          --
          -- Some things, like dict-fun Ids and default-method Ids are "born"
          -- with the Exported flag on, for exactly the above reason, but some
          -- we only discover as we go.  Specifically:
          --
          --   * The to/from functions for generic data types
          --
          --   * Top-level variables appearing free in the RHS of an orphan
          --     rule
          --
          --   * Top-level variables appearing free in a TH bracket

271
        tcg_th_used :: TcRef Bool,
272
273
          -- ^ @True@ <=> Template Haskell syntax used.
          --
274
275
276
277
          -- We need this so that we can generate a dependency on the
          -- Template Haskell package, becuase the desugarer is going
          -- to emit loads of references to TH symbols.  The reference
          -- is implicit rather than explicit, so we have to zap a
278
279
          -- mutable variable.

280
281
282
283
284
        tcg_th_splice_used :: TcRef Bool,
          -- ^ @True@ <=> A Template Haskell splice was used.
          --
          -- Splices disable recompilation avoidance (see #481)

285
286
	tcg_dfun_n  :: TcRef OccSet,
          -- ^ Allows us to choose unique DFun names.
287
288
289
290

	-- The next fields accumulate the payload of the module
	-- The binds, rules and foreign-decl fiels are collected
	-- initially in un-zonked form and are finally zonked in tcRnSrcDecls
291

292
        tcg_rn_exports :: Maybe [Located (IE Name)],
293
294
295
        tcg_rn_imports :: [LImportDecl Name],
		-- Keep the renamed imports regardless.  They are not 
		-- voluminous and are needed if you want to report unused imports
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
296

297
        tcg_used_rdrnames :: TcRef (Set RdrName),
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
298
299
300
		-- The set of used *imported* (not locally-defined) RdrNames
		-- Used only to report unused import declarations

301
302
303
	tcg_rn_decls :: Maybe (HsGroup Name),
          -- ^ Renamed decls, maybe.  @Nothing@ <=> Don't retain renamed
          -- decls.
304

305
        tcg_dependent_files :: TcRef [FilePath], -- ^ dependencies from addDependentFile
GregWeber's avatar
GregWeber committed
306

307
        tcg_ev_binds  :: Bag EvBind,	    -- Top-level evidence bindings
308
	tcg_binds     :: LHsBinds Id,	    -- Value bindings in this module
309
        tcg_sigs      :: NameSet, 	    -- ...Top-level names that *lack* a signature
310
        tcg_imp_specs :: [LTcSpecPrag],     -- ...SPECIALISE prags for imported Ids
Ian Lynagh's avatar
Ian Lynagh committed
311
	tcg_warns     :: Warnings,	    -- ...Warnings and deprecations
312
	tcg_anns      :: [Annotation],      -- ...Annotations
dreixel's avatar
dreixel committed
313
        tcg_tcs       :: [TyCon],           -- ...TyCons and Classes
314
	tcg_insts     :: [ClsInst],	    -- ...Instances
315
316
317
318
        tcg_fam_insts :: [FamInst],         -- ...Family instances
        tcg_rules     :: [LRuleDecl Id],    -- ...Rules
        tcg_fords     :: [LForeignDecl Id], -- ...Foreign import & exports
        tcg_vects     :: [LVectDecl Id],    -- ...Vectorisation declarations
319

320
	tcg_doc_hdr   :: Maybe LHsDocString, -- ^ Maybe Haddock header docs
321
322
323
        tcg_hpc       :: AnyHpcUsage,        -- ^ @True@ if any part of the
                                             --  prog uses hpc instrumentation.

324
        tcg_main      :: Maybe Name,         -- ^ The Name of the main
325
326
                                             -- function, if this module is
                                             -- the main module.
327
328
329
        tcg_safeInfer :: TcRef Bool          -- Has the typechecker
                                             -- inferred this module
                                             -- as -XSafe (Safe Haskell)
330
    }
331

332
333
334
335
336
337
338
data RecFieldEnv 
  = RecFields (NameEnv [Name])	-- Maps a constructor name *in this module*
				-- to the fields for that constructor
	      NameSet		-- Set of all fields declared *in this module*;
				-- used to suppress name-shadowing complaints
				-- when using record wild cards
				-- E.g.  let fld = e in C {..}
339
340
	-- This is used when dealing with ".." notation in record 
	-- construction and pattern matching.
341
	-- The FieldEnv deals *only* with constructors defined in *this*
Thomas Schilling's avatar
Thomas Schilling committed
342
343
	-- module.  For imported modules, we get the same info from the
	-- TypeEnv
344
345
\end{code}

346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
%************************************************************************
%*									*
		The interface environments
  	      Used when dealing with IfaceDecls
%*									*
%************************************************************************

\begin{code}
data IfGblEnv 
  = IfGblEnv {
	-- The type environment for the module being compiled,
	-- in case the interface refers back to it via a reference that
	-- was originally a hi-boot file.
	-- We need the module name so we can test when it's appropriate
	-- to look in this env.
361
	if_rec_types :: Maybe (Module, IfG TypeEnv)
362
363
364
365
366
367
368
369
370
371
		-- Allows a read effect, so it can be in a mutable
		-- variable; c.f. handling the external package type env
		-- Nothing => interactive stuff, no loops possible
    }

data IfLclEnv
  = IfLclEnv {
	-- The module for the current IfaceDecl
	-- So if we see   f = \x -> x
	-- it means M.f = \x -> x, where M is the if_mod
372
	if_mod :: Module,
373

374
375
376
377
378
379
380
	-- The field is used only for error reporting
	-- if (say) there's a Lint error in it
	if_loc :: SDoc,
		-- Where the interface came from:
		--	.hi file, or GHCi state, or ext core
		-- plus which bit is currently being examined

381
	if_tv_env  :: UniqFM TyVar,	-- Nested tyvar bindings
382
		      	     		-- (and coercions)
383
	if_id_env  :: UniqFM Id		-- Nested id binding
384
385
386
    }
\end{code}

387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409

%************************************************************************
%*									*
		The local typechecker environment
%*									*
%************************************************************************

The Global-Env/Local-Env story
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
During type checking, we keep in the tcg_type_env
	* All types and classes
	* All Ids derived from types and classes (constructors, selectors)

At the end of type checking, we zonk the local bindings,
and as we do so we add to the tcg_type_env
	* Locally defined top-level Ids

Why?  Because they are now Ids not TcIds.  This final GlobalEnv is
	a) fed back (via the knot) to typechecking the 
	   unfoldings of interface signatures
	b) used in the ModDetails of this module

\begin{code}
410
411
data TcLclEnv		-- Changes as we move inside an expression
			-- Discarded after typecheck/rename; not passed on to desugarer
412
  = TcLclEnv {
413
	tcl_loc  :: SrcSpan,		-- Source span
414
	tcl_ctxt :: [ErrCtxt],		-- Error context, innermost on top
415
	tcl_errs :: TcRef Messages,	-- Place to accumulate errors
416

417
418
	tcl_th_ctxt    :: ThStage,	      -- Template Haskell context
	tcl_arrow_ctxt :: ArrowCtxt,	      -- Arrow-notation context
419

420
	tcl_rdr :: LocalRdrEnv,		-- Local name envt
421
422
423
424
		-- Maintained during renaming, of course, but also during
		-- type checking, solely so that when renaming a Template-Haskell
		-- splice we have the right environment for the renamer.
		-- 
425
426
427
428
		--   Does *not* include global name envt; may shadow it
		--   Includes both ordinary variables and type variables;
		--   they are kept distinct because tyvar have a different
		--   occurrence contructor (Name.TvOcc)
429
430
431
		-- We still need the unsullied global name env so that
    		--   we can look up record field names

432
433
	tcl_env  :: TcTypeEnv,    -- The local type environment: Ids and
			          -- TyVars defined in this module
434
435
436

        tcl_tidy :: TidyEnv,      -- Used for tidying types; contains all
                                  -- in-scope type variables (but not term variables)
437
438
					
	tcl_tyvars :: TcRef TcTyVarSet,	-- The "global tyvars"
439
			-- Namely, the in-scope TyVars bound in tcl_env, 
440
441
442
443
			-- plus the tyvars mentioned in the types of Ids bound
			-- in tcl_lenv. 
                        -- Why mutable? see notes with tcGetGlobalTyVars

444
	tcl_lie   :: TcRef WantedConstraints,    -- Place to accumulate type constraints
445
446
447
448
449
450
451

	-- TcMetaTyVars have 
	tcl_meta  :: TcRef Unique,  -- The next free unique for TcMetaTyVars
		     		    -- Guaranteed to be allocated linearly
	tcl_untch :: Unique	    -- Any TcMetaTyVar with 
		     		    --     unique >= tcl_untch is touchable
		     		    --     unique <  tcl_untch is untouchable
452
453
    }

454
455
type TcTypeEnv = NameEnv TcTyThing

456

457
458
459
460
461
462
463
464
465
466
467
468
469
{- Note [Given Insts]
   ~~~~~~~~~~~~~~~~~~
Because of GADTs, we have to pass inwards the Insts provided by type signatures 
and existential contexts. Consider
	data T a where { T1 :: b -> b -> T [b] }
	f :: Eq a => T a -> Bool
	f (T1 x y) = [x]==[y]

The constructor T1 binds an existential variable 'b', and we need Eq [b].
Well, we have it, because Eq a refines to Eq [b], but we can only spot that if we 
pass it inwards.

-}
470

471
---------------------------
472
-- Template Haskell stages and levels 
473
474
---------------------------

475
476
477
478
479
480
481
482
483
484
485
486
data ThStage	-- See Note [Template Haskell state diagram] in TcSplice
  = Splice	-- Top-level splicing
		-- This code will be run *at compile time*;
		--   the result replaces the splice
		-- Binding level = 0
 
  | Comp   	-- Ordinary Haskell code
		-- Binding level = 1

  | Brack  			-- Inside brackets 
      ThStage 			--   Binding level = level(stage) + 1
      (TcRef [PendingSplice])	--   Accumulate pending splices here
487
      (TcRef WantedConstraints)	--     and type constraints here
488
489
490
491
492
493
494
495
496
497
498

topStage, topAnnStage, topSpliceStage :: ThStage
topStage       = Comp
topAnnStage    = Splice
topSpliceStage = Splice

instance Outputable ThStage where
   ppr Splice        = text "Splice"
   ppr Comp	     = text "Comp"
   ppr (Brack s _ _) = text "Brack" <> parens (ppr s)

499
type ThLevel = Int	
500
        -- See Note [Template Haskell levels] in TcSplice
501
502
	-- Incremented when going inside a bracket,
	-- decremented when going inside a splice
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
503
	-- NB: ThLevel is one greater than the 'n' in Fig 2 of the
504
	--     original "Template meta-programming for Haskell" paper
505

506
impLevel, outerLevel :: ThLevel
507
impLevel = 0	-- Imported things; they can be used inside a top level splice
508
509
510
outerLevel = 1	-- Things defined outside brackets
-- NB: Things at level 0 are not *necessarily* imported.
--	eg  $( \b -> ... )   here b is bound at level 0
511
512
513
514
515
516
--
-- For example: 
--	f = ...
--	g1 = $(map ...)		is OK
--	g2 = $(f ...)		is not OK; because we havn't compiled f yet

517
518
519
520
thLevel :: ThStage -> ThLevel
thLevel Splice        = 0
thLevel Comp          = 1
thLevel (Brack s _ _) = thLevel s + 1
521

ross's avatar
ross committed
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
---------------------------
-- Arrow-notation context
---------------------------

{-
In arrow notation, a variable bound by a proc (or enclosed let/kappa)
is not in scope to the left of an arrow tail (-<) or the head of (|..|).
For example

	proc x -> (e1 -< e2)

Here, x is not in scope in e1, but it is in scope in e2.  This can get
a bit complicated:

	let x = 3 in
	proc y -> (proc z -> e1) -< e2

Here, x and z are in scope in e1, but y is not.  We implement this by
recording the environment when passing a proc (using newArrowScope),
and returning to that (using escapeArrowScope) on the left of -< and the
head of (|..|).
-}

ross's avatar
ross committed
545
546
547
data ArrowCtxt
  = NoArrowCtxt
  | ArrowCtxt (Env TcGblEnv TcLclEnv)
ross's avatar
ross committed
548
549
550
551
552
553
554
555
556

-- Record the current environment (outside a proc)
newArrowScope :: TcM a -> TcM a
newArrowScope
  = updEnv $ \env ->
	env { env_lcl = (env_lcl env) { tcl_arrow_ctxt = ArrowCtxt env } }

-- Return to the stored environment (from the enclosing proc)
escapeArrowScope :: TcM a -> TcM a
ross's avatar
ross committed
557
558
559
560
escapeArrowScope
  = updEnv $ \ env -> case tcl_arrow_ctxt (env_lcl env) of
	NoArrowCtxt -> env
	ArrowCtxt env' -> env'
561

562
563
564
565
---------------------------
-- TcTyThing
---------------------------

566
data TcTyThing
567
  = AGlobal TyThing		-- Used only in the return type of a lookup
568

569
  | ATcId   {		-- Ids defined in this module; may not be fully zonked
570
571
572
	tct_id     :: TcId,		
	tct_closed :: TopLevelFlag,   -- See Note [Bindings with closed types]
	tct_level  :: ThLevel }
573

574
575
  | ATyVar  Name TcTyVar	-- The type variable to which the lexically scoped type 
				-- variable is bound. We only need the Name
576
577
				-- for error-message purposes; it is the corresponding
				-- Name in the domain of the envt
578

dreixel's avatar
dreixel committed
579
580
581
582
583
  | AThing  TcKind   -- Used temporarily, during kind checking, for the
		     --	tycons and clases in this recursive group
                     -- Can be a mono-kind or a poly-kind; in TcTyClsDcls see
                     -- Note [Type checking recursive type and class declarations]

584
585
586
587
588
589
590
591
  | APromotionErr PromotionErr 

data PromotionErr 
  = TyConPE          -- TyCon used in a kind before we are ready
                     --     data T :: T -> * where ...
  | ClassPE          -- Ditto Class

  | FamDataConPE     -- Data constructor for a data family
592
                     -- See Note [AFamDataCon: not promoting data family constructors] in TcRnDriver
dreixel's avatar
dreixel committed
593

594
  | RecDataConPE     -- Data constructor in a reuursive loop
595
                     -- See Note [ARecDataCon: recusion and promoting data constructors] in TcTyClsDecls
596
597

instance Outputable TcTyThing where	-- Debugging only
598
   ppr (AGlobal g)      = pprTyThing g
599
   ppr elt@(ATcId {})   = text "Identifier" <> 
600
601
			  brackets (ppr (tct_id elt) <> dcolon 
                                 <> ppr (varType (tct_id elt)) <> comma
602
				 <+> ppr (tct_closed elt) <> comma
603
				 <+> ppr (tct_level elt))
Simon Peyton Jones's avatar
Simon Peyton Jones committed
604
   ppr (ATyVar n tv)    = text "Type variable" <+> quotes (ppr n) <+> equals <+> ppr tv
605
   ppr (AThing k)       = text "AThing" <+> ppr k
606
607
608
609
610
611
612
   ppr (APromotionErr err) = text "APromotionErr" <+> ppr err

instance Outputable PromotionErr where
  ppr ClassPE      = text "ClassPE"
  ppr TyConPE      = text "TyConPE"
  ppr FamDataConPE = text "FamDataConPE"
  ppr RecDataConPE = text "RecDataConPE"
613
614

pprTcTyThingCategory :: TcTyThing -> SDoc
615
616
617
618
619
620
621
622
623
624
625
pprTcTyThingCategory (AGlobal thing)    = pprTyThingCategory thing
pprTcTyThingCategory (ATyVar {})        = ptext (sLit "Type variable")
pprTcTyThingCategory (ATcId {})         = ptext (sLit "Local identifier")
pprTcTyThingCategory (AThing {})        = ptext (sLit "Kinded thing")
pprTcTyThingCategory (APromotionErr pe) = pprPECategory pe

pprPECategory :: PromotionErr -> SDoc
pprPECategory ClassPE      = ptext (sLit "Class")
pprPECategory TyConPE      = ptext (sLit "Type constructor")
pprPECategory FamDataConPE = ptext (sLit "Data constructor")
pprPECategory RecDataConPE = ptext (sLit "Data constructor")
626
627
\end{code}

628

629
630
Note [Bindings with closed types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
631
632
633
634
635
636
Consider

  f x = let g ys = map not ys
        in ...

Can we generalise 'g' under the OutsideIn algorithm?  Yes, 
dreixel's avatar
dreixel committed
637
because all g's free variables are top-level; that is they themselves
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
have no free type variables, and it is the type variables in the
environment that makes things tricky for OutsideIn generalisation.

Definition:

   A variable is "closed", and has tct_closed set to TopLevel,
      iff 
   a) all its free variables are imported, or are themselves closed
   b) generalisation is not restricted by the monomorphism restriction

Under OutsideIn we are free to generalise a closed let-binding.
This is an extension compared to the JFP paper on OutsideIn, which
used "top-level" as a proxy for "closed".  (It's not a good proxy 
anyway -- the MR can make a top-level binding with a free type
variable.)

Note that:
  * A top-level binding may not be closed, if it suffer from the MR

  * A nested binding may be closed (eg 'g' in the example we started with)
    Indeed, that's the point; whether a function is defined at top level
    or nested is orthogonal to the question of whether or not it is closed 

  * A binding may be non-closed because it mentions a lexically scoped
    *type variable*  Eg
        f :: forall a. blah
        f x = let g y = ...(y::a)...

666

667
\begin{code}
668
type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, MsgDoc))
669
670
671
672
673
674
	-- Monadic so that we have a chance
	-- to deal with bound type variables just before error
	-- message construction

	-- Bool:  True <=> this is a landmark context; do not
	--		   discard it when trimming for display
675
676
677
678
679
680
681
682
683
684
\end{code}


%************************************************************************
%*									*
	Operations over ImportAvails
%*									*
%************************************************************************

\begin{code}
685
686
687
688
689
690
691
692
693
694
695
696
-- | 'ImportAvails' summarises what was imported from where, irrespective of
-- whether the imported things are actually used or not.  It is used:
--
--  * when processing the export list,
--
--  * when constructing usage info for the interface file,
--
--  * to identify the list of directly imported modules for initialisation
--    purposes and for optimised overlap checking of family instances,
--
--  * when figuring out what things are really unused
--
697
698
data ImportAvails 
   = ImportAvails {
699
700
	imp_mods :: ImportedMods,
	  --      = ModuleEnv [(ModuleName, Bool, SrcSpan, Bool)],
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
          -- ^ Domain is all directly-imported modules
          -- The 'ModuleName' is what the module was imported as, e.g. in
          -- @
          --     import Foo as Bar
          -- @
          -- it is @Bar@.
          --
          -- The 'Bool' means:
          --
          --  - @True@ => import was @import Foo ()@
          --
          --  - @False@ => import was some other form
          --
          -- Used
          --
          --   (a) to help construct the usage information in the interface
          --       file; if we import somethign we need to recompile if the
          --       export version changes
          --
          --   (b) to specify what child modules to initialise
          --
          -- We need a full ModuleEnv rather than a ModuleNameEnv here,
          -- because we might be importing modules of the same name from
          -- different packages. (currently not the case, but might be in the
          -- future).
726

727
728
729
730
731
732
733
734
735
736
737
        imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface),
          -- ^ Home-package modules needed by the module being compiled
          --
          -- It doesn't matter whether any of these dependencies
          -- are actually /used/ when compiling the module; they
          -- are listed if they are below it at all.  For
          -- example, suppose M imports A which imports X.  Then
          -- compiling M might not need to consult X.hi, but X
          -- is still listed in M's dependencies.

        imp_dep_pkgs :: [PackageId],
738
739
740
          -- ^ Packages needed by the module being compiled, whether directly,
          -- or via other modules in this package, or via modules imported
          -- from other packages.
741
742
743
744
745
746
747
748
749
750
        
        imp_trust_pkgs :: [PackageId],
          -- ^ This is strictly a subset of imp_dep_pkgs and records the
          -- packages the current module needs to trust for Safe Haskell
          -- compilation to succeed. A package is required to be trusted if
          -- we are dependent on a trustworthy module in that package.
          -- While perhaps making imp_dep_pkgs a tuple of (PackageId, Bool)
          -- where True for the bool indicates the package is required to be
          -- trusted is the more logical  design, doing so complicates a lot
          -- of code not concerned with Safe Haskell.
751
          -- See Note [RnNames . Tracking Trust Transitively]
752

753
754
755
756
757
758
759
        imp_trust_own_pkg :: Bool,
          -- ^ Do we require that our own package is trusted?
          -- This is to handle efficiently the case where a Safe module imports
          -- a Trustworthy module that resides in the same package as it.
          -- See Note [RnNames . Trust Own Package]

        imp_orphs :: [Module],
760
761
          -- ^ Orphan modules below us in the import tree (and maybe including
          -- us for imported modules)
762

763
        imp_finsts :: [Module]
764
765
          -- ^ Family instance modules below us in the import tree (and maybe
          -- including us for imported modules)
766
767
      }

Simon Marlow's avatar
Simon Marlow committed
768
769
770
mkModDeps :: [(ModuleName, IsBootInterface)]
	  -> ModuleNameEnv (ModuleName, IsBootInterface)
mkModDeps deps = foldl add emptyUFM deps
771
	       where
Simon Marlow's avatar
Simon Marlow committed
772
		 add env elt@(m,_) = addToUFM env m elt
773

774
emptyImportAvails :: ImportAvails
775
776
777
778
779
780
781
782
783
784
785
786
787
emptyImportAvails = ImportAvails { imp_mods          = emptyModuleEnv,
                                   imp_dep_mods      = emptyUFM,
                                   imp_dep_pkgs      = [],
                                   imp_trust_pkgs    = [],
                                   imp_trust_own_pkg = False,
                                   imp_orphs         = [],
                                   imp_finsts        = [] }

-- | Union two ImportAvails
--
-- This function is a key part of Import handling, basically
-- for each import we create a seperate ImportAvails structure
-- and then union them all together with this function.
788
789
plusImportAvails ::  ImportAvails ->  ImportAvails ->  ImportAvails
plusImportAvails
790
  (ImportAvails { imp_mods = mods1,
791
792
                  imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1,
                  imp_trust_pkgs = tpkgs1, imp_trust_own_pkg = tself1,
793
794
                  imp_orphs = orphs1, imp_finsts = finsts1 })
  (ImportAvails { imp_mods = mods2,
795
796
                  imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2,
                  imp_trust_pkgs = tpkgs2, imp_trust_own_pkg = tself2,
797
                  imp_orphs = orphs2, imp_finsts = finsts2 })
798
799
800
801
802
803
804
  = ImportAvails { imp_mods          = plusModuleEnv_C (++) mods1 mods2,
                   imp_dep_mods      = plusUFM_C plus_mod_dep dmods1 dmods2,
                   imp_dep_pkgs      = dpkgs1 `unionLists` dpkgs2,
                   imp_trust_pkgs    = tpkgs1 `unionLists` tpkgs2,
                   imp_trust_own_pkg = tself1 || tself2,
                   imp_orphs         = orphs1 `unionLists` orphs2,
                   imp_finsts        = finsts1 `unionLists` finsts2 }
805
  where
806
    plus_mod_dep (m1, boot1) (m2, boot2) 
807
808
809
        = WARN( not (m1 == m2), (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )
                -- Check mod-names match
          (m1, boot1 && boot2) -- If either side can "see" a non-hi-boot interface, use that
810
811
812
813
814
815
816
817
818
819
820
821
822
\end{code}

%************************************************************************
%*									*
\subsection{Where from}
%*									*
%************************************************************************

The @WhereFrom@ type controls where the renamer looks for an interface file

\begin{code}
data WhereFrom 
  = ImportByUser IsBootInterface	-- Ordinary user import (perhaps {-# SOURCE #-})
823
  | ImportBySystem			-- Non user import.
824
825

instance Outputable WhereFrom where
Ian Lynagh's avatar
Ian Lynagh committed
826
  ppr (ImportByUser is_boot) | is_boot     = ptext (sLit "{- SOURCE -}")
827
			     | otherwise   = empty
Ian Lynagh's avatar
Ian Lynagh committed
828
  ppr ImportBySystem     		   = ptext (sLit "{- SYSTEM -}")
829
830
\end{code}

831
832
833
834
835
836
837
838
839
840
%************************************************************************
%*									*
%*                       Canonical constraints                          *
%*                                                                      *
%*   These are the constraints the low-level simplifier works with      *
%*									*
%************************************************************************


\begin{code}
841
842
843
844
845
846
847
848
849
-- The syntax of xi types:
-- xi ::= a | T xis | xis -> xis | ... | forall a. tau
-- Two important notes:
--      (i) No type families, unless we are under a ForAll
--      (ii) Note that xi types can contain unexpanded type synonyms; 
--           however, the (transitive) expansions of those type synonyms 
--           will not contain any type functions, unless we are under a ForAll.
-- We enforce the structure of Xi types when we flatten (TcCanonical)

850
851
852
853
854
855
856
857
858
859
type Xi = Type       -- In many comments, "xi" ranges over Xi

type Cts = Bag Ct

type SubGoalDepth = Int -- An ever increasing number used to restrict 
                        -- simplifier iterations. Bounded by -fcontext-stack.

data Ct
  -- Atomic canonical constraints 
  = CDictCan {  -- e.g.  Num xi
860
861
      cc_ev :: CtEvidence,   -- See Note [Ct/evidence invariant]
      cc_class  :: Class,   
862
863
864
865
866
867
868
      cc_tyargs :: [Xi],

      cc_depth  :: SubGoalDepth -- Simplification depth of this constraint
                       -- See Note [WorkList]
    }

  | CIrredEvCan {  -- These stand for yet-unknown predicates
869
      cc_ev :: CtEvidence,   -- See Note [Ct/evidence invariant]
870
871
      cc_ty     :: Xi, -- cc_ty is flat hence it may only be of the form (tv xi1 xi2 ... xin)
                       -- Since, if it were a type constructor application, that'd make the
872
                       -- whole constraint a CDictCan, or CTyEqCan. And it can't be
873
874
875
876
877
878
879
880
881
882
                       -- a type family application either because it's a Xi type.
      cc_depth :: SubGoalDepth -- See Note [WorkList]
    }

  | CTyEqCan {  -- tv ~ xi	(recall xi means function free)
       -- Invariant: 
       --   * tv not in tvs(xi)   (occurs check)
       --   * typeKind xi `compatKind` typeKind tv
       --       See Note [Spontaneous solving and kind compatibility]
       --   * We prefer unification variables on the left *JUST* for efficiency
883
      cc_ev :: CtEvidence,    -- See Note [Ct/evidence invariant]
884
885
886
887
888
889
890
891
892
      cc_tyvar  :: TcTyVar, 
      cc_rhs    :: Xi,

      cc_depth :: SubGoalDepth -- See Note [WorkList] 
    }

  | CFunEqCan {  -- F xis ~ xi  
                 -- Invariant: * isSynFamilyTyCon cc_fun 
                 --            * typeKind (F xis) `compatKind` typeKind xi
893
      cc_ev :: CtEvidence,      -- See Note [Ct/evidence invariant]
894
895
896
897
898
899
900
901
902
903
      cc_fun    :: TyCon,	-- A type function
      cc_tyargs :: [Xi],	-- Either under-saturated or exactly saturated
      cc_rhs    :: Xi,      	--    *never* over-saturated (because if so
      		      		--    we should have decomposed)

      cc_depth  :: SubGoalDepth -- See Note [WorkList]
                   
    }

  | CNonCanonical { -- See Note [NonCanonical Semantics] 
904
      cc_ev :: CtEvidence, 
905
906
      cc_depth  :: SubGoalDepth
    }
907
908
\end{code}

909
910
911
912
913
914
915
916
Note [Ct/evidence invariant]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If  ct :: Ct, then extra fields of 'ct' cache precisely the ctev_pred field
of (cc_ev ct).   Eg for CDictCan, 
   ctev_pred (cc_ev ct) = (cc_class ct) (cc_tyargs ct)
This holds by construction; look at the unique place where CDictCan is
built (in TcCanonical)

917
\begin{code}
918
919
920
921
922
mkNonCanonical :: CtEvidence -> Ct
mkNonCanonical flav = CNonCanonical { cc_ev = flav, cc_depth = 0}

ctEvidence :: Ct -> CtEvidence
ctEvidence = cc_ev
923

924
ctPred :: Ct -> PredType 
925
-- See Note [Ct/evidence invariant]
926
ctPred ct = ctEvPred (cc_ev ct)
927
928
929
930
931
932

keepWanted :: Cts -> Cts
keepWanted = filterBag isWantedCt
    -- DV: there used to be a note here that read: 
    -- ``Important: use fold*r*Bag to preserve the order of the evidence variables'' 
    -- DV: Is this still relevant? 
933
934
935
\end{code}


936
937
%************************************************************************
%*									*
938
                    CtEvidence
939
940
941
942
943
944
945
         The "flavor" of a canonical constraint
%*									*
%************************************************************************

\begin{code}
ctWantedLoc :: Ct -> WantedLoc
-- Only works for Wanted/Derived
946
947
ctWantedLoc ct = ASSERT2( not (isGiven (cc_ev ct)), ppr ct )
                 getWantedLoc (cc_ev ct)
948
949

isWantedCt :: Ct -> Bool
950
isWantedCt = isWanted . cc_ev 
951

dimitris's avatar
dimitris committed
952
isGivenCt :: Ct -> Bool
953
isGivenCt = isGiven . cc_ev
954

dimitris's avatar
dimitris committed
955
isDerivedCt :: Ct -> Bool
956
isDerivedCt = isDerived . cc_ev
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974

isCTyEqCan :: Ct -> Bool 
isCTyEqCan (CTyEqCan {})  = True 
isCTyEqCan (CFunEqCan {}) = False
isCTyEqCan _              = False 

isCDictCan_Maybe :: Ct -> Maybe Class
isCDictCan_Maybe (CDictCan {cc_class = cls })  = Just cls
isCDictCan_Maybe _              = Nothing

isCIrredEvCan :: Ct -> Bool
isCIrredEvCan (CIrredEvCan {}) = True
isCIrredEvCan _                = False

isCFunEqCan_Maybe :: Ct -> Maybe TyCon
isCFunEqCan_Maybe (CFunEqCan { cc_fun = tc }) = Just tc
isCFunEqCan_Maybe _ = Nothing

975
976
977
978
isCFunEqCan :: Ct -> Bool
isCFunEqCan (CFunEqCan {}) = True
isCFunEqCan _ = False

979
980
981
982
983
isCNonCanonical :: Ct -> Bool
isCNonCanonical (CNonCanonical {}) = True 
isCNonCanonical _ = False 
\end{code}

984
\begin{code}
985
instance Outputable Ct where
986
  ppr ct = ppr (cc_ev ct) <+> 
dimitris's avatar
dimitris committed
987
988
           braces (ppr (cc_depth ct)) <+> parens (text ct_sort)
         where ct_sort = case ct of 
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
                           CTyEqCan {}      -> "CTyEqCan"
                           CFunEqCan {}     -> "CFunEqCan"
                           CNonCanonical {} -> "CNonCanonical"
                           CDictCan {}      -> "CDictCan"
                           CIrredEvCan {}   -> "CIrredEvCan"
\end{code}

\begin{code}
singleCt :: Ct -> Cts 
singleCt = unitBag 

andCts :: Cts -> Cts -> Cts 
andCts = unionBags

extendCts :: Cts -> Ct -> Cts 
extendCts = snocBag 

andManyCts :: [Cts] -> Cts 
andManyCts = unionManyBags

emptyCts :: Cts 
emptyCts = emptyBag

isEmptyCts :: Cts -> Bool
isEmptyCts = isEmptyBag
\end{code}
1015
1016
1017

%************************************************************************
%*									*
1018
1019
1020
1021
1022
1023
		Wanted constraints
     These are forced to be in TcRnTypes because
     	   TcLclEnv mentions WantedConstraints
	   WantedConstraint mentions CtLoc
	   CtLoc mentions ErrCtxt
	   ErrCtxt mentions TcM
1024
1025
1026
%*									*
v%************************************************************************

1027
\begin{code}
1028

1029
data WantedConstraints
1030
  = WC { wc_flat  :: Cts               -- Unsolved constraints, all wanted
1031
       , wc_impl  :: Bag Implication
1032
       , wc_insol :: Cts               -- Insoluble constraints, can be
1033
1034
1035
1036
1037
1038
1039
                                       -- wanted, given, or derived
                                       -- See Note [Insoluble constraints]
    }

emptyWC :: WantedConstraints
emptyWC = WC { wc_flat = emptyBag, wc_impl = emptyBag, wc_insol = emptyBag }

1040
1041
1042
mkFlatWC :: [Ct] -> WantedConstraints
mkFlatWC cts 
  = WC { wc_flat = listToBag cts, wc_impl = emptyBag, wc_insol = emptyBag }
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059

isEmptyWC :: WantedConstraints -> Bool
isEmptyWC (WC { wc_flat = f, wc_impl = i, wc_insol = n })
  = isEmptyBag f && isEmptyBag i && isEmptyBag n

insolubleWC :: WantedConstraints -> Bool
-- True if there are any insoluble constraints in the wanted bag
insolubleWC wc = not (isEmptyBag (wc_insol wc))
               || anyBag ic_insol (wc_impl wc)

andWC :: WantedConstraints -> WantedConstraints -> WantedConstraints
andWC (WC { wc_flat = f1, wc_impl = i1, wc_insol = n1 })
      (WC { wc_flat = f2, wc_impl = i2, wc_insol = n2 })
  = WC { wc_flat  = f1 `unionBags` f2
       , wc_impl  = i1 `unionBags` i2
       , wc_insol = n1 `unionBags` n2 }

1060
1061
addFlats :: WantedConstraints -> Bag Ct -> WantedConstraints
addFlats wc cts
1062
  = wc { wc_flat = wc_flat wc `unionBags` cts }
1063
1064

addImplics :: WantedConstraints -> Bag Implication -> WantedConstraints
1065
addImplics wc implic = wc { wc_impl = wc_impl wc `unionBags` implic }
1066
1067
1068
1069
1070

instance Outputable WantedConstraints where
  ppr (WC {wc_flat = f, wc_impl = i, wc_insol = n})
   = ptext (sLit "WC") <+> braces (vcat
        [ if isEmptyBag f then empty else
1071
          ptext (sLit "wc_flat =")  <+> pprBag ppr f
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
        , if isEmptyBag i then empty else
          ptext (sLit "wc_impl =")  <+> pprBag ppr i
        , if isEmptyBag n then empty else
          ptext (sLit "wc_insol =") <+> pprBag ppr n ])

pprBag :: (a -> SDoc) -> Bag a -> SDoc
pprBag pp b = foldrBag (($$) . pp) empty b
\end{code}
 

1082
\begin{code}
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
data Untouchables = NoUntouchables
                  | TouchableRange
                          Unique  -- Low end
                          Unique  -- High end
 -- A TcMetaTyvar is *touchable* iff its unique u satisfies
 --   u >= low
 --   u < high

instance Outputable Untouchables where
  ppr NoUntouchables = ptext (sLit "No untouchables")
  ppr (TouchableRange low high) = ptext (sLit "Touchable range:") <+> 
                                  ppr low <+> char '-' <+> ppr high

1096
1097
1098
1099
isNoUntouchables :: Untouchables -> Bool
isNoUntouchables NoUntouchables      = True
isNoUntouchables (TouchableRange {}) = False

1100
1101
1102
1103
1104
1105
inTouchableRange :: Untouchables -> TcTyVar -> Bool
inTouchableRange NoUntouchables _ = True
inTouchableRange (TouchableRange low high) tv 
  = uniq >= low && uniq < high
  where
    uniq = varUnique tv
1106

1107
-- EvVar defined in module Var.lhs:
1108
1109
1110
1111
-- Evidence variables include all *quantifiable* constraints
--   dictionaries
--   implicit parameters
--   coercion variables
1112
\end{code}
1113

1114
1115
1116
1117
1118
%************************************************************************
%*									*
                Implication constraints
%*                                                                      *
%************************************************************************
1119

1120
\begin{code}
1121
1122
data Implication
  = Implic {  
1123
      ic_untch :: Untouchables, -- Untouchables: unification variables
1124
                                -- free in the environment
1125
      ic_env   :: TcTypeEnv,    -- The type environment
1126
                                -- Used only when generating error messages
1127
	  -- Generally, ic_untch is a superset of tvsof(ic_env)
1128
1129
	  -- However, we don't zonk ic_env when zonking the Implication
	  -- Instead we do that when generating a skolem-escape error message
1130

1131
      ic_skols  :: [TcTyVar],    -- Introduced skolems 
1132
      		   	         -- See Note [Skolems in an implication]
1133

1134
1135
      ic_given  :: [EvVar],      -- Given evidence variables
      		   		 --   (order does not matter)
1136
1137
1138
      ic_loc   :: GivenLoc,      -- Binding location of the implication,
                                 --   which is also the location of all the
                                 --   given evidence variables
1139

simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
1140
      ic_wanted :: WantedConstraints,  -- The wanted
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
1141
      ic_insol  :: Bool,               -- True iff insolubleWC ic_wanted is true
1142

1143
1144
1145
      ic_binds  :: EvBindsVar   -- Points to the place to fill in the
                                -- abstraction and bindings
    }
1146

1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
instance Outputable Implication where
  ppr (Implic { ic_untch = untch, ic_skols = skols, ic_given = given
              , ic_wanted = wanted
              , ic_binds = binds, ic_loc = loc })
   = ptext (sLit "Implic") <+> braces 
     (sep [ ptext (sLit "Untouchables = ") <+> ppr untch
          , ptext (sLit "Skolems = ") <+> ppr skols
          , ptext (sLit "Given = ") <+> pprEvVars given
          , ptext (sLit "Wanted = ") <+> ppr wanted
          , ptext (sLit "Binds = ") <+> ppr binds
          , pprSkolInfo (ctLocOrigin loc)
          , ppr (ctLocSpan loc) ])
1159
1160
\end{code}

1161
1162
1163
1164
1165
1166
Note [Skolems in an implication]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The skolems in an implication are not there to perform a skolem escape
check.  That happens because all the environment variables are in the
untouchables, and therefore cannot be unified with anything at all,
let alone the skolems.
1167

1168
1169
1170
Instead, ic_skols is used only when considering floating a constraint
outside the implication in TcSimplify.floatEqualities or 
TcSimplify.approximateImplications
1171

1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
Note [Insoluble constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Some of the errors that we get during canonicalization are best
reported when all constraints have been simplified as much as
possible. For instance, assume that during simplification the
following constraints arise:
   
 [Wanted]   F alpha ~  uf1 
 [Wanted]   beta ~ uf1 beta 

When canonicalizing the wanted (beta ~ uf1 beta), if we eagerly fail
we will simply see a message:
    'Can't construct the infinite type  beta ~ uf1 beta' 
and the user has no idea what the uf1 variable is.

Instead our plan is that we will NOT fail immediately, but:
    (1) Record the "frozen" error in the ic_insols field
    (2) Isolate the offending constraint from the rest of the inerts 
    (3) Keep on simplifying/canonicalizing

At the end, we will hopefully have substituted uf1 := F alpha, and we
will be able to report a more informative error:
    'Can't construct the infinite type beta ~ F alpha beta'
Ian Lynagh's avatar
Ian Lynagh committed
1195

1196
1197
1198
1199
1200
1201
Insoluble constraints *do* include Derived constraints. For example,
a functional dependency might give rise to [D] Int ~ Bool, and we must
report that.  If insolubles did not contain Deriveds, reportErrors would
never see it.


1202
1203
%************************************************************************
%*									*
1204
            Pretty printing
1205
1206
%*									*
%************************************************************************
Ian Lynagh's avatar
Ian Lynagh committed
1207

1208
1209
1210
1211
1212
1213
1214
1215
\begin{code}
pprEvVars :: [EvVar] -> SDoc	-- Print with their types
pprEvVars ev_vars = vcat (map pprEvVarWithType ev_vars)

pprEvVarTheta :: [EvVar] -> SDoc
pprEvVarTheta ev_vars = pprTheta (map evVarPred ev_vars)
                              
pprEvVarWithType :: EvVar -> SDoc
batterseapower's avatar
batterseapower committed
1216
pprEvVarWithType v = ppr v <+> dcolon <+> pprType (evVarPred v)
1217

1218
1219
pprWantedsWithLocs :: WantedConstraints -> SDoc
pprWantedsWithLocs wcs
1220
  =  vcat [ pprBag ppr (wc_flat wcs)
1221
1222
1223
          , pprBag ppr (wc_impl wcs)
          , pprBag ppr (wc_insol wcs) ]
\end{code}
1224

1225
1226
1227
1228
1229
1230
%************************************************************************
%*									*
            CtLoc
%*									*
%************************************************************************

1231
1232
1233
1234
1235
1236
Note [Evidence field of CtEvidence]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
During constraint solving we never look at the type of ctev_evtm, or
ctev_evar; instead we look at the cte_pred field.  The evtm/evar field
may be un-zonked.

1237
\begin{code}
1238
data CtEvidence 
1239
1240
1241
1242
  = Given { ctev_gloc :: GivenLoc
          , ctev_pred :: TcPredType
          , ctev_evtm :: EvTerm }          -- See Note [Evidence field of CtEvidence]
    -- Truly given, not depending on subgoals
dimitris's avatar
dimitris committed
1243
1244
    -- NB: Spontaneous unifications belong here
    
1245
1246
1247
  | Wanted { ctev_wloc :: WantedLoc
           , ctev_pred :: TcPredType
           , ctev_evar :: EvVar }          -- See Note [Evidence field of CtEvidence]
dimitris's avatar
dimitris committed
1248
1249
    -- Wanted goal 
    
1250
1251
  | Derived { ctev_wloc :: WantedLoc 
            , ctev_pred :: TcPredType }
dimitris's avatar
dimitris committed
1252
    -- A goal that we don't really have to solve and can't immediately 
1253
    -- rewrite anything other than a derived (there's no evidence!) 
dimitris's avatar
dimitris committed
1254
1255
    -- but if we do manage to solve it may help in solving other goals.

1256
ctEvPred :: CtEvidence -> TcPredType
dimitris's avatar
dimitris committed
1257
-- The predicate of a flavor
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
ctEvPred = ctev_pred

ctEvTerm :: CtEvidence -> EvTerm
ctEvTerm (Given   { ctev_evtm = tm }) = tm
ctEvTerm (Wanted  { ctev_evar = ev }) = EvId ev
ctEvTerm ctev@(Derived {}) = pprPanic "ctEvTerm: derived constraint cannot have id" 
                                      (ppr ctev)

ctEvId :: CtEvidence -> TcId
ctEvId (Wanted  { ctev_evar = ev }) = ev
ctEvId ctev = pprPanic "ctEvId:" (ppr ctev)

instance Outputable CtEvidence where
dimitris's avatar
dimitris committed
1271
  ppr fl = case fl of
1272
1273
1274
1275
             Given {}   -> ptext (sLit "[G]") <+> ppr (ctev_evtm fl) <+> ppr_pty
             Wanted {}  -> ptext (sLit "[W]") <+> ppr (ctev_evar fl) <+> ppr_pty
             Derived {} -> ptext (sLit "[D]") <+> text "_" <+> ppr_pty
         where ppr_pty = dcolon <+> ppr (ctEvPred fl)
dimitris's avatar
dimitris committed
1276

1277
getWantedLoc :: CtEvidence -> WantedLoc