TcRnTypes.lhs 71.2 KB
Newer Older
1

Gabor Greif's avatar
Gabor Greif committed
2
% (c) The University of Glasgow 2006-2012
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
19
\begin{code}
module TcRnTypes(
20
21
        TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module
        TcRef,
22

23
24
25
26
        -- The environment types
        Env(..),
        TcGblEnv(..), TcLclEnv(..),
        IfGblEnv(..), IfLclEnv(..),
27

28
29
30
31
        -- Ranamer types
        ErrCtxt, RecFieldEnv(..),
        ImportAvails(..), emptyImportAvails, plusImportAvails,
        WhereFrom(..), mkModDeps,
32

33
34
        -- Typechecker types
        TcTypeEnv, TcIdBinder(..), TcTyThing(..), PromotionErr(..),
35
        pprTcTyThingCategory, pprPECategory,
36

37
38
39
        -- Template Haskell
        ThStage(..), topStage, topAnnStage, topSpliceStage,
        ThLevel, impLevel, outerLevel, thLevel,
40

41
42
        -- Arrows
        ArrowCtxt(NoArrowCtxt), newArrowScope, escapeArrowScope,
ross's avatar
ross committed
43

44
        -- Canonical constraints
45
        Xi, Ct(..), Cts, emptyCts, andCts, andManyCts, dropDerivedWC,
46
47
        singleCt, listToCts, ctsElts, extendCts, extendCtsList, 
        isEmptyCts, isCTyEqCan, isCFunEqCan,
Simon Peyton Jones's avatar
Simon Peyton Jones committed
48
        isCDictCan_Maybe, isCFunEqCan_maybe,
49
        isCIrredEvCan, isCNonCanonical, isWantedCt, isDerivedCt,
50
        isGivenCt, isHoleCt,
51
52
53
        ctEvidence, ctLoc, ctPred,
        mkNonCanonical, mkNonCanonicalCt,
        ctEvPred, ctEvTerm, ctEvId,
54

55
        WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC,
56
        andWC, unionsWC, addFlats, addImplics, mkFlatWC, addInsols,
57
58

        Implication(..),
59
        SubGoalCounter(..),
60
61
        SubGoalDepth, initialSubGoalDepth, maxSubGoalDepth,
        bumpSubGoalDepth, subGoalCounterValue, subGoalDepthExceeded,
62
        CtLoc(..), ctLocSpan, ctLocEnv, ctLocOrigin,
63
        ctLocDepth, bumpCtLocDepth,
64
        setCtLocOrigin, setCtLocEnv,
65
        CtOrigin(..),
66
        pushErrCtxt, pushErrCtxtSameOrigin,
67

68
        SkolemInfo(..),
69

70
        CtEvidence(..),
71
        mkGivenLoc,
72
73
        isWanted, isGiven, isDerived,
        canRewrite, canRewriteOrSame,
74

75
        -- Pretty printing
76
        pprEvVarTheta, pprWantedsWithLocs,
77
        pprEvVars, pprEvVarWithType,
78
        pprArising, pprArisingAt,
79

80
81
82
        -- Misc other types
        TcId, TcIdSet, TcTyVarBind(..), TcTyVarBinds

83
84
85
86
  ) where

#include "HsVersions.h"

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

119
import Data.Set (Set)
120
121

#ifdef GHCI
122
123
124
125
import Data.Map      ( Map )
import Data.Dynamic  ( Dynamic )
import Data.Typeable ( TypeRep )

126
127
import qualified Language.Haskell.TH as TH
#endif
128
129
130
131
\end{code}


%************************************************************************
132
133
%*                                                                      *
               Standard monad definition for TcRn
134
    All the combinators for the monad can be found in TcRnMonad
135
%*                                                                      *
136
137
%************************************************************************

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

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

145

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

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

156
157
158
159
160
161
162
163
164
165
166
167
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}

168
169

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

\begin{code}
176
177
178
179
-- 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
180
  = Env {
181
182
        env_top  :: HscEnv,  -- Top-level stuff that never changes
                             -- Includes all info about imported things
183

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

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

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

Ian Lynagh's avatar
Ian Lynagh committed
193
194
instance ContainsDynFlags (Env gbl lcl) where
    extractDynFlags env = hsc_dflags (env_top env)
195
196
    replaceDynFlags env dflags
        = env {env_top = replaceDynFlags (env_top env) dflags}
Ian Lynagh's avatar
Ian Lynagh committed
197

198
199
200
instance ContainsModule gbl => ContainsModule (Env gbl lcl) where
    extractModule env = extractModule (env_gbl env)

201
-- TcGblEnv describes the top-level of the module at the
202
203
-- point at which the typechecker is finished work.
-- It is this structure that is handed on to the desugarer
204
205
-- For state that needs to be updated during the typechecking
-- phase and returned at end, use a TcRef (= IORef).
206
207
208

data TcGblEnv
  = TcGblEnv {
209
210
        tcg_mod     :: Module,         -- ^ Module being compiled
        tcg_src     :: HscSource,
211
          -- ^ What kind of module (regular Haskell, hs-boot, ext-core)
212

213
214
        tcg_rdr_env :: GlobalRdrEnv,   -- ^ Top level envt; used during renaming
        tcg_default :: Maybe [Type],
215
          -- ^ Types used for defaulting. @Nothing@ => no @default@ decl
216

217
218
        tcg_fix_env   :: FixityEnv,     -- ^ Just for things in this module
        tcg_field_env :: RecFieldEnv,   -- ^ Just for things in this module
219

220
        tcg_type_env :: TypeEnv,
221
          -- ^ Global type env for the module we are compiling now.  All
222
223
224
225
226
227
228
229
230
231
232
233
234
235
          -- 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)

        tcg_type_env_var :: TcRef TypeEnv,
                -- 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)

        tcg_inst_env     :: InstEnv,
          -- ^ Instance envt for all /home-package/ modules;
236
          -- Includes the dfuns in tcg_insts
237
        tcg_fam_inst_env :: FamInstEnv, -- ^ Ditto for family instances
238
        tcg_ann_env      :: AnnEnv,     -- ^ And for annotations
239
240
241
242
243
244
245

                -- 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.
        tcg_exports :: [AvailInfo],     -- ^ What is exported
        tcg_imports :: ImportAvails,
246
          -- ^ Information about what was imported from where, including
247
          -- things bound in this module. Also store Safe Haskell info
248
          -- here about transative trusted packaage requirements.
249

250
251
252
        tcg_dus :: DefUses,   -- ^ What is defined in this module and what is used.
        tcg_used_rdrnames :: TcRef (Set RdrName),
          -- See Note [Tracking unused binding and imports]
253

254
        tcg_keep :: TcRef NameSet,
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
          -- ^ 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

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

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

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

290
291
292
        -- 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
293

294
        tcg_rn_exports :: Maybe [Located (IE Name)],
295
        tcg_rn_imports :: [LImportDecl Name],
296
297
                -- 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
298

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

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

305
306
307
308
309
310
#ifdef GHCI
        tcg_th_topdecls :: TcRef [LHsDecl RdrName],
        -- ^ Top-level declarations from addTopDecls

        tcg_th_topnames :: TcRef NameSet,
        -- ^ Exact names bound in top-level declarations in tcg_th_topdecls
311
312
313

        tcg_th_modfinalizers :: TcRef [TH.Q ()],
        -- ^ Template Haskell module finalizers
314
315
316

        tcg_th_state :: TcRef (Map TypeRep Dynamic),
        -- ^ Template Haskell state
317
318
#endif /* GHCI */

319
320
321
        tcg_ev_binds  :: Bag EvBind,        -- Top-level evidence bindings
        tcg_binds     :: LHsBinds Id,       -- Value bindings in this module
        tcg_sigs      :: NameSet,           -- ...Top-level names that *lack* a signature
322
        tcg_imp_specs :: [LTcSpecPrag],     -- ...SPECIALISE prags for imported Ids
323
324
        tcg_warns     :: Warnings,          -- ...Warnings and deprecations
        tcg_anns      :: [Annotation],      -- ...Annotations
dreixel's avatar
dreixel committed
325
        tcg_tcs       :: [TyCon],           -- ...TyCons and Classes
326
        tcg_insts     :: [ClsInst],         -- ...Instances
327
        tcg_fam_insts :: [FamInst],         -- ...Family instances
328
329
330
        tcg_rules     :: [LRuleDecl Id],    -- ...Rules
        tcg_fords     :: [LForeignDecl Id], -- ...Foreign import & exports
        tcg_vects     :: [LVectDecl Id],    -- ...Vectorisation declarations
331

332
        tcg_doc_hdr   :: Maybe LHsDocString, -- ^ Maybe Haddock header docs
333
334
335
        tcg_hpc       :: AnyHpcUsage,        -- ^ @True@ if any part of the
                                             --  prog uses hpc instrumentation.

336
        tcg_main      :: Maybe Name,         -- ^ The Name of the main
337
338
                                             -- function, if this module is
                                             -- the main module.
339
340
341
        tcg_safeInfer :: TcRef Bool          -- Has the typechecker
                                             -- inferred this module
                                             -- as -XSafe (Safe Haskell)
342
    }
343

344
345
346
instance ContainsModule TcGblEnv where
    extractModule env = tcg_mod env

347
348
349
350
351
352
353
354
355
356
357
358
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 {..}
        -- This is used when dealing with ".." notation in record
        -- construction and pattern matching.
        -- The FieldEnv deals *only* with constructors defined in *this*
        -- module.  For imported modules, we get the same info from the
        -- TypeEnv
359
360
\end{code}

361
362
363
364
365
366
367
368
369
370
371
Note [Tracking unused binding and imports]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We gather two sorts of usage information
 * tcg_dus (defs/uses)
      Records *defined* Names (local, top-level)
          and *used*    Names (local or imported)

      Used (a) to report "defined but not used"
               (see RnNames.reportUnusedNames)
           (b) to generate version-tracking usage info in interface
               files (see MkIface.mkUsedNames)
372
   This usage info is mainly gathered by the renamer's
373
374
375
376
377
378
379
   gathering of free-variables

 * tcg_used_rdrnames
      Records used *imported* (not locally-defined) RdrNames
      Used only to report unused import declarations
      Notice that they are RdrNames, not Names, so we can
      tell whether the reference was qualified or unqualified, which
380
      is esssential in deciding whether a particular import decl
381
382
383
      is unnecessary.  This info isn't present in Names.


384
%************************************************************************
385
386
387
388
%*                                                                      *
                The interface environments
              Used when dealing with IfaceDecls
%*                                                                      *
389
390
391
%************************************************************************

\begin{code}
392
data IfGblEnv
393
  = IfGblEnv {
394
395
396
397
398
399
400
401
402
        -- 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.
        if_rec_types :: Maybe (Module, IfG TypeEnv)
                -- 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
403
404
405
406
    }

data IfLclEnv
  = IfLclEnv {
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
        -- 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
        if_mod :: Module,

        -- 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

        if_tv_env  :: UniqFM TyVar,     -- Nested tyvar bindings
                                        -- (and coercions)
        if_id_env  :: UniqFM Id         -- Nested id binding
422
423
424
    }
\end{code}

425
426

%************************************************************************
427
428
429
%*                                                                      *
                The local typechecker environment
%*                                                                      *
430
431
432
433
434
%************************************************************************

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

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

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

\begin{code}
448
449
data TcLclEnv           -- Changes as we move inside an expression
                        -- Discarded after typecheck/rename; not passed on to desugarer
450
  = TcLclEnv {
451
452
453
        tcl_loc        :: SrcSpan,         -- Source span
        tcl_ctxt       :: [ErrCtxt],       -- Error context, innermost on top
        tcl_untch      :: Untouchables,    -- Birthplace for new unification variables
454

455
        tcl_th_ctxt    :: ThStage,         -- Template Haskell context
456
457
458
        tcl_th_bndrs   :: ThBindEnv,       -- Binding level of in-scope Names
                                           -- defined in this module (not imported)

459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
        tcl_arrow_ctxt :: ArrowCtxt,       -- Arrow-notation context

        tcl_rdr :: LocalRdrEnv,         -- Local name envt
                -- 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.
                --
                --   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)
                -- We still need the unsullied global name env so that
                --   we can look up record field names

        tcl_env  :: TcTypeEnv,    -- The local type environment:
                                  -- Ids and TyVars defined in this module
475
476
477

        tcl_bndrs :: [TcIdBinder],   -- Stack of locally-bound Ids, innermost on top
                                     -- Used only for error reporting
478
479
480

        tcl_tidy :: TidyEnv,      -- Used for tidying types; contains all
                                  -- in-scope type variables (but not term variables)
481
482
483
484
485

        tcl_tyvars :: TcRef TcTyVarSet, -- The "global tyvars"
                        -- Namely, the in-scope TyVars bound in tcl_env,
                        -- plus the tyvars mentioned in the types of Ids bound
                        -- in tcl_lenv.
486
487
                        -- Why mutable? see notes with tcGetGlobalTyVars

488
489
        tcl_lie  :: TcRef WantedConstraints,    -- Place to accumulate type constraints
        tcl_errs :: TcRef Messages              -- Place to accumulate errors
490
491
    }

492
type TcTypeEnv = NameEnv TcTyThing
493

494
495
496
497
498
499
500
501
502
type ThBindEnv = NameEnv (TopLevelFlag, ThLevel)
   -- Domain = all Ids bound in this module (ie not imported)
   -- The TopLevelFlag tells if the binding is syntactically top level.
   -- We need to know this, because the cross-stage persistence story allows
   -- cross-stage at arbitrary types if the Id is bound at top level.
   --
   -- Nota bene: a ThLevel of 'outerLevel' is *not* the same as being
   -- bound at top level!  See Note [Template Haskell levels] in TcSplice

503
504
505
data TcIdBinder
  = TcIdBndr
       TcId
506
507
508
       TopLevelFlag    -- Tells whether the bindind is syntactically top-level
                       -- (The monomorphic Ids for a recursive group count
                       --  as not-top-level for this purpose.)
509

510
511
{- Note [Given Insts]
   ~~~~~~~~~~~~~~~~~~
512
Because of GADTs, we have to pass inwards the Insts provided by type signatures
513
and existential contexts. Consider
514
515
516
        data T a where { T1 :: b -> b -> T [b] }
        f :: Eq a => T a -> Bool
        f (T1 x y) = [x]==[y]
517
518

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

-}
523

524
---------------------------
525
-- Template Haskell stages and levels
526
527
---------------------------

528
529
530
531
532
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
533
      Bool      -- True if in a typed splice, False otherwise
534
535
536

  | Comp        -- Ordinary Haskell code
                -- Binding level = 1
537

538
  | Brack                       -- Inside brackets
539
      Bool                      --   True if inside a typed bracket, False otherwise
540
541
542
      ThStage                   --   Binding level = level(stage) + 1
      (TcRef [PendingSplice])   --   Accumulate pending splices here
      (TcRef WantedConstraints) --     and type constraints here
543
544
545

topStage, topAnnStage, topSpliceStage :: ThStage
topStage       = Comp
546
547
topAnnStage    = Splice False
topSpliceStage = Splice False
548
549

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

554
type ThLevel = Int
555
556
557
558
559
    -- NB: see Note [Template Haskell levels] in TcSplice
    -- Incremented when going inside a bracket,
    -- decremented when going inside a splice
    -- NB: ThLevel is one greater than the 'n' in Fig 2 of the
    --     original "Template meta-programming for Haskell" paper
560

561
impLevel, outerLevel :: ThLevel
562
563
impLevel = 0    -- Imported things; they can be used inside a top level splice
outerLevel = 1  -- Things defined outside brackets
564

565
thLevel :: ThStage -> ThLevel
566
567
568
thLevel (Splice _)      = 0
thLevel Comp            = 1
thLevel (Brack _ s _ _) = thLevel s + 1
569

ross's avatar
ross committed
570
571
572
573
---------------------------
-- Arrow-notation context
---------------------------

574
575
{- Note [Escaping the arrow scope]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
ross's avatar
ross committed
576
577
578
579
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

580
        proc x -> (e1 -< e2)
ross's avatar
ross committed
581
582
583
584

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

585
586
        let x = 3 in
        proc y -> (proc z -> e1) -< e2
ross's avatar
ross committed
587

588
Here, x and z are in scope in e1, but y is not.
589
590

We implement this by
ross's avatar
ross committed
591
592
593
recording the environment when passing a proc (using newArrowScope),
and returning to that (using escapeArrowScope) on the left of -< and the
head of (|..|).
594

595
All this can be dealt with by the *renamer*; by the time we get to
596
the *type checker* we have sorted out the scopes
ross's avatar
ross committed
597
598
-}

ross's avatar
ross committed
599
600
601
data ArrowCtxt
  = NoArrowCtxt
  | ArrowCtxt (Env TcGblEnv TcLclEnv)
ross's avatar
ross committed
602
603
604
605
606

-- Record the current environment (outside a proc)
newArrowScope :: TcM a -> TcM a
newArrowScope
  = updEnv $ \env ->
607
        env { env_lcl = (env_lcl env) { tcl_arrow_ctxt = ArrowCtxt env } }
ross's avatar
ross committed
608
609
610

-- Return to the stored environment (from the enclosing proc)
escapeArrowScope :: TcM a -> TcM a
ross's avatar
ross committed
611
612
escapeArrowScope
  = updEnv $ \ env -> case tcl_arrow_ctxt (env_lcl env) of
613
614
        NoArrowCtxt -> env
        ArrowCtxt env' -> env'
615

616
617
618
619
---------------------------
-- TcTyThing
---------------------------

620
data TcTyThing
621
  = AGlobal TyThing             -- Used only in the return type of a lookup
622

623
624
  | ATcId   {           -- Ids defined in this module; may not be fully zonked
        tct_id     :: TcId,
625
        tct_closed :: TopLevelFlag }   -- See Note [Bindings with closed types]
626

627
628
629
630
  | ATyVar  Name TcTyVar        -- The type variable to which the lexically scoped type
                                -- variable is bound. We only need the Name
                                -- for error-message purposes; it is the corresponding
                                -- Name in the domain of the envt
631

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

637
  | APromotionErr PromotionErr
638

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

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

647
  | RecDataConPE     -- Data constructor in a reuursive loop
648
                     -- See Note [ARecDataCon: recusion and promoting data constructors] in TcTyClsDecls
649
  | NoDataKinds      -- -XDataKinds not enabled
650

651
instance Outputable TcTyThing where     -- Debugging only
652
   ppr (AGlobal g)      = pprTyThing g
653
654
   ppr elt@(ATcId {})   = text "Identifier" <>
                          brackets (ppr (tct_id elt) <> dcolon
655
                                 <> ppr (varType (tct_id elt)) <> comma
656
                                 <+> ppr (tct_closed elt))
Simon Peyton Jones's avatar
Simon Peyton Jones committed
657
   ppr (ATyVar n tv)    = text "Type variable" <+> quotes (ppr n) <+> equals <+> ppr tv
658
   ppr (AThing k)       = text "AThing" <+> ppr k
659
660
661
662
663
664
665
   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"
666
  ppr NoDataKinds  = text "NoDataKinds"
667
668

pprTcTyThingCategory :: TcTyThing -> SDoc
669
670
671
672
673
674
675
676
677
678
679
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")
680
pprPECategory NoDataKinds  = ptext (sLit "Data constructor")
681
682
\end{code}

683

684
685
Note [Bindings with closed types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
686
687
688
689
690
Consider

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

691
Can we generalise 'g' under the OutsideIn algorithm?  Yes,
dreixel's avatar
dreixel committed
692
because all g's free variables are top-level; that is they themselves
693
694
695
696
697
698
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,
699
      iff
700
701
702
703
704
   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
705
used "top-level" as a proxy for "closed".  (It's not a good proxy
706
707
708
709
710
711
712
713
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
714
    or nested is orthogonal to the question of whether or not it is closed
715
716
717
718
719
720

  * 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)...

721

722
\begin{code}
723
type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, MsgDoc))
724
725
726
        -- Monadic so that we have a chance
        -- to deal with bound type variables just before error
        -- message construction
727

728
729
        -- Bool:  True <=> this is a landmark context; do not
        --                 discard it when trimming for display
730
731
732
733
\end{code}


%************************************************************************
734
735
736
%*                                                                      *
        Operations over ImportAvails
%*                                                                      *
737
738
739
%************************************************************************

\begin{code}
740
741
742
743
744
745
746
747
748
749
750
751
-- | '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
--
752
data ImportAvails
753
   = ImportAvails {
754
755
        imp_mods :: ImportedMods,
          --      = ModuleEnv [(ModuleName, Bool, SrcSpan, Bool)],
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
          -- ^ 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).
781

782
783
784
785
786
787
788
789
790
791
792
        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],
793
794
795
          -- ^ Packages needed by the module being compiled, whether directly,
          -- or via other modules in this package, or via modules imported
          -- from other packages.
796

797
798
799
800
801
802
803
804
805
        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.
806
          -- See Note [RnNames . Tracking Trust Transitively]
807

808
809
810
811
812
813
814
        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],
815
816
          -- ^ Orphan modules below us in the import tree (and maybe including
          -- us for imported modules)
817

818
        imp_finsts :: [Module]
819
820
          -- ^ Family instance modules below us in the import tree (and maybe
          -- including us for imported modules)
821
822
      }

Simon Marlow's avatar
Simon Marlow committed
823
mkModDeps :: [(ModuleName, IsBootInterface)]
824
          -> ModuleNameEnv (ModuleName, IsBootInterface)
Simon Marlow's avatar
Simon Marlow committed
825
mkModDeps deps = foldl add emptyUFM deps
826
827
               where
                 add env elt@(m,_) = addToUFM env m elt
828

829
emptyImportAvails :: ImportAvails
830
831
832
833
834
835
836
837
838
839
840
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
Gabor Greif's avatar
Gabor Greif committed
841
-- for each import we create a separate ImportAvails structure
842
-- and then union them all together with this function.
843
844
plusImportAvails ::  ImportAvails ->  ImportAvails ->  ImportAvails
plusImportAvails
845
  (ImportAvails { imp_mods = mods1,
846
847
                  imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1,
                  imp_trust_pkgs = tpkgs1, imp_trust_own_pkg = tself1,
848
849
                  imp_orphs = orphs1, imp_finsts = finsts1 })
  (ImportAvails { imp_mods = mods2,
850
851
                  imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2,
                  imp_trust_pkgs = tpkgs2, imp_trust_own_pkg = tself2,
852
                  imp_orphs = orphs2, imp_finsts = finsts2 })
853
854
855
856
857
858
859
  = 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 }
860
  where
861
    plus_mod_dep (m1, boot1) (m2, boot2)
862
863
864
        = 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
865
866
867
\end{code}

%************************************************************************
868
%*                                                                      *
869
\subsection{Where from}
870
%*                                                                      *
871
872
873
874
875
%************************************************************************

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

\begin{code}
876
877
878
data WhereFrom
  = ImportByUser IsBootInterface        -- Ordinary user import (perhaps {-# SOURCE #-})
  | ImportBySystem                      -- Non user import.
879
  | ImportByPlugin                      -- Importing a plugin;
880
                                        -- See Note [Care with plugin imports] in LoadIface
881
882

instance Outputable WhereFrom where
Ian Lynagh's avatar
Ian Lynagh committed
883
  ppr (ImportByUser is_boot) | is_boot     = ptext (sLit "{- SOURCE -}")
884
885
                             | otherwise   = empty
  ppr ImportBySystem                       = ptext (sLit "{- SYSTEM -}")
886
  ppr ImportByPlugin                       = ptext (sLit "{- PLUGIN -}")
887
888
\end{code}

889
%************************************************************************
890
%*                                                                      *
891
892
893
%*                       Canonical constraints                          *
%*                                                                      *
%*   These are the constraints the low-level simplifier works with      *
894
%*                                                                      *
895
896
897
898
%************************************************************************


\begin{code}
899
900
901
902
-- 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
903
904
--      (ii) Note that xi types can contain unexpanded type synonyms;
--           however, the (transitive) expansions of those type synonyms
905
906
907
--           will not contain any type functions, unless we are under a ForAll.
-- We enforce the structure of Xi types when we flatten (TcCanonical)

908
909
910
911
912
type Xi = Type       -- In many comments, "xi" ranges over Xi

type Cts = Bag Ct

data Ct
913
  -- Atomic canonical constraints
914
  = CDictCan {  -- e.g.  Num xi
915
      cc_ev :: CtEvidence,   -- See Note [Ct/evidence invariant]
916
      cc_class  :: Class,
917
      cc_tyargs :: [Xi]
918
919
    }

920
  | CIrredEvCan {  -- These stand for yet-unusable predicates
921
      cc_ev :: CtEvidence   -- See Note [Ct/evidence invariant]
922
        -- The ctev_pred of the evidence is
923
        -- of form   (tv xi1 xi2 ... xin)
924
925
        --      or   (tv1 ~ ty2)   where the CTyEqCan  kind invariant fails
        --      or   (F tys ~ ty)  where the CFunEqCan kind invariant fails
926
        -- See Note [CIrredEvCan constraints]
927
928
    }

929
930
  | CTyEqCan {  -- tv ~ xi      (recall xi means function free)
       -- Invariant:
931
       --   * tv not in tvs(xi)   (occurs check)
932
933
       --   * typeKind xi `subKind` typeKind tv
       --       See Note [Kind orientation for CTyEqCan]
934
       --   * We prefer unification variables on the left *JUST* for efficiency
935
      cc_ev :: CtEvidence,    -- See Note [Ct/evidence invariant]
936
      cc_tyvar  :: TcTyVar,
937
      cc_rhs    :: Xi
938
939
    }

940
  | CFunEqCan {  -- F xis ~ xi
941
       -- Invariant: * isSynFamilyTyCon cc_fun
942
943
       --            * typeKind (F xis) `subKind` typeKind xi
       --       See Note [Kind orientation for CFunEqCan]
944
      cc_ev     :: CtEvidence,  -- See Note [Ct/evidence invariant]
945
946
      cc_fun    :: TyCon,       -- A type function
      cc_tyargs :: [Xi],        -- Either under-saturated or exactly saturated
947
      cc_rhs    :: Xi           --    *never* over-saturated (because if so
948
                                --    we should have decomposed)
949
950
    }

951
  | CNonCanonical {        -- See Note [NonCanonical Semantics]
952
      cc_ev  :: CtEvidence
953
    }
954

955
956
  | CHoleCan {             -- Treated as an "insoluble" constraint
                           -- See Note [Insoluble constraints]
957
      cc_ev  :: CtEvidence,
958
      cc_occ :: OccName    -- The name of this hole
959
    }
960
961
\end{code}

962
963
964
965
966
Note [Kind orientation for CTyEqCan]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Given an equality  (t:* ~ s:Open), we absolutely want to re-orient it.
We can't solve it by updating t:=s, ragardless of how touchable 't' is,
because the kinds don't work.  Indeed we don't want to leave it with
967
the orientation (t ~ s), because if that gets into the inert set we'll
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
start replacing t's by s's, and that too is the wrong way round.

Hence in a CTyEqCan, (t:k1 ~ xi:k2) we require that k2 is a subkind of k1.

If the two have incompatible kinds, we just don't use a CTyEqCan at all.
See Note [Equalities with incompatible kinds] in TcCanonical

We can't require *equal* kinds, because
     * wanted constraints don't necessarily have identical kinds
               eg   alpha::? ~ Int
     * a solved wanted constraint becomes a given

Note [Kind orientation for CFunEqCan]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For (F xis ~ rhs) we require that kind(rhs) is a subkind of kind(lhs).
This reallly only maters when rhs is an Open type variable (since only type
variables have Open kinds):
   F ty ~ (a:Open)
which can happen, say, from
      f :: F a b
      f = undefined   -- The a:Open comes from instantiating 'undefined'

Note that the kind invariant is maintained by rewriting.
Eg wanted1 rewrites wanted2; if both were compatible kinds before,
   wanted2 will be afterwards.  Similarly givens.

Caveat:
995
996
997
  - Givens from higher-rank, such as:
          type family T b :: * -> * -> *
          type instance T Bool = (->)
998

999
1000
1001
1002
          f :: forall a. ((T a ~ (->)) => ...) -> a -> ...
          flop = f (...) True
     Whereas we would be able to apply the type instance, we would not be able to
     use the given (T Bool ~ (->)) in the body of 'flop'
1003
1004


1005
1006
1007
1008
1009
1010
1011
1012
Note [CIrredEvCan constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CIrredEvCan constraints are used for constraints that are "stuck"
   - we can't solve them (yet)
   - we can't use them to solve other constraints
   - but they may become soluble if we substitute for some
     of the type variables in the constraint

1013
Example 1:  (c Int), where c :: * -> Constraint.  We can't do anything
1014
1015
1016
1017
            with this yet, but if later c := Num, *then* we can solve it

Example 2:  a ~ b, where a :: *, b :: k, where k is a kind variable
            We don't want to use this to substitute 'b' for 'a', in case
1018
            'k' is subequently unifed with (say) *->*, because then
1019
1020
1021
            we'd have ill-kinded types floating about.  Rather we want
            to defer using the equality altogether until 'k' get resolved.

1022
1023
1024
Note [Ct/evidence invariant]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If  ct :: Ct, then extra fields of 'ct' cache precisely the ctev_pred field
1025
of (cc_ev ct), and is fully rewritten wrt the substitution.   Eg for CDictCan,
1026
1027
   ctev_pred (cc_ev ct) = (cc_class ct) (cc_tyargs ct)
This holds by construction; look at the unique place where CDictCan is
1028
1029
1030
1031
built (in TcCanonical).

In contrast, the type of the evidence *term* (ccev_evtm or ctev_evar) in
the evidence may *not* be fully zonked; we are careful not to look at it
Gabor Greif's avatar
Gabor Greif committed
1032
during constraint solving.  See Note [Evidence field of CtEvidence]
1033

1034
\begin{code}
1035
1036
mkNonCanonical :: CtEvidence -> Ct
mkNonCanonical ev = CNonCanonical { cc_ev = ev }
1037

1038
mkNonCanonicalCt :: Ct -> Ct
1039
mkNonCanonicalCt ct = CNonCanonical { cc_ev = cc_ev ct }
1040

1041
1042
ctEvidence :: Ct -> CtEvidence
ctEvidence = cc_ev
1043

1044
1045
1046
ctLoc :: Ct -> CtLoc
ctLoc = ctev_loc . cc_ev

1047
ctPred :: Ct -> PredType
1048
-- See Note [Ct/evidence invariant]
1049
ctPred ct = ctEvPred (cc_ev ct)
1050

1051
dropDerivedWC :: WantedConstraints -> WantedConstraints
1052
1053
1054
1055
1056
-- See Note [Insoluble derived constraints]
dropDerivedWC wc@(WC { wc_flat = flats, wc_insol = insols })
  = wc { wc_flat  = filterBag isWantedCt          flats
       , wc_insol = filterBag (not . isDerivedCt) insols  }
    -- Keep Givens from insols because they indicate unreachable code
1057
    -- The implications are (recursively) already filtered
1058
1059
\end{code}

1060
1061
1062
Note [Insoluble derived constraints]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In general we discard derived constraints at the end of constraint solving;
1063
see dropDerivedWC.  For example,
1064

1065
 * If we have an unsolved (Ord a), we don't want to complain about
1066
   an unsolved (Eq a) as well.
1067
1068
 * If we have kind-incompatible (a::* ~ Int#::#) equality, we
   don't want to complain about the kind error twice.
1069

1070
1071
Arguably, for *some* derived constraints we might want to report errors.
Notably, functional dependencies.  If we have
1072
1073
1074
1075
1076
1077
1078
    class C a b | a -> b
and we have
    [W] C a b, [W] C a c
where a,b,c are all signature variables.  Then we could reasonably
report an error unifying (b ~ c). But it's probably not worth it;
after all, we also get an error because we can't discharge the constraint.

1079

1080
%************************************************************************
1081
%*                                                                      *
Simon Peyton Jones's avatar