TcRnTypes.hs 69.4 KB
Newer Older
1 2 3
{-
(c) The University of Glasgow 2006-2012
(c) The GRASP Project, Glasgow University, 1992-2002
4

5 6 7 8 9 10 11 12

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
Gabor Greif's avatar
Gabor Greif committed
13
like fashion when entering expressions... etc.
14 15

For state that is global and should be returned at the end (e.g not part
Gabor Greif's avatar
Gabor Greif committed
16
of the stack mechanism), you should use a TcRef (= IORef) to store them.
17
-}
18

19
{-# LANGUAGE CPP, DeriveFunctor, ExistentialQuantification, GeneralizedNewtypeDeriving,
20
             ViewPatterns #-}
21

22
module TcRnTypes(
23 24
        TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module
        TcRef,
25

26 27 28
        -- The environment types
        Env(..),
        TcGblEnv(..), TcLclEnv(..),
29 30
        setLclEnvTcLevel, getLclEnvTcLevel,
        setLclEnvLoc, getLclEnvLoc,
31
        IfGblEnv(..), IfLclEnv(..),
32
        tcVisibleOrphanMods,
33

34 35 36
        -- Frontend types (shouldn't really be here)
        FrontendResult(..),

37
        -- Renamer types
38
        ErrCtxt, RecFieldEnv, pushErrCtxt, pushErrCtxtSameOrigin,
39
        ImportAvails(..), emptyImportAvails, plusImportAvails,
40
        WhereFrom(..), mkModDeps, modDepsElts,
41

42
        -- Typechecker types
43
        TcTypeEnv, TcBinderStack, TcBinder(..),
44
        TcTyThing(..), PromotionErr(..),
45
        IdBindingInfo(..), ClosedTypeId, RhsNames,
46
        IsGroupClosed(..),
47
        SelfBootInfo(..),
48
        pprTcTyThingCategory, pprPECategory, CompleteMatch(..),
49

50
        -- Desugaring types
51
        DsM, DsLclEnv(..), DsGblEnv(..),
52 53
        DsMetaEnv, DsMetaVal(..), CompleteMatchMap,
        mkCompleteMatchMap, extendCompleteMatchMap,
54

55
        -- Template Haskell
56 57
        ThStage(..), SpliceType(..), PendingStuff(..),
        topStage, topAnnStage, topSpliceStage,
58
        ThLevel, impLevel, outerLevel, thLevel,
59
        ForeignSrcLang(..),
60

61
        -- Arrows
62
        ArrowCtxt(..),
63

64
        -- TcSigInfo
65
        TcSigFun, TcSigInfo(..), TcIdSigInfo(..),
66
        TcIdSigInst(..), TcPatSynInfo(..),
67
        isPartialSig, hasCompleteSig,
68

69 70 71
        -- Misc other types
        TcId, TcIdSet,
        NameShape(..),
72
        removeBindingShadowing,
73

74 75 76
        -- Constraint solver plugins
        TcPlugin(..), TcPluginResult(..), TcPluginSolver,
        TcPluginM, runTcPluginM, unsafeTcPluginTcM,
77
        getEvBindsTcPluginM,
78

79 80
        -- Role annotations
        RoleAnnotEnv, emptyRoleAnnotEnv, mkRoleAnnotEnv,
81
        lookupRoleAnnot, getRoleAnnots
82 83 84 85
  ) where

#include "HsVersions.h"

86 87
import GhcPrelude

88
import GHC.Hs
89
import HscTypes
90
import TcEvidence
91
import Type
92 93
import TyCon    ( TyCon, tyConKind )
import PatSyn   ( PatSyn )
94
import Id       ( idType, idName )
95
import FieldLabel ( FieldLabel )
96
import TcType
97 98
import Constraint
import TcOrigin
99
import Annotations
100 101
import InstEnv
import FamInstEnv
102
import {-# SOURCE #-} GHC.HsToCore.PmCheck.Types (Delta)
103
import IOEnv
104 105
import RdrName
import Name
106
import NameEnv
107
import NameSet
108
import Avail
109 110
import Var
import VarEnv
111
import Module
112 113 114
import SrcLoc
import VarSet
import ErrUtils
115
import UniqFM
116
import BasicTypes
117
import Bag
Ian Lynagh's avatar
Ian Lynagh committed
118
import DynFlags
119
import Outputable
120
import ListSetOps
Edward Z. Yang's avatar
Edward Z. Yang committed
121
import Fingerprint
122
import Util
123
import PrelNames ( isUnboundName )
124
import CostCentreState
125

126
import Control.Monad (ap)
quchen's avatar
quchen committed
127
import qualified Control.Monad.Fail as MonadFail
128
import Data.Set      ( Set )
129
import qualified Data.Set as S
130

131
import Data.List ( sort )
132
import Data.Map ( Map )
133 134
import Data.Dynamic  ( Dynamic )
import Data.Typeable ( TypeRep )
135
import Data.Maybe    ( mapMaybe )
136
import GHCi.Message
137
import GHCi.RemoteTypes
138

139 140
import {-# SOURCE #-} TcHoleFitTypes ( HoleFitPlugin )

141
import qualified Language.Haskell.TH as TH
142

Edward Z. Yang's avatar
Edward Z. Yang committed
143 144
-- | A 'NameShape' is a substitution on 'Name's that can be used
-- to refine the identities of a hole while we are renaming interfaces
145
-- (see 'GHC.Iface.Rename').  Specifically, a 'NameShape' for
Edward Z. Yang's avatar
Edward Z. Yang committed
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
-- 'ns_module_name' @A@, defines a mapping from @{A.T}@
-- (for some 'OccName' @T@) to some arbitrary other 'Name'.
--
-- The most intruiging thing about a 'NameShape', however, is
-- how it's constructed.  A 'NameShape' is *implied* by the
-- exported 'AvailInfo's of the implementor of an interface:
-- if an implementor of signature @<H>@ exports @M.T@, you implicitly
-- define a substitution from @{H.T}@ to @M.T@.  So a 'NameShape'
-- is computed from the list of 'AvailInfo's that are exported
-- by the implementation of a module, or successively merged
-- together by the export lists of signatures which are joining
-- together.
--
-- It's not the most obvious way to go about doing this, but it
-- does seem to work!
--
-- NB: Can't boot this and put it in NameShape because then we
-- start pulling in too many DynFlags things.
data NameShape = NameShape {
        ns_mod_name :: ModuleName,
        ns_exports :: [AvailInfo],
        ns_map :: OccEnv Name
    }


171 172 173
{-
************************************************************************
*                                                                      *
174
               Standard monad definition for TcRn
175
    All the combinators for the monad can be found in TcRnMonad
176 177
*                                                                      *
************************************************************************
178

179
The monad itself has to be defined here, because it is mentioned by ErrCtxt
180
-}
181

cactus's avatar
cactus committed
182
type TcRnIf a b = IOEnv (Env a b)
183 184 185 186 187 188 189 190 191 192 193 194
type TcRn       = TcRnIf TcGblEnv TcLclEnv    -- Type inference
type IfM lcl    = TcRnIf IfGblEnv lcl         -- Iface stuff
type IfG        = IfM ()                      --    Top level
type IfL        = IfM IfLclEnv                --    Nested
type DsM        = TcRnIf DsGblEnv DsLclEnv    -- Desugaring

-- TcRn is the type-checking and renaming monad: the main monad that
-- most type-checking takes place in.  The global environment is
-- 'TcGblEnv', which tracks all of the top-level type-checking
-- information we've accumulated while checking a module, while the
-- local environment is 'TcLclEnv', which tracks local information as
-- we move inside expressions.
Edward Z. Yang's avatar
Edward Z. Yang committed
195 196 197 198 199 200

-- | Historical "renaming monad" (now it's just 'TcRn').
type RnM  = TcRn

-- | Historical "type-checking monad" (now it's just 'TcRn').
type TcM  = TcRn
201

Rik Steenkamp's avatar
Rik Steenkamp committed
202
-- We 'stack' these envs through the Reader like monad infrastructure
203 204 205
-- as we move into an expression (although the change is focused in
-- the lcl type).
data Env gbl lcl
206
  = Env {
207
        env_top  :: !HscEnv, -- Top-level stuff that never changes
208
                             -- Includes all info about imported things
209
                             -- BangPattern is to fix leak, see #15111
210

211
        env_um   :: !Char,   -- Mask for Uniques
212

213 214
        env_gbl  :: gbl,     -- Info about things defined at the top level
                             -- of the module being compiled
215

216
        env_lcl  :: lcl      -- Nested stuff; changes as we go into
217
    }
218

Ian Lynagh's avatar
Ian Lynagh committed
219 220 221
instance ContainsDynFlags (Env gbl lcl) where
    extractDynFlags env = hsc_dflags (env_top env)

222 223 224
instance ContainsModule gbl => ContainsModule (Env gbl lcl) where
    extractModule env = extractModule (env_gbl env)

225 226 227 228 229 230 231 232 233 234 235 236

{-
************************************************************************
*                                                                      *
                The interface environments
              Used when dealing with IfaceDecls
*                                                                      *
************************************************************************
-}

data IfGblEnv
  = IfGblEnv {
237 238 239
        -- Some information about where this environment came from;
        -- useful for debugging.
        if_doc :: SDoc,
240 241 242 243 244
        -- 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.
245
        -- See Note [Tying the knot] in GHC.IfaceToCore
246 247 248 249 250 251 252 253 254 255 256
        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
    }

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
Edward Z. Yang's avatar
Edward Z. Yang committed
257 258
        -- NB: This is a semantic module, see
        -- Note [Identity versus semantic module]
259 260
        if_mod :: Module,

261 262 263 264 265
        -- Whether or not the IfaceDecl came from a boot
        -- file or not; we'll use this to choose between
        -- NoUnfolding and BootUnfolding
        if_boot :: Bool,

266 267 268 269 270 271 272
        -- 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

Edward Z. Yang's avatar
Edward Z. Yang committed
273 274
        if_nsubst :: Maybe NameShape,

275 276 277
        -- This field is used to make sure "implicit" declarations
        -- (anything that cannot be exported in mi_exports) get
        -- wired up correctly in typecheckIfacesForMerging.  Most
278 279
        -- of the time it's @Nothing@.  See Note [Resolving never-exported Names]
        -- in GHC.IfaceToCore.
280 281
        if_implicits_env :: Maybe TypeEnv,

niteria's avatar
niteria committed
282 283
        if_tv_env  :: FastStringEnv TyVar,     -- Nested tyvar bindings
        if_id_env  :: FastStringEnv Id         -- Nested id binding
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
    }

{-
************************************************************************
*                                                                      *
                Desugarer monad
*                                                                      *
************************************************************************

Now the mondo monad magic (yes, @DsM@ is a silly name)---carry around
a @UniqueSupply@ and some annotations, which
presumably include source-file location information:
-}

data DsGblEnv
        = DsGblEnv
        { ds_mod          :: Module             -- For SCC profiling
        , ds_fam_inst_env :: FamInstEnv         -- Like tcg_fam_inst_env
        , ds_unqual  :: PrintUnqualified
        , ds_msgs    :: IORef Messages          -- Warning messages
        , ds_if_env  :: (IfGblEnv, IfLclEnv)    -- Used for looking up global,
                                                -- possibly-imported things
306 307
        , ds_complete_matches :: CompleteMatchMap
           -- Additional complete pattern matches
308 309
        , ds_cc_st   :: IORef CostCentreState
           -- Tracking indices for cost centre annotations
310 311 312 313 314 315 316
        }

instance ContainsModule DsGblEnv where
    extractModule = ds_mod

data DsLclEnv = DsLclEnv {
        dsl_meta    :: DsMetaEnv,        -- Template Haskell bindings
317
        dsl_loc     :: RealSrcSpan,      -- To put in pattern-matching error msgs
Simon Peyton Jones's avatar
Simon Peyton Jones committed
318 319

        -- See Note [Note [Type and Term Equality Propagation] in Check.hs
320 321
        -- The oracle state Delta is augmented as we walk inwards,
        -- through each pattern match in turn
322
        dsl_delta   :: Delta
323 324 325 326 327 328 329 330 331 332 333
     }

-- Inside [| |] brackets, the desugarer looks
-- up variables in the DsMetaEnv
type DsMetaEnv = NameEnv DsMetaVal

data DsMetaVal
   = DsBound Id         -- Bound by a pattern inside the [| |].
                        -- Will be dynamically alpha renamed.
                        -- The Id has type THSyntax.Var

334 335
   | DsSplice (HsExpr GhcTc) -- These bindings are introduced by
                             -- the PendingSplices on a HsBracketOut
336 337 338 339 340 341 342 343 344 345


{-
************************************************************************
*                                                                      *
                Global typechecker environment
*                                                                      *
************************************************************************
-}

346 347 348 349 350 351 352 353
-- | 'FrontendResult' describes the result of running the
-- frontend of a Haskell module.  Usually, you'll get
-- a 'FrontendTypecheck', since running the frontend involves
-- typechecking a program, but for an hs-boot merge you'll
-- just get a ModIface, since no actual typechecking occurred.
--
-- This data type really should be in HscTypes, but it needs
-- to have a TcGblEnv which is only defined here.
354 355 356
data FrontendResult
        = FrontendTypecheck TcGblEnv

Edward Z. Yang's avatar
Edward Z. Yang committed
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
-- Note [Identity versus semantic module]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- When typechecking an hsig file, it is convenient to keep track
-- of two different "this module" identifiers:
--
--      - The IDENTITY module is simply thisPackage + the module
--        name; i.e. it uniquely *identifies* the interface file
--        we're compiling.  For example, p[A=<A>]:A is an
--        identity module identifying the requirement named A
--        from library p.
--
--      - The SEMANTIC module, which is the actual module that
--        this signature is intended to represent (e.g. if
--        we have a identity module p[A=base:Data.IORef]:A,
--        then the semantic module is base:Data.IORef)
--
-- Which one should you use?
--
--      - In the desugarer and later phases of compilation,
--        identity and semantic modules coincide, since we never compile
--        signatures (we just generate blank object files for
--        hsig files.)
--
380 381 382 383 384 385 386
--        A corrolary of this is that the following invariant holds at any point
--        past desugaring,
--
--            if I have a Module, this_mod, in hand representing the module
--            currently being compiled,
--            then moduleUnitId this_mod == thisPackage dflags
--
Edward Z. Yang's avatar
Edward Z. Yang committed
387
--      - For any code involving Names, we want semantic modules.
388 389
--        See lookupIfaceTop in GHC.Iface.Env, mkIface and addFingerprints
--        in GHC.Iface.Utils, and tcLookupGlobal in TcEnv
Edward Z. Yang's avatar
Edward Z. Yang committed
390 391 392 393 394
--
--      - When reading interfaces, we want the identity module to
--        identify the specific interface we want (such interfaces
--        should never be loaded into the EPS).  However, if a
--        hole module <A> is requested, we look for A.hi
395
--        in the home library we are compiling.  (See GHC.Iface.Load.)
396
--        Similarly, in GHC.Rename.Names we check for self-imports using
Edward Z. Yang's avatar
Edward Z. Yang committed
397
--        identity modules, to allow signatures to import their implementor.
398 399 400 401
--
--      - For recompilation avoidance, you want the identity module,
--        since that will actually say the specific interface you
--        want to track (and recompile if it changes)
Edward Z. Yang's avatar
Edward Z. Yang committed
402

Edward Z. Yang's avatar
Edward Z. Yang committed
403
-- | 'TcGblEnv' describes the top-level of the module at the
404 405
-- point at which the typechecker is finished work.
-- It is this structure that is handed on to the desugarer
406
-- For state that needs to be updated during the typechecking
Edward Z. Yang's avatar
Edward Z. Yang committed
407
-- phase and returned at end, use a 'TcRef' (= 'IORef').
408 409
data TcGblEnv
  = TcGblEnv {
410
        tcg_mod     :: Module,         -- ^ Module being compiled
Edward Z. Yang's avatar
Edward Z. Yang committed
411 412
        tcg_semantic_mod :: Module,    -- ^ If a signature, the backing module
            -- See also Note [Identity versus semantic module]
413
        tcg_src     :: HscSource,
414
          -- ^ What kind of module (regular Haskell, hs-boot, hsig)
415

416 417
        tcg_rdr_env :: GlobalRdrEnv,   -- ^ Top level envt; used during renaming
        tcg_default :: Maybe [Type],
418
          -- ^ Types used for defaulting. @Nothing@ => no @default@ decl
419

420 421
        tcg_fix_env   :: FixityEnv,     -- ^ Just for things in this module
        tcg_field_env :: RecFieldEnv,   -- ^ Just for things in this module
422
                                        -- See Note [The interactive package] in HscTypes
423

424
        tcg_type_env :: TypeEnv,
425
          -- ^ Global type env for the module we are compiling now.  All
426 427 428 429 430
          -- 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)
431 432 433
          --
          -- NB: for what "things in this module" means, see
          -- Note [The interactive package] in HscTypes
434 435 436 437 438 439 440

        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)

441
        tcg_inst_env     :: !InstEnv,
442
          -- ^ Instance envt for all /home-package/ modules;
443
          -- Includes the dfuns in tcg_insts
444 445 446
          -- NB. BangPattern is to fix a leak, see #15111
        tcg_fam_inst_env :: !FamInstEnv, -- ^ Ditto for family instances
          -- NB. BangPattern is to fix a leak, see #15111
447
        tcg_ann_env      :: AnnEnv,     -- ^ And for annotations
448 449 450 451 452 453 454

                -- 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,
455
          -- ^ Information about what was imported from where, including
456
          -- things bound in this module. Also store Safe Haskell info
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
          -- here about transitive trusted package requirements.
          --
          -- There are not many uses of this field, so you can grep for
          -- all them.
          --
          -- The ImportAvails records information about the following
          -- things:
          --
          --    1. All of the modules you directly imported (tcRnImports)
          --    2. The orphans (only!) of all imported modules in a GHCi
          --       session (runTcInteractive)
          --    3. The module that instantiated a signature
          --    4. Each of the signatures that merged in
          --
          -- It is used in the following ways:
          --    - imp_orphs is used to determine what orphan modules should be
          --      visible in the context (tcVisibleOrphanMods)
          --    - imp_finsts is used to determine what family instances should
          --      be visible (tcExtendLocalFamInstEnv)
          --    - To resolve the meaning of the export list of a module
          --      (tcRnExports)
          --    - imp_mods is used to compute usage info (mkIfaceTc, deSugar)
          --    - imp_trust_own_pkg is used for Safe Haskell in interfaces
          --      (mkIfaceTc, as well as in HscMain)
          --    - To create the Dependencies field in interface (mkDependencies)
482

483 484 485 486 487
          -- These three fields track unused bindings and imports
          -- See Note [Tracking unused binding and imports]
        tcg_dus       :: DefUses,
        tcg_used_gres :: TcRef [GlobalRdrElt],
        tcg_keep      :: TcRef NameSet,
488

489
        tcg_th_used :: TcRef Bool,
490 491
          -- ^ @True@ <=> Template Haskell syntax used.
          --
492
          -- We need this so that we can generate a dependency on the
Gabor Greif's avatar
Gabor Greif committed
493
          -- Template Haskell package, because the desugarer is going
494 495
          -- to emit loads of references to TH symbols.  The reference
          -- is implicit rather than explicit, so we have to zap a
496 497
          -- mutable variable.

498 499 500 501 502
        tcg_th_splice_used :: TcRef Bool,
          -- ^ @True@ <=> A Template Haskell splice was used.
          --
          -- Splices disable recompilation avoidance (see #481)

503
        tcg_dfun_n  :: TcRef OccSet,
504
          -- ^ Allows us to choose unique DFun names.
505

Edward Z. Yang's avatar
Edward Z. Yang committed
506 507 508 509
        tcg_merged :: [(Module, Fingerprint)],
          -- ^ The requirements we merged with; we always have to recompile
          -- if any of these changed.

510
        -- The next fields accumulate the payload of the module
Gabor Greif's avatar
Gabor Greif committed
511
        -- The binds, rules and foreign-decl fields are collected
512
        -- initially in un-zonked form and are finally zonked in tcRnSrcDecls
513

514
        tcg_rn_exports :: Maybe [(Located (IE GhcRn), Avails)],
515
                -- Nothing <=> no explicit export list
516
                -- Is always Nothing if we don't want to retain renamed
517 518 519
                -- exports.
                -- If present contains each renamed export list item
                -- together with its exported names.
520

521
        tcg_rn_imports :: [LImportDecl GhcRn],
522 523
                -- 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
524

525
        tcg_rn_decls :: Maybe (HsGroup GhcRn),
526 527
          -- ^ Renamed decls, maybe.  @Nothing@ <=> Don't retain renamed
          -- decls.
528

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

531
        tcg_th_topdecls :: TcRef [LHsDecl GhcPs],
532 533
        -- ^ Top-level declarations from addTopDecls

534
        tcg_th_foreign_files :: TcRef [(ForeignSrcLang, FilePath)],
535
        -- ^ Foreign files emitted from TH.
536

537 538
        tcg_th_topnames :: TcRef NameSet,
        -- ^ Exact names bound in top-level declarations in tcg_th_topdecls
539

540
        tcg_th_modfinalizers :: TcRef [(TcLclEnv, ThModFinalizers)],
541 542
        -- ^ Template Haskell module finalizers.
        --
543
        -- They can use particular local environments.
544

545 546 547
        tcg_th_coreplugins :: TcRef [String],
        -- ^ Core plugins added by Template Haskell code.

548
        tcg_th_state :: TcRef (Map TypeRep Dynamic),
549
        tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState))),
550
        -- ^ Template Haskell state
551

552
        tcg_ev_binds  :: Bag EvBind,        -- Top-level evidence bindings
553

554 555 556
        -- Things defined in this module, or (in GHCi)
        -- in the declarations for a single GHCi command.
        -- For the latter, see Note [The interactive package] in HscTypes
557
        tcg_tr_module :: Maybe Id,   -- Id for $trModule :: GHC.Types.Module
558 559
                                             -- for which every module has a top-level defn
                                             -- except in GHCi in which case we have Nothing
560
        tcg_binds     :: LHsBinds GhcTc,     -- Value bindings in this module
561 562 563 564 565 566 567
        tcg_sigs      :: NameSet,            -- ...Top-level names that *lack* a signature
        tcg_imp_specs :: [LTcSpecPrag],      -- ...SPECIALISE prags for imported Ids
        tcg_warns     :: Warnings,           -- ...Warnings and deprecations
        tcg_anns      :: [Annotation],       -- ...Annotations
        tcg_tcs       :: [TyCon],            -- ...TyCons and Classes
        tcg_insts     :: [ClsInst],          -- ...Instances
        tcg_fam_insts :: [FamInst],          -- ...Family instances
568 569 570
        tcg_rules     :: [LRuleDecl GhcTc],  -- ...Rules
        tcg_fords     :: [LForeignDecl GhcTc], -- ...Foreign import & exports
        tcg_patsyns   :: [PatSyn],            -- ...Pattern synonyms
571

572
        tcg_doc_hdr   :: Maybe LHsDocString, -- ^ Maybe Haddock header docs
573
        tcg_hpc       :: !AnyHpcUsage,       -- ^ @True@ if any part of the
574
                                             --  prog uses hpc instrumentation.
575
           -- NB. BangPattern is to fix a leak, see #15111
576

577 578 579
        tcg_self_boot :: SelfBootInfo,       -- ^ Whether this module has a
                                             -- corresponding hi-boot file

580
        tcg_main      :: Maybe Name,         -- ^ The Name of the main
581 582
                                             -- function, if this module is
                                             -- the main module.
583

584 585 586 587 588
        tcg_safeInfer :: TcRef (Bool, WarningMessages),
        -- ^ Has the typechecker inferred this module as -XSafe (Safe Haskell)
        -- See Note [Safe Haskell Overlapping Instances Implementation],
        -- although this is used for more than just that failure case.

589
        tcg_tc_plugins :: [TcPluginSolver],
590
        -- ^ A list of user-defined plugins for the constraint solver.
591 592
        tcg_hf_plugins :: [HoleFitPlugin],
        -- ^ A list of user-defined plugins for hole fit suggestions.
593

Edward Z. Yang's avatar
Edward Z. Yang committed
594 595 596
        tcg_top_loc :: RealSrcSpan,
        -- ^ The RealSrcSpan this module came from

597 598
        tcg_static_wc :: TcRef WantedConstraints,
          -- ^ Wanted constraints of static forms.
599
        -- See Note [Constraints in static forms].
600 601 602 603
        tcg_complete_matches :: [CompleteMatch],

        -- ^ Tracking indices for cost centre annotations
        tcg_cc_st   :: TcRef CostCentreState
604
    }
Lemmih's avatar
Lemmih committed
605

Edward Z. Yang's avatar
Edward Z. Yang committed
606 607 608
-- NB: topModIdentity, not topModSemantic!
-- Definition sites of orphan identities will be identity modules, not semantic
-- modules.
609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630

-- Note [Constraints in static forms]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- When a static form produces constraints like
--
-- f :: StaticPtr (Bool -> String)
-- f = static show
--
-- we collect them in tcg_static_wc and resolve them at the end
-- of type checking. They need to be resolved separately because
-- we don't want to resolve them in the context of the enclosing
-- expression. Consider
--
-- g :: Show a => StaticPtr (a -> String)
-- g = static show
--
-- If the @Show a0@ constraint that the body of the static form produces was
-- resolved in the context of the enclosing expression, then the body of the
-- static form wouldn't be closed because the Show dictionary would come from
-- g's context instead of coming from the top level.

631 632 633 634
tcVisibleOrphanMods :: TcGblEnv -> ModuleSet
tcVisibleOrphanMods tcg_env
    = mkModuleSet (tcg_mod tcg_env : imp_orphs (tcg_imports tcg_env))

635
instance ContainsModule TcGblEnv where
Edward Z. Yang's avatar
Edward Z. Yang committed
636
    extractModule env = tcg_semantic_mod env
637

638 639 640
type RecFieldEnv = NameEnv [FieldLabel]
        -- Maps a constructor name *in this module*
        -- to the fields for that constructor.
641 642 643 644 645
        -- 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
646

647 648 649 650
data SelfBootInfo
  = NoSelfBoot    -- No corresponding hi-boot file
  | SelfBoot
       { sb_mds :: ModDetails   -- There was a hi-boot file,
651 652
       , sb_tcs :: NameSet }    -- defining these TyCons,
-- What is sb_tcs used for?  See Note [Extra dependencies from .hs-boot files]
653
-- in GHC.Rename.Source
654

655

656 657
{- Note [Tracking unused binding and imports]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
658 659 660 661
We gather three sorts of usage information

 * tcg_dus :: DefUses (defs/uses)
      Records what is defined in this module and what is used.
662

663 664 665 666
      Records *defined* Names (local, top-level)
          and *used*    Names (local or imported)

      Used (a) to report "defined but not used"
667
               (see GHC.Rename.Names.reportUnusedNames)
668
           (b) to generate version-tracking usage info in interface
669
               files (see GHC.Iface.Utils.mkUsedNames)
670
   This usage info is mainly gathered by the renamer's
671 672
   gathering of free-variables

673 674 675
 * tcg_used_gres :: TcRef [GlobalRdrElt]
      Records occurrences of imported entities.

676
      Used only to report unused import declarations
677 678 679 680 681 682 683

      Records each *occurrence* an *imported* (not locally-defined) entity.
      The occurrence is recorded by keeping a GlobalRdrElt for it.
      These is not the GRE that is in the GlobalRdrEnv; rather it
      is recorded *after* the filtering done by pickGREs.  So it reflect
      /how that occurrence is in scope/.   See Note [GRE filtering] in
      RdrName.
684

685 686 687 688 689 690 691 692 693 694 695 696 697 698 699
  * tcg_keep :: TcRef NameSet
      Records names of the type constructors, data constructors, and Ids that
      are used by the constraint solver.

      The typechecker may use find that some imported or
      locally-defined things are used, even though they
      do not appear to be mentioned in the source code:

      (a) The to/from functions for generic data types

      (b) Top-level variables appearing free in the RHS of an
          orphan rule

      (c) Top-level variables appearing free in a TH bracket
          See Note [Keeping things alive for Template Haskell]
700
          in GHC.Rename.Splice
701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721

      (d) The data constructor of a newtype that is used
          to solve a Coercible instance (e.g. #10347). Example
              module T10347 (N, mkN) where
                import Data.Coerce
                newtype N a = MkN Int
                mkN :: Int -> N a
                mkN = coerce

          Then we wish to record `MkN` as used, since it is (morally)
          used to perform the coercion in `mkN`. To do so, the
          Coercible solver updates tcg_keep's TcRef whenever it
          encounters a use of `coerce` that crosses newtype boundaries.

      The tcg_keep field is used in two distinct ways:

      * Desugar.addExportFlagsAndRules.  Where things like (a-c) are locally
        defined, we should give them an 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).

722 723
      * GHC.Rename.Names.reportUnusedNames.  Where newtype data constructors
        like (d) are imported, we don't want to report them as unused.
724

725

726 727
************************************************************************
*                                                                      *
728
                The local typechecker environment
729 730
*                                                                      *
************************************************************************
731

Edward Z. Yang's avatar
Edward Z. Yang committed
732 733
Note [The Global-Env/Local-Env story]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
734
During type checking, we keep in the tcg_type_env
735 736
        * All types and classes
        * All Ids derived from types and classes (constructors, selectors)
737 738 739

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

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

748 749
data TcLclEnv           -- Changes as we move inside an expression
                        -- Discarded after typecheck/rename; not passed on to desugarer
750
  = TcLclEnv {
751
        tcl_loc        :: RealSrcSpan,     -- Source span
752
        tcl_ctxt       :: [ErrCtxt],       -- Error context, innermost on top
753
        tcl_tclvl      :: TcLevel,         -- Birthplace for new unification variables
754

755
        tcl_th_ctxt    :: ThStage,         -- Template Haskell context
756 757 758 759 760
        tcl_th_bndrs   :: ThBindEnv,       -- and binder info
            -- The ThBindEnv records the TH binding level of in-scope Names
            -- defined in this module (not imported)
            -- We can't put this info in the TypeEnv because it's needed
            -- (and extended) in the renamer, for untyed splices
761

762 763 764 765 766 767 768 769 770 771
        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
772
                --   occurrence constructor (Name.TvOcc)
773 774 775 776 777
                -- 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
778

779 780
        tcl_bndrs :: TcBinderStack,   -- Used for reporting relevant bindings,
                                      -- and for tidying types
781 782 783

        tcl_lie  :: TcRef WantedConstraints,    -- Place to accumulate type constraints
        tcl_errs :: TcRef Messages              -- Place to accumulate errors
784 785
    }

786 787 788 789 790 791 792 793 794 795 796 797
setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv
setLclEnvTcLevel env lvl = env { tcl_tclvl = lvl }

getLclEnvTcLevel :: TcLclEnv -> TcLevel
getLclEnvTcLevel = tcl_tclvl

setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv
setLclEnvLoc env loc = env { tcl_loc = loc }

getLclEnvLoc :: TcLclEnv -> RealSrcSpan
getLclEnvLoc = tcl_loc

798 799 800 801 802 803 804 805
type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, MsgDoc))
        -- 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

806 807 808 809 810 811 812 813 814 815 816 817
-- These are here to avoid module loops: one might expect them
-- in Constraint, but they refer to ErrCtxt which refers to TcM.
-- Easier to just keep these definitions here, alongside TcM.
pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc
pushErrCtxt o err loc@(CtLoc { ctl_env = lcl })
  = loc { ctl_origin = o, ctl_env = lcl { tcl_ctxt = err : tcl_ctxt lcl } }

pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc
-- Just add information w/o updating the origin!
pushErrCtxtSameOrigin err loc@(CtLoc { ctl_env = lcl })
  = loc { ctl_env = lcl { tcl_ctxt = err : tcl_ctxt lcl } }

818
type TcTypeEnv = NameEnv TcTyThing
819

820 821 822 823 824 825 826 827 828
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

829 830
{- Note [Given Insts]
   ~~~~~~~~~~~~~~~~~~
831
Because of GADTs, we have to pass inwards the Insts provided by type signatures
832
and existential contexts. Consider
833 834 835
        data T a where { T1 :: b -> b -> T [b] }
        f :: Eq a => T a -> Bool
        f (T1 x y) = [x]==[y]
836 837

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

-}
842

843 844 845 846 847 848 849 850
-- | Type alias for 'IORef'; the convention is we'll use this for mutable
-- bits of data in 'TcGblEnv' which are updated during typechecking and
-- returned at the end.
type TcRef a     = IORef a
-- ToDo: when should I refer to it as a 'TcId' instead of an 'Id'?
type TcId        = Id
type TcIdSet     = IdSet

851
---------------------------
852
-- The TcBinderStack
853 854
---------------------------

855 856 857 858 859
type TcBinderStack = [TcBinder]
   -- This is a stack of locally-bound ids and tyvars,
   --   innermost on top
   -- Used only in error reporting (relevantBindings in TcError),
   --   and in tidying
Simon Peyton Jones's avatar
Simon Peyton Jones committed
860 861
   -- We can't use the tcl_env type environment, because it doesn't
   --   keep track of the nesting order
862

863
data TcBinder
864 865
  = TcIdBndr
       TcId
866
       TopLevelFlag    -- Tells whether the binding is syntactically top-level
867 868
                       -- (The monomorphic Ids for a recursive group count
                       --  as not-top-level for this purpose.)
869

870 871 872 873 874
  | TcIdBndr_ExpType  -- Variant that allows the type to be specified as
                      -- an ExpType
       Name
       ExpType
       TopLevelFlag
875

876 877 878 879 880 881
  | TcTvBndr          -- e.g.   case x of P (y::a) -> blah
       Name           -- We bind the lexical name "a" to the type of y,
       TyVar          -- which might be an utterly different (perhaps
                      -- existential) tyvar

instance Outputable TcBinder where
882 883
   ppr (TcIdBndr id top_lvl)           = ppr id <> brackets (ppr top_lvl)
   ppr (TcIdBndr_ExpType id _ top_lvl) = ppr id <> brackets (ppr top_lvl)
884
   ppr (TcTvBndr name tv)              = ppr name <+> ppr tv
885

886 887 888 889
instance HasOccName TcBinder where
    occName (TcIdBndr id _)             = occName (idName id)
    occName (TcIdBndr_ExpType name _ _) = occName name
    occName (TcTvBndr name _)           = occName name
890

891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
-- fixes #12177
-- Builds up a list of bindings whose OccName has not been seen before
-- i.e., If    ys  = removeBindingShadowing xs
-- then
--  - ys is obtained from xs by deleting some elements
--  - ys has no duplicate OccNames
--  - The first duplicated OccName in xs is retained in ys
-- Overloaded so that it can be used for both GlobalRdrElt in typed-hole
-- substitutions and TcBinder when looking for relevant bindings.
removeBindingShadowing :: HasOccName a => [a] -> [a]
removeBindingShadowing bindings = reverse $ fst $ foldl
    (\(bindingAcc, seenNames) binding ->
    if occName binding `elemOccSet` seenNames -- if we've seen it
        then (bindingAcc, seenNames)              -- skip it
        else (binding:bindingAcc, extendOccSet seenNames (occName binding)))
    ([], emptyOccSet) bindings

908
---------------------------
909
-- Template Haskell stages and levels
910 911
---------------------------

912 913
data SpliceType = Typed | Untyped

914 915 916 917 918 919
data ThStage    -- See Note [Template Haskell state diagram]
                -- and Note [Template Haskell levels] in TcSplice
    -- Start at:   Comp
    -- At bracket: wrap current stage in Brack
    -- At splice:  currently Brack: return to previous stage
    --             currently Comp/Splice: compile and run
920 921 922 923
  = Splice SpliceType -- Inside a top-level splice
                      -- This code will be run *at compile time*;
                      --   the result replaces the splice
                      -- Binding level = 0
924

925 926 927 928 929 930 931 932
  | RunSplice (TcRef [ForeignRef (TH.Q ())])
      -- Set when running a splice, i.e. NOT when renaming or typechecking the
      -- Haskell code for the splice. See Note [RunSplice ThLevel].
      --
      -- Contains a list of mod finalizers collected while executing the splice.
      --
      -- 'addModFinalizer' inserts finalizers here, and from here they are taken
      -- to construct an @HsSpliced@ annotation for untyped splices. See Note
933
      -- [Delaying modFinalizers in untyped splices] in GHC.Rename.Splice.
934 935 936 937 938 939
      --
      -- For typed splices, the typechecker takes finalizers from here and
      -- inserts them in the list of finalizers in the global environment.
      --
      -- See Note [Collecting modFinalizers in typed splices] in "TcSplice".

940 941
  | Comp        -- Ordinary Haskell code
                -- Binding level = 1
942

943
  | Brack                       -- Inside brackets
944 945 946 947 948 949 950 951 952
      ThStage                   --   Enclosing stage
      PendingStuff

data PendingStuff
  = RnPendingUntyped              -- Renaming the inside of an *untyped* bracket
      (TcRef [PendingRnSplice])   -- Pending splices in here

  | RnPendingTyped                -- Renaming the inside of a *typed* bracket

953
  | TcPending                     -- Typechecking the inside of a typed bracket
954 955
      (TcRef [PendingTcSplice])   --   Accumulate pending splices here
      (TcRef WantedConstraints)   --     and type constraints here
956 957 958 959 960 961 962
      QuoteWrapper                -- A type variable and evidence variable
                                  -- for the overall monad of
                                  -- the bracket. Splices are checked
                                  -- against this monad. The evidence
                                  -- variable is used for desugaring
                                  -- `lift`.

963 964 965

topStage, topAnnStage, topSpliceStage :: ThStage
topStage       = Comp
966 967
topAnnStage    = Splice Untyped
topSpliceStage = Splice Untyped
968 969

instance Outputable ThStage where
970 971 972 973
   ppr (Splice _)    = text "Splice"
   ppr (RunSplice _) = text "RunSplice"
   ppr Comp          = text "Comp"
   ppr (Brack s _)   = text "Brack" <> parens (ppr s)
974

975
type ThLevel = Int
976 977 978 979 980
    -- 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
981

982
impLevel, outerLevel :: ThLevel
983 984
impLevel = 0    -- Imported things; they can be used inside a top level splice
outerLevel = 1  -- Things defined outside brackets
985

986
thLevel :: ThStage -> ThLevel
987 988 989
thLevel (Splice _)    = 0
thLevel Comp          = 1
thLevel (Brack s _)   = thLevel s + 1
990 991
thLevel (RunSplice _) = panic "thLevel: called when running a splice"
                        -- See Note [RunSplice ThLevel].
992 993 994 995 996 997 998 999 1000

{- Node [RunSplice ThLevel]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The 'RunSplice' stage is set when executing a splice, and only when running a
splice. In particular it is not set when the splice is renamed or typechecked.

'RunSplice' is needed to provide a reference where 'addModFinalizer' can insert
the finalizer (see Note [Delaying modFinalizers in untyped splices]), and
'addModFinalizer' runs when doing Q things. Therefore, It doesn't make sense to
1001
set 'RunSplice' when renaming or typechecking the splice, where 'Splice',
1002
'Brack' or 'Comp' are used instead.
1003 1004

-}
1005

1006 1007 1008 1009
---------------------------
-- Arrow-notation context
---------------------------

1010 1011
{- Note [Escaping the arrow scope]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1012 1013 1014 1015
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

1016
        proc x -> (e1 -< e2)
1017 1018 1019 1020

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

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

1024
Here, x and z are in scope in e1, but y is not.
1025 1026

We implement this by
1027 1028 1029
recording the environment when passing a proc (using newArrowScope),
and returning to that (using escapeArrowScope) on the left of -< and the
head of (|..|).
1030

1031 1032 1033 1034 1035 1036 1037 1038 1039 1040
All this can be dealt with by the *renamer*. But the type checker needs
to be involved too.  Example (arrowfail001)
  class Foo a where foo :: a -> ()
  data Bar = forall a. Foo a => Bar a
  get :: Bar -> ()
  get = proc x -> case x of Bar a -> foo -< a
Here the call of 'foo' gives rise to a (Foo a) constraint that should not
be captured by the pattern match on 'Bar'.  Rather it should join the
constraints from further out.  So we must capture the constraint bag
from further out in the ArrowCtxt that we push inwards.
1041 1042
-}

1043
data ArrowCtxt   -- Note [Escaping the arrow scope]
1044
  = NoArrowCtxt
1045 1046
  | ArrowCtxt LocalRdrEnv (TcRef WantedConstraints)

1047

1048 1049 1050 1051
---------------------------
-- TcTyThing
---------------------------

Edward Z. Yang's avatar
Edward Z. Yang committed
1052 1053 1054
-- | A typecheckable thing available in a local context.  Could be
-- 'AGlobal' 'TyThing', but also lexically scoped variables, etc.
-- See 'TcEnv' for how to retrieve a 'TyThing' given a 'Name'.
1055
data TcTyThing
1056
  = AGlobal TyThing             -- Used only in the return type of a lookup
1057

1058 1059 1060 1061
  | ATcId           -- Ids defined in this module; may not be fully zonked
      { tct_id   :: TcId
      , tct_info :: IdBindingInfo   -- See Note [Meaning of IdBindingInfo]
      }
1062

1063
  | ATyVar  Name TcTyVar   -- See Note [Type variables in the type environment]
1064

1065
  | ATcTyCon TyCon   -- Used temporarily, during kind checking, for the
1066
                     -- tycons and clases in this recursive group
1067 1068
                     -- The TyCon is always a TcTyCon.  Its kind
                     -- can be a mono-kind or a poly-kind; in TcTyClsDcls see
dreixel's avatar
dreixel committed
1069 1070
                     -- Note [Type checking recursive type and class declarations]

1071
  | APromotionErr PromotionErr
1072

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

  | FamDataConPE     -- Data constructor for a data family
1079 1080
                     -- See Note [AFamDataCon: not promoting data family constructors]
                     -- in TcEnv.
1081 1082 1083 1084
  | ConstrainedDataConPE PredType
                     -- Data constructor with a non-equality context
                     -- See Note [Don't promote data constructors with
                     --           non-equality contexts] in TcHsType
1085 1086
  | PatSynPE         -- Pattern synonyms
                     -- See Note [Don't promote pattern synonyms] in TcEnv
dreixel's avatar
dreixel committed
1087

Krzysztof Gogolewski's avatar
Krzysztof Gogolewski committed
1088
  | RecDataConPE     -- Data constructor in a recursive loop
1089
                     -- See Note [Recursion and promoting data constructors] in TcTyClsDecls
1090 1091
  | NoDataKindsTC    -- -XDataKinds not enabled (for a tycon)
  | NoDataKindsDC    -- -XDataKinds not enabled (for a datacon)
1092

1093
instance Outputable TcTyThing where     -- Debugging only
1094
   ppr (AGlobal g)      = ppr g
1095 1096
   ppr elt@(ATcId {})   = text "Identifier" <>
                          brackets (ppr (tct_id elt) <> dcolon
1097
                                 <> ppr (varType (tct_id elt)) <> comma
1098
                                 <+> ppr (tct_info elt))
1099
   ppr (ATyVar n tv)    = text "Type variable" <+> quotes (ppr n) <+> equals <+> ppr tv
1100
                            <+> dcolon <+> ppr (varType tv)
1101
   ppr (ATcTyCon tc)    = text "ATcTyCon" <+> ppr tc <+> dcolon <+> ppr (tyConKind tc)
1102 1103
   ppr (APromotionErr err) = text "APromotionErr" <+> ppr err

1104
-- | IdBindingInfo describes how an Id is bound.
1105 1106 1107
--
-- It is used for the following purposes:
-- a) for static forms in TcExpr.checkClosedInStaticForm and
1108 1109
-- b) to figure out when a nested binding can be generalised,
--    in TcBinds.decideGeneralisationPlan.
1110
--
1111
data IdBindingInfo -- See Note [Meaning of IdBindingInfo and ClosedTypeId]
1112 1113
    = NotLetBound
    | ClosedLet
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162
    | NonClosedLet
         RhsNames        -- Used for (static e) checks only
         ClosedTypeId    -- Used for generalisation checks
                         -- and for (static e) checks

-- | IsGroupClosed describes a group of mutually-recursive bindings
data IsGroupClosed
  = IsGroupClosed
      (NameEnv RhsNames)  -- Free var info for the RHS of each binding in the goup
                          -- Used only for (static e) checks

      ClosedTypeId        -- True <=> all the free vars of the group are
                          --          imported or ClosedLet or
                          --          NonClosedLet with ClosedTypeId=True.
                          --          In particular, no tyvars, no NotLetBound

type RhsNames = NameSet   -- Names of variables, mentioned on the RHS of
                          -- a definition, that are not Global or ClosedLet

type ClosedTypeId = Bool
  -- See Note [Meaning of IdBindingInfo and ClosedTypeId]

{- Note [Meaning of IdBindingInfo]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
NotLetBound means that
  the Id is not let-bound (e.g. it is bound in a
  lambda-abstraction or in a case pattern)

ClosedLet means that
   - The Id is let-bound,
   - Any free term variables are also Global or ClosedLet
   - Its type has no free variables (NB: a top-level binding subject
     to the MR might have free vars in its type)
   These ClosedLets can definitely be floated to top level; and we
   may need to do so for static forms.

   Property:   ClosedLet
             is equivalent to
               NonClosedLet emptyNameSet True

(NonClosedLet (fvs::RhsNames) (cl::ClosedTypeId)) means that
   - The Id is let-bound

   - The fvs::RhsNames contains the free names of the RHS,
     excluding Global and ClosedLet ones.

   - For the ClosedTypeId field see Note [Bindings with closed types]

For (static e) to be valid, we need for every 'x' free in 'e',
1163 1164
that x's binding is floatable to the top level.  Specifically:
   * x's RhsNames must be empty
1165 1166 1167 1168 1169 1170 1171 1172 1173
   * x's type has no free variables
See Note [Grand plan for static forms] in StaticPtrTable.hs.
This test is made in TcExpr.checkClosedInStaticForm.
Actually knowing x's RhsNames (rather than just its emptiness
or otherwise) is just so we can produce better error messages

Note [Bindings with closed types: ClosedTypeId]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
1174

1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
  f x = let g ys = map not ys
        in ...

Can we generalise 'g' under the OutsideIn algorithm?  Yes,
because all g's free variables are top-level; that is they themselves
have no free type variables, and it is the type variables in the
environment that makes things tricky for OutsideIn generalisation.

Here's the invariant:
   If an Id has ClosedTypeId=True (in its IdBindingInfo), then
   the Id's type is /definitely/ closed (has no free type variables).
   Specifically,
1187
       a) The Id's actual type is closed (has no free tyvars)
1188
       b) Either the Id has a (closed) user-supplied type signature
Gabor Greif's avatar
Gabor Greif committed
1189
          or all its free variables are Global/ClosedLet
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
             or NonClosedLet with ClosedTypeId=True.
          In particular, none are NotLetBound.

Why is (b) needed?   Consider
    \x. (x :: Int, let y = x+1 in ...)
Initially x::alpha.  If we happen to typecheck the 'let' before the
(x::Int), y's type will have a free tyvar; but if the other way round
it won't.  So we treat any let-bound variable with a free
non-let-bound variable as not ClosedTypeId, regardless of what the
free vars of its type actually are.

But if it has a signature, all is well:
   \x. ...(let { y::Int; y = x+1 } in
           let { v = y+2 } in ...)...
Here the signature on 'v' makes 'y' a ClosedTypeId, so we can
generalise 'v'.

Note that:

  * A top-level binding may not have ClosedTypeId=True, if it suffers
    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)...

Under OutsideIn we are free to generalise an Id all of whose free
variables have ClosedTypeId=True (or imported).  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.)
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268

Note [Type variables in the type environment]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The type environment has a binding for each lexically-scoped
type variable that is in scope.  For example

  f :: forall a. a -> a
  f x = (x :: a)

  g1 :: [a] -> a
  g1 (ys :: [b]) = head ys :: b

  g2 :: [Int] -> Int
  g2 (ys :: [c]) = head ys :: c

* The forall'd variable 'a' in the signature scopes over f's RHS.

* The pattern-bound type variable 'b' in 'g1' scopes over g1's
  RHS; note that it is bound to a skolem 'a' which is not itself
  lexically in scope.

* The pattern-bound type variable 'c' in 'g2' is bound to
  Int; that is, pattern-bound type variables can stand for
  arbitrary types. (see
    GHC proposal #128 "Allow ScopedTypeVariables to refer to types"
    https://github.com/ghc-proposals/ghc-proposals/pull/128,
  and the paper
    "Type variables in patterns", Haskell Symposium 2018.


This is implemented by the constructor
   ATyVar Name TcTyVar
in the type environment.

* The Name is the name of the original, lexically scoped type
  variable

* The TcTyVar is sometimes a skolem (like in 'f'), and sometimes
  a unification variable (like in 'g1', 'g2').  We never zonk the
  type environment so in the latter case it always stays as a
  unification variable, although that variable may be later
  unified with a type (such as Int in 'g2').
1269
-}
1270 1271 1272 1273 1274 1275 1276

instance Outputable IdBindingInfo where
  ppr NotLetBound = text "NotLetBound"
  ppr ClosedLet = text "TopLevelLet"
  ppr (NonClosedLet fvs closed_type) =
    text "TopLevelLet" <+> ppr fvs <+> ppr closed_type

1277
instance Outputable PromotionErr where
1278 1279 1280 1281 1282 1283 1284 1285 1286
  ppr ClassPE                     = text "ClassPE"
  ppr TyConPE                     = text "TyConPE"
  ppr PatSynPE                    = text "PatSynPE"
  ppr FamDataConPE                = text "FamDataConPE"
  ppr (ConstrainedDataConPE pred) = text "ConstrainedDataConPE"
                                      <+> parens (ppr pred)
  ppr RecDataConPE                = text "RecDataConPE"
  ppr NoDataKindsTC               = text "NoDataKindsTC"
  ppr NoDataKindsDC               = text "NoDataKindsDC"
1287 1288

pprTcTyThingCategory :: TcTyThing -> SDoc
1289
pprTcTyThingCategory (AGlobal thing)    = pprTyThingCategory thing
1290 1291 1292
pprTcTyThingCategory (ATyVar {})        = text "Type variable"
pprTcTyThingCategory (ATcId {})         = text "Local identifier"
pprTcTyThingCategory (ATcTyCon {})     = text "Local tycon"
1293 1294 1295
pprTcTyThingCategory (APromotionErr pe) = pprPECategory pe

pprPECategory :: PromotionErr -> SDoc
1296 1297 1298 1299 1300 1301 1302 1303
pprPECategory ClassPE                = text "Class"
pprPECategory TyConPE                = text "Type constructor"
pprPECategory PatSynPE               = text "Pattern synonym"
pprPECategory FamDataConPE           = text "Data constructor"
pprPECategory ConstrainedDataConPE{} = text "Data constructor"
pprPECategory RecDataConPE           = text "Data constructor"
pprPECategory NoDataKindsTC          = text "Type constructor"
pprPECategory NoDataKindsDC          = text "Data constructor"
1304

1305 1306 1307
{-
************************************************************************
*                                                                      *
1308
        Operations over ImportAvails
1309 1310 1311
*                                                                      *
************************************************************************
-}
1312

1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
-- | '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
--
1325
data ImportAvails
1326
   = ImportAvails {
1327
        imp_mods :: ImportedMods,
1328
          --      = ModuleEnv [ImportedModsVal],
1329
          -- ^ Domain is all directly-imported modules
1330
          --
Gabor Greif's avatar
Gabor Greif committed
1331
          -- See the documentation on ImportedModsVal in HscTypes for the
1332
          -- meaning of the fields.
1333
          --
1334 1335 1336 1337
          -- 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).
1338

1339
        imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface),
1340 1341 1342 1343 1344 1345 1346 1347 1348
          -- ^ 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.

1349
        imp_dep_pkgs :: Set InstalledUnitId,
1350 1351 1352
          -- ^ Packages needed by the module being compiled, whether directly,
          -- or via other modules in this package, or via modules imported
          -- from other packages.
1353

1354
        imp_trust_pkgs :: Set InstalledUnitId,
1355 1356 1357 1358
          -- ^ 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.
1359
          -- While perhaps making imp_dep_pkgs a tuple of (UnitId, Bool)
1360 1361 1362
          -- 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.
1363
          -- See Note [Tracking Trust Transitively] in GHC.Rename.Names
1364

1365 1366 1367 1368
        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.
1369
          -- See Note [Trust Own Package] in GHC.Rename.Names
1370 1371

        imp_orphs :: [Module],
1372 1373
          -- ^ Orphan modules below us in the import tree (and maybe including
          -- us for imported modules)
1374

1375
        imp_finsts :: [Module