{-# LANGUAGE DerivingStrategies         #-}
{-# LANGUAGE ExistentialQuantification  #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GADTs                      #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE PatternSynonyms            #-}

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

-}

-- | Various types used during typechecking.
--
-- Please see "GHC.Tc.Utils.Monad" 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.
module GHC.Tc.Types(
        TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module
        TcRef,

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

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

        -- Renamer types
        ErrCtxt,
        ImportAvails(..), emptyImportAvails, plusImportAvails,
        ImportUserSpec(..),
        ImpUserList(..),
        mkModDeps,

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

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

        -- Arrows
        ArrowCtxt(..),

        -- TcSigInfo
        TcSigFun,
        TcSigInfo(..), TcIdSig(..),
        TcCompleteSig(..), TcPartialSig(..), TcPatSynSig(..),
        TcIdSigInst(..),
        isPartialSig, hasCompleteSig, tcSigInfoName, tcIdSigLoc,
        completeSigPolyId_maybe,

        -- Misc other types
        TcId,
        NameShape(..),
        removeBindingShadowing,
        getPlatform,

        -- Constraint solver plugins
        TcPlugin(..),
        TcPluginSolveResult(TcPluginContradiction, TcPluginOk, ..),
        TcPluginRewriteResult(..),
        TcPluginSolver, TcPluginRewriter,
        TcPluginM(runTcPluginM), unsafeTcPluginTcM,

        -- Defaulting plugin
        DefaultingPlugin(..), DefaultingProposal(..),
        FillDefaulting,

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

        -- Linting
        lintGblEnv,

        -- Diagnostics
        TcRnMessage
  ) where

import GHC.Prelude
import GHC.Platform

import GHC.Driver.Env
import GHC.Driver.Env.KnotVars
import GHC.Driver.Config.Core.Lint
import GHC.Driver.DynFlags
import {-# SOURCE #-} GHC.Driver.Hooks

import GHC.Linker.Types

import GHC.Hs

import GHC.Tc.Utils.TcType
import GHC.Tc.Types.Constraint
import GHC.Tc.Types.CtLoc( CtLoc )
import GHC.Tc.Types.Evidence
import GHC.Tc.Types.TH
import GHC.Tc.Types.TcRef
import GHC.Tc.Types.LclEnv
import GHC.Tc.Types.BasicTypes
import GHC.Tc.Types.ErrCtxt
import {-# SOURCE #-} GHC.Tc.Errors.Hole.Plugin ( HoleFitPlugin )
import GHC.Tc.Errors.Types

import GHC.Core.Reduction ( Reduction(..) )
import GHC.Core.Type
import GHC.Core.TyCon  ( TyCon )
import GHC.Core.PatSyn ( PatSyn )
import GHC.Core.Lint   ( lintAxioms )
import GHC.Core.InstEnv
import GHC.Core.FamInstEnv
import GHC.Core.Predicate

import GHC.Types.DefaultEnv ( DefaultEnv )
import GHC.Types.Fixity.Env
import GHC.Types.Annotations
import GHC.Types.CompleteMatch
import GHC.Types.Name.Reader
import GHC.Types.Name
import GHC.Types.Name.Env
import GHC.Types.Name.Set
import GHC.Types.Avail
import GHC.Types.Var
import GHC.Types.TypeEnv
import GHC.Types.SourceFile
import GHC.Types.SrcLoc
import GHC.Types.Unique.FM
import GHC.Types.Basic
import GHC.Types.CostCentre.State
import GHC.Types.HpcInfo

import GHC.Data.IOEnv
import GHC.Data.Bag
import GHC.Data.List.SetOps

import GHC.Unit
import GHC.Unit.Module.Warnings
import GHC.Unit.Module.Deps
import GHC.Unit.Module.ModDetails

import GHC.Utils.Error
import GHC.Utils.Outputable
import GHC.Utils.Fingerprint
import GHC.Utils.Panic
import GHC.Utils.Logger

import GHC.Builtin.Names ( isUnboundName )

import GHCi.Message
import GHCi.RemoteTypes

import Data.Set      ( Set )
import qualified Data.Set as S
import qualified Data.Map as M
import Data.Dynamic  ( Dynamic )
import Data.Map ( Map )
import Data.Typeable ( TypeRep )
import Data.Maybe    ( mapMaybe )

-- | The import specification as written by the user, including
-- the list of explicitly imported names. Used in 'ModIface' to
-- allow GHCi to reconstruct the top level environment on demand.
--
-- This is distinct from 'ImportSpec' because we don't want to store
-- the list of explicitly imported names along with each 'GRE'
--
-- We don't want to store the entire GlobalRdrEnv for modules that
-- are imported without explicit export lists, as these may grow
-- to be very large. However, GlobalRdrEnvs which are the result
-- of explicit import lists are typically quite small.
--
-- Why do we not store something like (Maybe (ImportListInterpretation, [IE GhcPs]) in such a case?
-- Because we don't want to store source syntax including annotations in
-- interface files.
data ImportUserSpec
  = ImpUserSpec { ImportUserSpec -> ImpDeclSpec
ius_decl :: !ImpDeclSpec
                , ImportUserSpec -> ImpUserList
ius_imports :: !ImpUserList
                }

data ImpUserList
  = ImpUserAll -- ^ no user import list
  | ImpUserExplicit !GlobalRdrEnv
  | ImpUserEverythingBut !NameSet

-- | 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 "GHC.Iface.Rename").  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 intriguing 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 GHC.Tc.Utils.Monad
*                                                                      *
************************************************************************

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

-- 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 {
        forall gbl lcl. 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

        forall gbl lcl. Env gbl lcl -> Char
env_ut   :: {-# UNPACK #-} !Char,   -- Tag for Uniques

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

        forall gbl lcl. 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 ContainsHooks (Env gbl lcl) where
    extractHooks :: Env gbl lcl -> Hooks
extractHooks Env gbl lcl
env = HscEnv -> Hooks
hsc_hooks (Env gbl lcl -> HscEnv
forall gbl lcl. Env gbl lcl -> HscEnv
env_top Env gbl lcl
env)

instance ContainsLogger (Env gbl lcl) where
    extractLogger :: Env gbl lcl -> Logger
extractLogger Env gbl lcl
env = HscEnv -> Logger
hsc_logger (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)

{-
************************************************************************
*                                                                      *
*                            RewriteEnv
*                     The rewriting environment
*                                                                      *
************************************************************************
-}

-- | A 'RewriteEnv' carries the necessary context for performing rewrites
-- (i.e. type family reductions and following filled-in metavariables)
-- in the solver.
data RewriteEnv
  = RE { RewriteEnv -> CtLoc
re_loc     :: !CtLoc
       -- ^ In which context are we rewriting?
       --
       -- Type-checking plugins might want to use this location information
       -- when emitting new Wanted constraints when rewriting type family
       -- applications. This ensures that such Wanted constraints will,
       -- when unsolved, give rise to error messages with the
       -- correct source location.

       -- Within GHC, we use this field to keep track of reduction depth.
       -- See Note [Rewriter CtLoc] in GHC.Tc.Solver.Rewrite.
       , RewriteEnv -> CtFlavour
re_flavour :: !CtFlavour
       , RewriteEnv -> EqRel
re_eq_rel  :: !EqRel
          -- ^ At what role are we rewriting?
          -- See Note [Rewriter EqRels] in GHC.Tc.Solver.Rewrite

       , RewriteEnv -> TcRef RewriterSet
re_rewriters :: !(TcRef RewriterSet)  -- ^ See Note [Wanteds rewrite Wanteds]
       }
-- RewriteEnv is mostly used in @GHC.Tc.Solver.Rewrite@, but it is defined
-- here so that it can also be passed to rewriting plugins.
-- See the 'tcPluginRewrite' field of 'TcPlugin'.


{-
************************************************************************
*                                                                      *
                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 GHC.IfaceToCore
        IfGblEnv -> KnotVars (IfG TypeEnv)
if_rec_types :: (KnotVars (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 -> IsBootInterface
if_boot :: IsBootInterface,

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

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

-- | 'FrontendResult' describes the result of running the frontend of a Haskell
-- module. Currently one always gets a 'FrontendTypecheck', since running the
-- frontend involves typechecking a program. hs-sig merges are not handled here.
--
-- This data type really should be in GHC.Driver.Env, 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 corollary 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 moduleUnit this_mod == thisPackage dflags
--
--      - For any code involving Names, we want semantic modules.
--        See lookupIfaceTop in GHC.Iface.Env, mkIface and addFingerprints
--        in GHC.Iface.{Make,Recomp}, and tcLookupGlobal in GHC.Tc.Utils.Env
--
--      - 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 GHC.Iface.Load.)
--        Similarly, in GHC.Rename.Names 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 -> DefaultEnv
tcg_default         :: DefaultEnv,     -- ^ All class defaults in scope in the module
        TcGblEnv -> DefaultEnv
tcg_default_exports :: DefaultEnv,     -- ^ All class defaults exported from the module

        TcGblEnv -> FixityEnv
tcg_fix_env :: FixityEnv,      -- ^ Just for things in this module

        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 "GHC.Runtime.Context"

        TcGblEnv -> KnotVars (IORef TypeEnv)
tcg_type_env_var :: KnotVars (IORef 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 "GHC.Driver.Main")
          --    - To create the Dependencies field in interface (mkDependencies)


          -- This field tracks the user-written imports of a module, so they can be
          -- recorded in an interface file in order to reconstruct the top-level environment
          -- if necessary for GHCi.
        TcGblEnv -> [ImportUserSpec]
tcg_import_decls :: ![ImportUserSpec],

          -- 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],
          -- ^ INVARIANT: all these GREs were imported; that is,
          -- they all have a non-empty gre_imp field.
        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 ([Linkable], PkgsLoaded)
tcg_th_needed_deps :: TcRef ([Linkable], PkgsLoaded),
          -- ^ The set of runtime dependencies required by this module
          -- See Note [Object File Dependencies]

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

        TcGblEnv -> TcRef Integer
tcg_zany_n :: TcRef Integer,
          -- ^ A source of unique identities for ZonkAny instances
          -- See Note [Any types] in GHC.Builtin.Types, wrinkle (Any4)

        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 [(LIE GhcRn, [AvailInfo])]
tcg_rn_exports :: Maybe [(LIE 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 -> TcRef THDocs
tcg_th_docs   :: TcRef THDocs,
        -- ^ Docs added in Template Haskell via @putDoc@.

        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
        -- GHC.Runtime.Context
        TcGblEnv -> Maybe TyVar
tcg_tr_module :: Maybe Id,   -- Id for $trModule :: GHC.Unit.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 GhcRn
tcg_warns     :: (Warnings GhcRn), -- ...Warnings and deprecations
        TcGblEnv -> [Annotation]
tcg_anns      :: [Annotation],       -- ...Annotations
        TcGblEnv -> [TyCon]
tcg_tcs       :: [TyCon],            -- ...TyCons and Classes
        TcGblEnv -> NameSet
tcg_ksigs     :: NameSet,            -- ...Top-level TyCon names that *lack* a signature
        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 (LHsDoc GhcRn), Maybe (XRec GhcRn ModuleName))
tcg_hdr_info   :: (Maybe (LHsDoc GhcRn), Maybe (XRec GhcRn ModuleName)),
        -- ^ Maybe Haddock header docs and Maybe located module name

        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
tcg_safe_infer :: TcRef Bool,
        -- ^ 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 -> TcRef (Messages TcRnMessage)
tcg_safe_infer_reasons :: TcRef (Messages TcRnMessage),
        -- ^ Unreported reasons why tcg_safe_infer is False.
        -- INVARIANT: If this Messages is non-empty, then tcg_safe_infer is False.
        -- It may be that tcg_safe_infer is False but this is empty, if no reasons
        -- are supplied (#19714), or if those reasons have already been
        -- reported by GHC.Driver.Main.markUnsafeInfer

        TcGblEnv -> [TcPluginSolver]
tcg_tc_plugin_solvers :: [TcPluginSolver],
        -- ^ A list of user-defined type-checking plugins for constraint solving.

        TcGblEnv -> UniqFM TyCon [TcPluginRewriter]
tcg_tc_plugin_rewriters :: UniqFM TyCon [TcPluginRewriter],
        -- ^ A collection of all the user-defined type-checking plugins for rewriting
        -- type family applications, collated by their type family 'TyCon's.

        TcGblEnv -> [FillDefaulting]
tcg_defaulting_plugins :: [FillDefaulting],
        -- ^ A list of user-defined plugins for type defaulting plugins.

        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 -> CompleteMatches
tcg_complete_matches :: !CompleteMatches,

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

        TcGblEnv -> TcRef (ModuleEnv Int)
tcg_next_wrapper_num :: TcRef (ModuleEnv Int)
        -- ^ See Note [Generating fresh names for FFI wrappers]
    }

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

data SelfBootInfo
  = NoSelfBoot    -- No corresponding hi-boot file
  | SelfBoot
       { SelfBootInfo -> ModDetails
sb_mds :: ModDetails }  -- There was a hi-boot file

bootExports :: SelfBootInfo -> NameSet
bootExports :: SelfBootInfo -> NameSet
bootExports SelfBootInfo
boot =
  case SelfBootInfo
boot of
    SelfBootInfo
NoSelfBoot -> NameSet
emptyNameSet
    SelfBoot { sb_mds :: SelfBootInfo -> ModDetails
sb_mds = ModDetails
mds} ->
      let exports :: [AvailInfo]
exports = ModDetails -> [AvailInfo]
md_exports ModDetails
mds
      in [AvailInfo] -> NameSet
availsToNameSet [AvailInfo]
exports



{- 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 GHC.Rename.Names.reportUnusedNames)
           (b) to generate version-tracking usage info in interface
               files (see GHC.Iface.Make.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 GHC.Rename.Splice

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

      (e) Record fields that are used to solve HasField constraints
          (see Note [Unused name reporting and HasField] in GHC.Tc.Instance.Class)

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

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


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

-}


-- 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 :: forall a. HasOccName a => [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 b a. (b -> a -> b) -> b -> [a] -> b
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


-- | Get target platform
getPlatform :: TcRnIf a b Platform
getPlatform :: forall a b. TcRnIf a b Platform
getPlatform = DynFlags -> Platform
targetPlatform (DynFlags -> Platform)
-> IOEnv (Env a b) DynFlags -> IOEnv (Env a b) Platform
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IOEnv (Env a b) DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags


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

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


mkModDeps :: Set (UnitId, ModuleNameWithIsBoot)
          -> InstalledModuleEnv ModuleNameWithIsBoot
mkModDeps :: Set (UnitId, ModuleNameWithIsBoot)
-> InstalledModuleEnv ModuleNameWithIsBoot
mkModDeps Set (UnitId, ModuleNameWithIsBoot)
deps = (InstalledModuleEnv ModuleNameWithIsBoot
 -> (UnitId, ModuleNameWithIsBoot)
 -> InstalledModuleEnv ModuleNameWithIsBoot)
-> InstalledModuleEnv ModuleNameWithIsBoot
-> Set (UnitId, ModuleNameWithIsBoot)
-> InstalledModuleEnv ModuleNameWithIsBoot
forall a b. (a -> b -> a) -> a -> Set b -> a
S.foldl' InstalledModuleEnv ModuleNameWithIsBoot
-> (UnitId, ModuleNameWithIsBoot)
-> InstalledModuleEnv ModuleNameWithIsBoot
add InstalledModuleEnv ModuleNameWithIsBoot
forall a. InstalledModuleEnv a
emptyInstalledModuleEnv Set (UnitId, ModuleNameWithIsBoot)
deps
  where
    add :: InstalledModuleEnv ModuleNameWithIsBoot
-> (UnitId, ModuleNameWithIsBoot)
-> InstalledModuleEnv ModuleNameWithIsBoot
add InstalledModuleEnv ModuleNameWithIsBoot
env (UnitId
uid, ModuleNameWithIsBoot
elt) = InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModule
-> ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
forall a.
InstalledModuleEnv a
-> InstalledModule -> a -> InstalledModuleEnv a
extendInstalledModuleEnv InstalledModuleEnv ModuleNameWithIsBoot
env (UnitId -> ModuleName -> InstalledModule
forall u. u -> ModuleName -> GenModule u
mkModule UnitId
uid (ModuleNameWithIsBoot -> ModuleName
forall mod. GenWithIsBoot mod -> mod
gwib_mod ModuleNameWithIsBoot
elt)) ModuleNameWithIsBoot
elt

plusModDeps :: InstalledModuleEnv ModuleNameWithIsBoot
            -> InstalledModuleEnv ModuleNameWithIsBoot
            -> InstalledModuleEnv ModuleNameWithIsBoot
plusModDeps :: InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
plusModDeps = (ModuleNameWithIsBoot
 -> ModuleNameWithIsBoot -> ModuleNameWithIsBoot)
-> InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
forall elt.
(elt -> elt -> elt)
-> InstalledModuleEnv elt
-> InstalledModuleEnv elt
-> InstalledModuleEnv elt
plusInstalledModuleEnv ModuleNameWithIsBoot
-> ModuleNameWithIsBoot -> ModuleNameWithIsBoot
forall {a}.
(Eq a, Outputable a) =>
GenWithIsBoot a -> GenWithIsBoot a -> GenWithIsBoot a
plus_mod_dep
  where
    plus_mod_dep :: GenWithIsBoot a -> GenWithIsBoot a -> GenWithIsBoot a
plus_mod_dep r1 :: GenWithIsBoot a
r1@(GWIB { gwib_mod :: forall mod. GenWithIsBoot mod -> mod
gwib_mod = a
m1, gwib_isBoot :: forall mod. GenWithIsBoot mod -> IsBootInterface
gwib_isBoot = IsBootInterface
boot1 })
                 r2 :: GenWithIsBoot a
r2@(GWIB {gwib_mod :: forall mod. GenWithIsBoot mod -> mod
gwib_mod = a
m2, gwib_isBoot :: forall mod. GenWithIsBoot mod -> IsBootInterface
gwib_isBoot = IsBootInterface
boot2})
      | Bool -> SDoc -> IsBootInterface -> IsBootInterface
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (a
m1 a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
m2) ((a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
m1 SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
m2) SDoc -> SDoc -> SDoc
forall doc. IsDoc doc => doc -> doc -> doc
$$ (Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr (IsBootInterface
boot1 IsBootInterface -> IsBootInterface -> Bool
forall a. Eq a => a -> a -> Bool
== IsBootInterface
IsBoot) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr (IsBootInterface
boot2 IsBootInterface -> IsBootInterface -> Bool
forall a. Eq a => a -> a -> Bool
== IsBootInterface
IsBoot)))
        IsBootInterface
boot1 IsBootInterface -> IsBootInterface -> Bool
forall a. Eq a => a -> a -> Bool
== IsBootInterface
IsBoot = GenWithIsBoot a
r2
      | Bool
otherwise = GenWithIsBoot a
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

emptyImportAvails :: ImportAvails
emptyImportAvails :: ImportAvails
emptyImportAvails = ImportAvails { imp_mods :: ImportedMods
imp_mods          = ImportedMods
forall k a. Map k a
M.empty,
                                   imp_direct_dep_mods :: InstalledModuleEnv ModuleNameWithIsBoot
imp_direct_dep_mods = InstalledModuleEnv ModuleNameWithIsBoot
forall a. InstalledModuleEnv a
emptyInstalledModuleEnv,
                                   imp_dep_direct_pkgs :: Set UnitId
imp_dep_direct_pkgs = Set UnitId
forall a. Set a
S.empty,
                                   imp_sig_mods :: [ModuleName]
imp_sig_mods      = [],
                                   imp_trust_pkgs :: Set UnitId
imp_trust_pkgs    = Set UnitId
forall a. Set a
S.empty,
                                   imp_trust_own_pkg :: Bool
imp_trust_own_pkg = Bool
False,
                                   imp_boot_mods :: InstalledModuleEnv ModuleNameWithIsBoot
imp_boot_mods   = InstalledModuleEnv ModuleNameWithIsBoot
forall a. InstalledModuleEnv a
emptyInstalledModuleEnv,
                                   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_direct_dep_mods :: ImportAvails -> InstalledModuleEnv ModuleNameWithIsBoot
imp_direct_dep_mods = InstalledModuleEnv ModuleNameWithIsBoot
ddmods1,
                  imp_dep_direct_pkgs :: ImportAvails -> Set UnitId
imp_dep_direct_pkgs = Set UnitId
ddpkgs1,
                  imp_boot_mods :: ImportAvails -> InstalledModuleEnv ModuleNameWithIsBoot
imp_boot_mods = InstalledModuleEnv ModuleNameWithIsBoot
srs1,
                  imp_sig_mods :: ImportAvails -> [ModuleName]
imp_sig_mods = [ModuleName]
sig_mods1,
                  imp_trust_pkgs :: ImportAvails -> Set UnitId
imp_trust_pkgs = Set UnitId
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_direct_dep_mods :: ImportAvails -> InstalledModuleEnv ModuleNameWithIsBoot
imp_direct_dep_mods = InstalledModuleEnv ModuleNameWithIsBoot
ddmods2,
                  imp_dep_direct_pkgs :: ImportAvails -> Set UnitId
imp_dep_direct_pkgs = Set UnitId
ddpkgs2,
                  imp_boot_mods :: ImportAvails -> InstalledModuleEnv ModuleNameWithIsBoot
imp_boot_mods = InstalledModuleEnv ModuleNameWithIsBoot
srcs2,
                  imp_sig_mods :: ImportAvails -> [ModuleName]
imp_sig_mods = [ModuleName]
sig_mods2,
                  imp_trust_pkgs :: ImportAvails -> Set UnitId
imp_trust_pkgs = Set UnitId
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 { imp_mods :: ImportedMods
imp_mods          = ([ImportedBy] -> [ImportedBy] -> [ImportedBy])
-> ImportedMods -> ImportedMods -> ImportedMods
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWith [ImportedBy] -> [ImportedBy] -> [ImportedBy]
forall a. [a] -> [a] -> [a]
(++) ImportedMods
mods1 ImportedMods
mods2,
                   imp_direct_dep_mods :: InstalledModuleEnv ModuleNameWithIsBoot
imp_direct_dep_mods = InstalledModuleEnv ModuleNameWithIsBoot
ddmods1 InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
`plusModDeps` InstalledModuleEnv ModuleNameWithIsBoot
ddmods2,
                   imp_dep_direct_pkgs :: Set UnitId
imp_dep_direct_pkgs      = Set UnitId
ddpkgs1 Set UnitId -> Set UnitId -> Set UnitId
forall a. Ord a => Set a -> Set a -> Set a
`S.union` Set UnitId
ddpkgs2,
                   imp_trust_pkgs :: Set UnitId
imp_trust_pkgs    = Set UnitId
tpkgs1 Set UnitId -> Set UnitId -> Set UnitId
forall a. Ord a => Set a -> Set a -> Set a
`S.union` Set UnitId
tpkgs2,
                   imp_trust_own_pkg :: Bool
imp_trust_own_pkg = Bool
tself1 Bool -> Bool -> Bool
|| Bool
tself2,
                   imp_boot_mods :: InstalledModuleEnv ModuleNameWithIsBoot
imp_boot_mods   = InstalledModuleEnv ModuleNameWithIsBoot
srs1 InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
-> InstalledModuleEnv ModuleNameWithIsBoot
`plusModDeps` InstalledModuleEnv ModuleNameWithIsBoot
srcs2,
                   imp_sig_mods :: [ModuleName]
imp_sig_mods      = [ModuleName] -> [ModuleName] -> [ModuleName]
forall a.
(HasDebugCallStack, Outputable a, Ord a) =>
[a] -> [a] -> [a]
unionListsOrd [ModuleName]
sig_mods1 [ModuleName]
sig_mods2,
                   imp_orphs :: [Module]
imp_orphs         = [Module] -> [Module] -> [Module]
forall a.
(HasDebugCallStack, Outputable a, Ord a) =>
[a] -> [a] -> [a]
unionListsOrd [Module]
orphs1 [Module]
orphs2,
                   imp_finsts :: [Module]
imp_finsts        = [Module] -> [Module] -> [Module]
forall a.
(HasDebugCallStack, Outputable a, Ord a) =>
[a] -> [a] -> [a]
unionListsOrd [Module]
finsts1 [Module]
finsts2 }


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

-- | The @solve@ function of a type-checking plugin takes in Given
-- and Wanted constraints, and should return a 'TcPluginSolveResult'
-- indicating which Wanted constraints it could solve, or whether any are
-- insoluble.
type TcPluginSolver = EvBindsVar
                   -> [Ct] -- ^ Givens
                   -> [Ct] -- ^ Wanteds
                   -> TcPluginM TcPluginSolveResult

-- | For rewriting type family applications, a type-checking plugin provides
-- a function of this type for each type family 'TyCon'.
--
-- The function is provided with the current set of Given constraints, together
-- with the arguments to the type family.
-- The type family application will always be fully saturated.
type TcPluginRewriter
  =  RewriteEnv -- ^ Rewriter environment
  -> [Ct]       -- ^ Givens
  -> [TcType]   -- ^ type family arguments
  -> TcPluginM TcPluginRewriteResult

-- | 'TcPluginM' is the monad in which type-checking plugins operate.
newtype TcPluginM a = TcPluginM { forall a. TcPluginM a -> TcM a
runTcPluginM :: TcM a }
  deriving newtype ((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
$cfmap :: forall a b. (a -> b) -> TcPluginM a -> TcPluginM b
fmap :: forall a b. (a -> b) -> TcPluginM a -> TcPluginM b
$c<$ :: forall a b. a -> TcPluginM b -> TcPluginM a
<$ :: forall a b. a -> TcPluginM b -> TcPluginM a
Functor, Functor TcPluginM
Functor TcPluginM =>
(forall a. a -> TcPluginM a)
-> (forall a b. TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b)
-> (forall a b c.
    (a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c)
-> (forall a b. TcPluginM a -> TcPluginM b -> TcPluginM b)
-> (forall a b. TcPluginM a -> TcPluginM b -> TcPluginM a)
-> Applicative TcPluginM
forall a. a -> TcPluginM a
forall a b. TcPluginM a -> TcPluginM b -> TcPluginM a
forall a b. TcPluginM a -> TcPluginM b -> TcPluginM b
forall a b. TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b
forall a b c.
(a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall a. a -> TcPluginM a
pure :: forall a. a -> TcPluginM a
$c<*> :: forall a b. TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b
<*> :: forall a b. TcPluginM (a -> b) -> TcPluginM a -> TcPluginM b
$cliftA2 :: forall a b c.
(a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c
liftA2 :: forall a b c.
(a -> b -> c) -> TcPluginM a -> TcPluginM b -> TcPluginM c
$c*> :: forall a b. TcPluginM a -> TcPluginM b -> TcPluginM b
*> :: forall a b. TcPluginM a -> TcPluginM b -> TcPluginM b
$c<* :: forall a b. TcPluginM a -> TcPluginM b -> TcPluginM a
<* :: forall a b. TcPluginM a -> TcPluginM b -> TcPluginM a
Applicative, Applicative TcPluginM
Applicative TcPluginM =>
(forall a b. TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b)
-> (forall a b. TcPluginM a -> TcPluginM b -> TcPluginM b)
-> (forall a. a -> TcPluginM a)
-> Monad TcPluginM
forall a. a -> TcPluginM a
forall a b. TcPluginM a -> TcPluginM b -> TcPluginM b
forall a b. TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall a b. TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b
>>= :: forall a b. TcPluginM a -> (a -> TcPluginM b) -> TcPluginM b
$c>> :: forall a b. TcPluginM a -> TcPluginM b -> TcPluginM b
>> :: forall a b. TcPluginM a -> TcPluginM b -> TcPluginM b
$creturn :: forall a. a -> TcPluginM a
return :: forall a. a -> TcPluginM a
Monad, Monad TcPluginM
Monad TcPluginM =>
(forall a. FilePath -> TcPluginM a) -> MonadFail TcPluginM
forall a. FilePath -> TcPluginM a
forall (m :: * -> *).
Monad m =>
(forall a. FilePath -> m a) -> MonadFail m
$cfail :: forall a. FilePath -> TcPluginM a
fail :: forall a. FilePath -> TcPluginM a
MonadFail)

-- | 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 :: forall a. TcM a -> TcPluginM a
unsafeTcPluginTcM = TcM a -> TcPluginM a
forall a. TcM a -> TcPluginM a
TcPluginM

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

  , ()
tcPluginSolve :: s -> TcPluginSolver
    -- ^ Solve some constraints.
    --
    -- This function will be invoked at two points in the constraint solving
    -- process: once to simplify Given constraints, and once to solve
    -- Wanted constraints. In the first case (and only in the first case),
    -- no Wanted constraints will be passed to the plugin.
    --
    -- The plugin can either return a contradiction,
    -- or specify that it has solved some constraints (with evidence),
    -- and possibly emit additional constraints. These returned constraints
    -- must be Givens in the first case, and Wanteds in the second.
    --
    -- Use @ \\ _ _ _ _ -> pure $ TcPluginOk [] [] @ if your plugin
    -- does not provide this functionality.

  , ()
tcPluginRewrite :: s -> UniqFM TyCon TcPluginRewriter
    -- ^ Rewrite saturated type family applications.
    --
    -- The plugin is expected to supply a mapping from type family names to
    -- rewriting functions. For each type family 'TyCon', the plugin should
    -- provide a function which takes in the given constraints and arguments
    -- of a saturated type family application, and return a possible rewriting.
    -- See 'TcPluginRewriter' for the expected shape of such a function.
    --
    -- Use @ \\ _ -> emptyUFM @ if your plugin does not provide this functionality.

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

-- | The plugin found a contradiction.
-- The returned constraints are removed from the inert set,
-- and recorded as insoluble.
--
-- The returned list of constraints should never be empty.
pattern TcPluginContradiction :: [Ct] -> TcPluginSolveResult
pattern $mTcPluginContradiction :: forall {r}. TcPluginSolveResult -> ([Ct] -> r) -> ((# #) -> r) -> r
$bTcPluginContradiction :: [Ct] -> TcPluginSolveResult
TcPluginContradiction insols
  = TcPluginSolveResult
  { tcPluginInsolubleCts = insols
  , tcPluginSolvedCts    = []
  , tcPluginNewCts       = [] }

-- | The plugin has not found any contradictions,
--
-- The first field is for constraints that were solved.
-- The second field contains new work, that should be processed by
-- the constraint solver.
pattern TcPluginOk :: [(EvTerm, Ct)] -> [Ct] -> TcPluginSolveResult
pattern $mTcPluginOk :: forall {r}.
TcPluginSolveResult
-> ([(EvTerm, Ct)] -> [Ct] -> r) -> ((# #) -> r) -> r
$bTcPluginOk :: [(EvTerm, Ct)] -> [Ct] -> TcPluginSolveResult
TcPluginOk solved new
  = TcPluginSolveResult
  { tcPluginInsolubleCts = []
  , tcPluginSolvedCts    = solved
  , tcPluginNewCts       = new }

-- | Result of running a solver plugin.
data TcPluginSolveResult
  = TcPluginSolveResult
  { -- | Insoluble constraints found by the plugin.
    --
    -- These constraints will be added to the inert set,
    -- and reported as insoluble to the user.
    TcPluginSolveResult -> [Ct]
tcPluginInsolubleCts :: [Ct]
    -- | Solved constraints, together with their evidence.
    --
    -- These are removed from the inert set, and the
    -- evidence for them is recorded.
  , TcPluginSolveResult -> [(EvTerm, Ct)]
tcPluginSolvedCts :: [(EvTerm, Ct)]
    -- | New constraints that the plugin wishes to emit.
    --
    -- These will be added to the work list.
  , TcPluginSolveResult -> [Ct]
tcPluginNewCts :: [Ct]
  }

data TcPluginRewriteResult
  =
  -- | The plugin does not rewrite the type family application.
    TcPluginNoRewrite

  -- | The plugin rewrites the type family application
  -- providing a rewriting together with evidence: a 'Reduction',
  -- which contains the rewritten type together with a 'Coercion'
  -- whose right-hand-side type is the rewritten type.
  --
  -- The plugin can also emit additional Wanted constraints.
  | TcPluginRewriteTo
    { TcPluginRewriteResult -> Reduction
tcPluginReduction    :: !Reduction
    , TcPluginRewriteResult -> [Ct]
tcRewriterNewWanteds :: [Ct]
    }

-- | A collection of candidate default types for sets of type variables.
data DefaultingProposal
  = DefaultingProposal
    { DefaultingProposal -> [[(TyVar, Type)]]
deProposals :: [[(TcTyVar, Type)]]
      -- ^ The type variable assignments to try.
    , DefaultingProposal -> [Ct]
deProposalCts :: [Ct]
      -- ^ The constraints against which defaults are checked.
    }

instance Outputable DefaultingProposal where
  ppr :: DefaultingProposal -> SDoc
ppr DefaultingProposal
p = FilePath -> SDoc
forall doc. IsLine doc => FilePath -> doc
text FilePath
"DefaultingProposal"
          SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> [[(TyVar, Type)]] -> SDoc
forall a. Outputable a => a -> SDoc
ppr (DefaultingProposal -> [[(TyVar, Type)]]
deProposals DefaultingProposal
p)
          SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> [Ct] -> SDoc
forall a. Outputable a => a -> SDoc
ppr (DefaultingProposal -> [Ct]
deProposalCts DefaultingProposal
p)

type FillDefaulting
  = WantedConstraints
      -- Zonked constraints containing the unfilled metavariables that
      -- can be defaulted. See wrinkle (DP1) of Note [Defaulting plugins]
      -- in GHC.Tc.Solver
  -> TcPluginM [DefaultingProposal]

-- | A plugin for controlling defaulting.
data DefaultingPlugin = forall s. DefaultingPlugin
  { ()
dePluginInit :: TcPluginM s
    -- ^ Initialize plugin, when entering type-checker.
  , ()
dePluginRun :: s -> FillDefaulting
    -- ^ Default some types
  , ()
dePluginStop :: s -> TcPluginM ()
   -- ^ Clean up after the plugin, when exiting the type-checker.
  }

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

type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)

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

emptyRoleAnnotEnv :: RoleAnnotEnv
emptyRoleAnnotEnv :: RoleAnnotEnv
emptyRoleAnnotEnv = RoleAnnotEnv
NameEnv (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcRn))
forall a. NameEnv a
emptyNameEnv

lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
lookupRoleAnnot = RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
NameEnv (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcRn))
-> Name -> Maybe (GenLocated SrcSpanAnnA (RoleAnnotDecl 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 (GenLocated SrcSpanAnnA (RoleAnnotDecl GhcRn)))
-> [Name] -> [GenLocated SrcSpanAnnA (RoleAnnotDecl GhcRn)]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
lookupRoleAnnot RoleAnnotEnv
role_env) [Name]
bndrs

{- *********************************************************************
*                                                                      *
                  Linting a TcGblEnv
*                                                                      *
********************************************************************* -}

-- | Check the 'TcGblEnv' for consistency. Currently, only checks
-- axioms, but should check other aspects, too.
lintGblEnv :: Logger -> DynFlags -> TcGblEnv -> TcM ()
lintGblEnv :: Logger -> DynFlags -> TcGblEnv -> TcM ()
lintGblEnv Logger
logger DynFlags
dflags TcGblEnv
tcg_env =
  -- TODO empty list means no extra in scope from GHCi, is this correct?
  IO () -> TcM ()
forall a. IO a -> IOEnv (Env TcGblEnv TcLclEnv) a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> TcM ()) -> IO () -> TcM ()
forall a b. (a -> b) -> a -> b
$ Logger -> LintConfig -> SDoc -> [CoAxiom Branched] -> IO ()
lintAxioms Logger
logger (DynFlags -> [TyVar] -> LintConfig
initLintConfig DynFlags
dflags []) (FilePath -> SDoc
forall doc. IsLine doc => FilePath -> doc
text FilePath
"TcGblEnv axioms") [CoAxiom Branched]
axioms
  where
    axioms :: [CoAxiom Branched]
axioms = TypeEnv -> [CoAxiom Branched]
typeEnvCoAxioms (TcGblEnv -> TypeEnv
tcg_type_env TcGblEnv
tcg_env)

-- | This is a mirror of Template Haskell's DocLoc, but the TH names are
-- resolved to GHC names.
data DocLoc = DeclDoc Name
            | ArgDoc Name Int
            | InstDoc Name
            | ModuleDoc
  deriving (DocLoc -> DocLoc -> Bool
(DocLoc -> DocLoc -> Bool)
-> (DocLoc -> DocLoc -> Bool) -> Eq DocLoc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DocLoc -> DocLoc -> Bool
== :: DocLoc -> DocLoc -> Bool
$c/= :: DocLoc -> DocLoc -> Bool
/= :: DocLoc -> DocLoc -> Bool
Eq, Eq DocLoc
Eq DocLoc =>
(DocLoc -> DocLoc -> Ordering)
-> (DocLoc -> DocLoc -> Bool)
-> (DocLoc -> DocLoc -> Bool)
-> (DocLoc -> DocLoc -> Bool)
-> (DocLoc -> DocLoc -> Bool)
-> (DocLoc -> DocLoc -> DocLoc)
-> (DocLoc -> DocLoc -> DocLoc)
-> Ord DocLoc
DocLoc -> DocLoc -> Bool
DocLoc -> DocLoc -> Ordering
DocLoc -> DocLoc -> DocLoc
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DocLoc -> DocLoc -> Ordering
compare :: DocLoc -> DocLoc -> Ordering
$c< :: DocLoc -> DocLoc -> Bool
< :: DocLoc -> DocLoc -> Bool
$c<= :: DocLoc -> DocLoc -> Bool
<= :: DocLoc -> DocLoc -> Bool
$c> :: DocLoc -> DocLoc -> Bool
> :: DocLoc -> DocLoc -> Bool
$c>= :: DocLoc -> DocLoc -> Bool
>= :: DocLoc -> DocLoc -> Bool
$cmax :: DocLoc -> DocLoc -> DocLoc
max :: DocLoc -> DocLoc -> DocLoc
$cmin :: DocLoc -> DocLoc -> DocLoc
min :: DocLoc -> DocLoc -> DocLoc
Ord)

-- | The current collection of docs that Template Haskell has built up via
-- putDoc.
type THDocs = Map DocLoc (HsDoc GhcRn)