{-
(c) The University of Glasgow 2006-2012
(c) The GRASP Project, Glasgow University, 1992-2002


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

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

{-# LANGUAGE CPP, DeriveFunctor, ExistentialQuantification, GeneralizedNewtypeDeriving,
             ViewPatterns #-}

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

        -- The environment types
        Env(..),
        TcGblEnv(..), TcLclEnv(..),
        setLclEnvTcLevel, getLclEnvTcLevel,
        setLclEnvLoc, getLclEnvLoc,
        IfGblEnv(..), IfLclEnv(..),
        tcVisibleOrphanMods,

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

        -- Renamer types
        ErrCtxt, RecFieldEnv, pushErrCtxt, pushErrCtxtSameOrigin,
        ImportAvails(..), emptyImportAvails, plusImportAvails,
        WhereFrom(..), mkModDeps, modDepsElts,

        -- Typechecker types
        TcTypeEnv, TcBinderStack, TcBinder(..),
        TcTyThing(..), PromotionErr(..),
        IdBindingInfo(..), ClosedTypeId, RhsNames,
        IsGroupClosed(..),
        SelfBootInfo(..),
        pprTcTyThingCategory, pprPECategory, CompleteMatch(..),

        -- Desugaring types
        DsM, DsLclEnv(..), DsGblEnv(..),
        DsMetaEnv, DsMetaVal(..), CompleteMatchMap,
        mkCompleteMatchMap, extendCompleteMatchMap,

        -- Template Haskell
        ThStage(..), SpliceType(..), PendingStuff(..),
        topStage, topAnnStage, topSpliceStage,
        ThLevel, impLevel, outerLevel, thLevel,
        ForeignSrcLang(..),

        -- Arrows
        ArrowCtxt(..),

        -- TcSigInfo
        TcSigFun, TcSigInfo(..), TcIdSigInfo(..),
        TcIdSigInst(..), TcPatSynInfo(..),
        isPartialSig, hasCompleteSig,

        -- Misc other types
        TcId, TcIdSet,
        Hole(..), holeOcc,
        NameShape(..),
        removeBindingShadowing,

        -- Constraint solver plugins
        TcPlugin(..), TcPluginResult(..), TcPluginSolver,
        TcPluginM, runTcPluginM, unsafeTcPluginTcM,
        getEvBindsTcPluginM,

        -- Role annotations
        RoleAnnotEnv, emptyRoleAnnotEnv, mkRoleAnnotEnv,
        lookupRoleAnnot, getRoleAnnots
  ) where

#include "GhclibHsVersions.h"

import GhcPrelude

import GHC.Hs
import HscTypes
import TcEvidence
import Type
import TyCon    ( TyCon, tyConKind )
import PatSyn   ( PatSyn )
import Id       ( idType, idName )
import FieldLabel ( FieldLabel )
import TcType
import Constraint
import TcOrigin
import Annotations
import InstEnv
import FamInstEnv
import {-# SOURCE #-} GHC.HsToCore.PmCheck.Types (Delta)
import IOEnv
import RdrName
import Name
import NameEnv
import NameSet
import Avail
import Var
import VarEnv
import Module
import SrcLoc
import VarSet
import ErrUtils
import UniqFM
import BasicTypes
import Bag
import DynFlags
import Outputable
import ListSetOps
import Fingerprint
import Util
import PrelNames ( isUnboundName )
import CostCentreState

import Control.Monad (ap)
import qualified Control.Monad.Fail as MonadFail
import Data.Set      ( Set )
import qualified Data.Set as S

import Data.List ( sort )
import Data.Map ( Map )
import Data.Dynamic  ( Dynamic )
import Data.Typeable ( TypeRep )
import Data.Maybe    ( mapMaybe )
import GHCi.Message
import GHCi.RemoteTypes

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

import qualified Language.Haskell.TH as TH

-- | A 'NameShape' is a substitution on 'Name's that can be used
-- to refine the identities of a hole while we are renaming interfaces
-- (see 'RnModIface').  Specifically, a 'NameShape' for
-- '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 {
        NameShape -> ModuleName
ns_mod_name :: ModuleName,
        NameShape -> [AvailInfo]
ns_exports :: [AvailInfo],
        NameShape -> OccEnv Name
ns_map :: OccEnv Name
    }


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

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

type TcRnIf a b = IOEnv (Env a b)
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.

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

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

-- We 'stack' these envs through the Reader like monad infrastructure
-- as we move into an expression (although the change is focused in
-- the lcl type).
data Env gbl lcl
  = Env {
        Env gbl lcl -> HscEnv
env_top  :: !HscEnv, -- Top-level stuff that never changes
                             -- Includes all info about imported things
                             -- BangPattern is to fix leak, see #15111

        Env gbl lcl -> Char
env_um   :: !Char,   -- Mask for Uniques

        Env gbl lcl -> gbl
env_gbl  :: gbl,     -- Info about things defined at the top level
                             -- of the module being compiled

        Env gbl lcl -> lcl
env_lcl  :: lcl      -- Nested stuff; changes as we go into
    }

instance ContainsDynFlags (Env gbl lcl) where
    extractDynFlags :: Env gbl lcl -> DynFlags
extractDynFlags Env gbl lcl
env = HscEnv -> DynFlags
hsc_dflags (Env gbl lcl -> HscEnv
forall gbl lcl. Env gbl lcl -> HscEnv
env_top Env gbl lcl
env)

instance ContainsModule gbl => ContainsModule (Env gbl lcl) where
    extractModule :: Env gbl lcl -> Module
extractModule Env gbl lcl
env = gbl -> Module
forall t. ContainsModule t => t -> Module
extractModule (Env gbl lcl -> gbl
forall gbl lcl. Env gbl lcl -> gbl
env_gbl Env gbl lcl
env)


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

data IfGblEnv
  = IfGblEnv {
        -- Some information about where this environment came from;
        -- useful for debugging.
        IfGblEnv -> SDoc
if_doc :: SDoc,
        -- 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.
        -- See Note [Tying the knot] in TcIface
        IfGblEnv -> Maybe (Module, IfG TypeEnv)
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
        -- NB: This is a semantic module, see
        -- Note [Identity versus semantic module]
        IfLclEnv -> Module
if_mod :: Module,

        -- Whether or not the IfaceDecl came from a boot
        -- file or not; we'll use this to choose between
        -- NoUnfolding and BootUnfolding
        IfLclEnv -> Bool
if_boot :: Bool,

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

        IfLclEnv -> Maybe NameShape
if_nsubst :: Maybe NameShape,

        -- This field is used to make sure "implicit" declarations
        -- (anything that cannot be exported in mi_exports) get
        -- wired up correctly in typecheckIfacesForMerging.  Most
        -- of the time it's @Nothing@.  See Note [Resolving never-exported Names in TcIface]
        -- in TcIface.
        IfLclEnv -> Maybe TypeEnv
if_implicits_env :: Maybe TypeEnv,

        IfLclEnv -> FastStringEnv TyVar
if_tv_env  :: FastStringEnv TyVar,     -- Nested tyvar bindings
        IfLclEnv -> FastStringEnv TyVar
if_id_env  :: FastStringEnv Id         -- Nested id binding
    }

{-
************************************************************************
*                                                                      *
                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
        { DsGblEnv -> Module
ds_mod          :: Module             -- For SCC profiling
        , DsGblEnv -> FamInstEnv
ds_fam_inst_env :: FamInstEnv         -- Like tcg_fam_inst_env
        , DsGblEnv -> PrintUnqualified
ds_unqual  :: PrintUnqualified
        , DsGblEnv -> IORef Messages
ds_msgs    :: IORef Messages          -- Warning messages
        , DsGblEnv -> (IfGblEnv, IfLclEnv)
ds_if_env  :: (IfGblEnv, IfLclEnv)    -- Used for looking up global,
                                                -- possibly-imported things
        , DsGblEnv -> CompleteMatchMap
ds_complete_matches :: CompleteMatchMap
           -- Additional complete pattern matches
        , DsGblEnv -> IORef CostCentreState
ds_cc_st   :: IORef CostCentreState
           -- Tracking indices for cost centre annotations
        }

instance ContainsModule DsGblEnv where
    extractModule :: DsGblEnv -> Module
extractModule = DsGblEnv -> Module
ds_mod

data DsLclEnv = DsLclEnv {
        DsLclEnv -> DsMetaEnv
dsl_meta    :: DsMetaEnv,        -- Template Haskell bindings
        DsLclEnv -> RealSrcSpan
dsl_loc     :: RealSrcSpan,      -- To put in pattern-matching error msgs

        -- See Note [Note [Type and Term Equality Propagation] in Check.hs
        -- The oracle state Delta is augmented as we walk inwards,
        -- through each pattern match in turn
        DsLclEnv -> Delta
dsl_delta   :: Delta
     }

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

   | DsSplice (HsExpr GhcTc) -- These bindings are introduced by
                             -- the PendingSplices on a HsBracketOut


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

-- | '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.
data FrontendResult
        = FrontendTypecheck TcGblEnv

-- 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.)
--
--        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
--
--      - For any code involving Names, we want semantic modules.
--        See lookupIfaceTop in IfaceEnv, mkIface and addFingerprints
--        in MkIface, and tcLookupGlobal in TcEnv
--
--      - 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
--        in the home library we are compiling.  (See LoadIface.)
--        Similarly, in RnNames we check for self-imports using
--        identity modules, to allow signatures to import their implementor.
--
--      - 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)

-- | 'TcGblEnv' describes the top-level of the module at the
-- point at which the typechecker is finished work.
-- It is this structure that is handed on to the desugarer
-- For state that needs to be updated during the typechecking
-- phase and returned at end, use a 'TcRef' (= 'IORef').
data TcGblEnv
  = TcGblEnv {
        TcGblEnv -> Module
tcg_mod     :: Module,         -- ^ Module being compiled
        TcGblEnv -> Module
tcg_semantic_mod :: Module,    -- ^ If a signature, the backing module
            -- See also Note [Identity versus semantic module]
        TcGblEnv -> HscSource
tcg_src     :: HscSource,
          -- ^ What kind of module (regular Haskell, hs-boot, hsig)

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

        TcGblEnv -> FixityEnv
tcg_fix_env   :: FixityEnv,     -- ^ Just for things in this module
        TcGblEnv -> RecFieldEnv
tcg_field_env :: RecFieldEnv,   -- ^ Just for things in this module
                                        -- See Note [The interactive package] in HscTypes

        TcGblEnv -> TypeEnv
tcg_type_env :: TypeEnv,
          -- ^ Global type env for the module we are compiling now.  All
          -- TyCons and Classes (for this module) end up in here right away,
          -- along with their derived constructors, selectors.
          --
          -- (Ids defined in this module start in the local envt, though they
          --  move to the global envt during zonking)
          --
          -- NB: for what "things in this module" means, see
          -- Note [The interactive package] in HscTypes

        TcGblEnv -> TcRef TypeEnv
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)

        TcGblEnv -> InstEnv
tcg_inst_env     :: !InstEnv,
          -- ^ Instance envt for all /home-package/ modules;
          -- Includes the dfuns in tcg_insts
          -- NB. BangPattern is to fix a leak, see #15111
        TcGblEnv -> FamInstEnv
tcg_fam_inst_env :: !FamInstEnv, -- ^ Ditto for family instances
          -- NB. BangPattern is to fix a leak, see #15111
        TcGblEnv -> AnnEnv
tcg_ann_env      :: AnnEnv,     -- ^ And for annotations

                -- 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.
        TcGblEnv -> [AvailInfo]
tcg_exports :: [AvailInfo],     -- ^ What is exported
        TcGblEnv -> ImportAvails
tcg_imports :: ImportAvails,
          -- ^ Information about what was imported from where, including
          -- things bound in this module. Also store Safe Haskell info
          -- 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)

          -- These three fields track unused bindings and imports
          -- See Note [Tracking unused binding and imports]
        TcGblEnv -> DefUses
tcg_dus       :: DefUses,
        TcGblEnv -> TcRef [GlobalRdrElt]
tcg_used_gres :: TcRef [GlobalRdrElt],
        TcGblEnv -> TcRef NameSet
tcg_keep      :: TcRef NameSet,

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

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

        TcGblEnv -> TcRef (Set RealSrcSpan)
tcg_th_top_level_locs :: TcRef (Set RealSrcSpan),
          -- ^ Locations of the top-level splices; used for providing details on
          -- scope in error messages for out-of-scope variables

        TcGblEnv -> TcRef OccSet
tcg_dfun_n  :: TcRef OccSet,
          -- ^ Allows us to choose unique DFun names.

        TcGblEnv -> [(Module, Fingerprint)]
tcg_merged :: [(Module, Fingerprint)],
          -- ^ The requirements we merged with; we always have to recompile
          -- if any of these changed.

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

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

        TcGblEnv -> [LImportDecl GhcRn]
tcg_rn_imports :: [LImportDecl GhcRn],
                -- Keep the renamed imports regardless.  They are not
                -- voluminous and are needed if you want to report unused imports

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

        TcGblEnv -> TcRef [FilePath]
tcg_dependent_files :: TcRef [FilePath], -- ^ dependencies from addDependentFile

        TcGblEnv -> TcRef [LHsDecl GhcPs]
tcg_th_topdecls :: TcRef [LHsDecl GhcPs],
        -- ^ Top-level declarations from addTopDecls

        TcGblEnv -> TcRef [(ForeignSrcLang, FilePath)]
tcg_th_foreign_files :: TcRef [(ForeignSrcLang, FilePath)],
        -- ^ Foreign files emitted from TH.

        TcGblEnv -> TcRef NameSet
tcg_th_topnames :: TcRef NameSet,
        -- ^ Exact names bound in top-level declarations in tcg_th_topdecls

        TcGblEnv -> TcRef [(TcLclEnv, ThModFinalizers)]
tcg_th_modfinalizers :: TcRef [(TcLclEnv, ThModFinalizers)],
        -- ^ Template Haskell module finalizers.
        --
        -- They can use particular local environments.

        TcGblEnv -> TcRef [FilePath]
tcg_th_coreplugins :: TcRef [String],
        -- ^ Core plugins added by Template Haskell code.

        TcGblEnv -> TcRef (Map TypeRep Dynamic)
tcg_th_state :: TcRef (Map TypeRep Dynamic),
        TcGblEnv -> TcRef (Maybe (ForeignRef (IORef QState)))
tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState))),
        -- ^ Template Haskell state

        TcGblEnv -> Bag EvBind
tcg_ev_binds  :: Bag EvBind,        -- Top-level evidence bindings

        -- 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
        TcGblEnv -> Maybe TyVar
tcg_tr_module :: Maybe Id,   -- Id for $trModule :: GHC.Types.Module
                                             -- for which every module has a top-level defn
                                             -- except in GHCi in which case we have Nothing
        TcGblEnv -> LHsBinds GhcTc
tcg_binds     :: LHsBinds GhcTc,     -- Value bindings in this module
        TcGblEnv -> NameSet
tcg_sigs      :: NameSet,            -- ...Top-level names that *lack* a signature
        TcGblEnv -> [LTcSpecPrag]
tcg_imp_specs :: [LTcSpecPrag],      -- ...SPECIALISE prags for imported Ids
        TcGblEnv -> Warnings
tcg_warns     :: Warnings,           -- ...Warnings and deprecations
        TcGblEnv -> [Annotation]
tcg_anns      :: [Annotation],       -- ...Annotations
        TcGblEnv -> [TyCon]
tcg_tcs       :: [TyCon],            -- ...TyCons and Classes
        TcGblEnv -> [ClsInst]
tcg_insts     :: [ClsInst],          -- ...Instances
        TcGblEnv -> [FamInst]
tcg_fam_insts :: [FamInst],          -- ...Family instances
        TcGblEnv -> [LRuleDecl GhcTc]
tcg_rules     :: [LRuleDecl GhcTc],  -- ...Rules
        TcGblEnv -> [LForeignDecl GhcTc]
tcg_fords     :: [LForeignDecl GhcTc], -- ...Foreign import & exports
        TcGblEnv -> [PatSyn]
tcg_patsyns   :: [PatSyn],            -- ...Pattern synonyms

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

        TcGblEnv -> SelfBootInfo
tcg_self_boot :: SelfBootInfo,       -- ^ Whether this module has a
                                             -- corresponding hi-boot file

        TcGblEnv -> Maybe Name
tcg_main      :: Maybe Name,         -- ^ The Name of the main
                                             -- function, if this module is
                                             -- the main module.

        TcGblEnv -> TcRef (Bool, WarningMessages)
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.

        TcGblEnv -> [TcPluginSolver]
tcg_tc_plugins :: [TcPluginSolver],
        -- ^ A list of user-defined plugins for the constraint solver.
        TcGblEnv -> [HoleFitPlugin]
tcg_hf_plugins :: [HoleFitPlugin],
        -- ^ A list of user-defined plugins for hole fit suggestions.

        TcGblEnv -> RealSrcSpan
tcg_top_loc :: RealSrcSpan,
        -- ^ The RealSrcSpan this module came from

        TcGblEnv -> TcRef WantedConstraints
tcg_static_wc :: TcRef WantedConstraints,
          -- ^ Wanted constraints of static forms.
        -- See Note [Constraints in static forms].
        TcGblEnv -> [CompleteMatch]
tcg_complete_matches :: [CompleteMatch],

        -- ^ Tracking indices for cost centre annotations
        TcGblEnv -> IORef CostCentreState
tcg_cc_st   :: TcRef CostCentreState
    }

-- NB: topModIdentity, not topModSemantic!
-- Definition sites of orphan identities will be identity modules, not semantic
-- modules.

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

tcVisibleOrphanMods :: TcGblEnv -> ModuleSet
tcVisibleOrphanMods :: TcGblEnv -> ModuleSet
tcVisibleOrphanMods TcGblEnv
tcg_env
    = [Module] -> ModuleSet
mkModuleSet (TcGblEnv -> Module
tcg_mod TcGblEnv
tcg_env Module -> [Module] -> [Module]
forall a. a -> [a] -> [a]
: ImportAvails -> [Module]
imp_orphs (TcGblEnv -> ImportAvails
tcg_imports TcGblEnv
tcg_env))

instance ContainsModule TcGblEnv where
    extractModule :: TcGblEnv -> Module
extractModule TcGblEnv
env = TcGblEnv -> Module
tcg_semantic_mod TcGblEnv
env

type RecFieldEnv = NameEnv [FieldLabel]
        -- Maps a constructor name *in this module*
        -- to the fields for that constructor.
        -- 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

data SelfBootInfo
  = NoSelfBoot    -- No corresponding hi-boot file
  | SelfBoot
       { SelfBootInfo -> ModDetails
sb_mds :: ModDetails   -- There was a hi-boot file,
       , SelfBootInfo -> NameSet
sb_tcs :: NameSet }    -- defining these TyCons,
-- What is sb_tcs used for?  See Note [Extra dependencies from .hs-boot files]
-- in RnSource


{- Note [Tracking unused binding and imports]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We gather three sorts of usage information

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

      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)
   This usage info is mainly gathered by the renamer's
   gathering of free-variables

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

      Used only to report unused import declarations

      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.

  * 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]
          in RnSplice

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

      * RnNames.reportUnusedNames.  Where newtype data constructors like (d)
        are imported, we don't want to report them as unused.


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

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

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

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

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

        TcLclEnv -> ThStage
tcl_th_ctxt    :: ThStage,         -- Template Haskell context
        TcLclEnv -> ThBindEnv
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

        TcLclEnv -> ArrowCtxt
tcl_arrow_ctxt :: ArrowCtxt,       -- Arrow-notation context

        TcLclEnv -> LocalRdrEnv
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 constructor (Name.TvOcc)
                -- We still need the unsullied global name env so that
                --   we can look up record field names

        TcLclEnv -> TcTypeEnv
tcl_env  :: TcTypeEnv,    -- The local type environment:
                                  -- Ids and TyVars defined in this module

        TcLclEnv -> TcBinderStack
tcl_bndrs :: TcBinderStack,   -- Used for reporting relevant bindings,
                                      -- and for tidying types

        TcLclEnv -> TcRef WantedConstraints
tcl_lie  :: TcRef WantedConstraints,    -- Place to accumulate type constraints
        TcLclEnv -> IORef Messages
tcl_errs :: TcRef Messages              -- Place to accumulate errors
    }

setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv
setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv
setLclEnvTcLevel TcLclEnv
env TcLevel
lvl = TcLclEnv
env { tcl_tclvl :: TcLevel
tcl_tclvl = TcLevel
lvl }

getLclEnvTcLevel :: TcLclEnv -> TcLevel
getLclEnvTcLevel :: TcLclEnv -> TcLevel
getLclEnvTcLevel = TcLclEnv -> TcLevel
tcl_tclvl

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

getLclEnvLoc :: TcLclEnv -> RealSrcSpan
getLclEnvLoc :: TcLclEnv -> RealSrcSpan
getLclEnvLoc = TcLclEnv -> RealSrcSpan
tcl_loc

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

-- 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 :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc
pushErrCtxt CtOrigin
o ErrCtxt
err loc :: CtLoc
loc@(CtLoc { ctl_env :: CtLoc -> TcLclEnv
ctl_env = TcLclEnv
lcl })
  = CtLoc
loc { ctl_origin :: CtOrigin
ctl_origin = CtOrigin
o, ctl_env :: TcLclEnv
ctl_env = TcLclEnv
lcl { tcl_ctxt :: [ErrCtxt]
tcl_ctxt = ErrCtxt
err ErrCtxt -> [ErrCtxt] -> [ErrCtxt]
forall a. a -> [a] -> [a]
: TcLclEnv -> [ErrCtxt]
tcl_ctxt TcLclEnv
lcl } }

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

type TcTypeEnv = NameEnv TcTyThing

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

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

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

-}

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

---------------------------
-- The TcBinderStack
---------------------------

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
   -- We can't use the tcl_env type environment, because it doesn't
   --   keep track of the nesting order

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

  | TcIdBndr_ExpType  -- Variant that allows the type to be specified as
                      -- an ExpType
       Name
       ExpType
       TopLevelFlag

  | 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
   ppr :: TcBinder -> SDoc
ppr (TcIdBndr TyVar
id TopLevelFlag
top_lvl)           = TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
id SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
brackets (TopLevelFlag -> SDoc
forall a. Outputable a => a -> SDoc
ppr TopLevelFlag
top_lvl)
   ppr (TcIdBndr_ExpType Name
id ExpType
_ TopLevelFlag
top_lvl) = Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
id SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
brackets (TopLevelFlag -> SDoc
forall a. Outputable a => a -> SDoc
ppr TopLevelFlag
top_lvl)
   ppr (TcTvBndr Name
name TyVar
tv)              = Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
<+> TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
tv

instance HasOccName TcBinder where
    occName :: TcBinder -> OccName
occName (TcIdBndr TyVar
id TopLevelFlag
_)             = Name -> OccName
forall name. HasOccName name => name -> OccName
occName (TyVar -> Name
idName TyVar
id)
    occName (TcIdBndr_ExpType Name
name ExpType
_ TopLevelFlag
_) = Name -> OccName
forall name. HasOccName name => name -> OccName
occName Name
name
    occName (TcTvBndr Name
name TyVar
_)           = Name -> OccName
forall name. HasOccName name => name -> OccName
occName Name
name

-- 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 :: [a] -> [a]
removeBindingShadowing [a]
bindings = [a] -> [a]
forall a. [a] -> [a]
reverse ([a] -> [a]) -> [a] -> [a]
forall a b. (a -> b) -> a -> b
$ ([a], OccSet) -> [a]
forall a b. (a, b) -> a
fst (([a], OccSet) -> [a]) -> ([a], OccSet) -> [a]
forall a b. (a -> b) -> a -> b
$ (([a], OccSet) -> a -> ([a], OccSet))
-> ([a], OccSet) -> [a] -> ([a], OccSet)
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl
    (\([a]
bindingAcc, OccSet
seenNames) a
binding ->
    if a -> OccName
forall name. HasOccName name => name -> OccName
occName a
binding OccName -> OccSet -> Bool
`elemOccSet` OccSet
seenNames -- if we've seen it
        then ([a]
bindingAcc, OccSet
seenNames)              -- skip it
        else (a
bindinga -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
bindingAcc, OccSet -> OccName -> OccSet
extendOccSet OccSet
seenNames (a -> OccName
forall name. HasOccName name => name -> OccName
occName a
binding)))
    ([], OccSet
emptyOccSet) [a]
bindings

---------------------------
-- Template Haskell stages and levels
---------------------------

data SpliceType = Typed | Untyped

data ThStage    -- See Note [Template Haskell state diagram] in TcSplice
  = Splice SpliceType -- Inside a top-level splice
                      -- This code will be run *at compile time*;
                      --   the result replaces the splice
                      -- Binding level = 0

  | 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
      -- [Delaying modFinalizers in untyped splices] in "RnSplice".
      --
      -- 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".

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

  | Brack                       -- Inside brackets
      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

  | TcPending                     -- Typechecking the inside of a typed bracket
      (TcRef [PendingTcSplice])   --   Accumulate pending splices here
      (TcRef WantedConstraints)   --     and type constraints here

topStage, topAnnStage, topSpliceStage :: ThStage
topStage :: ThStage
topStage       = ThStage
Comp
topAnnStage :: ThStage
topAnnStage    = SpliceType -> ThStage
Splice SpliceType
Untyped
topSpliceStage :: ThStage
topSpliceStage = SpliceType -> ThStage
Splice SpliceType
Untyped

instance Outputable ThStage where
   ppr :: ThStage -> SDoc
ppr (Splice SpliceType
_)    = FilePath -> SDoc
text FilePath
"Splice"
   ppr (RunSplice TcRef [ForeignRef (Q ())]
_) = FilePath -> SDoc
text FilePath
"RunSplice"
   ppr ThStage
Comp          = FilePath -> SDoc
text FilePath
"Comp"
   ppr (Brack ThStage
s PendingStuff
_)   = FilePath -> SDoc
text FilePath
"Brack" SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
parens (ThStage -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThStage
s)

type ThLevel = Int
    -- 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

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

thLevel :: ThStage -> ThLevel
thLevel :: ThStage -> ThLevel
thLevel (Splice SpliceType
_)    = ThLevel
0
thLevel (RunSplice TcRef [ForeignRef (Q ())]
_) =
    -- See Note [RunSplice ThLevel].
    FilePath -> ThLevel
forall a. FilePath -> a
panic FilePath
"thLevel: called when running a splice"
thLevel ThStage
Comp          = ThLevel
1
thLevel (Brack ThStage
s PendingStuff
_)   = ThStage -> ThLevel
thLevel ThStage
s ThLevel -> ThLevel -> ThLevel
forall a. Num a => a -> a -> a
+ ThLevel
1

{- 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
set 'RunSplice' when renaming or typechecking the splice, where 'Splice',
'Brack' or 'Comp' are used instead.

-}

---------------------------
-- Arrow-notation context
---------------------------

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

        proc x -> (e1 -< e2)

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

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

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

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

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

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


---------------------------
-- TcTyThing
---------------------------

-- | 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'.
data TcTyThing
  = AGlobal TyThing             -- Used only in the return type of a lookup

  | ATcId           -- Ids defined in this module; may not be fully zonked
      { TcTyThing -> TyVar
tct_id   :: TcId
      , TcTyThing -> IdBindingInfo
tct_info :: IdBindingInfo   -- See Note [Meaning of IdBindingInfo]
      }

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

  | ATcTyCon TyCon   -- Used temporarily, during kind checking, for the
                     -- tycons and clases in this recursive group
                     -- The TyCon is always a TcTyCon.  Its kind
                     -- can be a mono-kind or a poly-kind; in TcTyClsDcls see
                     -- Note [Type checking recursive type and class declarations]

  | APromotionErr PromotionErr

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

  | FamDataConPE     -- Data constructor for a data family
                     -- See Note [AFamDataCon: not promoting data family constructors]
                     -- in TcEnv.
  | ConstrainedDataConPE PredType
                     -- Data constructor with a non-equality context
                     -- See Note [Don't promote data constructors with
                     --           non-equality contexts] in TcHsType
  | PatSynPE         -- Pattern synonyms
                     -- See Note [Don't promote pattern synonyms] in TcEnv

  | RecDataConPE     -- Data constructor in a recursive loop
                     -- See Note [Recursion and promoting data constructors] in TcTyClsDecls
  | NoDataKindsTC    -- -XDataKinds not enabled (for a tycon)
  | NoDataKindsDC    -- -XDataKinds not enabled (for a datacon)

instance Outputable TcTyThing where     -- Debugging only
   ppr :: TcTyThing -> SDoc
ppr (AGlobal TyThing
g)      = TyThing -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyThing
g
   ppr elt :: TcTyThing
elt@(ATcId {})   = FilePath -> SDoc
text FilePath
"Identifier" SDoc -> SDoc -> SDoc
<>
                          SDoc -> SDoc
brackets (TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcTyThing -> TyVar
tct_id TcTyThing
elt) SDoc -> SDoc -> SDoc
<> SDoc
dcolon
                                 SDoc -> SDoc -> SDoc
<> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyVar -> Type
varType (TcTyThing -> TyVar
tct_id TcTyThing
elt)) SDoc -> SDoc -> SDoc
<> SDoc
comma
                                 SDoc -> SDoc -> SDoc
<+> IdBindingInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TcTyThing -> IdBindingInfo
tct_info TcTyThing
elt))
   ppr (ATyVar Name
n TyVar
tv)    = FilePath -> SDoc
text FilePath
"Type variable" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
n) SDoc -> SDoc -> SDoc
<+> SDoc
equals SDoc -> SDoc -> SDoc
<+> TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
tv
                            SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyVar -> Type
varType TyVar
tv)
   ppr (ATcTyCon TyCon
tc)    = FilePath -> SDoc
text FilePath
"ATcTyCon" SDoc -> SDoc -> SDoc
<+> TyCon -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyCon
tc SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyCon -> Type
tyConKind TyCon
tc)
   ppr (APromotionErr PromotionErr
err) = FilePath -> SDoc
text FilePath
"APromotionErr" SDoc -> SDoc -> SDoc
<+> PromotionErr -> SDoc
forall a. Outputable a => a -> SDoc
ppr PromotionErr
err

-- | IdBindingInfo describes how an Id is bound.
--
-- It is used for the following purposes:
-- a) for static forms in TcExpr.checkClosedInStaticForm and
-- b) to figure out when a nested binding can be generalised,
--    in TcBinds.decideGeneralisationPlan.
--
data IdBindingInfo -- See Note [Meaning of IdBindingInfo and ClosedTypeId]
    = NotLetBound
    | ClosedLet
    | 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',
that x's binding is floatable to the top level.  Specifically:
   * x's RhsNames must be empty
   * 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

  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,
       a) The Id's acutal type is closed (has no free tyvars)
       b) Either the Id has a (closed) user-supplied type signature
          or all its free variables are Global/ClosedLet
             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.)

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').
-}

instance Outputable IdBindingInfo where
  ppr :: IdBindingInfo -> SDoc
ppr IdBindingInfo
NotLetBound = FilePath -> SDoc
text FilePath
"NotLetBound"
  ppr IdBindingInfo
ClosedLet = FilePath -> SDoc
text FilePath
"TopLevelLet"
  ppr (NonClosedLet NameSet
fvs Bool
closed_type) =
    FilePath -> SDoc
text FilePath
"TopLevelLet" SDoc -> SDoc -> SDoc
<+> NameSet -> SDoc
forall a. Outputable a => a -> SDoc
ppr NameSet
fvs SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
closed_type

instance Outputable PromotionErr where
  ppr :: PromotionErr -> SDoc
ppr PromotionErr
ClassPE                     = FilePath -> SDoc
text FilePath
"ClassPE"
  ppr PromotionErr
TyConPE                     = FilePath -> SDoc
text FilePath
"TyConPE"
  ppr PromotionErr
PatSynPE                    = FilePath -> SDoc
text FilePath
"PatSynPE"
  ppr PromotionErr
FamDataConPE                = FilePath -> SDoc
text FilePath
"FamDataConPE"
  ppr (ConstrainedDataConPE Type
pred) = FilePath -> SDoc
text FilePath
"ConstrainedDataConPE"
                                      SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
parens (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
pred)
  ppr PromotionErr
RecDataConPE                = FilePath -> SDoc
text FilePath
"RecDataConPE"
  ppr PromotionErr
NoDataKindsTC               = FilePath -> SDoc
text FilePath
"NoDataKindsTC"
  ppr PromotionErr
NoDataKindsDC               = FilePath -> SDoc
text FilePath
"NoDataKindsDC"

pprTcTyThingCategory :: TcTyThing -> SDoc
pprTcTyThingCategory :: TcTyThing -> SDoc
pprTcTyThingCategory (AGlobal TyThing
thing)    = TyThing -> SDoc
pprTyThingCategory TyThing
thing
pprTcTyThingCategory (ATyVar {})        = FilePath -> SDoc
text FilePath
"Type variable"
pprTcTyThingCategory (ATcId {})         = FilePath -> SDoc
text FilePath
"Local identifier"
pprTcTyThingCategory (ATcTyCon {})     = FilePath -> SDoc
text FilePath
"Local tycon"
pprTcTyThingCategory (APromotionErr PromotionErr
pe) = PromotionErr -> SDoc
pprPECategory PromotionErr
pe

pprPECategory :: PromotionErr -> SDoc
pprPECategory :: PromotionErr -> SDoc
pprPECategory PromotionErr
ClassPE                = FilePath -> SDoc
text FilePath
"Class"
pprPECategory PromotionErr
TyConPE                = FilePath -> SDoc
text FilePath
"Type constructor"
pprPECategory PromotionErr
PatSynPE               = FilePath -> SDoc
text FilePath
"Pattern synonym"
pprPECategory PromotionErr
FamDataConPE           = FilePath -> SDoc
text FilePath
"Data constructor"
pprPECategory ConstrainedDataConPE{} = FilePath -> SDoc
text FilePath
"Data constructor"
pprPECategory PromotionErr
RecDataConPE           = FilePath -> SDoc
text FilePath
"Data constructor"
pprPECategory PromotionErr
NoDataKindsTC          = FilePath -> SDoc
text FilePath
"Type constructor"
pprPECategory PromotionErr
NoDataKindsDC          = FilePath -> SDoc
text FilePath
"Data constructor"

{-
************************************************************************
*                                                                      *
        Operations over ImportAvails
*                                                                      *
************************************************************************
-}

-- | '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
--
data ImportAvails
   = ImportAvails {
        ImportAvails -> ImportedMods
imp_mods :: ImportedMods,
          --      = ModuleEnv [ImportedModsVal],
          -- ^ Domain is all directly-imported modules
          --
          -- See the documentation on ImportedModsVal in HscTypes for the
          -- meaning of the fields.
          --
          -- 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).

        ImportAvails -> ModuleNameEnv (ModuleName, Bool)
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.

        ImportAvails -> Set InstalledUnitId
imp_dep_pkgs :: Set InstalledUnitId,
          -- ^ Packages needed by the module being compiled, whether directly,
          -- or via other modules in this package, or via modules imported
          -- from other packages.

        ImportAvails -> Set InstalledUnitId
imp_trust_pkgs :: Set InstalledUnitId,
          -- ^ 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 (UnitId, 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.
          -- See Note [RnNames . Tracking Trust Transitively]

        ImportAvails -> Bool
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]

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

        ImportAvails -> [Module]
imp_finsts :: [Module]
          -- ^ Family instance modules below us in the import tree (and maybe
          -- including us for imported modules)
      }

mkModDeps :: [(ModuleName, IsBootInterface)]
          -> ModuleNameEnv (ModuleName, IsBootInterface)
mkModDeps :: [(ModuleName, Bool)] -> ModuleNameEnv (ModuleName, Bool)
mkModDeps [(ModuleName, Bool)]
deps = (ModuleNameEnv (ModuleName, Bool)
 -> (ModuleName, Bool) -> ModuleNameEnv (ModuleName, Bool))
-> ModuleNameEnv (ModuleName, Bool)
-> [(ModuleName, Bool)]
-> ModuleNameEnv (ModuleName, Bool)
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' ModuleNameEnv (ModuleName, Bool)
-> (ModuleName, Bool) -> ModuleNameEnv (ModuleName, Bool)
forall key b.
Uniquable key =>
UniqFM (key, b) -> (key, b) -> UniqFM (key, b)
add ModuleNameEnv (ModuleName, Bool)
forall elt. UniqFM elt
emptyUFM [(ModuleName, Bool)]
deps
               where
                 add :: UniqFM (key, b) -> (key, b) -> UniqFM (key, b)
add UniqFM (key, b)
env elt :: (key, b)
elt@(key
m,b
_) = UniqFM (key, b) -> key -> (key, b) -> UniqFM (key, b)
forall key elt.
Uniquable key =>
UniqFM elt -> key -> elt -> UniqFM elt
addToUFM UniqFM (key, b)
env key
m (key, b)
elt

modDepsElts
  :: ModuleNameEnv (ModuleName, IsBootInterface)
  -> [(ModuleName, IsBootInterface)]
modDepsElts :: ModuleNameEnv (ModuleName, Bool) -> [(ModuleName, Bool)]
modDepsElts = [(ModuleName, Bool)] -> [(ModuleName, Bool)]
forall a. Ord a => [a] -> [a]
sort ([(ModuleName, Bool)] -> [(ModuleName, Bool)])
-> (ModuleNameEnv (ModuleName, Bool) -> [(ModuleName, Bool)])
-> ModuleNameEnv (ModuleName, Bool)
-> [(ModuleName, Bool)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModuleNameEnv (ModuleName, Bool) -> [(ModuleName, Bool)]
forall elt. UniqFM elt -> [elt]
nonDetEltsUFM
  -- It's OK to use nonDetEltsUFM here because sorting by module names
  -- restores determinism

emptyImportAvails :: ImportAvails
emptyImportAvails :: ImportAvails
emptyImportAvails = ImportAvails :: ImportedMods
-> ModuleNameEnv (ModuleName, Bool)
-> Set InstalledUnitId
-> Set InstalledUnitId
-> Bool
-> [Module]
-> [Module]
-> ImportAvails
ImportAvails { imp_mods :: ImportedMods
imp_mods          = ImportedMods
forall a. ModuleEnv a
emptyModuleEnv,
                                   imp_dep_mods :: ModuleNameEnv (ModuleName, Bool)
imp_dep_mods      = ModuleNameEnv (ModuleName, Bool)
forall elt. UniqFM elt
emptyUFM,
                                   imp_dep_pkgs :: Set InstalledUnitId
imp_dep_pkgs      = Set InstalledUnitId
forall a. Set a
S.empty,
                                   imp_trust_pkgs :: Set InstalledUnitId
imp_trust_pkgs    = Set InstalledUnitId
forall a. Set a
S.empty,
                                   imp_trust_own_pkg :: Bool
imp_trust_own_pkg = Bool
False,
                                   imp_orphs :: [Module]
imp_orphs         = [],
                                   imp_finsts :: [Module]
imp_finsts        = [] }

-- | Union two ImportAvails
--
-- This function is a key part of Import handling, basically
-- for each import we create a separate ImportAvails structure
-- and then union them all together with this function.
plusImportAvails ::  ImportAvails ->  ImportAvails ->  ImportAvails
plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails
plusImportAvails
  (ImportAvails { imp_mods :: ImportAvails -> ImportedMods
imp_mods = ImportedMods
mods1,
                  imp_dep_mods :: ImportAvails -> ModuleNameEnv (ModuleName, Bool)
imp_dep_mods = ModuleNameEnv (ModuleName, Bool)
dmods1, imp_dep_pkgs :: ImportAvails -> Set InstalledUnitId
imp_dep_pkgs = Set InstalledUnitId
dpkgs1,
                  imp_trust_pkgs :: ImportAvails -> Set InstalledUnitId
imp_trust_pkgs = Set InstalledUnitId
tpkgs1, imp_trust_own_pkg :: ImportAvails -> Bool
imp_trust_own_pkg = Bool
tself1,
                  imp_orphs :: ImportAvails -> [Module]
imp_orphs = [Module]
orphs1, imp_finsts :: ImportAvails -> [Module]
imp_finsts = [Module]
finsts1 })
  (ImportAvails { imp_mods :: ImportAvails -> ImportedMods
imp_mods = ImportedMods
mods2,
                  imp_dep_mods :: ImportAvails -> ModuleNameEnv (ModuleName, Bool)
imp_dep_mods = ModuleNameEnv (ModuleName, Bool)
dmods2, imp_dep_pkgs :: ImportAvails -> Set InstalledUnitId
imp_dep_pkgs = Set InstalledUnitId
dpkgs2,
                  imp_trust_pkgs :: ImportAvails -> Set InstalledUnitId
imp_trust_pkgs = Set InstalledUnitId
tpkgs2, imp_trust_own_pkg :: ImportAvails -> Bool
imp_trust_own_pkg = Bool
tself2,
                  imp_orphs :: ImportAvails -> [Module]
imp_orphs = [Module]
orphs2, imp_finsts :: ImportAvails -> [Module]
imp_finsts = [Module]
finsts2 })
  = ImportAvails :: ImportedMods
-> ModuleNameEnv (ModuleName, Bool)
-> Set InstalledUnitId
-> Set InstalledUnitId
-> Bool
-> [Module]
-> [Module]
-> ImportAvails
ImportAvails { imp_mods :: ImportedMods
imp_mods          = ([ImportedBy] -> [ImportedBy] -> [ImportedBy])
-> ImportedMods -> ImportedMods -> ImportedMods
forall a.
(a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
plusModuleEnv_C [ImportedBy] -> [ImportedBy] -> [ImportedBy]
forall a. [a] -> [a] -> [a]
(++) ImportedMods
mods1 ImportedMods
mods2,
                   imp_dep_mods :: ModuleNameEnv (ModuleName, Bool)
imp_dep_mods      = ((ModuleName, Bool) -> (ModuleName, Bool) -> (ModuleName, Bool))
-> ModuleNameEnv (ModuleName, Bool)
-> ModuleNameEnv (ModuleName, Bool)
-> ModuleNameEnv (ModuleName, Bool)
forall elt.
(elt -> elt -> elt) -> UniqFM elt -> UniqFM elt -> UniqFM elt
plusUFM_C (ModuleName, Bool) -> (ModuleName, Bool) -> (ModuleName, Bool)
forall a.
(Eq a, Outputable a) =>
(a, Bool) -> (a, Bool) -> (a, Bool)
plus_mod_dep ModuleNameEnv (ModuleName, Bool)
dmods1 ModuleNameEnv (ModuleName, Bool)
dmods2,
                   imp_dep_pkgs :: Set InstalledUnitId
imp_dep_pkgs      = Set InstalledUnitId
dpkgs1 Set InstalledUnitId -> Set InstalledUnitId -> Set InstalledUnitId
forall a. Ord a => Set a -> Set a -> Set a
`S.union` Set InstalledUnitId
dpkgs2,
                   imp_trust_pkgs :: Set InstalledUnitId
imp_trust_pkgs    = Set InstalledUnitId
tpkgs1 Set InstalledUnitId -> Set InstalledUnitId -> Set InstalledUnitId
forall a. Ord a => Set a -> Set a -> Set a
`S.union` Set InstalledUnitId
tpkgs2,
                   imp_trust_own_pkg :: Bool
imp_trust_own_pkg = Bool
tself1 Bool -> Bool -> Bool
|| Bool
tself2,
                   imp_orphs :: [Module]
imp_orphs         = [Module]
orphs1 [Module] -> [Module] -> [Module]
forall a.
(HasDebugCallStack, Outputable a, Eq a) =>
[a] -> [a] -> [a]
`unionLists` [Module]
orphs2,
                   imp_finsts :: [Module]
imp_finsts        = [Module]
finsts1 [Module] -> [Module] -> [Module]
forall a.
(HasDebugCallStack, Outputable a, Eq a) =>
[a] -> [a] -> [a]
`unionLists` [Module]
finsts2 }
  where
    plus_mod_dep :: (a, Bool) -> (a, Bool) -> (a, Bool)
plus_mod_dep r1 :: (a, Bool)
r1@(a
m1, Bool
boot1) r2 :: (a, Bool)
r2@(a
m2, Bool
boot2)
      | ASSERT2( m1 == m2, (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )
        Bool
boot1 = (a, Bool)
r2
      | Bool
otherwise = (a, Bool)
r1
      -- If either side can "see" a non-hi-boot interface, use that
      -- Reusing existing tuples saves 10% of allocations on test
      -- perf/compiler/MultiLayerModules

{-
************************************************************************
*                                                                      *
\subsection{Where from}
*                                                                      *
************************************************************************

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

data WhereFrom
  = ImportByUser IsBootInterface        -- Ordinary user import (perhaps {-# SOURCE #-})
  | ImportBySystem                      -- Non user import.
  | ImportByPlugin                      -- Importing a plugin;
                                        -- See Note [Care with plugin imports] in LoadIface

instance Outputable WhereFrom where
  ppr :: WhereFrom -> SDoc
ppr (ImportByUser Bool
is_boot) | Bool
is_boot     = FilePath -> SDoc
text FilePath
"{- SOURCE -}"
                             | Bool
otherwise   = SDoc
empty
  ppr WhereFrom
ImportBySystem                       = FilePath -> SDoc
text FilePath
"{- SYSTEM -}"
  ppr WhereFrom
ImportByPlugin                       = FilePath -> SDoc
text FilePath
"{- PLUGIN -}"


{- *********************************************************************
*                                                                      *
                Type signatures
*                                                                      *
********************************************************************* -}

-- These data types need to be here only because
-- TcSimplify uses them, and TcSimplify is fairly
-- low down in the module hierarchy

type TcSigFun  = Name -> Maybe TcSigInfo

data TcSigInfo = TcIdSig     TcIdSigInfo
               | TcPatSynSig TcPatSynInfo

data TcIdSigInfo   -- See Note [Complete and partial type signatures]
  = CompleteSig    -- A complete signature with no wildcards,
                   -- so the complete polymorphic type is known.
      { TcIdSigInfo -> TyVar
sig_bndr :: TcId          -- The polymorphic Id with that type

      , TcIdSigInfo -> UserTypeCtxt
sig_ctxt :: UserTypeCtxt  -- In the case of type-class default methods,
                                  -- the Name in the FunSigCtxt is not the same
                                  -- as the TcId; the former is 'op', while the
                                  -- latter is '$dmop' or some such

      , TcIdSigInfo -> SrcSpan
sig_loc  :: SrcSpan       -- Location of the type signature
      }

  | PartialSig     -- A partial type signature (i.e. includes one or more
                   -- wildcards). In this case it doesn't make sense to give
                   -- the polymorphic Id, because we are going to /infer/ its
                   -- type, so we can't make the polymorphic Id ab-initio
      { TcIdSigInfo -> Name
psig_name  :: Name   -- Name of the function; used when report wildcards
      , TcIdSigInfo -> LHsSigWcType GhcRn
psig_hs_ty :: LHsSigWcType GhcRn  -- The original partial signature in
                                          -- HsSyn form
      , sig_ctxt   :: UserTypeCtxt
      , sig_loc    :: SrcSpan            -- Location of the type signature
      }


{- Note [Complete and partial type signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
A type signature is partial when it contains one or more wildcards
(= type holes).  The wildcard can either be:
* A (type) wildcard occurring in sig_theta or sig_tau. These are
  stored in sig_wcs.
      f :: Bool -> _
      g :: Eq _a => _a -> _a -> Bool
* Or an extra-constraints wildcard, stored in sig_cts:
      h :: (Num a, _) => a -> a

A type signature is a complete type signature when there are no
wildcards in the type signature, i.e. iff sig_wcs is empty and
sig_extra_cts is Nothing.
-}

data TcIdSigInst
  = TISI { TcIdSigInst -> TcIdSigInfo
sig_inst_sig :: TcIdSigInfo

         , TcIdSigInst -> [(Name, TyVar)]
sig_inst_skols :: [(Name, TcTyVar)]
               -- Instantiated type and kind variables, TyVarTvs
               -- The Name is the Name that the renamer chose;
               --   but the TcTyVar may come from instantiating
               --   the type and hence have a different unique.
               -- No need to keep track of whether they are truly lexically
               --   scoped because the renamer has named them uniquely
               -- See Note [Binding scoped type variables] in TcSigs
               --
               -- NB: The order of sig_inst_skols is irrelevant
               --     for a CompleteSig, but for a PartialSig see
               --     Note [Quantified varaibles in partial type signatures]

         , TcIdSigInst -> [Type]
sig_inst_theta  :: TcThetaType
               -- Instantiated theta.  In the case of a
               -- PartialSig, sig_theta does not include
               -- the extra-constraints wildcard

         , TcIdSigInst -> Type
sig_inst_tau :: TcSigmaType   -- Instantiated tau
               -- See Note [sig_inst_tau may be polymorphic]

         -- Relevant for partial signature only
         , TcIdSigInst -> [(Name, TyVar)]
sig_inst_wcs   :: [(Name, TcTyVar)]
               -- Like sig_inst_skols, but for /named/ wildcards (_a etc).
               -- The named wildcards scope over the binding, and hence
               -- their Names may appear in type signatures in the binding

         , TcIdSigInst -> Maybe Type
sig_inst_wcx   :: Maybe TcType
               -- Extra-constraints wildcard to fill in, if any
               -- If this exists, it is surely of the form (meta_tv |> co)
               -- (where the co might be reflexive). This is filled in
               -- only from the return value of TcHsType.tcAnonWildCardOcc
         }

{- Note [sig_inst_tau may be polymorphic]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Note that "sig_inst_tau" might actually be a polymorphic type,
if the original function had a signature like
   forall a. Eq a => forall b. Ord b => ....
But that's ok: tcMatchesFun (called by tcRhs) can deal with that
It happens, too!  See Note [Polymorphic methods] in TcClassDcl.

Note [Quantified varaibles in partial type signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
   f :: forall a b. _ -> a -> _ -> b
   f (x,y) p q = q

Then we expect f's final type to be
  f :: forall {x,y}. forall a b. (x,y) -> a -> b -> b

Note that x,y are Inferred, and can't be use for visible type
application (VTA).  But a,b are Specified, and remain Specified
in the final type, so we can use VTA for them.  (Exception: if
it turns out that a's kind mentions b we need to reorder them
with scopedSort.)

The sig_inst_skols of the TISI from a partial signature records
that original order, and is used to get the variables of f's
final type in the correct order.


Note [Wildcards in partial signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The wildcards in psig_wcs may stand for a type mentioning
the universally-quantified tyvars of psig_ty

E.g.  f :: forall a. _ -> a
      f x = x
We get sig_inst_skols = [a]
       sig_inst_tau   = _22 -> a
       sig_inst_wcs   = [_22]
and _22 in the end is unified with the type 'a'

Moreover the kind of a wildcard in sig_inst_wcs may mention
the universally-quantified tyvars sig_inst_skols
e.g.   f :: t a -> t _
Here we get
   sig_inst_skols = [k:*, (t::k ->*), (a::k)]
   sig_inst_tau   = t a -> t _22
   sig_inst_wcs   = [ _22::k ]
-}

data TcPatSynInfo
  = TPSI {
        TcPatSynInfo -> Name
patsig_name           :: Name,
        TcPatSynInfo -> [TyVarBinder]
patsig_implicit_bndrs :: [TyVarBinder], -- Implicitly-bound kind vars (Inferred) and
                                                -- implicitly-bound type vars (Specified)
          -- See Note [The pattern-synonym signature splitting rule] in TcPatSyn
        TcPatSynInfo -> [TyVar]
patsig_univ_bndrs     :: [TyVar],       -- Bound by explicit user forall
        TcPatSynInfo -> [Type]
patsig_req            :: TcThetaType,
        TcPatSynInfo -> [TyVar]
patsig_ex_bndrs       :: [TyVar],       -- Bound by explicit user forall
        TcPatSynInfo -> [Type]
patsig_prov           :: TcThetaType,
        TcPatSynInfo -> Type
patsig_body_ty        :: TcSigmaType
    }

instance Outputable TcSigInfo where
  ppr :: TcSigInfo -> SDoc
ppr (TcIdSig     TcIdSigInfo
idsi) = TcIdSigInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSigInfo
idsi
  ppr (TcPatSynSig TcPatSynInfo
tpsi) = FilePath -> SDoc
text FilePath
"TcPatSynInfo" SDoc -> SDoc -> SDoc
<+> TcPatSynInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcPatSynInfo
tpsi

instance Outputable TcIdSigInfo where
    ppr :: TcIdSigInfo -> SDoc
ppr (CompleteSig { sig_bndr :: TcIdSigInfo -> TyVar
sig_bndr = TyVar
bndr })
        = TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
bndr SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyVar -> Type
idType TyVar
bndr)
    ppr (PartialSig { psig_name :: TcIdSigInfo -> Name
psig_name = Name
name, psig_hs_ty :: TcIdSigInfo -> LHsSigWcType GhcRn
psig_hs_ty = LHsSigWcType GhcRn
hs_ty })
        = FilePath -> SDoc
text FilePath
"psig" SDoc -> SDoc -> SDoc
<+> Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> LHsSigWcType GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsSigWcType GhcRn
hs_ty

instance Outputable TcIdSigInst where
    ppr :: TcIdSigInst -> SDoc
ppr (TISI { sig_inst_sig :: TcIdSigInst -> TcIdSigInfo
sig_inst_sig = TcIdSigInfo
sig, sig_inst_skols :: TcIdSigInst -> [(Name, TyVar)]
sig_inst_skols = [(Name, TyVar)]
skols
              , sig_inst_theta :: TcIdSigInst -> [Type]
sig_inst_theta = [Type]
theta, sig_inst_tau :: TcIdSigInst -> Type
sig_inst_tau = Type
tau })
        = SDoc -> ThLevel -> SDoc -> SDoc
hang (TcIdSigInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSigInfo
sig) ThLevel
2 ([SDoc] -> SDoc
vcat [ [(Name, TyVar)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(Name, TyVar)]
skols, [Type] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Type]
theta SDoc -> SDoc -> SDoc
<+> SDoc
darrow SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
tau ])

instance Outputable TcPatSynInfo where
    ppr :: TcPatSynInfo -> SDoc
ppr (TPSI{ patsig_name :: TcPatSynInfo -> Name
patsig_name = Name
name}) = Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name

isPartialSig :: TcIdSigInst -> Bool
isPartialSig :: TcIdSigInst -> Bool
isPartialSig (TISI { sig_inst_sig :: TcIdSigInst -> TcIdSigInfo
sig_inst_sig = PartialSig {} }) = Bool
True
isPartialSig TcIdSigInst
_                                       = Bool
False

-- | No signature or a partial signature
hasCompleteSig :: TcSigFun -> Name -> Bool
hasCompleteSig :: TcSigFun -> Name -> Bool
hasCompleteSig TcSigFun
sig_fn Name
name
  = case TcSigFun
sig_fn Name
name of
      Just (TcIdSig (CompleteSig {})) -> Bool
True
      Maybe TcSigInfo
_                               -> Bool
False


{-
Constraint Solver Plugins
-------------------------
-}

type TcPluginSolver = [Ct]    -- given
                   -> [Ct]    -- derived
                   -> [Ct]    -- wanted
                   -> TcPluginM TcPluginResult

newtype TcPluginM a = TcPluginM (EvBindsVar -> TcM a) deriving (a -> TcPluginM b -> TcPluginM a
(a -> b) -> TcPluginM a -> TcPluginM b
(forall a b. (a -> b) -> TcPluginM a -> TcPluginM b)
-> (forall a b. a -> TcPluginM b -> TcPluginM a)
-> Functor TcPluginM
forall a b. a -> TcPluginM b -> TcPluginM a
forall a b. (a -> b) -> TcPluginM a -> TcPluginM b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> TcPluginM b -> TcPluginM a
$c<$ :: forall a b. a -> TcPluginM b -> TcPluginM a
fmap :: (a -> b) -> TcPluginM a -> TcPluginM b
$cfmap :: forall a b. (a -> b) -> TcPluginM a -> TcPluginM b
Functor)

instance Applicative TcPluginM where
  pure :: a -> TcPluginM a
pure a
x = (EvBindsVar -> TcM a) -> TcPluginM a
forall a. (EvBindsVar -> TcM a) -> TcPluginM a
TcPluginM (TcM a -> EvBindsVar -> TcM a
forall a b. a -> b -> a
const (TcM a -> EvBindsVar -> TcM a) -> TcM a -> EvBindsVar -> TcM a
forall a b. (a -> b) -> a -> b
$ a -> TcM a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x)
  <*> :: TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b
(<*>) = TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap

instance Monad TcPluginM where
#if !MIN_VERSION_base(4,13,0)
  fail = MonadFail.fail
#endif
  TcPluginM EvBindsVar -> TcM a
m >>= :: TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b
>>= a -> TcPluginM b
k =
    (EvBindsVar -> TcM b) -> TcPluginM b
forall a. (EvBindsVar -> TcM a) -> TcPluginM a
TcPluginM (\ EvBindsVar
ev -> do a
a <- EvBindsVar -> TcM a
m EvBindsVar
ev
                          TcPluginM b -> EvBindsVar -> TcM b
forall a. TcPluginM a -> EvBindsVar -> TcM a
runTcPluginM (a -> TcPluginM b
k a
a) EvBindsVar
ev)

instance MonadFail.MonadFail TcPluginM where
  fail :: FilePath -> TcPluginM a
fail FilePath
x   = (EvBindsVar -> TcM a) -> TcPluginM a
forall a. (EvBindsVar -> TcM a) -> TcPluginM a
TcPluginM (TcM a -> EvBindsVar -> TcM a
forall a b. a -> b -> a
const (TcM a -> EvBindsVar -> TcM a) -> TcM a -> EvBindsVar -> TcM a
forall a b. (a -> b) -> a -> b
$ FilePath -> TcM a
forall (m :: * -> *) a. MonadFail m => FilePath -> m a
fail FilePath
x)

runTcPluginM :: TcPluginM a -> EvBindsVar -> TcM a
runTcPluginM :: TcPluginM a -> EvBindsVar -> TcM a
runTcPluginM (TcPluginM EvBindsVar -> TcM a
m) = EvBindsVar -> TcM a
m

-- | This function provides an escape for direct access to
-- the 'TcM` monad.  It should not be used lightly, and
-- the provided 'TcPluginM' API should be favoured instead.
unsafeTcPluginTcM :: TcM a -> TcPluginM a
unsafeTcPluginTcM :: TcM a -> TcPluginM a
unsafeTcPluginTcM = (EvBindsVar -> TcM a) -> TcPluginM a
forall a. (EvBindsVar -> TcM a) -> TcPluginM a
TcPluginM ((EvBindsVar -> TcM a) -> TcPluginM a)
-> (TcM a -> EvBindsVar -> TcM a) -> TcM a -> TcPluginM a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TcM a -> EvBindsVar -> TcM a
forall a b. a -> b -> a
const

-- | Access the 'EvBindsVar' carried by the 'TcPluginM' during
-- constraint solving.  Returns 'Nothing' if invoked during
-- 'tcPluginInit' or 'tcPluginStop'.
getEvBindsTcPluginM :: TcPluginM EvBindsVar
getEvBindsTcPluginM :: TcPluginM EvBindsVar
getEvBindsTcPluginM = (EvBindsVar -> TcM EvBindsVar) -> TcPluginM EvBindsVar
forall a. (EvBindsVar -> TcM a) -> TcPluginM a
TcPluginM EvBindsVar -> TcM EvBindsVar
forall (m :: * -> *) a. Monad m => a -> m a
return


data TcPlugin = forall s. TcPlugin
  { ()
tcPluginInit  :: TcPluginM s
    -- ^ Initialize plugin, when entering type-checker.

  , ()
tcPluginSolve :: s -> TcPluginSolver
    -- ^ Solve some constraints.
    -- TODO: WRITE MORE DETAILS ON HOW THIS WORKS.

  , ()
tcPluginStop  :: s -> TcPluginM ()
   -- ^ Clean up after the plugin, when exiting the type-checker.
  }

data TcPluginResult
  = TcPluginContradiction [Ct]
    -- ^ The plugin found a contradiction.
    -- The returned constraints are removed from the inert set,
    -- and recorded as insoluble.

  | TcPluginOk [(EvTerm,Ct)] [Ct]
    -- ^ The first field is for constraints that were solved.
    -- These are removed from the inert set,
    -- and the evidence for them is recorded.
    -- The second field contains new work, that should be processed by
    -- the constraint solver.

{- *********************************************************************
*                                                                      *
                        Role annotations
*                                                                      *
********************************************************************* -}

type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)

mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv
mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv
mkRoleAnnotEnv [LRoleAnnotDecl GhcRn]
role_annot_decls
 = [(Name, LRoleAnnotDecl GhcRn)] -> RoleAnnotEnv
forall a. [(Name, a)] -> NameEnv a
mkNameEnv [ (Name
name, LRoleAnnotDecl GhcRn
ra_decl)
             | LRoleAnnotDecl GhcRn
ra_decl <- [LRoleAnnotDecl GhcRn]
role_annot_decls
             , let name :: IdP GhcRn
name = RoleAnnotDecl GhcRn -> IdP GhcRn
forall (p :: Pass). RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p)
roleAnnotDeclName (LRoleAnnotDecl GhcRn -> SrcSpanLess (LRoleAnnotDecl GhcRn)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LRoleAnnotDecl GhcRn
ra_decl)
             , Bool -> Bool
not (Name -> Bool
isUnboundName Name
name) ]
       -- Some of the role annots will be unbound;
       -- we don't wish to include these

emptyRoleAnnotEnv :: RoleAnnotEnv
emptyRoleAnnotEnv :: RoleAnnotEnv
emptyRoleAnnotEnv = RoleAnnotEnv
forall elt. UniqFM elt
emptyNameEnv

lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
lookupRoleAnnot = RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv

getRoleAnnots :: [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn]
getRoleAnnots :: [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn]
getRoleAnnots [Name]
bndrs RoleAnnotEnv
role_env
  = (Name -> Maybe (LRoleAnnotDecl GhcRn))
-> [Name] -> [LRoleAnnotDecl GhcRn]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
lookupRoleAnnot RoleAnnotEnv
role_env) [Name]
bndrs