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))
604
   ppr (ATyVar tv _)    = text "Type variable" <+> quotes (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