    {-# LANGUAGE DataKinds           #-}
    {-# LANGUAGE FlexibleContexts    #-}
    {-# LANGUAGE MonadComprehensions #-}
    {-# LANGUAGE RankNTypes          #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TypeFamilies        #-}
    {-# LANGUAGE ViewPatterns        #-}
    {-# LANGUAGE RecursiveDo        #-}

    {-
    (c) The University of Glasgow 2006
    (c) The GRASP/AQUA Project, Glasgow University, 1992-1998

    -}

    -- | Typechecking user-specified @MonoTypes@
    module GHC.Tc.Gen.HsType (
            -- Type signatures
            kcClassSigType, tcClassSigType,
            tcHsSigType, tcHsSigWcType,
            tcHsPartialSigType,
            tcStandaloneKindSig,
            funsSigCtxt, addSigCtxt, pprSigCtxt,

            tcHsClsInstType,
            tcDefaultDeclClass, tcHsDeriv, tcDerivStrategy,
            tcHsTypeApp,
            UserTypeCtxt(..),
            bindImplicitTKBndrs_Tv, bindImplicitTKBndrs_Skol,
                bindImplicitTKBndrs_Q_Tv, bindImplicitTKBndrs_Q_Skol,
            bindExplicitTKBndrs_Tv, bindExplicitTKBndrs_Skol,
                bindExplicitTKBndrs_Q_Tv, bindExplicitTKBndrs_Q_Skol,

            bindOuterFamEqnTKBndrs_Q_Tv, bindOuterFamEqnTKBndrs,
            tcOuterTKBndrs, scopedSortOuter, outerTyVars, outerTyVarBndrs,
            tcGadtConTyVarBndrs,
            bindOuterSigTKBndrs_Tv,
            tcExplicitTKBndrs,
            bindNamedWildCardBinders,

            -- Type checking type and class decls, and instances thereof
            bindTyClTyVars, bindTyClTyVarsAndZonk,
            tcFamTyPats,
            maybeEtaExpandAlgTyCon, tcbVisibilities,
            etaExpandAlgTyCon,

              -- tyvars
            zonkAndScopedSort,

            -- Kind-checking types
            -- No kind generalisation, no checkValidType
            InitialKindStrategy(..),
            SAKS_or_CUSK(..),
            ContextKind(..),
            kcDeclHeader, checkForDuplicateScopedTyVars,
            tcHsLiftedType,   tcHsOpenType,
            tcHsLiftedTypeNC, tcHsOpenTypeNC,
            tcInferLHsType, tcInferLHsTypeKind, tcInferLHsTypeUnsaturated,
            tcCheckLHsTypeInContext, tcCheckLHsType,
            tcHsContext, tcLHsPredType,

            kindGeneralizeAll,

            -- Sort-checking kinds
            tcLHsKindSig, checkDataKindSig, DataSort(..),
            checkClassKindSig,

            -- Multiplicity
            tcMult,

            -- Pattern type signatures
            tcHsPatSigType, tcHsTyPat, tcRuleBndrSig,
            HoleMode(..),

            -- Utils
            tyLitFromLit, tyLitFromOverloadedLit,

       ) where

    import GHC.Prelude hiding ( head, init, last, tail )

    import GHC.Hs
    import GHC.Rename.Utils
    import GHC.Tc.Errors.Types
    import GHC.Tc.Utils.Monad
    import GHC.Tc.Types.Origin
    import GHC.Tc.Types.LclEnv
    import GHC.Tc.Types.ErrCtxt
    import GHC.Tc.Types.Constraint
    import GHC.Tc.Utils.Env
    import GHC.Tc.Utils.TcMType
    import GHC.Tc.Validity
    import GHC.Tc.Utils.Unify
    import GHC.IfaceToCore
    import GHC.Tc.Solver
    import GHC.Tc.Zonk.Type
    import GHC.Tc.Utils.TcType
    import GHC.Tc.Utils.Instantiate ( tcInstInvisibleTyBinders, tcInstInvisibleTyBindersN,
                                      tcInstInvisibleTyBinder, tcSkolemiseInvisibleBndrs,
                                      tcInstTypeBndrs )
    import GHC.Tc.Zonk.TcType

    import GHC.Core.Type
    import GHC.Core.TyCo.Rep
    import GHC.Core.TyCo.Ppr

    import GHC.Builtin.Types.Prim
    import GHC.Types.Error
    import GHC.Types.Name.Env
    import GHC.Types.Name.Reader( WithUserRdr(..), lookupLocalRdrOcc )
    import GHC.Types.Var
    import GHC.Types.Var.Set
    import GHC.Core.TyCon
    import GHC.Core.ConLike
    import GHC.Core.DataCon
    import GHC.Core.Class
    import GHC.Types.Name
    import GHC.Types.Var.Env
    import GHC.Builtin.Types
    import GHC.Types.Basic
    import GHC.Types.SrcLoc
    import GHC.Types.Unique
    import GHC.Types.Unique.FM
    import GHC.Utils.Misc
    import GHC.Types.Unique.Supply
    import GHC.Utils.Outputable
    import GHC.Utils.Panic
    import GHC.Builtin.Names hiding ( wildCardName )
    import GHC.Driver.DynFlags
    import qualified GHC.LanguageExtensions as LangExt

    import GHC.Data.FastString
    import GHC.Data.List.Infinite ( Infinite (..) )
    import qualified GHC.Data.List.Infinite as Inf
    import GHC.Data.List.SetOps
    import GHC.Data.Maybe
    import GHC.Data.Bag( unitBag )

    import Data.Function ( on )
    import Data.List.NonEmpty ( NonEmpty(..), nonEmpty )
    import qualified Data.List.NonEmpty as NE
    import Data.List ( mapAccumL )
    import Control.Monad
    import Data.Tuple( swap )
    import GHC.Types.SourceText

    {-
            ----------------------------
                    General notes
            ----------------------------

    Unlike with expressions, type-checking types both does some checking and
    desugars at the same time. This is necessary because we often want to perform
    equality checks on the types right away, and it would be incredibly painful
    to do this on un-desugared types. Luckily, desugared types are close enough
    to HsTypes to make the error messages sane.

    During type-checking, we perform as little validity checking as possible.
    Generally, after type-checking, you will want to do validity checking, say
    with GHC.Tc.Validity.checkValidType.

    Validity checking
    ~~~~~~~~~~~~~~~~~
    Some of the validity check could in principle be done by the kind checker,
    but not all:

    - During desugaring, we normalise by expanding type synonyms.  Only
      after this step can we check things like type-synonym saturation
      e.g.  type T k = k Int
            type S a = a
      Then (T S) is ok, because T is saturated; (T S) expands to (S Int);
      and then S is saturated.  This is a GHC extension.

    - Similarly, also a GHC extension, we look through synonyms before complaining
      about the form of a class or instance declaration

    - Ambiguity checks involve functional dependencies

    Also, in a mutually recursive group of types, we can't look at the TyCon until we've
    finished building the loop.  So to keep things simple, we postpone most validity
    checking until step (3).

    %************************************************************************
    %*                                                                      *
                  Check types AND do validity checking
    *                                                                      *
    ************************************************************************

    Note [Keeping implicitly quantified variables in order]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When the user implicitly quantifies over variables (say, in a type
    signature), we need to come up with some ordering on these variables.
    This is done by bumping the TcLevel, bringing the tyvars into scope,
    and then type-checking the thing_inside. The constraints are all
    wrapped in an implication, which is then solved. Finally, we can
    zonk all the binders and then order them with scopedSort.

    It's critical to solve before zonking and ordering in order to uncover
    any unifications. You might worry that this eager solving could cause
    trouble elsewhere. I don't think it will. Because it will solve only
    in an increased TcLevel, it can't unify anything that was mentioned
    elsewhere. Additionally, we require that the order of implicitly
    quantified variables is manifest by the scope of these variables, so
    we're not going to learn more information later that will help order
    these variables.

    Note [Recipe for checking a signature]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Kind-checking a user-written signature requires several steps:

     0. Bump the TcLevel
     1.   Bind any lexically-scoped type variables.
     2.   Generate constraints.
     3. Solve constraints.
     4. Sort any implicitly-bound variables into dependency order
     5. Promote tyvars and/or kind-generalize.
     6. Zonk.
     7. Check validity.

    Very similar steps also apply when kind-checking a type or class
    declaration.

    The general pattern looks something like this.  (But NB every
    specific instance varies in one way or another!)

        do { (tclvl, wanted, (spec_tkvs, ty))
                  <- pushLevelAndSolveEqualitiesX "tc_top_lhs_type" $
                     bindImplicitTKBndrs_Skol sig_vars              $
                     <kind-check the type>

           ; spec_tkvs <- zonkAndScopedSort spec_tkvs

           ; reportUnsolvedEqualities skol_info spec_tkvs tclvl wanted

           ; let ty1 = mkSpecForAllTys spec_tkvs ty
           ; kvs <- kindGeneralizeAll ty1

           ; final_ty <- zonkTcTypeToType (mkInfForAllTys kvs ty1)

           ; checkValidType final_ty

    This pattern is repeated many times in GHC.Tc.Gen.HsType,
    GHC.Tc.Gen.Sig, and GHC.Tc.TyCl, with variations.  In more detail:

    * pushLevelAndSolveEqualitiesX (Step 0, step 3) bumps the TcLevel,
      calls the thing inside to generate constraints, solves those
      constraints as much as possible, returning the residual unsolved
      constraints in 'wanted'.

    * bindImplicitTKBndrs_Skol (Step 1) binds the user-specified type
      variables E.g.  when kind-checking f :: forall a. F a -> a we must
      bring 'a' into scope before kind-checking (F a -> a)

    * zonkAndScopedSort (Step 4) puts those user-specified variables in
      the dependency order.  (For "implicit" variables the order is no
      user-specified.  E.g.  forall (a::k1) (b::k2). blah k1 and k2 are
      implicitly brought into scope.

    * reportUnsolvedEqualities (Step 3 continued) reports any unsolved
      equalities, carefully wrapping them in an implication that binds the
      skolems.  We can't do that in pushLevelAndSolveEqualitiesX because
      that function doesn't have access to the skolems.

    * kindGeneralize (Step 5). See Note [Kind generalisation]

    * The final zonkTcTypeToType must happen after promoting/generalizing,
      because promoting and generalizing fill in metavariables.

    Doing Step 3 (constraint solving) eagerly (rather than building an
    implication constraint and solving later) is necessary for several
    reasons:

    * Exactly as for Solver.simplifyInfer: when generalising, we solve all
      the constraints we can so that we don't have to quantify over them
      or, since we don't quantify over constraints in kinds, float them
      and inhibit generalisation.

    * Most signatures also bring implicitly quantified variables into
      scope, and solving is necessary to get these in the right order
      (Step 4) see Note [Keeping implicitly quantified variables in
      order]).

    Note [Kind generalisation]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~
    Step 5 of Note [Recipe for checking a signature], namely
    kind-generalisation, is done by
        kindGeneraliseAll
        kindGeneraliseSome
        kindGeneraliseNone

    Here, we have to deal with the fact that metatyvars generated in the
    type will have a bumped TcLevel, because explicit foralls raise the
    TcLevel. To avoid these variables from ever being visible in the
    surrounding context, we must obey the following dictum:

      Every metavariable in a type must either be
        (A) generalized, or
        (B) promoted, or        See Note [Promotion in signatures]
        (C) a cause to error    See Note [Naughty quantification candidates]
                                in GHC.Tc.Utils.TcMType

    There are three steps (look at kindGeneraliseSome):

    1. candidateQTyVarsOfType finds the free variables of the type or kind,
       to generalise

    2. filterConstrainedCandidates filters out candidates that appear
       in the unsolved 'wanteds', and promotes the ones that get filtered out
       thereby.

    3. quantifyTyVars quantifies the remaining type variables

    The kindGeneralize functions do not require pre-zonking; they zonk as they
    go.

    kindGeneraliseAll specialises for the case where step (2) is vacuous.
    kindGeneraliseNone specialises for the case where we do no quantification,
    but we must still promote.

    If you are actually doing kind-generalization, you need to bump the
    level before generating constraints, as we will only generalize
    variables with a TcLevel higher than the ambient one.
    Hence the "pushLevel" in pushLevelAndSolveEqualities.

    Note [Promotion in signatures]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    If an unsolved metavariable in a signature is not generalized
    (because we're not generalizing the construct -- e.g., pattern
    sig -- or because the metavars are constrained -- see kindGeneralizeSome)
    we need to promote to maintain (WantedInv) of Note [TcLevel invariants]
    in GHC.Tc.Utils.TcType. Note that promotion is identical in effect to generalizing
    and the reinstantiating with a fresh metavariable at the current level.
    So in some sense, we generalize *all* variables, but then re-instantiate
    some of them.

    Here is an example of why we must promote:
      foo (x :: forall a. a -> Proxy b) = ...

    In the pattern signature, `b` is unbound, and will thus be brought into
    scope. We do not know its kind: it will be assigned kappa[2]. Note that
    kappa is at TcLevel 2, because it is invented under a forall. (A priori,
    the kind kappa might depend on `a`, so kappa rightly has a higher TcLevel
    than the surrounding context.) This kappa cannot be solved for while checking
    the pattern signature (which is not kind-generalized). When we are checking
    the *body* of foo, though, we need to unify the type of x with the argument
    type of bar. At this point, the ambient TcLevel is 1, and spotting a
    metavariable with level 2 would violate the (WantedInv) invariant of
    Note [TcLevel invariants]. So, instead of kind-generalizing,
    we promote the metavariable to level 1. This is all done in kindGeneralizeNone.

    -}

    funsSigCtxt :: [LocatedN Name] -> UserTypeCtxt
    -- Returns FunSigCtxt, with no redundant-context-reporting,
    -- form a list of located names
    funsSigCtxt :: [GenLocated SrcSpanAnnN Name] -> UserTypeCtxt
    funsSigCtxt (L SrcSpanAnnN
    _ Name
    name1 : [GenLocated SrcSpanAnnN Name]
    _) = Name -> ReportRedundantConstraints -> UserTypeCtxt
    FunSigCtxt Name
    name1 ReportRedundantConstraints
    NoRRC
    funsSigCtxt []              = String -> UserTypeCtxt
    forall a. HasCallStack => String -> a
    panic String
    "funSigCtxt"

    addSigCtxt :: UserTypeCtxt -> UserSigType GhcRn -> TcM a -> TcM a
    addSigCtxt :: forall a. UserTypeCtxt -> UserSigType GhcRn -> TcM a -> TcM a
    addSigCtxt UserTypeCtxt
    ctxt UserSigType GhcRn
    hs_ty TcM a
    thing_inside
      = SrcSpan -> TcM a -> TcM a
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan SrcSpan
    l (TcM a -> TcM a) -> TcM a -> TcM a
    forall a b. (a -> b) -> a -> b
    $
        ErrCtxtMsg -> TcM a -> TcM a
    forall a. ErrCtxtMsg -> TcM a -> TcM a
    addErrCtxt (UserTypeCtxt -> UserSigType GhcRn -> ErrCtxtMsg
    UserSigCtxt UserTypeCtxt
    ctxt UserSigType GhcRn
    hs_ty) (TcM a -> TcM a) -> TcM a -> TcM a
    forall a b. (a -> b) -> a -> b
    $
        TcM a
    thing_inside
      where
        l :: SrcSpan
    l = case UserSigType GhcRn
    hs_ty of
          UserLHsSigType LHsSigType GhcRn
    ty -> GenLocated SrcSpanAnnA (HsSigType GhcRn) -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA LHsSigType GhcRn
    GenLocated SrcSpanAnnA (HsSigType GhcRn)
    ty
          UserLHsType LHsType GhcRn
    ty    -> GenLocated SrcSpanAnnA (HsType GhcRn) -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    ty

    pprSigCtxt :: Outputable hs_ty => UserTypeCtxt -> LocatedA hs_ty -> SDoc
    -- (pprSigCtxt ctxt <extra> <type>)
    -- prints    In the type signature for 'f':
    --              f :: <type>
    -- The <extra> is either empty or "the ambiguity check for"
    pprSigCtxt :: forall hs_ty.
    Outputable hs_ty =>
    UserTypeCtxt -> LocatedA hs_ty -> SDoc
    pprSigCtxt UserTypeCtxt
    ctxt LocatedA hs_ty
    hs_ty
      | Just Name
    n <- UserTypeCtxt -> Maybe Name
    isSigMaybe UserTypeCtxt
    ctxt
      = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "In the type signature:")
           Int
    2 (Name -> SDoc
    forall a. OutputableBndr a => a -> SDoc
    pprPrefixOcc Name
    n SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> LocatedA hs_ty -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LocatedA hs_ty
    hs_ty)

      | Bool
    otherwise
      = SDoc -> Int -> SDoc -> SDoc
    hang (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "In" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> UserTypeCtxt -> SDoc
    pprUserTypeCtxt UserTypeCtxt
    ctxt SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon)
           Int
    2 (LocatedA hs_ty -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LocatedA hs_ty
    hs_ty)

    tcHsSigWcType :: UserTypeCtxt -> LHsSigWcType GhcRn -> TcM Type
    -- This one is used when we have a LHsSigWcType, but in
    -- a place where wildcards aren't allowed. The renamer has
    -- already checked this, so we can simply ignore it.
    tcHsSigWcType :: UserTypeCtxt -> LHsSigWcType GhcRn -> TcM Type
    tcHsSigWcType UserTypeCtxt
    ctxt LHsSigWcType GhcRn
    sig_ty = UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tcHsSigType UserTypeCtxt
    ctxt (LHsSigWcType GhcRn -> LHsSigType GhcRn
    forall (p :: Pass).
    LHsSigWcType (GhcPass p) -> LHsSigType (GhcPass p)
    dropWildCards LHsSigWcType GhcRn
    sig_ty)

    kcClassSigType :: [LocatedN Name] -> LHsSigType GhcRn -> TcM ()
    -- This is a special form of tcClassSigType that is used during the
    -- kind-checking phase to infer the kind of class variables. Cf. tc_lhs_sig_type.
    -- Importantly, this does *not* kind-generalize. Consider
    --   class SC f where
    --     meth :: forall a (x :: f a). Proxy x -> ()
    -- When instantiating Proxy with kappa, we must unify kappa := f a. But we're
    -- still working out the kind of f, and thus f a will have a coercion in it.
    -- Coercions may block unification (Note [Equalities with heterogeneous kinds] in
    -- GHC.Tc.Solver.Equality, wrinkle (EIK2)) and so we fail to unify. If we try to
    -- kind-generalize, we'll end up promoting kappa to the top level (because
    -- kind-generalization is normally done right before adding a binding to the context),
    -- and then we can't set kappa := f a, because a is local.
    kcClassSigType :: [GenLocated SrcSpanAnnN Name] -> LHsSigType GhcRn -> TcM ()
    kcClassSigType [GenLocated SrcSpanAnnN Name]
    names
        sig_ty :: LHsSigType GhcRn
    sig_ty@(L SrcSpanAnnA
    _ (HsSig { sig_bndrs :: forall pass. HsSigType pass -> HsOuterSigTyVarBndrs pass
    sig_bndrs = HsOuterSigTyVarBndrs GhcRn
    hs_outer_bndrs, sig_body :: forall pass. HsSigType pass -> LHsType pass
    sig_body = LHsType GhcRn
    hs_ty }))
      = UserTypeCtxt -> UserSigType GhcRn -> TcM () -> TcM ()
    forall a. UserTypeCtxt -> UserSigType GhcRn -> TcM a -> TcM a
    addSigCtxt ([GenLocated SrcSpanAnnN Name] -> UserTypeCtxt
    funsSigCtxt [GenLocated SrcSpanAnnN Name]
    names) (LHsSigType GhcRn -> UserSigType GhcRn
    forall p. LHsSigType p -> UserSigType p
    UserLHsSigType LHsSigType GhcRn
    sig_ty) (TcM () -> TcM ()) -> TcM () -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
        do { _ <- HsOuterSigTyVarBndrs GhcRn
    -> TcM Type -> TcM (HsOuterTyVarBndrs Specificity GhcTc, Type)
    forall a.
    HsOuterSigTyVarBndrs GhcRn
    -> TcM a -> TcM (HsOuterTyVarBndrs Specificity GhcTc, a)
    bindOuterSigTKBndrs_Tv HsOuterSigTyVarBndrs GhcRn
    hs_outer_bndrs    (TcM Type -> TcM (HsOuterTyVarBndrs Specificity GhcTc, Type))
    -> TcM Type -> TcM (HsOuterTyVarBndrs Specificity GhcTc, Type)
    forall a b. (a -> b) -> a -> b
    $
                  LHsType GhcRn -> Type -> TcM Type
    tcCheckLHsType LHsType GhcRn
    hs_ty Type
    liftedTypeKind
           ; return () }

    tcClassSigType :: [LocatedN Name] -> LHsSigType GhcRn -> TcM Type
    -- Does not do validity checking
    tcClassSigType :: [GenLocated SrcSpanAnnN Name] -> LHsSigType GhcRn -> TcM Type
    tcClassSigType [GenLocated SrcSpanAnnN Name]
    names LHsSigType GhcRn
    sig_ty
      = UserTypeCtxt -> UserSigType GhcRn -> TcM Type -> TcM Type
    forall a. UserTypeCtxt -> UserSigType GhcRn -> TcM a -> TcM a
    addSigCtxt UserTypeCtxt
    sig_ctxt (LHsSigType GhcRn -> UserSigType GhcRn
    forall p. LHsSigType p -> UserSigType p
    UserLHsSigType LHsSigType GhcRn
    sig_ty) (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
        do { skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
    forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
    mkSkolemInfo SkolemInfoAnon
    skol_info_anon
           ; (implic, ty) <- tc_lhs_sig_type skol_info sig_ty (TheKind liftedTypeKind)
           ; emitImplication implic
           ; return ty }
           -- Do not zonk-to-Type, nor perform a validity check
           -- We are in a knot with the class and associated types
           -- Zonking and validity checking is done by tcClassDecl
           --
           -- No need to fail here if the type has an error:
           --   If we're in the kind-checking phase, the solveEqualities
           --     in kcTyClGroup catches the error
           --   If we're in the type-checking phase, the solveEqualities
           --     in tcClassDecl1 gets it
           -- Failing fast here degrades the error message in, e.g., tcfail135:
           --   class Foo f where
           --     baa :: f a -> f
           -- If we fail fast, we're told that f has kind `k1` when we wanted `*`.
           -- It should be that f has kind `k2 -> *`, but we never get a chance
           -- to run the solver where the kind of f is touchable. This is
           -- painfully delicate.
      where
        sig_ctxt :: UserTypeCtxt
    sig_ctxt = [GenLocated SrcSpanAnnN Name] -> UserTypeCtxt
    funsSigCtxt [GenLocated SrcSpanAnnN Name]
    names
        skol_info_anon :: SkolemInfoAnon
    skol_info_anon = UserTypeCtxt -> SkolemInfoAnon
    SigTypeSkol UserTypeCtxt
    sig_ctxt

    tcHsSigType :: UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    -- Does validity checking
    -- See Note [Recipe for checking a signature]
    tcHsSigType :: UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tcHsSigType UserTypeCtxt
    ctxt LHsSigType GhcRn
    sig_ty
      = UserTypeCtxt -> UserSigType GhcRn -> TcM Type -> TcM Type
    forall a. UserTypeCtxt -> UserSigType GhcRn -> TcM a -> TcM a
    addSigCtxt UserTypeCtxt
    ctxt (LHsSigType GhcRn -> UserSigType GhcRn
    forall p. LHsSigType p -> UserSigType p
    UserLHsSigType LHsSigType GhcRn
    sig_ty) (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
        do { String -> SDoc -> TcM ()
    traceTc String
    "tcHsSigType {" (GenLocated SrcSpanAnnA (HsSigType GhcRn) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsSigType GhcRn
    GenLocated SrcSpanAnnA (HsSigType GhcRn)
    sig_ty)
           ; skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
    forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
    mkSkolemInfo SkolemInfoAnon
    skol_info
              -- Generalise here: see Note [Kind generalisation]
           ; (implic, ty) <- tc_lhs_sig_type skol_info sig_ty  (expectedKindInCtxt ctxt)

           -- Float out constraints, failing fast if not possible
           -- See Note [Failure in local type signatures] in GHC.Tc.Solver
           ; traceTc "tcHsSigType 2" (ppr implic)
           ; simplifyAndEmitFlatConstraints (mkImplicWC (unitBag implic))

           ; ty <- liftZonkM $ zonkTcType ty
           ; checkValidType ctxt ty
           ; traceTc "end tcHsSigType }" (ppr ty)
           ; return ty }
      where
        skol_info :: SkolemInfoAnon
    skol_info = UserTypeCtxt -> SkolemInfoAnon
    SigTypeSkol UserTypeCtxt
    ctxt

    tc_lhs_sig_type :: SkolemInfo -> LHsSigType GhcRn
                   -> ContextKind -> TcM (Implication, TcType)
    -- Kind-checks/desugars an 'LHsSigType',
    --   solve equalities,
    --   and then kind-generalizes.
    -- This will never emit constraints, as it uses solveEqualities internally.
    -- No validity checking or zonking
    -- Returns also an implication for the unsolved constraints
    tc_lhs_sig_type :: SkolemInfo
    -> LHsSigType GhcRn -> ContextKind -> TcM (Implication, Type)
    tc_lhs_sig_type SkolemInfo
    skol_info full_hs_ty :: LHsSigType GhcRn
    full_hs_ty@(L SrcSpanAnnA
    loc (HsSig { sig_bndrs :: forall pass. HsSigType pass -> HsOuterSigTyVarBndrs pass
    sig_bndrs = HsOuterSigTyVarBndrs GhcRn
    hs_outer_bndrs
                                                       , sig_body :: forall pass. HsSigType pass -> LHsType pass
    sig_body = LHsType GhcRn
    hs_ty })) ContextKind
    ctxt_kind
      = SrcSpanAnnA -> TcM (Implication, Type) -> TcM (Implication, Type)
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    loc (TcM (Implication, Type) -> TcM (Implication, Type))
    -> TcM (Implication, Type) -> TcM (Implication, Type)
    forall a b. (a -> b) -> a -> b
    $
        do { (tc_lvl, wanted, (exp_kind, (outer_bndrs, ty)))
                  <- String
    -> TcM (Type, (HsOuterTyVarBndrs Specificity GhcTc, Type))
    -> TcM
         (TcLevel, WantedConstraints,
          (Type, (HsOuterTyVarBndrs Specificity GhcTc, Type)))
    forall a. String -> TcM a -> TcM (TcLevel, WantedConstraints, a)
    pushLevelAndSolveEqualitiesX String
    "tc_lhs_sig_type" (TcM (Type, (HsOuterTyVarBndrs Specificity GhcTc, Type))
     -> TcM
          (TcLevel, WantedConstraints,
           (Type, (HsOuterTyVarBndrs Specificity GhcTc, Type))))
    -> TcM (Type, (HsOuterTyVarBndrs Specificity GhcTc, Type))
    -> TcM
         (TcLevel, WantedConstraints,
          (Type, (HsOuterTyVarBndrs Specificity GhcTc, Type)))
    forall a b. (a -> b) -> a -> b
    $
                     -- See Note [Failure in local type signatures]
                     do { exp_kind <- ContextKind -> TcM Type
    newExpectedKind ContextKind
    ctxt_kind
                              -- See Note [Escaping kind in type signatures]
                        ; stuff <- tcOuterTKBndrs skol_info hs_outer_bndrs $
                                   tcCheckLHsType hs_ty exp_kind
                        ; return (exp_kind, stuff) }

           -- Default any unconstrained variables free in the kind
           -- See Note [Escaping kind in type signatures]
           ; exp_kind_dvs <- candidateQTyVarsOfType exp_kind
           ; doNotQuantifyTyVars exp_kind_dvs (err_ctx exp_kind)

           ; traceTc "tc_lhs_sig_type" (ppr hs_outer_bndrs $$ ppr outer_bndrs)
           ; outer_bndrs <- scopedSortOuter outer_bndrs

           ; let outer_tv_bndrs :: [InvisTVBinder] = outerTyVarBndrs outer_bndrs
                 ty1 = [VarBndr TyVar Specificity] -> Type -> Type
    mkInvisForAllTys [VarBndr TyVar Specificity]
    outer_tv_bndrs Type
    ty
           ; kvs <- kindGeneralizeSome skol_info wanted ty1

           -- Build an implication for any as-yet-unsolved kind equalities
           -- See Note [Skolem escape in type signatures]
           ; implic <- buildTvImplication (getSkolemInfo skol_info) kvs tc_lvl wanted

           ; return (implic, mkInfForAllTys kvs ty1) }
      where
        err_ctx :: Type -> TidyEnv -> ZonkM (TidyEnv, UninferrableTyVarCtx)
    err_ctx Type
    exp_kind TidyEnv
    tidy_env
          = do { (tidy_env2, exp_kind) <- TidyEnv -> Type -> ZonkM (TidyEnv, Type)
    zonkTidyTcType TidyEnv
    tidy_env Type
    exp_kind
               ; return (tidy_env2, UninfTyCtx_Sig exp_kind full_hs_ty) }

    {- Note [Escaping kind in type signatures]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider kind-checking the signature for `foo` (#19495, #24686):
      type family T (r :: RuntimeRep) :: TYPE r

      foo :: forall (r :: RuntimeRep). T r
      foo = ...

    We kind-check the type with expected kind `TYPE delta` (see newExpectedKind),
    where `delta :: RuntimeRep` is as-yet unknown. (We can't use `TYPE LiftedRep`
    because we allow signatures like `foo :: Int#`.)

    Suppose we are at level L currently.  We do this
      * pushLevelAndSolveEqualitiesX: moves to level L+1
      * newExpectedKind: allocates delta{L+1}. Note carefully that
        this call is /outside/ the tcOuterTKBndrs call.
      * tcOuterTKBndrs: pushes the level again to L+2, binds skolem r{L+2}
      * kind-check the body (T r) :: TYPE delta{L+1}

    Then
    * We can't unify delta{L+1} with r{L+2}.
      And rightly so: skolem would escape.

    * If delta{L+1} is unified with some-kind{L}, that is fine.
      This can happen
          \(x::a) -> let y :: a; y = x in ...(x :: Int#)...
      Here (x :: a :: TYPE gamma) is in the environment when we check
      the signature y::a.  We unify delta := gamma, and all is well.

    * If delta{L+1} is unconstrained, we /must not/ quantify over it!
      E.g. Consider f :: Any   where Any :: forall k. k
      We kind-check this with expected kind TYPE kappa. We get
          Any @(TYPE kappa) :: TYPE kappa
      We don't want to generalise to     forall k. Any @k
      because that is ill-kinded: the kind of the body of the forall,
      (Any @k :: k) mentions the bound variable k.

      Instead we want to default it to LiftedRep.

      An alternative would be to promote it, similar to the monomorphism
      restriction, but the MR is pretty confusing.  Defaulting seems better

    How does that defaulting happen?  Well, since we /currently/ default
    RuntimeRep variables during generalisation, it'll happen in
    kindGeneralize. But in principle we might allow generalisation over
    RuntimeRep variables in future.  Moreover, what if we had
       kappa{L+1} := F alpha{L+1}
    where F :: Type -> RuntimeRep.   Now it's alpha that is free in the kind
    and it /won't/ be defaulted.

    So we use doNotQuantifyTyVars to either default the free vars of
    exp_kind (if possible), or error (if not).

    Note [Skolem escape in type signatures]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    tcHsSigType is tricky.  Consider (T11142)
      foo :: forall b. (forall k (a :: k). SameKind a b) -> ()
    This is ill-kinded because of a nested skolem-escape.

    That will show up as an un-solvable constraint in the implication
    returned by buildTvImplication in tc_lhs_sig_type.  See Note [Skolem
    escape prevention] in GHC.Tc.Utils.TcType for why it is unsolvable
    (the unification variable for b's kind is untouchable).

    Then, in GHC.Tc.Solver.simplifyAndEmitFlatConstraints (called from tcHsSigType)
    we'll try to float out the constraint, be unable to do so, and fail.
    See GHC.Tc.Solver Note [Failure in local type signatures] for more
    detail on this.

    The separation between tcHsSigType and tc_lhs_sig_type is because
    tcClassSigType wants to use the latter, but *not* fail fast, because
    there are skolems from the class decl which are in scope; but it's fine
    not to because tcClassDecl1 has a solveEqualities wrapped around all
    the tcClassSigType calls.

    That's why tcHsSigType does simplifyAndEmitFlatConstraints (which
    fails fast) but tcClassSigType just does emitImplication (which does
    not).  Ugh.

    c.f. see also Note [Skolem escape and forall-types]. The difference
    is that we don't need to simplify at a forall type, only at the
    top level of a signature.
    -}

    -- Does validity checking and zonking.
    tcStandaloneKindSig :: LStandaloneKindSig GhcRn -> TcM (Name, Kind)
    tcStandaloneKindSig :: LStandaloneKindSig GhcRn -> TcM (Name, Type)
    tcStandaloneKindSig (L SrcSpanAnnA
    _ (StandaloneKindSig XStandaloneKindSig GhcRn
    _ (L SrcSpanAnnN
    _ Name
    name) LHsSigType GhcRn
    ksig))
      = UserTypeCtxt
    -> UserSigType GhcRn -> TcM (Name, Type) -> TcM (Name, Type)
    forall a. UserTypeCtxt -> UserSigType GhcRn -> TcM a -> TcM a
    addSigCtxt UserTypeCtxt
    ctxt (LHsSigType GhcRn -> UserSigType GhcRn
    forall p. LHsSigType p -> UserSigType p
    UserLHsSigType LHsSigType GhcRn
    ksig) (TcM (Name, Type) -> TcM (Name, Type))
    -> TcM (Name, Type) -> TcM (Name, Type)
    forall a b. (a -> b) -> a -> b
    $
        do { kind <- TypeOrKind -> UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tc_top_lhs_type TypeOrKind
    KindLevel UserTypeCtxt
    ctxt LHsSigType GhcRn
    ksig
           ; checkValidType ctxt kind
           ; return (name, kind) }
      where
       ctxt :: UserTypeCtxt
    ctxt = Name -> UserTypeCtxt
    StandaloneKindSigCtxt Name
    name

    tcTopLHsType :: UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tcTopLHsType :: UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tcTopLHsType UserTypeCtxt
    ctxt LHsSigType GhcRn
    lsig_ty
      = TcM Type -> TcM Type
    forall r. TcM r -> TcM r
    checkNoErrs (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $  -- Fail eagerly to avoid follow-on errors.  We are at
                       -- top level so these constraints will never be solved later.
        TypeOrKind -> UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tc_top_lhs_type TypeOrKind
    TypeLevel UserTypeCtxt
    ctxt LHsSigType GhcRn
    lsig_ty

    tc_top_lhs_type :: TypeOrKind -> UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    -- tc_top_lhs_type is used for kind-checking top-level LHsSigTypes where
    --   we want to fully solve /all/ equalities, and report errors
    -- Does zonking, but not validity checking because it's used
    --   for things (like deriving and instances) that aren't
    --   ordinary types
    -- Used for both types and kinds
    tc_top_lhs_type :: TypeOrKind -> UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tc_top_lhs_type TypeOrKind
    tyki UserTypeCtxt
    ctxt (L SrcSpanAnnA
    loc sig_ty :: HsSigType GhcRn
    sig_ty@(HsSig { sig_bndrs :: forall pass. HsSigType pass -> HsOuterSigTyVarBndrs pass
    sig_bndrs = HsOuterSigTyVarBndrs GhcRn
    hs_outer_bndrs
                                                   , sig_body :: forall pass. HsSigType pass -> LHsType pass
    sig_body = LHsType GhcRn
    body }))
      = SrcSpanAnnA -> TcM Type -> TcM Type
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    loc (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
        do { String -> SDoc -> TcM ()
    traceTc String
    "tc_top_lhs_type {" (HsSigType GhcRn -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HsSigType GhcRn
    sig_ty)
           ; skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
    forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
    mkSkolemInfo SkolemInfoAnon
    skol_info_anon
           ; (tclvl, wanted, (outer_bndrs, ty))
                  <- pushLevelAndSolveEqualitiesX "tc_top_lhs_type"    $
                     do { kind <- newExpectedKind (expectedKindInCtxt ctxt)
                        ; tcOuterTKBndrs skol_info hs_outer_bndrs $
                          tc_check_lhs_type (mkMode tyki) body kind }

           ; outer_bndrs <- scopedSortOuter outer_bndrs
           ; let outer_tv_bndrs = HsOuterTyVarBndrs Specificity GhcTc -> [VarBndr TyVar Specificity]
    outerTyVarBndrs HsOuterTyVarBndrs Specificity GhcTc
    outer_bndrs
                 ty1 = [VarBndr TyVar Specificity] -> Type -> Type
    mkInvisForAllTys [VarBndr TyVar Specificity]
    outer_tv_bndrs Type
    ty

           ; kvs <- kindGeneralizeAll skol_info ty1  -- "All" because it's a top-level type
           ; reportUnsolvedEqualities skol_info kvs tclvl wanted

           ; final_ty <- initZonkEnv DefaultFlexi
                       $ zonkTcTypeToTypeX (mkInfForAllTys kvs ty1)
           ; traceTc "tc_top_lhs_type }" (vcat [ppr sig_ty, ppr final_ty])
           ; return final_ty }
      where
        skol_info_anon :: SkolemInfoAnon
    skol_info_anon = UserTypeCtxt -> SkolemInfoAnon
    SigTypeSkol UserTypeCtxt
    ctxt

    -- | Typecheck the class in a default declaration, checking that:
    --
    --  - it is indeed a class (not e.g. a type family),
    --  - that the class expects some invisible arguments followed
    --    by a single visible argument.
    tcDefaultDeclClass :: LIdP GhcRn -> TcM (Maybe Class)
    tcDefaultDeclClass :: LIdP GhcRn -> TcM (Maybe Class)
    tcDefaultDeclClass LIdP GhcRn
    l_nm
      = SrcSpan -> TcM (Maybe Class) -> TcM (Maybe Class)
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan (GenLocated SrcSpanAnnN Name -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA LIdP GhcRn
    GenLocated SrcSpanAnnN Name
    l_nm) (TcM (Maybe Class) -> TcM (Maybe Class))
    -> TcM (Maybe Class) -> TcM (Maybe Class)
    forall a b. (a -> b) -> a -> b
    $
      do { let nm :: Name
    nm = GenLocated SrcSpanAnnN Name -> Name
    forall l e. GenLocated l e -> e
    unLoc LIdP GhcRn
    GenLocated SrcSpanAnnN Name
    l_nm
         ; thing <- Name -> TcM TyThing
    tcLookupGlobal Name
    nm
         ; case thing of
            ATyCon TyCon
    tc
              | Just Class
    cls <- TyCon -> Maybe Class
    tyConClass_maybe TyCon
    tc
              -> if [TyConBinder] -> Bool
    is_unary (TyCon -> [TyConBinder]
    tyConBinders TyCon
    tc)
                 then Maybe Class -> TcM (Maybe Class)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe Class -> TcM (Maybe Class))
    -> Maybe Class -> TcM (Maybe Class)
    forall a b. (a -> b) -> a -> b
    $ Class -> Maybe Class
    forall a. a -> Maybe a
    Just Class
    cls
                 else
                   do { TcRnMessage -> TcM ()
    addErrTc (TcRnMessage -> TcM ()) -> TcRnMessage -> TcM ()
    forall a b. (a -> b) -> a -> b
    $ UserTypeCtxt -> TypedThing -> TcRnMessage
    TcRnNonUnaryTypeclassConstraint UserTypeCtxt
    DefaultDeclCtxt (Name -> TypedThing
    NameThing Name
    nm)
                      ; Maybe Class -> TcM (Maybe Class)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Class
    forall a. Maybe a
    Nothing }

            TyThing
    _ -> do { TcRnMessage -> TcM ()
    addErrTc (TcRnMessage -> TcM ()) -> TcRnMessage -> TcM ()
    forall a b. (a -> b) -> a -> b
    $ Name -> TcRnMessage
    TcRnIllegalDefaultClass Name
    nm
                    ; Maybe Class -> TcM (Maybe Class)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Class
    forall a. Maybe a
    Nothing }
         }
      where
        is_unary :: [TyConBinder] -> Bool
        is_unary :: [TyConBinder] -> Bool
    is_unary = ( [TyConBinder] -> Int -> Bool
    forall a. [a] -> Int -> Bool
    `lengthIs` Int
    1 ) ([TyConBinder] -> Bool)
    -> ([TyConBinder] -> [TyConBinder]) -> [TyConBinder] -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (TyConBinder -> Bool) -> [TyConBinder] -> [TyConBinder]
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile TyConBinder -> Bool
    forall tv. VarBndr tv TyConBndrVis -> Bool
    isInvisibleTyConBinder

    -----------------
    tcHsDeriv :: LHsSigType GhcRn -> TcM (Maybe (Class, [TyCoVar], [Type], Kind))
    -- ^ Like tcHsSigType, but for the @...deriving( C ty1 ty2 )@ clause
    --
    -- Returns a class constraint with the last argument missing, and the
    -- expected kind of the remaining argument.
    --
    -- E.g.:
    --
    --  @class C (a::*) (b::k->k)@
    --  @data T a b = ... deriving( C Int )@
    --
    -- This function returns @(C, [k], [k, Int], k->k)@.
    --
    -- Return values are fully zonked
    tcHsDeriv :: LHsSigType GhcRn -> TcM (Maybe (Class, [TyVar], [Type], Type))
    tcHsDeriv LHsSigType GhcRn
    hs_ty
      = do { ty <- UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tcTopLHsType UserTypeCtxt
    DerivClauseCtxt LHsSigType GhcRn
    hs_ty

           ; let (tvs, pred)    = splitForAllTyCoVars ty
                 (kind_args, _) = splitFunTys (typeKind pred)
          -- Checking that `pred` a is type class application

           ; case splitTyConApp_maybe pred of
                Just (TyCon
    tc, [Type]
    tc_args) ->
                  case TyCon -> Maybe Class
    tyConClass_maybe TyCon
    tc of
                    Just Class
    cls ->
                      case [Scaled Type]
    kind_args of
                        [Scaled Type
    _ Type
    last_kind] ->
                          Maybe (Class, [TyVar], [Type], Type)
    -> TcM (Maybe (Class, [TyVar], [Type], Type))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (Class, [TyVar], [Type], Type)
     -> TcM (Maybe (Class, [TyVar], [Type], Type)))
    -> Maybe (Class, [TyVar], [Type], Type)
    -> TcM (Maybe (Class, [TyVar], [Type], Type))
    forall a b. (a -> b) -> a -> b
    $ (Class, [TyVar], [Type], Type)
    -> Maybe (Class, [TyVar], [Type], Type)
    forall a. a -> Maybe a
    Just ((Class, [TyVar], [Type], Type)
     -> Maybe (Class, [TyVar], [Type], Type))
    -> (Class, [TyVar], [Type], Type)
    -> Maybe (Class, [TyVar], [Type], Type)
    forall a b. (a -> b) -> a -> b
    $
                            (Class
    cls, [TyVar]
    tvs, [Type]
    tc_args, Type
    last_kind)
                        [Scaled Type]
    _ ->
                          do { TcRnMessage -> TcM ()
    addErrTc (TcRnMessage -> TcM ()) -> TcRnMessage -> TcM ()
    forall a b. (a -> b) -> a -> b
    $ UserTypeCtxt -> TypedThing -> TcRnMessage
    TcRnNonUnaryTypeclassConstraint UserTypeCtxt
    DerivClauseCtxt (Type -> TypedThing
    TypeThing Type
    pred)
                             ; Maybe (Class, [TyVar], [Type], Type)
    -> TcM (Maybe (Class, [TyVar], [Type], Type))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Class, [TyVar], [Type], Type)
    forall a. Maybe a
    Nothing
                             }
                    Maybe Class
    Nothing ->
                      do { TcRnMessage -> TcM ()
    addErrTc (TcRnMessage -> TcM ()) -> TcRnMessage -> TcM ()
    forall a b. (a -> b) -> a -> b
    $ IllegalInstanceReason -> TcRnMessage
    TcRnIllegalInstance
                                    (IllegalInstanceReason -> TcRnMessage)
    -> IllegalInstanceReason -> TcRnMessage
    forall a b. (a -> b) -> a -> b
    $ TypedThing -> IllegalClassInstanceReason -> IllegalInstanceReason
    IllegalClassInstance (Type -> TypedThing
    TypeThing Type
    ty)
                                    (IllegalClassInstanceReason -> IllegalInstanceReason)
    -> IllegalClassInstanceReason -> IllegalInstanceReason
    forall a b. (a -> b) -> a -> b
    $ IllegalInstanceHeadReason -> IllegalClassInstanceReason
    IllegalInstanceHead
                                    (IllegalInstanceHeadReason -> IllegalClassInstanceReason)
    -> IllegalInstanceHeadReason -> IllegalClassInstanceReason
    forall a b. (a -> b) -> a -> b
    $ InstHeadNonClassHead -> IllegalInstanceHeadReason
    InstHeadNonClassHead
                                    (InstHeadNonClassHead -> IllegalInstanceHeadReason)
    -> InstHeadNonClassHead -> IllegalInstanceHeadReason
    forall a b. (a -> b) -> a -> b
    $ WithUserRdr Name -> TyConFlavour Name -> InstHeadNonClassHead
    InstNonClassTyCon
                                        (Name -> WithUserRdr Name
    noUserRdr (Name -> WithUserRdr Name) -> Name -> WithUserRdr Name
    forall a b. (a -> b) -> a -> b
    $ TyCon -> Name
    tyConName TyCon
    tc)
                                        ((TyCon -> Name) -> TyConFlavour TyCon -> TyConFlavour Name
    forall a b. (a -> b) -> TyConFlavour a -> TyConFlavour b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap TyCon -> Name
    tyConName (TyConFlavour TyCon -> TyConFlavour Name)
    -> TyConFlavour TyCon -> TyConFlavour Name
    forall a b. (a -> b) -> a -> b
    $ TyCon -> TyConFlavour TyCon
    tyConFlavour TyCon
    tc)
                         ; Maybe (Class, [TyVar], [Type], Type)
    -> TcM (Maybe (Class, [TyVar], [Type], Type))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Class, [TyVar], [Type], Type)
    forall a. Maybe a
    Nothing }
                Maybe (TyCon, [Type])
    Nothing ->
                  do { TcRnMessage -> TcM ()
    addErrTc (TcRnMessage -> TcM ()) -> TcRnMessage -> TcM ()
    forall a b. (a -> b) -> a -> b
    $ LHsSigType GhcRn -> TcRnMessage
    TcRnIllegalDerivingItem LHsSigType GhcRn
    hs_ty; Maybe (Class, [TyVar], [Type], Type)
    -> TcM (Maybe (Class, [TyVar], [Type], Type))
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Class, [TyVar], [Type], Type)
    forall a. Maybe a
    Nothing }
           }

    -- | Typecheck a deriving strategy. For most deriving strategies, this is a
    -- no-op, but for the @via@ strategy, this requires typechecking the @via@ type.
    tcDerivStrategy :: Maybe (LDerivStrategy GhcRn)
                       -- ^ The deriving strategy
                    -> TcM (Maybe (LDerivStrategy GhcTc), [TcTyVar])
                       -- ^ The typechecked deriving strategy and the tyvars that it binds
                       -- (if using 'ViaStrategy').
    tcDerivStrategy :: Maybe (LDerivStrategy GhcRn)
    -> TcM (Maybe (LDerivStrategy GhcTc), [TyVar])
    tcDerivStrategy Maybe (LDerivStrategy GhcRn)
    mb_lds
      = case Maybe (LDerivStrategy GhcRn)
    mb_lds of
          Maybe (LDerivStrategy GhcRn)
    Nothing -> Maybe (GenLocated EpAnnCO (DerivStrategy GhcTc))
    -> TcM (Maybe (GenLocated EpAnnCO (DerivStrategy GhcTc)), [TyVar])
    forall ds a. ds -> TcM (ds, [a])
    boring_case Maybe (GenLocated EpAnnCO (DerivStrategy GhcTc))
    forall a. Maybe a
    Nothing
          Just (L EpAnnCO
    loc DerivStrategy GhcRn
    ds) ->
            EpAnnCO
    -> TcM (Maybe (LDerivStrategy GhcTc), [TyVar])
    -> TcM (Maybe (LDerivStrategy GhcTc), [TyVar])
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA EpAnnCO
    loc (TcM (Maybe (LDerivStrategy GhcTc), [TyVar])
     -> TcM (Maybe (LDerivStrategy GhcTc), [TyVar]))
    -> TcM (Maybe (LDerivStrategy GhcTc), [TyVar])
    -> TcM (Maybe (LDerivStrategy GhcTc), [TyVar])
    forall a b. (a -> b) -> a -> b
    $ do
              (ds', tvs) <- DerivStrategy GhcRn -> TcM (DerivStrategy GhcTc, [TyVar])
    tc_deriv_strategy DerivStrategy GhcRn
    ds
              pure (Just (L loc ds'), tvs)
      where
        tc_deriv_strategy :: DerivStrategy GhcRn
                          -> TcM (DerivStrategy GhcTc, [TyVar])
        tc_deriv_strategy :: DerivStrategy GhcRn -> TcM (DerivStrategy GhcTc, [TyVar])
    tc_deriv_strategy (StockStrategy    XStockStrategy GhcRn
    _) = DerivStrategy GhcTc -> TcM (DerivStrategy GhcTc, [TyVar])
    forall ds a. ds -> TcM (ds, [a])
    boring_case (XStockStrategy GhcTc -> DerivStrategy GhcTc
    forall pass. XStockStrategy pass -> DerivStrategy pass
    StockStrategy    XStockStrategy GhcTc
    NoExtField
    noExtField)
        tc_deriv_strategy (AnyclassStrategy XAnyClassStrategy GhcRn
    _) = DerivStrategy GhcTc -> TcM (DerivStrategy GhcTc, [TyVar])
    forall ds a. ds -> TcM (ds, [a])
    boring_case (XAnyClassStrategy GhcTc -> DerivStrategy GhcTc
    forall pass. XAnyClassStrategy pass -> DerivStrategy pass
    AnyclassStrategy XAnyClassStrategy GhcTc
    NoExtField
    noExtField)
        tc_deriv_strategy (NewtypeStrategy  XNewtypeStrategy GhcRn
    _) = DerivStrategy GhcTc -> TcM (DerivStrategy GhcTc, [TyVar])
    forall ds a. ds -> TcM (ds, [a])
    boring_case (XNewtypeStrategy GhcTc -> DerivStrategy GhcTc
    forall pass. XNewtypeStrategy pass -> DerivStrategy pass
    NewtypeStrategy  XNewtypeStrategy GhcTc
    NoExtField
    noExtField)
        tc_deriv_strategy (ViaStrategy XViaStrategy GhcRn
    hs_sig)
          = do { ty <- UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tcTopLHsType UserTypeCtxt
    DerivClauseCtxt XViaStrategy GhcRn
    LHsSigType GhcRn
    hs_sig
                 -- rec {..}: see Note [Keeping SkolemInfo inside a SkolemTv]
                 --           in GHC.Tc.Utils.TcType
               ; rec { (via_tvs, via_pred) <- tcSkolemiseInvisibleBndrs (DerivSkol via_pred) ty }
               ; pure (ViaStrategy via_pred, via_tvs) }

        boring_case :: ds -> TcM (ds, [a])
        boring_case :: forall ds a. ds -> TcM (ds, [a])
    boring_case ds
    ds = (ds, [a]) -> IOEnv (Env TcGblEnv TcLclEnv) (ds, [a])
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ds
    ds, [])

    tcHsClsInstType :: UserTypeCtxt    -- InstDeclCtxt or SpecInstCtxt
                    -> LHsSigType GhcRn
                    -> TcM Type
    -- Like tcHsSigType, but for a class instance declaration
    tcHsClsInstType :: UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tcHsClsInstType UserTypeCtxt
    user_ctxt LHsSigType GhcRn
    hs_inst_ty
      = SrcSpan -> TcM Type -> TcM Type
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan (GenLocated SrcSpanAnnA (HsSigType GhcRn) -> SrcSpan
    forall a e. HasLoc a => GenLocated a e -> SrcSpan
    getLocA LHsSigType GhcRn
    GenLocated SrcSpanAnnA (HsSigType GhcRn)
    hs_inst_ty) (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
        do { inst_ty <- UserTypeCtxt -> LHsSigType GhcRn -> TcM Type
    tcTopLHsType UserTypeCtxt
    user_ctxt LHsSigType GhcRn
    hs_inst_ty
           ; checkValidInstance user_ctxt hs_inst_ty inst_ty
           ; return inst_ty }

    ----------------------------------------------
    -- | Type-check a visible type application
    tcHsTypeApp :: LHsWcType GhcRn -> Kind -> TcM Type
    -- See Note [Recipe for checking a signature] in GHC.Tc.Gen.HsType
    tcHsTypeApp :: LHsWcType GhcRn -> Type -> TcM Type
    tcHsTypeApp LHsWcType GhcRn
    wc_ty Type
    kind
      | HsWC { hswc_ext :: forall pass thing. HsWildCardBndrs pass thing -> XHsWC pass thing
    hswc_ext = XHsWC GhcRn (LHsType GhcRn)
    sig_wcs, hswc_body :: forall pass thing. HsWildCardBndrs pass thing -> thing
    hswc_body = LHsType GhcRn
    hs_ty } <- LHsWcType GhcRn
    wc_ty
      = do { mode <- TypeOrKind -> HoleMode -> TcM TcTyMode
    mkHoleMode TypeOrKind
    TypeLevel HoleMode
    HM_VTA
                     -- HM_VTA: See Note [Wildcards in visible type application]
           ; ty <- addTypeCtxt hs_ty                  $
                   solveEqualities "tcHsTypeApp" $
                   -- We are looking at a user-written type, very like a
                   -- signature so we want to solve its equalities right now
                   bindNamedWildCardBinders sig_wcs $ \ [(Name, TyVar)]
    _ ->
                   TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode LHsType GhcRn
    hs_ty Type
    kind

           -- We do not kind-generalize type applications: we just
           -- instantiate with exactly what the user says.
           -- See Note [No generalization in type application]
           -- We still must call kindGeneralizeNone, though, according
           -- to Note [Recipe for checking a signature]
           ; kindGeneralizeNone ty
           ; ty <- liftZonkM $ zonkTcType ty
           ; checkValidType TypeAppCtxt ty
           ; return ty }

    {- Note [Wildcards in visible type application]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    A HsWildCardBndrs's hswc_ext now only includes /named/ wildcards, so
    any unnamed wildcards stay unchanged in hswc_body.  When called in
    tcHsTypeApp, tcCheckLHsTypeInContext will call emitAnonTypeHole
    on these anonymous wildcards. However, this would trigger
    error/warning when an anonymous wildcard is passed in as a visible type
    argument, which we do not want because users should be able to write
    @_ to skip a instantiating a type variable variable without fuss. The
    solution is to switch the PartialTypeSignatures flags here to let the
    typechecker know that it's checking a '@_' and do not emit hole
    constraints on it.  See related Note [Wildcards in visible kind
    application] and Note [The wildcard story for types] in GHC.Hs.Type

    Ugh!

    Note [No generalization in type application]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    We do not kind-generalize type applications. Imagine

      id @(Proxy Nothing)

    If we kind-generalized, we would get

      id @(forall {k}. Proxy @(Maybe k) (Nothing @k))

    which is very sneakily impredicative instantiation.

    There is also the possibility of mentioning a wildcard
    (`id @(Proxy _)`), which definitely should not be kind-generalized.

    -}

    tcFamTyPats :: TyCon
                -> HsFamEqnPats GhcRn                -- Patterns
                -> TcM (TcType, TcKind)          -- (lhs_type, lhs_kind)
    -- Check the LHS of a type/data family instance
    -- e.g.   type instance F ty1 .. tyn = ...
    -- Used for both type and data families
    tcFamTyPats :: TyCon -> HsFamEqnPats GhcRn -> TcM (Type, Type)
    tcFamTyPats TyCon
    fam_tc HsFamEqnPats GhcRn
    hs_pats
      = do { String -> SDoc -> TcM ()
    traceTc String
    "tcFamTyPats {" (SDoc -> TcM ()) -> SDoc -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
             [SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ TyCon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyCon
    fam_tc, String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "arity:" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    fam_arity ]

           ; mode <- TypeOrKind -> HoleMode -> TcM TcTyMode
    mkHoleMode TypeOrKind
    TypeLevel HoleMode
    HM_FamPat
                     -- HM_FamPat: See Note [Wildcards in family instances] in
                     -- GHC.Rename.Module
           ; let fun_ty = TyCon -> [Type] -> Type
    mkTyConApp TyCon
    fam_tc []
           ; (fam_app, res_kind) <- tcInferTyApps mode lhs_fun fun_ty hs_pats

           -- Hack alert: see Note [tcFamTyPats: zonking the result kind]
           ; res_kind <- liftZonkM $ zonkTcType res_kind

           ; traceTc "End tcFamTyPats }" $
             vcat [ ppr fam_tc, text "res_kind:" <+> ppr res_kind ]

           ; return (fam_app, res_kind) }
      where
        fam_name :: Name
    fam_name  = TyCon -> Name
    tyConName TyCon
    fam_tc
        fam_arity :: Int
    fam_arity = TyCon -> Int
    tyConArity TyCon
    fam_tc
        lhs_fun :: GenLocated SrcSpanAnnA (HsType GhcRn)
    lhs_fun   = HsType GhcRn -> GenLocated SrcSpanAnnA (HsType GhcRn)
    forall e a. HasAnnotation e => a -> GenLocated e a
    noLocA (XTyVar GhcRn -> PromotionFlag -> LIdOccP GhcRn -> HsType GhcRn
    forall pass.
    XTyVar pass -> PromotionFlag -> LIdOccP pass -> HsType pass
    HsTyVar XTyVar GhcRn
    forall a. NoAnn a => a
    noAnn PromotionFlag
    NotPromoted (WithUserRdr Name -> GenLocated SrcSpanAnnN (WithUserRdr Name)
    forall e a. HasAnnotation e => a -> GenLocated e a
    noLocA (WithUserRdr Name -> GenLocated SrcSpanAnnN (WithUserRdr Name))
    -> WithUserRdr Name -> GenLocated SrcSpanAnnN (WithUserRdr Name)
    forall a b. (a -> b) -> a -> b
    $ Name -> WithUserRdr Name
    noUserRdr Name
    fam_name))

    {- Note [tcFamTyPats: zonking the result kind]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider (#19250)
        F :: forall k. k -> k
        type instance F (x :: Constraint) = ()

    The tricky point is this:
      is that () an empty type tuple (() :: Type), or
      an empty constraint tuple (() :: Constraint)?
    We work this out in a hacky way, by looking at the expected kind:
    see Note [Inferring tuple kinds].

    In this case, we kind-check the RHS using the kind gotten from the LHS:
    see the call to tcCheckLHsTypeInContext in tcTyFamInstEqnGuts in GHC.Tc.Tycl.

    But we want the kind from the LHS to be /zonked/, so that when
    kind-checking the RHS (tcCheckLHsTypeInContext) we can "see" what we learned
    from kind-checking the LHS (tcFamTyPats).  In our example above, the
    type of the LHS is just `kappa` (by instantiating the forall k), but
    then we learn (from x::Constraint) that kappa ~ Constraint.  We want
    that info when kind-checking the RHS.

    Easy solution: just zonk that return kind.  Of course this won't help
    if there is lots of type-family reduction to do, but it works fine in
    common cases.
    -}

    {-
    ************************************************************************
    *                                                                      *
                The main kind checker: no validity checks here
    *                                                                      *
    ************************************************************************
    -}

    ---------------------------
    tcHsOpenType, tcHsLiftedType,
      tcHsOpenTypeNC, tcHsLiftedTypeNC :: LHsType GhcRn -> TcM TcType
    -- Used for type signatures
    -- Do not do validity checking
    tcHsOpenType :: LHsType GhcRn -> TcM Type
    tcHsOpenType   LHsType GhcRn
    hs_ty = LHsType GhcRn -> TcM Type -> TcM Type
    forall a. LHsType GhcRn -> TcM a -> TcM a
    addTypeCtxt LHsType GhcRn
    hs_ty (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $ LHsType GhcRn -> TcM Type
    tcHsOpenTypeNC LHsType GhcRn
    hs_ty
    tcHsLiftedType :: LHsType GhcRn -> TcM Type
    tcHsLiftedType LHsType GhcRn
    hs_ty = LHsType GhcRn -> TcM Type -> TcM Type
    forall a. LHsType GhcRn -> TcM a -> TcM a
    addTypeCtxt LHsType GhcRn
    hs_ty (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $ LHsType GhcRn -> TcM Type
    tcHsLiftedTypeNC LHsType GhcRn
    hs_ty

    tcHsOpenTypeNC :: LHsType GhcRn -> TcM Type
    tcHsOpenTypeNC   LHsType GhcRn
    hs_ty = do { ek <- TcM Type
    newOpenTypeKind; tcCheckLHsType hs_ty ek }
    tcHsLiftedTypeNC :: LHsType GhcRn -> TcM Type
    tcHsLiftedTypeNC LHsType GhcRn
    hs_ty = LHsType GhcRn -> Type -> TcM Type
    tcCheckLHsType LHsType GhcRn
    hs_ty Type
    liftedTypeKind

    -- Like tcCheckLHsType, but takes an expected kind
    tcCheckLHsTypeInContext :: LHsType GhcRn -> ContextKind -> TcM TcType
    tcCheckLHsTypeInContext :: LHsType GhcRn -> ContextKind -> TcM Type
    tcCheckLHsTypeInContext LHsType GhcRn
    hs_ty ContextKind
    exp_kind
      = LHsType GhcRn -> TcM Type -> TcM Type
    forall a. LHsType GhcRn -> TcM a -> TcM a
    addTypeCtxt LHsType GhcRn
    hs_ty (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
        do { ek <- ContextKind -> TcM Type
    newExpectedKind ContextKind
    exp_kind
           ; tcCheckLHsType hs_ty ek }

    tcInferLHsType :: LHsType GhcRn -> TcM TcType
    tcInferLHsType :: LHsType GhcRn -> TcM Type
    tcInferLHsType LHsType GhcRn
    hs_ty
      = do { (ty,_kind) <- LHsType GhcRn -> TcM (Type, Type)
    tcInferLHsTypeKind LHsType GhcRn
    hs_ty
           ; return ty }

    tcInferLHsTypeKind :: LHsType GhcRn -> TcM (TcType, TcKind)
    -- Called from outside: set the context
    -- Eagerly instantiate any trailing invisible binders
    tcInferLHsTypeKind :: LHsType GhcRn -> TcM (Type, Type)
    tcInferLHsTypeKind lhs_ty :: LHsType GhcRn
    lhs_ty@(L SrcSpanAnnA
    loc HsType GhcRn
    hs_ty)
      = LHsType GhcRn -> TcM (Type, Type) -> TcM (Type, Type)
    forall a. LHsType GhcRn -> TcM a -> TcM a
    addTypeCtxt LHsType GhcRn
    lhs_ty (TcM (Type, Type) -> TcM (Type, Type))
    -> TcM (Type, Type) -> TcM (Type, Type)
    forall a b. (a -> b) -> a -> b
    $
        SrcSpanAnnA -> TcM (Type, Type) -> TcM (Type, Type)
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    loc    (TcM (Type, Type) -> TcM (Type, Type))
    -> TcM (Type, Type) -> TcM (Type, Type)
    forall a b. (a -> b) -> a -> b
    $  -- Cover the tcInstInvisibleTyBinders
        do { (res_ty, res_kind) <- TcTyMode -> HsType GhcRn -> TcM (Type, Type)
    tc_infer_hs_type TcTyMode
    typeLevelMode HsType GhcRn
    hs_ty
           ; tcInstInvisibleTyBinders res_ty res_kind }
      -- See Note [Do not always instantiate eagerly in types]

    -- Used to check the argument of GHCi :kind
    -- Allow and report wildcards, e.g. :kind T _
    -- Do not saturate family applications: see Note [Dealing with :kind]
    -- Does not instantiate eagerly; See Note [Do not always instantiate eagerly in types]
    tcInferLHsTypeUnsaturated :: LHsType GhcRn -> TcM (TcType, TcKind)
    tcInferLHsTypeUnsaturated :: LHsType GhcRn -> TcM (Type, Type)
    tcInferLHsTypeUnsaturated LHsType GhcRn
    hs_ty
      = LHsType GhcRn -> TcM (Type, Type) -> TcM (Type, Type)
    forall a. LHsType GhcRn -> TcM a -> TcM a
    addTypeCtxt LHsType GhcRn
    hs_ty (TcM (Type, Type) -> TcM (Type, Type))
    -> TcM (Type, Type) -> TcM (Type, Type)
    forall a b. (a -> b) -> a -> b
    $
        do { mode <- TypeOrKind -> HoleMode -> TcM TcTyMode
    mkHoleMode TypeOrKind
    TypeLevel HoleMode
    HM_Sig  -- Allow and report holes
           ; case splitHsAppTys_maybe (unLoc hs_ty) of
               Just (LHsType GhcRn
    hs_fun_ty, HsFamEqnPats GhcRn
    hs_args)
                  -> do { (fun_ty, _ki) <- TcTyMode -> LHsType GhcRn -> TcM (Type, Type)
    tcInferTyAppHead TcTyMode
    mode LHsType GhcRn
    hs_fun_ty
                        ; tcInferTyApps_nosat mode hs_fun_ty fun_ty hs_args }
                          -- Notice the 'nosat'; do not instantiate trailing
                          -- invisible arguments of a type family.
                          -- See Note [Dealing with :kind]
               Maybe (LHsType GhcRn, HsFamEqnPats GhcRn)
    Nothing -> TcTyMode -> LHsType GhcRn -> TcM (Type, Type)
    tc_infer_lhs_type TcTyMode
    mode LHsType GhcRn
    hs_ty }

    {- Note [Dealing with :kind]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider this GHCi command
      ghci> type family F :: Either j k
      ghci> :kind F
      F :: forall {j,k}. Either j k

    We will only get the 'forall' if we /refrain/ from saturating those
    invisible binders. But generally we /do/ saturate those invisible
    binders (see tcInferTyApps), and we want to do so for nested application
    even in GHCi.  Consider for example (#16287)
      ghci> type family F :: k
      ghci> data T :: (forall k. k) -> Type
      ghci> :kind T F
    We want to reject this. It's just at the very top level that we want
    to switch off saturation.

    So tcInferLHsTypeUnsaturated does a little special case for top level
    applications.  Actually the common case is a bare variable, as above.

    Note [Do not always instantiate eagerly in types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Terms are eagerly instantiated. This means that if you say

      x = id

    then `id` gets instantiated to have type alpha -> alpha. The variable
    alpha is then unconstrained and regeneralized. So we may well end up with
      x = /\a. id @a
    But we cannot do this in types, as we have no type-level lambda.

    So, we must be careful only to instantiate at the last possible moment, when
    we're sure we're never going to want the lost polymorphism again. This is done
    in calls to `tcInstInvisibleTyBinders`; a particular case in point is in
    `checkExpectedKind`.

    For example, suppose we have:
        Actual:  ∀ k2 k. k -> k2   -> k
      Expected:  ∀    k. k -> Type -> k
    We must very delicately instantiate just k2 to kappa, and then unify
      (∀ k. k -> Type -> k) ~ (∀ k. k -> kappa -> k)

    Otherwise, we are careful /not/ to instantiate.  For example:
      * at a variable  in `tcTyVar`
      * in `tcInferLHsTypeUnsaturated`, which is used by :kind in GHCi.

    ************************************************************************
    *                                                                      *
          Type-checking modes
    *                                                                      *
    ************************************************************************

    The kind-checker is parameterised by a TcTyMode, which contains some
    information about where we're checking a type.

    The renamer issues errors about what it can. All errors issued here must
    concern things that the renamer can't handle.

    -}

    tcMult :: LHsType GhcRn -> TcM Mult
    tcMult :: LHsType GhcRn -> TcM Type
    tcMult LHsType GhcRn
    ty = TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    typeLevelMode LHsType GhcRn
    ty Type
    multiplicityTy

    -- | Info about the context in which we're checking a type. Currently,
    -- differentiates only between types and kinds, but this will likely
    -- grow, at least to include the distinction between patterns and
    -- not-patterns.
    --
    -- To find out where the mode is used, search for 'mode_tyki'
    --
    -- This data type is purely local, not exported from this module
    data TcTyMode
      = TcTyMode { TcTyMode -> TypeOrKind
    mode_tyki :: TypeOrKind
                 , TcTyMode -> HoleInfo
    mode_holes :: HoleInfo   }

    -- See Note [Levels for wildcards]
    -- Nothing <=> no wildcards expected
    type HoleInfo = Maybe (TcLevel, HoleMode)

    -- HoleMode says how to treat the occurrences
    -- of anonymous wildcards; see tcAnonWildCardOcc
    data HoleMode = HM_Sig      -- Partial type signatures: f :: _ -> Int
                  | HM_FamPat   -- Family instances: F _ Int = Bool
                  | HM_VTA      -- Visible type and kind application:
                                --   f @(Maybe _)
                                --   Maybe @(_ -> _)
                  | HM_TyAppPat -- Visible type applications in patterns:
                                --   foo (Con @_ @t x) = ...
                                --   case x of Con @_ @t v -> ...

    mkMode :: TypeOrKind -> TcTyMode
    mkMode :: TypeOrKind -> TcTyMode
    mkMode TypeOrKind
    tyki = TcTyMode { mode_tyki :: TypeOrKind
    mode_tyki = TypeOrKind
    tyki, mode_holes :: HoleInfo
    mode_holes = HoleInfo
    forall a. Maybe a
    Nothing }

    typeLevelMode, kindLevelMode :: TcTyMode
    -- These modes expect no wildcards (holes) in the type
    kindLevelMode :: TcTyMode
    kindLevelMode = TypeOrKind -> TcTyMode
    mkMode TypeOrKind
    KindLevel
    typeLevelMode :: TcTyMode
    typeLevelMode = TypeOrKind -> TcTyMode
    mkMode TypeOrKind
    TypeLevel

    mkHoleMode :: TypeOrKind -> HoleMode -> TcM TcTyMode
    mkHoleMode :: TypeOrKind -> HoleMode -> TcM TcTyMode
    mkHoleMode TypeOrKind
    tyki HoleMode
    hm
      = do { lvl <- TcM TcLevel
    getTcLevel
           ; return (TcTyMode { mode_tyki  = tyki
                              , mode_holes = Just (lvl,hm) }) }

    instance Outputable HoleMode where
      ppr :: HoleMode -> SDoc
    ppr HoleMode
    HM_Sig      = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "HM_Sig"
      ppr HoleMode
    HM_FamPat   = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "HM_FamPat"
      ppr HoleMode
    HM_VTA      = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "HM_VTA"
      ppr HoleMode
    HM_TyAppPat = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "HM_TyAppPat"

    instance Outputable TcTyMode where
      ppr :: TcTyMode -> SDoc
    ppr (TcTyMode { mode_tyki :: TcTyMode -> TypeOrKind
    mode_tyki = TypeOrKind
    tyki, mode_holes :: TcTyMode -> HoleInfo
    mode_holes = HoleInfo
    hm })
        = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "TcTyMode" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces ([SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    sep [ TypeOrKind -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TypeOrKind
    tyki SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    comma
                                          , HoleInfo -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HoleInfo
    hm ])

    {-
    Note [Bidirectional type checking]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In types, as in terms, we use bidirectional type infefence.  The main workhorse
    function looks like this:

        type ExpKind = ExpType
        data ExpType = Check TcSigmaKind | Infer ...(hole TcRhoType)...

        tcHsType :: TcTyMode -> HsType GhcRn -> ExpKind -> TcM TcType

    * When the `ExpKind` argument is (Check ki), we /check/ that the type has
      kind `ki`
    * When the `ExpKind` argument is (Infer hole), we /infer/ the kind of the
      type, and fill the hole with that kind
    -}

    ------------------------------------------
    -- | Check and desugar a type, returning the core type and its
    -- possibly-polymorphic kind. Much like 'tcInferRho' at the expression
    -- level.
    tc_infer_lhs_type :: TcTyMode -> LHsType GhcRn -> TcM (TcType, TcKind)
    tc_infer_lhs_type :: TcTyMode -> LHsType GhcRn -> TcM (Type, Type)
    tc_infer_lhs_type TcTyMode
    mode (L SrcSpanAnnA
    span HsType GhcRn
    ty)
      = SrcSpanAnnA -> TcM (Type, Type) -> TcM (Type, Type)
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    span (TcM (Type, Type) -> TcM (Type, Type))
    -> TcM (Type, Type) -> TcM (Type, Type)
    forall a b. (a -> b) -> a -> b
    $
        TcTyMode -> HsType GhcRn -> TcM (Type, Type)
    tc_infer_hs_type TcTyMode
    mode HsType GhcRn
    ty

    ---------------------------
    -- | Infer the kind of a type and desugar. This is the "up" type-checker,
    -- as described in Note [Bidirectional type checking]
    tc_infer_hs_type :: TcTyMode -> HsType GhcRn -> TcM (TcType, TcKind)
    tc_infer_hs_type :: TcTyMode -> HsType GhcRn -> TcM (Type, Type)
    tc_infer_hs_type TcTyMode
    mode HsType GhcRn
    rn_ty
      = (ExpSigmaType -> TcM Type) -> TcM (Type, Type)
    forall a. (ExpSigmaType -> TcM a) -> TcM (a, Type)
    runInferKind ((ExpSigmaType -> TcM Type) -> TcM (Type, Type))
    -> (ExpSigmaType -> TcM Type) -> TcM (Type, Type)
    forall a b. (a -> b) -> a -> b
    $ \ExpSigmaType
    exp_kind ->
        TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tcHsType TcTyMode
    mode HsType GhcRn
    rn_ty ExpSigmaType
    exp_kind

    {-
    Note [Typechecking HsCoreTys]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    HsCoreTy is an escape hatch that allows embedding Core Types in HsTypes.
    As such, there's not much to be done in order to typecheck an HsCoreTy,
    since it's already been typechecked to some extent. There is one thing that
    we must do, however: we must substitute the type variables from the tcl_env.
    To see why, consider GeneralizedNewtypeDeriving, which is one of the main
    clients of HsCoreTy (example adapted from #14579):

      newtype T a = MkT a deriving newtype Eq

    This will produce an InstInfo GhcPs that looks roughly like this:

      instance forall a_1. Eq a_1 => Eq (T a_1) where
        (==) = coerce @(  a_1 ->   a_1 -> Bool) -- The type within @(...) is an HsCoreTy
                      @(T a_1 -> T a_1 -> Bool) -- So is this
                      (==)

    This is then fed into the renamer. Since all of the type variables in this
    InstInfo use Exact RdrNames, the resulting InstInfo GhcRn looks basically
    identical. Things get more interesting when the InstInfo is fed into the
    typechecker, however. GHC will first generate fresh skolems to instantiate
    the instance-bound type variables with. In the example above, we might generate
    the skolem a_2 and use that to instantiate a_1, which extends the local type
    environment (tcl_env) with [a_1 :-> a_2]. This gives us:

      instance forall a_2. Eq a_2 => Eq (T a_2) where ...

    To ensure that the body of this instance is well scoped, every occurrence of
    the `a` type variable should refer to a_2, the new skolem. However, the
    HsCoreTys mention a_1, not a_2. Luckily, the tcl_env provides exactly the
    substitution we need ([a_1 :-> a_2]) to fix up the scoping. We apply this
    substitution to each HsCoreTy and all is well:

      instance forall a_2. Eq a_2 => Eq (T a_2) where
        (==) = coerce @(  a_2 ->   a_2 -> Bool)
                      @(T a_2 -> T a_2 -> Bool)
                      (==)
    -}

    ------------------------------------------
    tcCheckLHsType :: LHsType GhcRn -> TcKind -> TcM TcType
    tcCheckLHsType :: LHsType GhcRn -> Type -> TcM Type
    tcCheckLHsType LHsType GhcRn
    hs_ty Type
    exp_kind
      = TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    typeLevelMode LHsType GhcRn
    hs_ty Type
    exp_kind

    tc_check_lhs_type :: TcTyMode -> LHsType GhcRn -> TcKind -> TcM TcType
    tc_check_lhs_type :: TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode (L SrcSpanAnnA
    span HsType GhcRn
    ty) Type
    exp_kind
      = SrcSpanAnnA -> TcM Type -> TcM Type
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    span (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
        TcTyMode -> HsType GhcRn -> Type -> TcM Type
    tc_check_hs_type TcTyMode
    mode HsType GhcRn
    ty Type
    exp_kind

    tc_check_hs_type :: TcTyMode -> HsType GhcRn -> TcKind -> TcM TcType
    -- See Note [Bidirectional type checking]
    tc_check_hs_type :: TcTyMode -> HsType GhcRn -> Type -> TcM Type
    tc_check_hs_type TcTyMode
    mode HsType GhcRn
    ty Type
    ek = TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tcHsType TcTyMode
    mode HsType GhcRn
    ty (Type -> ExpSigmaType
    Check Type
    ek)

    tcLHsType :: TcTyMode -> LHsType GhcRn -> ExpKind -> TcM TcType
    tcLHsType :: TcTyMode -> LHsType GhcRn -> ExpSigmaType -> TcM Type
    tcLHsType TcTyMode
    mode (L SrcSpanAnnA
    span HsType GhcRn
    ty) ExpSigmaType
    exp_kind
      = SrcSpanAnnA -> TcM Type -> TcM Type
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    span (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
        TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tcHsType TcTyMode
    mode HsType GhcRn
    ty ExpSigmaType
    exp_kind

    tcHsType :: TcTyMode -> HsType GhcRn -> ExpKind -> TcM TcType
    -- The main workhorse for type kind checking
    -- See Note [Bidirectional type checking]

    tcHsType :: TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tcHsType TcTyMode
    mode (HsParTy XParTy GhcRn
    _ LHsType GhcRn
    ty)   ExpSigmaType
    exp_kind = TcTyMode -> LHsType GhcRn -> ExpSigmaType -> TcM Type
    tcLHsType TcTyMode
    mode LHsType GhcRn
    ty ExpSigmaType
    exp_kind
    tcHsType TcTyMode
    mode (HsDocTy XDocTy GhcRn
    _ LHsType GhcRn
    ty LHsDoc GhcRn
    _) ExpSigmaType
    exp_kind = TcTyMode -> LHsType GhcRn -> ExpSigmaType -> TcM Type
    tcLHsType TcTyMode
    mode LHsType GhcRn
    ty ExpSigmaType
    exp_kind

    -- HsSpliced is an annotation produced by 'GHC.Rename.Splice.rnSpliceType'.
    -- Here we get rid of it and add the finalizers to the global environment
    -- while capturing the local environment.
    --
    -- See Note [Delaying modFinalizers in untyped splices].
    tcHsType TcTyMode
    mode (HsSpliceTy (HsUntypedSpliceTop ThModFinalizers
    mod_finalizers GenLocated SrcSpanAnnA (HsType GhcRn)
    ty) HsUntypedSplice GhcRn
    _)
               ExpSigmaType
    exp_kind
      = do ThModFinalizers -> TcM ()
    addModFinalizersWithLclEnv ThModFinalizers
    mod_finalizers
           TcTyMode -> LHsType GhcRn -> ExpSigmaType -> TcM Type
    tcLHsType TcTyMode
    mode LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    ty ExpSigmaType
    exp_kind

    tcHsType TcTyMode
    _ (HsSpliceTy (HsUntypedSpliceNested Name
    n) HsUntypedSplice GhcRn
    s) ExpSigmaType
    _ = String -> SDoc -> TcM Type
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "tcHsType: invalid nested splice" (Bool -> Maybe Name -> HsUntypedSplice GhcRn -> SDoc
    forall (p :: Pass).
    OutputableBndrId p =>
    Bool -> Maybe Name -> HsUntypedSplice (GhcPass p) -> SDoc
    pprUntypedSplice Bool
    True (Name -> Maybe Name
    forall a. a -> Maybe a
    Just Name
    n) HsUntypedSplice GhcRn
    s)

    ---------- Functions and applications
    tcHsType TcTyMode
    mode (HsFunTy XFunTy GhcRn
    _ HsMultAnn GhcRn
    mult LHsType GhcRn
    ty1 LHsType GhcRn
    ty2) ExpSigmaType
    exp_kind
      = TcTyMode
    -> HsMultAnn GhcRn
    -> LHsType GhcRn
    -> LHsType GhcRn
    -> ExpSigmaType
    -> TcM Type
    tc_fun_type TcTyMode
    mode HsMultAnn GhcRn
    mult LHsType GhcRn
    ty1 LHsType GhcRn
    ty2 ExpSigmaType
    exp_kind

    tcHsType TcTyMode
    mode (HsOpTy XOpTy GhcRn
    _ PromotionFlag
    _ LHsType GhcRn
    ty1 (L SrcSpanAnnN
    _ (WithUserRdr RdrName
    _ Name
    op)) LHsType GhcRn
    ty2) ExpSigmaType
    exp_kind
      | Name
    op Name -> Unique -> Bool
    forall a. Uniquable a => a -> Unique -> Bool
    `hasKey` Unique
    unrestrictedFunTyConKey
      = TcTyMode
    -> HsMultAnn GhcRn
    -> LHsType GhcRn
    -> LHsType GhcRn
    -> ExpSigmaType
    -> TcM Type
    tc_fun_type TcTyMode
    mode (XUnannotated (GenLocated SrcSpanAnnA (HsType GhcRn)) GhcRn
    -> HsMultAnnOf (GenLocated SrcSpanAnnA (HsType GhcRn)) GhcRn
    forall mult pass. XUnannotated mult pass -> HsMultAnnOf mult pass
    HsUnannotated NoExtField
    XUnannotated (GenLocated SrcSpanAnnA (HsType GhcRn)) GhcRn
    noExtField) LHsType GhcRn
    ty1 LHsType GhcRn
    ty2 ExpSigmaType
    exp_kind

    --------- Foralls
    tcHsType TcTyMode
    mode t :: HsType GhcRn
    t@(HsForAllTy { hst_tele :: forall pass. HsType pass -> HsForAllTelescope pass
    hst_tele = HsForAllTelescope GhcRn
    tele, hst_body :: forall pass. HsType pass -> LHsType pass
    hst_body = LHsType GhcRn
    ty }) ExpSigmaType
    exp_kind
      | HsForAllInvis{} <- HsForAllTelescope GhcRn
    tele
      = HsForAllTelescope GhcRn
    -> GenLocated SrcSpanAnnA (HsType GhcRn)
    -> ExpSigmaType
    -> TcM Type
    tc_hs_forall_ty HsForAllTelescope GhcRn
    tele LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    ty ExpSigmaType
    exp_kind
                     -- For an invisible forall, we allow the body to have
                     -- an arbitrary kind (hence exp_kind above).
                     -- See Note [Body kind of a HsForAllTy]

      | HsForAllVis{} <- HsForAllTelescope GhcRn
    tele
      = do { ek <- TcM Type
    newOpenTypeKind
           ; r <- tc_hs_forall_ty tele ty (Check ek)
           ; checkExpKind t r ek exp_kind }
                     -- For a visible forall, we require that the body is of kind TYPE r.
                     -- See Note [Body kind of a HsForAllTy]

      where
        tc_hs_forall_ty :: HsForAllTelescope GhcRn
    -> GenLocated SrcSpanAnnA (HsType GhcRn)
    -> ExpSigmaType
    -> TcM Type
    tc_hs_forall_ty HsForAllTelescope GhcRn
    tele GenLocated SrcSpanAnnA (HsType GhcRn)
    ty ExpSigmaType
    ek
          = do { (tv_bndrs, ty') <- TcTyMode
    -> HsForAllTelescope GhcRn
    -> TcM Type
    -> TcM ([TcTyVarBinder], Type)
    forall a.
    TcTyMode
    -> HsForAllTelescope GhcRn -> TcM a -> TcM ([TcTyVarBinder], a)
    tcTKTelescope TcTyMode
    mode HsForAllTelescope GhcRn
    tele (TcM Type -> TcM ([TcTyVarBinder], Type))
    -> TcM Type -> TcM ([TcTyVarBinder], Type)
    forall a b. (a -> b) -> a -> b
    $
                                    TcTyMode -> LHsType GhcRn -> ExpSigmaType -> TcM Type
    tcLHsType TcTyMode
    mode LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    ty ExpSigmaType
    ek
                     -- Pass on the mode from the type, to any wildcards
                     -- in kind signatures on the forall'd variables
                     -- e.g.      f :: _ -> Int -> forall (a :: _). blah

                 -- Do not kind-generalise here!  See Note [Kind generalisation]
               ; return (mkForAllTys tv_bndrs ty') }

    tcHsType TcTyMode
    mode t :: HsType GhcRn
    t@(HsQualTy { hst_ctxt :: forall pass. HsType pass -> LHsContext pass
    hst_ctxt = LHsContext GhcRn
    ctxt, hst_body :: forall pass. HsType pass -> LHsType pass
    hst_body = LHsType GhcRn
    rn_ty }) ExpSigmaType
    exp_kind
      | [GenLocated SrcSpanAnnA (HsType GhcRn)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null (GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcRn)]
    -> [GenLocated SrcSpanAnnA (HsType GhcRn)]
    forall l e. GenLocated l e -> e
    unLoc LHsContext GhcRn
    GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcRn)]
    ctxt)
      = TcTyMode -> LHsType GhcRn -> ExpSigmaType -> TcM Type
    tcLHsType TcTyMode
    mode LHsType GhcRn
    rn_ty ExpSigmaType
    exp_kind
        -- See Note [Body kind of a HsQualTy], point (BK1)
      | Check Type
    kind <- ExpSigmaType
    exp_kind     -- Checking mode
      , Type -> Bool
    isConstraintLikeKind Type
    kind  -- CONSTRAINT rep
      = do { ctxt' <- TcTyMode -> LHsContext GhcRn -> TcM [Type]
    tc_hs_context TcTyMode
    mode LHsContext GhcRn
    ctxt
             -- See Note [Body kind of a HsQualTy], point (BK2)
           ; ty'   <- tc_check_lhs_type mode rn_ty constraintKind
           ; let res_ty = [Type] -> Type -> Type
    HasDebugCallStack => [Type] -> Type -> Type
    tcMkDFunPhiTy [Type]
    ctxt' Type
    ty'
           ; checkExpKind t res_ty constraintKind exp_kind }

      | Bool
    otherwise
      = do { ctxt' <- TcTyMode -> LHsContext GhcRn -> TcM [Type]
    tc_hs_context TcTyMode
    mode LHsContext GhcRn
    ctxt

          ; ek <- newOpenTypeKind  -- The body kind (result of the function) can
                                    -- be TYPE r, for any r, hence newOpenTypeKind
          ; ty' <- tc_check_lhs_type mode rn_ty ek
          ; let res_ty = [Type] -> Type -> Type
    HasDebugCallStack => [Type] -> Type -> Type
    tcMkPhiTy [Type]
    ctxt' Type
    ty'
          ; checkExpKind t res_ty liftedTypeKind exp_kind }

    --------- Lists, arrays, and tuples
    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsListTy XListTy GhcRn
    _ LHsType GhcRn
    elt_ty) ExpSigmaType
    exp_kind
      = do { tau_ty <- TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode LHsType GhcRn
    elt_ty Type
    liftedTypeKind
           ; checkWiredInTyCon listTyCon
           ; checkExpKind rn_ty (mkListTy tau_ty) liftedTypeKind exp_kind }

    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsTupleTy XTupleTy GhcRn
    _ HsTupleSort
    tup_sort [LHsType GhcRn]
    tys) ExpSigmaType
    exp_kind
      = do k <- ExpSigmaType -> TcM Type
    expTypeToType ExpSigmaType
    exp_kind
           tc_hs_tuple_ty rn_ty mode tup_sort tys k

    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsSumTy XSumTy GhcRn
    _ [LHsType GhcRn]
    hs_tys) ExpSigmaType
    exp_kind
      = do { let arity :: Int
    arity = [GenLocated SrcSpanAnnA (HsType GhcRn)] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_tys
           ; arg_kinds <- (GenLocated SrcSpanAnnA (HsType GhcRn) -> TcM Type)
    -> [GenLocated SrcSpanAnnA (HsType GhcRn)] -> TcM [Type]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (\GenLocated SrcSpanAnnA (HsType GhcRn)
    _ -> TcM Type
    newOpenTypeKind) [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_tys
           ; tau_tys   <- zipWithM (tc_check_lhs_type mode) hs_tys arg_kinds
           ; let arg_reps = (Type -> Type) -> [Type] -> [Type]
    forall a b. (a -> b) -> [a] -> [b]
    map HasDebugCallStack => Type -> Type
    Type -> Type
    kindRep [Type]
    arg_kinds
                 arg_tys  = [Type]
    arg_reps [Type] -> [Type] -> [Type]
    forall a. [a] -> [a] -> [a]
    ++ [Type]
    tau_tys
                 sum_ty   = TyCon -> [Type] -> Type
    mkTyConApp (Int -> TyCon
    sumTyCon Int
    arity) [Type]
    arg_tys
                 sum_kind = [Type] -> Type
    unboxedSumKind [Type]
    arg_reps
           ; checkExpKind rn_ty sum_ty sum_kind exp_kind
           }

    --------- Promoted lists and tuples
    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsExplicitListTy XExplicitListTy GhcRn
    _ PromotionFlag
    _ [LHsType GhcRn]
    tys) ExpSigmaType
    exp_kind
      -- See Note [Kind-checking explicit lists]

      | [GenLocated SrcSpanAnnA (HsType GhcRn)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    tys
      = do let ty :: Type
    ty = TyCon -> Type
    mkTyConTy TyCon
    promotedNilDataCon
           let kind :: Type
    kind = [TyVar] -> Type -> Type
    mkSpecForAllTys [TyVar
    alphaTyVar] (Type -> Type) -> Type -> Type
    forall a b. (a -> b) -> a -> b
    $ Type -> Type
    mkListTy Type
    alphaTy
           HsType GhcRn -> Type -> Type -> ExpSigmaType -> TcM Type
    checkExpKind HsType GhcRn
    rn_ty Type
    ty Type
    kind ExpSigmaType
    exp_kind

      | Bool
    otherwise
      = do { tks <- (GenLocated SrcSpanAnnA (HsType GhcRn) -> TcM (Type, Type))
    -> [GenLocated SrcSpanAnnA (HsType GhcRn)]
    -> IOEnv (Env TcGblEnv TcLclEnv) [(Type, Type)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (TcTyMode -> LHsType GhcRn -> TcM (Type, Type)
    tc_infer_lhs_type TcTyMode
    mode) [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    tys
           ; (taus', kind) <- unifyKinds tys tks
           ; let ty = ((Type -> Type -> Type) -> Type -> [Type] -> Type
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (Type -> Type -> Type -> Type
    mk_cons Type
    kind) (Type -> Type
    mk_nil Type
    kind) [Type]
    taus')
           ; checkExpKind rn_ty ty (mkListTy kind) exp_kind }
      where
        mk_cons :: Type -> Type -> Type -> Type
    mk_cons Type
    k Type
    a Type
    b = TyCon -> [Type] -> Type
    mkTyConApp (DataCon -> TyCon
    promoteDataCon DataCon
    consDataCon) [Type
    k, Type
    a, Type
    b]
        mk_nil :: Type -> Type
    mk_nil  Type
    k     = TyCon -> [Type] -> Type
    mkTyConApp (DataCon -> TyCon
    promoteDataCon DataCon
    nilDataCon) [Type
    k]

    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsExplicitTupleTy XExplicitTupleTy GhcRn
    _ PromotionFlag
    _ [LHsType GhcRn]
    tys) ExpSigmaType
    exp_kind
      -- using newMetaKindVar means that we force instantiations of any polykinded
      -- types. At first, I just used tc_infer_lhs_type, but that led to #11255.
      = do { ks   <- Int -> TcM Type -> TcM [Type]
    forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
    replicateM Int
    arity TcM Type
    newMetaKindVar
           ; taus <- zipWithM (tc_check_lhs_type mode) tys ks
           ; let kind_con   = Boxity -> Int -> TyCon
    tupleTyCon           Boxity
    Boxed Int
    arity
                 ty_con     = Boxity -> Int -> TyCon
    promotedTupleDataCon Boxity
    Boxed Int
    arity
                 tup_k      = TyCon -> [Type] -> Type
    mkTyConApp TyCon
    kind_con [Type]
    ks
           ; checkTupSize arity
           ; checkExpKind rn_ty (mkTyConApp ty_con (ks ++ taus)) tup_k exp_kind }
      where
        arity :: Int
    arity = [GenLocated SrcSpanAnnA (HsType GhcRn)] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    tys

    --------- Constraint types
    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsIParamTy XIParamTy GhcRn
    _ (L EpAnnCO
    _ HsIPName
    n) LHsType GhcRn
    ty) ExpSigmaType
    exp_kind
      = do { Bool -> TcM ()
    forall (m :: * -> *). (HasCallStack, Applicative m) => Bool -> m ()
    massert (TypeOrKind -> Bool
    isTypeLevel (TcTyMode -> TypeOrKind
    mode_tyki TcTyMode
    mode))
           ; ty' <- TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode LHsType GhcRn
    ty Type
    liftedTypeKind
           ; let n' = FastString -> Type
    mkStrLitTy (FastString -> Type) -> FastString -> Type
    forall a b. (a -> b) -> a -> b
    $ HsIPName -> FastString
    hsIPNameFS HsIPName
    n
           ; ipClass <- tcLookupClass ipClassName
           ; checkExpKind rn_ty (mkClassPred ipClass [n',ty'])
                               constraintKind exp_kind }

    tcHsType TcTyMode
    _ rn_ty :: HsType GhcRn
    rn_ty@(HsStarTy XStarTy GhcRn
    _ Bool
    _) ExpSigmaType
    exp_kind
      -- Desugaring 'HsStarTy' to 'Data.Kind.Type' here means that we don't
      -- have to handle it in 'coreView'
      = HsType GhcRn -> Type -> Type -> ExpSigmaType -> TcM Type
    checkExpKind HsType GhcRn
    rn_ty Type
    liftedTypeKind Type
    liftedTypeKind ExpSigmaType
    exp_kind

    --------- Literals
    tcHsType TcTyMode
    _ rn_ty :: HsType GhcRn
    rn_ty@(HsTyLit XTyLit GhcRn
    _ (HsNumTy XNumTy GhcRn
    _ Integer
    n)) ExpSigmaType
    exp_kind
      = do { TyCon -> TcM ()
    checkWiredInTyCon TyCon
    naturalTyCon
           ; HsType GhcRn -> Type -> Type -> ExpSigmaType -> TcM Type
    checkExpKind HsType GhcRn
    rn_ty (Integer -> Type
    mkNumLitTy Integer
    n) Type
    naturalTy ExpSigmaType
    exp_kind }

    tcHsType TcTyMode
    _ rn_ty :: HsType GhcRn
    rn_ty@(HsTyLit XTyLit GhcRn
    _ (HsStrTy XStrTy GhcRn
    _ FastString
    s)) ExpSigmaType
    exp_kind
      = do { TyCon -> TcM ()
    checkWiredInTyCon TyCon
    typeSymbolKindCon
           ; HsType GhcRn -> Type -> Type -> ExpSigmaType -> TcM Type
    checkExpKind HsType GhcRn
    rn_ty (FastString -> Type
    mkStrLitTy FastString
    s) Type
    typeSymbolKind ExpSigmaType
    exp_kind }
    tcHsType TcTyMode
    _ rn_ty :: HsType GhcRn
    rn_ty@(HsTyLit XTyLit GhcRn
    _ (HsCharTy XCharTy GhcRn
    _ Char
    c)) ExpSigmaType
    exp_kind
      = do { TyCon -> TcM ()
    checkWiredInTyCon TyCon
    charTyCon
           ; HsType GhcRn -> Type -> Type -> ExpSigmaType -> TcM Type
    checkExpKind HsType GhcRn
    rn_ty (Char -> Type
    mkCharLitTy Char
    c) Type
    charTy ExpSigmaType
    exp_kind }

    --------- Wildcards

    tcHsType TcTyMode
    mode ty :: HsType GhcRn
    ty@(HsWildCardTy XWildCardTy GhcRn
    _) ExpSigmaType
    ek
      = do k <- ExpSigmaType -> TcM Type
    expTypeToType ExpSigmaType
    ek
           tcAnonWildCardOcc NoExtraConstraint mode ty k

    --------- Type applications
    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsTyVar{})     ExpSigmaType
    exp_kind = TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tc_app_ty TcTyMode
    mode HsType GhcRn
    rn_ty ExpSigmaType
    exp_kind
    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsAppTy{})     ExpSigmaType
    exp_kind = TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tc_app_ty TcTyMode
    mode HsType GhcRn
    rn_ty ExpSigmaType
    exp_kind
    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsAppKindTy{}) ExpSigmaType
    exp_kind = TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tc_app_ty TcTyMode
    mode HsType GhcRn
    rn_ty ExpSigmaType
    exp_kind
    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsOpTy{})      ExpSigmaType
    exp_kind = TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tc_app_ty TcTyMode
    mode HsType GhcRn
    rn_ty ExpSigmaType
    exp_kind

    tcHsType TcTyMode
    mode rn_ty :: HsType GhcRn
    rn_ty@(HsKindSig XKindSig GhcRn
    _ LHsType GhcRn
    ty LHsType GhcRn
    sig) ExpSigmaType
    exp_kind
      = do { let mode' :: TcTyMode
    mode' = TcTyMode
    mode { mode_tyki = KindLevel }
           ; sig' <- TcTyMode -> UserTypeCtxt -> LHsType GhcRn -> TcM Type
    tc_lhs_kind_sig TcTyMode
    mode' UserTypeCtxt
    KindSigCtxt LHsType GhcRn
    sig
                     -- We must typecheck the kind signature, and solve all
                     -- its equalities etc; from this point on we may do
                     -- things like instantiate its foralls, so it needs
                     -- to be fully determined (#14904)
           ; traceTc "tcHsType:sig" (ppr ty $$ ppr sig')
           ; ty' <- tcAddKindSigPlaceholders sig $
                    tc_check_lhs_type mode ty sig'
           ; checkExpKind rn_ty ty' sig' exp_kind }

    -- See Note [Typechecking HsCoreTys]
    tcHsType TcTyMode
    _ rn_ty :: HsType GhcRn
    rn_ty@(XHsType XXType GhcRn
    ty) ExpSigmaType
    exp_kind
      = do env <- TcRnIf TcGblEnv TcLclEnv TcLclEnv
    forall gbl lcl. TcRnIf gbl lcl lcl
    getLclEnv
           -- Raw uniques since we go from NameEnv to TvSubstEnv.
           let subst_prs :: [(Unique, TcTyVar)]
               subst_prs = [ (Name -> Unique
    forall a. Uniquable a => a -> Unique
    getUnique Name
    nm, TyVar
    tv)
                           | ATyVar Name
    nm TyVar
    tv <- NameEnv TcTyThing -> [TcTyThing]
    forall a. NameEnv a -> [a]
    nonDetNameEnvElts (TcLclEnv -> NameEnv TcTyThing
    getLclEnvTypeEnv TcLclEnv
    env) ]
               subst = InScopeSet -> TvSubstEnv -> Subst
    mkTvSubst
                         ([TyVar] -> InScopeSet
    mkInScopeSetList ([TyVar] -> InScopeSet) -> [TyVar] -> InScopeSet
    forall a b. (a -> b) -> a -> b
    $ ((Unique, TyVar) -> TyVar) -> [(Unique, TyVar)] -> [TyVar]
    forall a b. (a -> b) -> [a] -> [b]
    map (Unique, TyVar) -> TyVar
    forall a b. (a, b) -> b
    snd [(Unique, TyVar)]
    subst_prs)
                         ([(Unique, Type)] -> TvSubstEnv
    forall {k} elt (key :: k). [(Unique, elt)] -> UniqFM key elt
    listToUFM_Directly ([(Unique, Type)] -> TvSubstEnv) -> [(Unique, Type)] -> TvSubstEnv
    forall a b. (a -> b) -> a -> b
    $ ((Unique, TyVar) -> (Unique, Type))
    -> [(Unique, TyVar)] -> [(Unique, Type)]
    forall a b. (a -> b) -> [a] -> [b]
    map ((TyVar -> Type) -> (Unique, TyVar) -> (Unique, Type)
    forall a b. (a -> b) -> (Unique, a) -> (Unique, b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap TyVar -> Type
    mkTyVarTy) [(Unique, TyVar)]
    subst_prs)
               ty' = HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst XXType GhcRn
    Type
    ty
           checkExpKind rn_ty ty' (typeKind ty') exp_kind

    tc_hs_tuple_ty :: HsType GhcRn
                   -> TcTyMode
                   -> HsTupleSort
                   -> [LHsType GhcRn]
                   -> TcKind
                   -> TcM TcType
    -- See Note [Distinguishing tuple kinds] in GHC.Hs.Type
    -- See Note [Inferring tuple kinds]
    tc_hs_tuple_ty :: HsType GhcRn
    -> TcTyMode -> HsTupleSort -> [LHsType GhcRn] -> Type -> TcM Type
    tc_hs_tuple_ty HsType GhcRn
    rn_ty TcTyMode
    mode HsTupleSort
    HsBoxedOrConstraintTuple [LHsType GhcRn]
    hs_tys Type
    exp_kind
         -- (NB: not zonking before looking at exp_k, to avoid left-right bias)
      | Just TupleSort
    tup_sort <- Type -> Maybe TupleSort
    tupKindSort_maybe Type
    exp_kind
      = String -> SDoc -> TcM ()
    traceTc String
    "tcHsType tuple" ([GenLocated SrcSpanAnnA (HsType GhcRn)] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_tys) TcM () -> TcM Type -> TcM Type
    forall a b.
    IOEnv (Env TcGblEnv TcLclEnv) a
    -> IOEnv (Env TcGblEnv TcLclEnv) b
    -> IOEnv (Env TcGblEnv TcLclEnv) b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
        HsType GhcRn
    -> TcTyMode -> TupleSort -> [LHsType GhcRn] -> Type -> TcM Type
    tc_tuple HsType GhcRn
    rn_ty TcTyMode
    mode TupleSort
    tup_sort [LHsType GhcRn]
    hs_tys Type
    exp_kind
      | Bool
    otherwise
      = do { String -> SDoc -> TcM ()
    traceTc String
    "tcHsType tuple 2" ([GenLocated SrcSpanAnnA (HsType GhcRn)] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_tys)
           ; (tys, kinds) <- (GenLocated SrcSpanAnnA (HsType GhcRn) -> TcM (Type, Type))
    -> [GenLocated SrcSpanAnnA (HsType GhcRn)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ([Type], [Type])
    forall (m :: * -> *) a b c.
    Applicative m =>
    (a -> m (b, c)) -> [a] -> m ([b], [c])
    mapAndUnzipM (TcTyMode -> LHsType GhcRn -> TcM (Type, Type)
    tc_infer_lhs_type TcTyMode
    mode) [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_tys
           ; kinds <- liftZonkM $ mapM zonkTcType kinds
               -- Infer each arg type separately, because errors can be
               -- confusing if we give them a shared kind.  Eg #7410
               -- (Either Int, Int), we do not want to get an error saying
               -- "the second argument of a tuple should have kind *->*"

           ; let (arg_kind, tup_sort)
                   = case [ (k,s) | k <- kinds
                                  , Just s <- [tupKindSort_maybe k] ] of
                        ((Type
    k,TupleSort
    s) : [(Type, TupleSort)]
    _) -> (Type
    k,TupleSort
    s)
                        [] -> (Type
    liftedTypeKind, TupleSort
    BoxedTuple)
             -- In the [] case, it's not clear what the kind is, so guess *

           ; tys' <- sequence [ setSrcSpanA loc $
                                checkExpectedKind hs_ty ty kind arg_kind
                              | ((L loc hs_ty),ty,kind) <- zip3 hs_tys tys kinds ]

           ; finish_tuple rn_ty tup_sort tys' (map (const arg_kind) tys') exp_kind }
    tc_hs_tuple_ty HsType GhcRn
    rn_ty TcTyMode
    mode HsTupleSort
    HsUnboxedTuple [LHsType GhcRn]
    tys Type
    exp_kind =
        HsType GhcRn
    -> TcTyMode -> TupleSort -> [LHsType GhcRn] -> Type -> TcM Type
    tc_tuple HsType GhcRn
    rn_ty TcTyMode
    mode TupleSort
    UnboxedTuple [LHsType GhcRn]
    tys Type
    exp_kind

    {-
    Note [Kind-checking explicit lists]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    In a type, suppose we have an application (F [t1,t2]),
    where [t1,t2] is an explicit list, and
       F :: [ki] -> blah

    Then we want to return the type
       F ((:) @ki t2 ((:) @ki t2 ([] @ki)))
    where the argument list is instantiated to F's argument kind `ki`.

    But what about (G []), where
       G :: (forall k. [k]) -> blah

    Here we want to return (G []), with no instantiation at all.  But since we have
    no lambda in types, we must be careful not to instantiate that `[]`, because we
    can't re-generalise it.  Hence, when kind-checking an explicit list, we need a
    special case for `[]`.

    Note [Variable Specificity and Forall Visibility]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    A HsForAllTy contains an HsForAllTelescope to denote the visibility of the forall
    binder. Furthermore, each invisible type variable binder also has a
    Specificity. Together, these determine the variable binders (ForAllTyFlag) for each
    variable in the generated ForAllTy type.

    This table summarises this relation:
    ----------------------------------------------------------------------------
    | User-written type         HsForAllTelescope   Specificity        ForAllTyFlag
    |---------------------------------------------------------------------------
    | f :: forall a. type       HsForAllInvis       SpecifiedSpec      Specified
    | f :: forall {a}. type     HsForAllInvis       InferredSpec       Inferred
    | f :: forall a -> type     HsForAllVis         SpecifiedSpec      Required
    | f :: forall {a} -> type   HsForAllVis         InferredSpec       /
    |   This last form is nonsensical and is thus rejected.
    ----------------------------------------------------------------------------

    For more information regarding the interpretation of the resulting ForAllTyFlag, see
    Note [VarBndrs, ForAllTyBinders, TyConBinders, and visibility] in "GHC.Core.TyCo.Rep".
    -}

    ------------------------------------------
    tc_fun_type :: TcTyMode -> HsMultAnn GhcRn -> LHsType GhcRn -> LHsType GhcRn -> ExpKind
                -> TcM TcType
    tc_fun_type :: TcTyMode
    -> HsMultAnn GhcRn
    -> LHsType GhcRn
    -> LHsType GhcRn
    -> ExpSigmaType
    -> TcM Type
    tc_fun_type TcTyMode
    mode HsMultAnn GhcRn
    mult LHsType GhcRn
    ty1 LHsType GhcRn
    ty2 ExpSigmaType
    exp_kind = case TcTyMode -> TypeOrKind
    mode_tyki TcTyMode
    mode of
      TypeOrKind
    TypeLevel ->
        do { String -> SDoc -> TcM ()
    traceTc String
    "tc_fun_type" (GenLocated SrcSpanAnnA (HsType GhcRn) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    ty1 SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ GenLocated SrcSpanAnnA (HsType GhcRn) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    ty2)
           ; arg_k <- TcM Type
    newOpenTypeKind
           ; res_k <- newOpenTypeKind
           ; ty1'  <- tc_check_lhs_type mode ty1 arg_k
           ; ty2'  <- tc_check_lhs_type mode ty2 res_k
           ; mult' <- tc_mult mode mult
           ; checkExpKind (HsFunTy noExtField mult ty1 ty2)
                          (tcMkVisFunTy mult' ty1' ty2')
                          liftedTypeKind exp_kind }
      TypeOrKind
    KindLevel ->  -- no representation polymorphism in kinds. yet.
        do { ty1'  <- TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode LHsType GhcRn
    ty1 Type
    liftedTypeKind
           ; ty2'  <- tc_check_lhs_type mode ty2 liftedTypeKind
           ; mult' <- tc_mult mode mult
           ; checkExpKind (HsFunTy noExtField mult ty1 ty2)
                          (tcMkVisFunTy mult' ty1' ty2')
                          liftedTypeKind exp_kind }
      where
        tc_mult :: TcTyMode
    -> HsMultAnnOf (GenLocated SrcSpanAnnA (HsType GhcRn)) GhcRn
    -> TcM Type
    tc_mult TcTyMode
    mode HsMultAnnOf (GenLocated SrcSpanAnnA (HsType GhcRn)) GhcRn
    mult = case HsMultAnn GhcRn -> Maybe (LHsType GhcRn)
    multAnnToHsType HsMultAnn GhcRn
    HsMultAnnOf (GenLocated SrcSpanAnnA (HsType GhcRn)) GhcRn
    mult of
          Just LHsType GhcRn
    mult' -> TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode LHsType GhcRn
    mult' Type
    multiplicityTy
          Maybe (LHsType GhcRn)
    Nothing    -> Type -> TcM Type
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Type
    manyDataConTy

    {- Note [Skolem escape and forall-types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    See also Note [Checking telescopes].

    Consider
      f :: forall a. (forall kb (b :: kb). Proxy '[a, b]) -> ()

    The Proxy '[a,b] forces a and b to have the same kind.  But a's
    kind must be bound outside the 'forall a', and hence escapes.
    We discover this by building an implication constraint for
    each forall.  So the inner implication constraint will look like
        forall kb (b::kb).  kb ~ ka
    where ka is a's kind.  We can't unify these two, /even/ if ka is
    unification variable, because it would be untouchable inside
    this inner implication.

    That's what the pushLevelAndCaptureConstraints, plus subsequent
    buildTvImplication/emitImplication is all about, when kind-checking
    HsForAllTy.

    Note that

    * We don't need to /simplify/ the constraints here
      because we aren't generalising. We just capture them.

    * We can't use emitResidualTvConstraint, because that has a fast-path
      for empty constraints.  We can't take that fast path here, because
      we must do the bad-telescope check even if there are no inner wanted
      constraints. See Note [Checking telescopes] in
      GHC.Tc.Types.Constraint.  Lacking this check led to #16247.
    -}

    {- *********************************************************************
    *                                                                      *
                    Tuples
    *                                                                      *
    ********************************************************************* -}

    ---------------------------
    tupKindSort_maybe :: TcKind -> Maybe TupleSort
    tupKindSort_maybe :: Type -> Maybe TupleSort
    tupKindSort_maybe Type
    k
      | Just (Type
    k', Coercion
    _) <- Type -> Maybe (Type, Coercion)
    splitCastTy_maybe Type
    k = Type -> Maybe TupleSort
    tupKindSort_maybe Type
    k'
      | Just Type
    k'      <- Type -> Maybe Type
    coreView Type
    k          = Type -> Maybe TupleSort
    tupKindSort_maybe Type
    k'
      | Type -> Bool
    isConstraintKind Type
    k                  = TupleSort -> Maybe TupleSort
    forall a. a -> Maybe a
    Just TupleSort
    ConstraintTuple
      | Type -> Bool
    tcIsLiftedTypeKind Type
    k                = TupleSort -> Maybe TupleSort
    forall a. a -> Maybe a
    Just TupleSort
    BoxedTuple
      | Bool
    otherwise                           = Maybe TupleSort
    forall a. Maybe a
    Nothing

    tc_tuple :: HsType GhcRn -> TcTyMode -> TupleSort -> [LHsType GhcRn] -> TcKind -> TcM TcType
    tc_tuple :: HsType GhcRn
    -> TcTyMode -> TupleSort -> [LHsType GhcRn] -> Type -> TcM Type
    tc_tuple HsType GhcRn
    rn_ty TcTyMode
    mode TupleSort
    tup_sort [LHsType GhcRn]
    tys Type
    exp_kind
      = do { arg_kinds <- case TupleSort
    tup_sort of
               TupleSort
    BoxedTuple      -> [Type] -> TcM [Type]
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> Type -> [Type]
    forall a. Int -> a -> [a]
    replicate Int
    arity Type
    liftedTypeKind)
               TupleSort
    UnboxedTuple    -> Int -> TcM Type -> TcM [Type]
    forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
    replicateM Int
    arity TcM Type
    newOpenTypeKind
               TupleSort
    ConstraintTuple -> [Type] -> TcM [Type]
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> Type -> [Type]
    forall a. Int -> a -> [a]
    replicate Int
    arity Type
    constraintKind)
           ; tau_tys <- zipWithM (tc_check_lhs_type mode) tys arg_kinds
           ; finish_tuple rn_ty tup_sort tau_tys arg_kinds exp_kind }
      where
        arity :: Int
    arity   = [GenLocated SrcSpanAnnA (HsType GhcRn)] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [LHsType GhcRn]
    [GenLocated SrcSpanAnnA (HsType GhcRn)]
    tys

    finish_tuple :: HsType GhcRn
                 -> TupleSort
                 -> [TcType]    -- ^ argument types
                 -> [TcKind]    -- ^ of these kinds
                 -> TcKind      -- ^ expected kind of the whole tuple
                 -> TcM TcType
    finish_tuple :: HsType GhcRn -> TupleSort -> [Type] -> [Type] -> Type -> TcM Type
    finish_tuple HsType GhcRn
    rn_ty TupleSort
    tup_sort [Type]
    tau_tys [Type]
    tau_kinds Type
    exp_kind = do
      String -> SDoc -> TcM ()
    traceTc String
    "finish_tuple" (TupleSort -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TupleSort
    tup_sort SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ [Type] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [Type]
    tau_kinds SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    exp_kind)
      case TupleSort
    tup_sort of
        TupleSort
    ConstraintTuple -> do
          let tycon :: TyCon
    tycon = Int -> TyCon
    cTupleTyCon Int
    arity
          Int -> TcM ()
    checkCTupSize Int
    arity
          Type -> Type -> TcM Type
    check_expected_kind (TyCon -> [Type] -> Type
    mkTyConApp TyCon
    tycon [Type]
    tau_tys) Type
    constraintKind
        TupleSort
    BoxedTuple -> do
          let tycon :: TyCon
    tycon = Boxity -> Int -> TyCon
    tupleTyCon Boxity
    Boxed Int
    arity
          Int -> TcM ()
    checkTupSize Int
    arity
          TyCon -> TcM ()
    checkWiredInTyCon TyCon
    tycon
          Type -> Type -> TcM Type
    check_expected_kind (TyCon -> [Type] -> Type
    mkTyConApp TyCon
    tycon [Type]
    tau_tys) Type
    liftedTypeKind
        TupleSort
    UnboxedTuple -> do
          let tycon :: TyCon
    tycon    = Boxity -> Int -> TyCon
    tupleTyCon Boxity
    Unboxed Int
    arity
              tau_reps :: [Type]
    tau_reps = (Type -> Type) -> [Type] -> [Type]
    forall a b. (a -> b) -> [a] -> [b]
    map HasDebugCallStack => Type -> Type
    Type -> Type
    kindRep [Type]
    tau_kinds
              -- See also Note [Unboxed tuple RuntimeRep vars] in GHC.Core.TyCon
              arg_tys :: [Type]
    arg_tys  = [Type]
    tau_reps [Type] -> [Type] -> [Type]
    forall a. [a] -> [a] -> [a]
    ++ [Type]
    tau_tys
              res_kind :: Type
    res_kind = [Type] -> Type
    unboxedTupleKind [Type]
    tau_reps
          Int -> TcM ()
    checkTupSize Int
    arity
          Type -> Type -> TcM Type
    check_expected_kind (TyCon -> [Type] -> Type
    mkTyConApp TyCon
    tycon [Type]
    arg_tys) Type
    res_kind
      where
        arity :: Int
    arity = [Type] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [Type]
    tau_tys
        check_expected_kind :: Type -> Type -> TcM Type
    check_expected_kind Type
    ty Type
    act_kind =
          HasDebugCallStack =>
    HsType GhcRn -> Type -> Type -> Type -> TcM Type
    HsType GhcRn -> Type -> Type -> Type -> TcM Type
    checkExpectedKind HsType GhcRn
    rn_ty Type
    ty Type
    act_kind Type
    exp_kind

    {- *********************************************************************
    *                                                                      *
                    Type applications
    *                                                                      *
    ********************************************************************* -}

    splitHsAppTys_maybe :: HsType GhcRn -> Maybe (LHsType GhcRn, [LHsTypeArg GhcRn])
    splitHsAppTys_maybe :: HsType GhcRn -> Maybe (LHsType GhcRn, HsFamEqnPats GhcRn)
    splitHsAppTys_maybe HsType GhcRn
    hs_ty
      | HsType GhcRn -> Bool
    is_app HsType GhcRn
    hs_ty = (GenLocated SrcSpanAnnA (HsType GhcRn),
     [HsArg
        GhcRn
        (GenLocated SrcSpanAnnA (HsType GhcRn))
        (GenLocated SrcSpanAnnA (HsType GhcRn))])
    -> Maybe
         (GenLocated SrcSpanAnnA (HsType GhcRn),
          [HsArg
             GhcRn
             (GenLocated SrcSpanAnnA (HsType GhcRn))
             (GenLocated SrcSpanAnnA (HsType GhcRn))])
    forall a. a -> Maybe a
    Just (HsType GhcRn -> (LHsType GhcRn, HsFamEqnPats GhcRn)
    splitHsAppTys HsType GhcRn
    hs_ty)
      | Bool
    otherwise    = Maybe (LHsType GhcRn, HsFamEqnPats GhcRn)
    Maybe
      (GenLocated SrcSpanAnnA (HsType GhcRn),
       [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))])
    forall a. Maybe a
    Nothing
      where
        is_app :: HsType GhcRn -> Bool
        is_app :: HsType GhcRn -> Bool
    is_app (HsAppKindTy {})        = Bool
    True
        is_app (HsAppTy {})            = Bool
    True
        is_app (HsOpTy XOpTy GhcRn
    _ PromotionFlag
    _ LHsType GhcRn
    _ (L SrcSpanAnnN
    _ (WithUserRdr RdrName
    _ Name
    op)) LHsType GhcRn
    _)
          = Bool -> Bool
    not (Name
    op Name -> Unique -> Bool
    forall a. Uniquable a => a -> Unique -> Bool
    `hasKey` Unique
    unrestrictedFunTyConKey)
          -- I'm not sure why this funTyConKey test is necessary
          -- Can it even happen?  Perhaps for   t1 `(->)` t2
          -- but then maybe it's ok to treat that like a normal
          -- application rather than using the special rule for HsFunTy
        is_app (HsTyVar {})            = Bool
    True
        is_app (HsParTy XParTy GhcRn
    _ (L SrcSpanAnnA
    _ HsType GhcRn
    ty))    = HsType GhcRn -> Bool
    is_app HsType GhcRn
    ty
        is_app HsType GhcRn
    _                       = Bool
    False

    splitHsAppTys :: HsType GhcRn -> (LHsType GhcRn, [LHsTypeArg GhcRn])

    splitHsAppTys :: HsType GhcRn -> (LHsType GhcRn, HsFamEqnPats GhcRn)
    splitHsAppTys HsType GhcRn
    hs_ty = LHsType GhcRn
    -> HsFamEqnPats GhcRn -> (LHsType GhcRn, HsFamEqnPats GhcRn)
    go (HsType GhcRn -> GenLocated SrcSpanAnnA (HsType GhcRn)
    forall e a. HasAnnotation e => a -> GenLocated e a
    noLocA HsType GhcRn
    hs_ty) []
      where
        go :: LHsType GhcRn
           -> [HsArg GhcRn (LHsType GhcRn) (LHsKind GhcRn)]
           -> (LHsType GhcRn,
               [HsArg GhcRn (LHsType GhcRn) (LHsKind GhcRn)]) -- AZ temp
        go :: LHsType GhcRn
    -> HsFamEqnPats GhcRn -> (LHsType GhcRn, HsFamEqnPats GhcRn)
    go (L SrcSpanAnnA
    _  (HsAppTy XAppTy GhcRn
    _ LHsType GhcRn
    f LHsType GhcRn
    a))      HsFamEqnPats GhcRn
    as = LHsType GhcRn
    -> HsFamEqnPats GhcRn -> (LHsType GhcRn, HsFamEqnPats GhcRn)
    go LHsType GhcRn
    f (XValArg GhcRn
    -> GenLocated SrcSpanAnnA (HsType GhcRn)
    -> HsArg
         GhcRn
         (GenLocated SrcSpanAnnA (HsType GhcRn))
         (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall p tm ty. XValArg p -> tm -> HsArg p tm ty
    HsValArg NoExtField
    XValArg GhcRn
    noExtField LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    a HsArg
      GhcRn
      (GenLocated SrcSpanAnnA (HsType GhcRn))
      (GenLocated SrcSpanAnnA (HsType GhcRn))
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    forall a. a -> [a] -> [a]
    : HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    as)
        go (L SrcSpanAnnA
    _  (HsAppKindTy XAppKindTy GhcRn
    _ LHsType GhcRn
    ty LHsType GhcRn
    k)) HsFamEqnPats GhcRn
    as = LHsType GhcRn
    -> HsFamEqnPats GhcRn -> (LHsType GhcRn, HsFamEqnPats GhcRn)
    go LHsType GhcRn
    ty (XTypeArg GhcRn
    -> GenLocated SrcSpanAnnA (HsType GhcRn)
    -> HsArg
         GhcRn
         (GenLocated SrcSpanAnnA (HsType GhcRn))
         (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall p tm ty. XTypeArg p -> ty -> HsArg p tm ty
    HsTypeArg NoExtField
    XTypeArg GhcRn
    noExtField LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    k HsArg
      GhcRn
      (GenLocated SrcSpanAnnA (HsType GhcRn))
      (GenLocated SrcSpanAnnA (HsType GhcRn))
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    forall a. a -> [a] -> [a]
    : HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    as)
        go (L SrcSpanAnnA
    sp (HsParTy XParTy GhcRn
    _ LHsType GhcRn
    f))        HsFamEqnPats GhcRn
    as = LHsType GhcRn
    -> HsFamEqnPats GhcRn -> (LHsType GhcRn, HsFamEqnPats GhcRn)
    go LHsType GhcRn
    f (XArgPar GhcRn
    -> HsArg
         GhcRn
         (GenLocated SrcSpanAnnA (HsType GhcRn))
         (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall p tm ty. XArgPar p -> HsArg p tm ty
    HsArgPar (SrcSpanAnnA -> SrcSpan
    forall a. HasLoc a => a -> SrcSpan
    locA SrcSpanAnnA
    sp) HsArg
      GhcRn
      (GenLocated SrcSpanAnnA (HsType GhcRn))
      (GenLocated SrcSpanAnnA (HsType GhcRn))
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    forall a. a -> [a] -> [a]
    : HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    as)
        go (L SrcSpanAnnA
    _  (HsOpTy XOpTy GhcRn
    _ PromotionFlag
    prom LHsType GhcRn
    l op :: LIdOccP GhcRn
    op@(L SrcSpanAnnN
    sp WithUserRdr Name
    _) LHsType GhcRn
    r)) HsFamEqnPats GhcRn
    as
          = ( SrcSpanAnnA
    -> HsType GhcRn -> GenLocated SrcSpanAnnA (HsType GhcRn)
    forall l e. l -> e -> GenLocated l e
    L (SrcSpanAnnN -> SrcSpanAnnA
    forall a b. (HasLoc a, HasAnnotation b) => a -> b
    l2l SrcSpanAnnN
    sp) (XTyVar GhcRn -> PromotionFlag -> LIdOccP GhcRn -> HsType GhcRn
    forall pass.
    XTyVar pass -> PromotionFlag -> LIdOccP pass -> HsType pass
    HsTyVar XTyVar GhcRn
    EpToken "'"
    forall a. NoAnn a => a
    noAnn PromotionFlag
    prom LIdOccP GhcRn
    op)
            , XValArg GhcRn
    -> GenLocated SrcSpanAnnA (HsType GhcRn)
    -> HsArg
         GhcRn
         (GenLocated SrcSpanAnnA (HsType GhcRn))
         (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall p tm ty. XValArg p -> tm -> HsArg p tm ty
    HsValArg NoExtField
    XValArg GhcRn
    noExtField LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    l HsArg
      GhcRn
      (GenLocated SrcSpanAnnA (HsType GhcRn))
      (GenLocated SrcSpanAnnA (HsType GhcRn))
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    forall a. a -> [a] -> [a]
    : XValArg GhcRn
    -> GenLocated SrcSpanAnnA (HsType GhcRn)
    -> HsArg
         GhcRn
         (GenLocated SrcSpanAnnA (HsType GhcRn))
         (GenLocated SrcSpanAnnA (HsType GhcRn))
    forall p tm ty. XValArg p -> tm -> HsArg p tm ty
    HsValArg NoExtField
    XValArg GhcRn
    noExtField LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    r HsArg
      GhcRn
      (GenLocated SrcSpanAnnA (HsType GhcRn))
      (GenLocated SrcSpanAnnA (HsType GhcRn))
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    forall a. a -> [a] -> [a]
    : HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    as )
        go LHsType GhcRn
    f HsFamEqnPats GhcRn
    as = (LHsType GhcRn
    f, HsFamEqnPats GhcRn
    as)

    ---------------------------
    tcInferTyAppHead :: TcTyMode -> LHsType GhcRn -> TcM (TcType, TcKind)
    -- Version of tc_infer_lhs_type specialised for the head of an
    -- application. In particular, for a HsTyVar (which includes type
    -- constructors, it does not zoom off into tcInferTyApps and family
    -- saturation
    tcInferTyAppHead :: TcTyMode -> LHsType GhcRn -> TcM (Type, Type)
    tcInferTyAppHead TcTyMode
    _ (L SrcSpanAnnA
    _ (HsTyVar XTyVar GhcRn
    _ PromotionFlag
    _ (L SrcSpanAnnN
    _ (WithUserRdr RdrName
    _ Name
    tv))))
      = Name -> TcM (Type, Type)
    tcTyVar Name
    tv
    tcInferTyAppHead TcTyMode
    mode LHsType GhcRn
    ty
      = TcTyMode -> LHsType GhcRn -> TcM (Type, Type)
    tc_infer_lhs_type TcTyMode
    mode LHsType GhcRn
    ty

    tc_app_ty :: TcTyMode -> HsType GhcRn -> ExpKind -> TcM TcType
    tc_app_ty :: TcTyMode -> HsType GhcRn -> ExpSigmaType -> TcM Type
    tc_app_ty TcTyMode
    mode HsType GhcRn
    rn_ty ExpSigmaType
    exp_kind
      = do { (fun_ty, _ki) <- TcTyMode -> LHsType GhcRn -> TcM (Type, Type)
    tcInferTyAppHead TcTyMode
    mode LHsType GhcRn
    hs_fun_ty
           ; (ty, infered_kind) <- tcInferTyApps mode hs_fun_ty fun_ty hs_args
           ; checkExpKind rn_ty ty infered_kind exp_kind }
      where
        (LHsType GhcRn
    hs_fun_ty, HsFamEqnPats GhcRn
    hs_args) = HsType GhcRn -> (LHsType GhcRn, HsFamEqnPats GhcRn)
    splitHsAppTys HsType GhcRn
    rn_ty

    ---------------------------
    -- | Apply a type of a given kind to a list of arguments. This instantiates
    -- invisible parameters as necessary. Always consumes all the arguments,
    -- using matchExpectedFunKind as necessary.
    -- This takes an optional @VarEnv Kind@ which maps kind variables to kinds.-
    -- These kinds should be used to instantiate invisible kind variables;
    -- they come from an enclosing class for an associated type/data family.
    --
    -- tcInferTyApps also arranges to saturate any trailing invisible arguments
    --   of a type-family application, which is usually the right thing to do
    -- tcInferTyApps_nosat does not do this saturation; it is used only
    --   by ":kind" in GHCi
    tcInferTyApps, tcInferTyApps_nosat
        :: TcTyMode
        -> LHsType GhcRn        -- ^ Function (for printing only)
        -> TcType               -- ^ Function
        -> [LHsTypeArg GhcRn]   -- ^ Args
        -> TcM (TcType, TcKind) -- ^ (f args, result kind)
    tcInferTyApps :: TcTyMode
    -> LHsType GhcRn -> Type -> HsFamEqnPats GhcRn -> TcM (Type, Type)
    tcInferTyApps TcTyMode
    mode LHsType GhcRn
    hs_ty Type
    fun HsFamEqnPats GhcRn
    hs_args
      = do { (f_args, res_k) <- TcTyMode
    -> LHsType GhcRn -> Type -> HsFamEqnPats GhcRn -> TcM (Type, Type)
    tcInferTyApps_nosat TcTyMode
    mode LHsType GhcRn
    hs_ty Type
    fun HsFamEqnPats GhcRn
    hs_args
           ; saturateFamApp f_args res_k }

    tcInferTyApps_nosat :: TcTyMode
    -> LHsType GhcRn -> Type -> HsFamEqnPats GhcRn -> TcM (Type, Type)
    tcInferTyApps_nosat TcTyMode
    mode LHsType GhcRn
    orig_hs_ty Type
    fun HsFamEqnPats GhcRn
    orig_hs_args
      = do { String -> SDoc -> TcM ()
    traceTc String
    "tcInferTyApps {" (GenLocated SrcSpanAnnA (HsType GhcRn) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    orig_hs_ty SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    orig_hs_args)
           ; (f_args, res_k) <- Int
    -> Type
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> TcM (Type, Type)
    go_init Int
    1 Type
    fun HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    orig_hs_args
           ; traceTc "tcInferTyApps }" (ppr f_args <+> dcolon <+> ppr res_k)
           ; return (f_args, res_k) }
      where

        -- go_init just initialises the auxiliary
        -- arguments of the 'go' loop
        go_init :: Int
    -> Type
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> TcM (Type, Type)
    go_init Int
    n Type
    fun [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    all_args
          = Int
    -> Type -> Subst -> Type -> HsFamEqnPats GhcRn -> TcM (Type, Type)
    go Int
    n Type
    fun Subst
    empty_subst Type
    fun_ki HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    all_args
          where
            fun_ki :: Type
    fun_ki = HasDebugCallStack => Type -> Type
    Type -> Type
    typeKind Type
    fun
               -- We do (typeKind fun) here, even though the caller
               -- knows the function kind, to absolutely guarantee
               -- INVARIANT for 'go'
               -- Note that in a typical application (F t1 t2 t3),
               -- the 'fun' is just a TyCon, so typeKind is fast

            empty_subst :: Subst
    empty_subst = InScopeSet -> Subst
    mkEmptySubst (InScopeSet -> Subst) -> InScopeSet -> Subst
    forall a b. (a -> b) -> a -> b
    $ TyVarSet -> InScopeSet
    mkInScopeSet (TyVarSet -> InScopeSet) -> TyVarSet -> InScopeSet
    forall a b. (a -> b) -> a -> b
    $
                          Type -> TyVarSet
    tyCoVarsOfType Type
    fun_ki

        go :: Int             -- The # of the next argument
           -> TcType          -- Function applied to some args
           -> Subst        -- Applies to function kind
           -> TcKind          -- Function kind
           -> [LHsTypeArg GhcRn]    -- Un-type-checked args
           -> TcM (TcType, TcKind)  -- Result type and its kind
        -- INVARIANT: in any call (go n fun subst fun_ki args)
        --               typeKind fun  =  subst(fun_ki)
        -- So the 'subst' and 'fun_ki' arguments are simply
        -- there to avoid repeatedly calling typeKind.
        --
        -- Reason for INVARIANT: to support the Purely Kinded Type Invariant
        -- it's important that if fun_ki has a forall, then so does
        -- (typeKind fun), because the next thing we are going to do
        -- is apply 'fun' to an argument type.

        -- Dispatch on all_args first, for performance reasons
        go :: Int
    -> Type -> Subst -> Type -> HsFamEqnPats GhcRn -> TcM (Type, Type)
    go Int
    n Type
    fun Subst
    subst Type
    fun_ki HsFamEqnPats GhcRn
    all_args = case (HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    all_args, Type -> Maybe (PiTyVarBinder, Type)
    tcSplitPiTy_maybe Type
    fun_ki) of

          ---------------- No user-written args left. We're done!
          ([], Maybe (PiTyVarBinder, Type)
    _) -> (Type, Type) -> TcM (Type, Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type
    fun, HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst Type
    fun_ki)

          ---------------- HsArgPar: We don't care about parens here
          (HsArgPar XArgPar GhcRn
    _ : [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    args, Maybe (PiTyVarBinder, Type)
    _) -> Int
    -> Type -> Subst -> Type -> HsFamEqnPats GhcRn -> TcM (Type, Type)
    go Int
    n Type
    fun Subst
    subst Type
    fun_ki HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    args

          ---------------- HsTypeArg: a kind application (fun @ki)
          (HsTypeArg XTypeArg GhcRn
    _ GenLocated SrcSpanAnnA (HsType GhcRn)
    hs_ki_arg : [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    hs_args, Just (PiTyVarBinder
    ki_binder, Type
    inner_ki)) ->
            case PiTyVarBinder
    ki_binder of

            -- FunTy with PredTy on LHS, or ForAllTy with Inferred
            Named (Bndr TyVar
    kv ForAllTyFlag
    Inferred)         -> TyVar -> Type -> TcM (Type, Type)
    instantiate TyVar
    kv Type
    inner_ki

            Named (Bndr TyVar
    _ ForAllTyFlag
    Specified) ->  -- Visible kind application
              do { String -> SDoc -> TcM ()
    traceTc String
    "tcInferTyApps (vis kind app)"
                           ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ PiTyVarBinder -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr PiTyVarBinder
    ki_binder, GenLocated SrcSpanAnnA (HsType GhcRn) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr GenLocated SrcSpanAnnA (HsType GhcRn)
    hs_ki_arg
                                 , Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (PiTyVarBinder -> Type
    piTyBinderType PiTyVarBinder
    ki_binder)
                                 , Subst -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Subst
    subst ])

                 ; let exp_kind :: Type
    exp_kind = HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst (Type -> Type) -> Type -> Type
    forall a b. (a -> b) -> a -> b
    $ PiTyVarBinder -> Type
    piTyBinderType PiTyVarBinder
    ki_binder
                 ; arg_mode <- TypeOrKind -> HoleMode -> TcM TcTyMode
    mkHoleMode TypeOrKind
    KindLevel HoleMode
    HM_VTA
                       -- HM_VKA: see Note [Wildcards in visible kind application]
                 ; ki_arg <- addErrCtxt (FunAppCtxt (FunAppCtxtTy orig_hs_ty hs_ki_arg) n) $
                             tc_check_lhs_type arg_mode hs_ki_arg exp_kind

                 ; traceTc "tcInferTyApps (vis kind app)" (ppr exp_kind)
                 ; (subst', fun') <- mkAppTyM subst fun ki_binder ki_arg
                 ; go (n+1) fun' subst' inner_ki hs_args }

            -- Attempted visible kind application (fun @ki), but fun_ki is
            --   forall k -> blah   or   k1 -> k2
            -- So we need a normal application.  Error.
            PiTyVarBinder
    _ -> GenLocated SrcSpanAnnA (HsType GhcRn) -> Type -> TcM (Type, Type)
    forall {a}. GenLocated SrcSpanAnnA (HsType GhcRn) -> Type -> TcRn a
    ty_app_err GenLocated SrcSpanAnnA (HsType GhcRn)
    hs_ki_arg (Type -> TcM (Type, Type)) -> Type -> TcM (Type, Type)
    forall a b. (a -> b) -> a -> b
    $ HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst Type
    fun_ki

          -- No binder; try applying the substitution, or fail if that's not possible
          (HsTypeArg XTypeArg GhcRn
    _ GenLocated SrcSpanAnnA (HsType GhcRn)
    ki_arg : [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    _, Maybe (PiTyVarBinder, Type)
    Nothing) -> TcM (Type, Type) -> TcM (Type, Type)
    try_again_after_substing_or (TcM (Type, Type) -> TcM (Type, Type))
    -> TcM (Type, Type) -> TcM (Type, Type)
    forall a b. (a -> b) -> a -> b
    $
                                               GenLocated SrcSpanAnnA (HsType GhcRn) -> Type -> TcM (Type, Type)
    forall {a}. GenLocated SrcSpanAnnA (HsType GhcRn) -> Type -> TcRn a
    ty_app_err GenLocated SrcSpanAnnA (HsType GhcRn)
    ki_arg Type
    substed_fun_ki

          ---------------- HsValArg: a normal argument (fun ty)
          (HsValArg XValArg GhcRn
    _ GenLocated SrcSpanAnnA (HsType GhcRn)
    arg : [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    args, Just (PiTyVarBinder
    ki_binder, Type
    inner_ki))
            -- next binder is invisible; need to instantiate it
            | Named (Bndr TyVar
    kv ForAllTyFlag
    flag) <- PiTyVarBinder
    ki_binder
            , ForAllTyFlag -> Bool
    isInvisibleForAllTyFlag ForAllTyFlag
    flag   -- ForAllTy with Inferred or Specified
             -> TyVar -> Type -> TcM (Type, Type)
    instantiate TyVar
    kv Type
    inner_ki

            -- "normal" case
            | Bool
    otherwise
             -> do { String -> SDoc -> TcM ()
    traceTc String
    "tcInferTyApps (vis normal app)"
                              ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ PiTyVarBinder -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr PiTyVarBinder
    ki_binder
                                    , GenLocated SrcSpanAnnA (HsType GhcRn) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr GenLocated SrcSpanAnnA (HsType GhcRn)
    arg
                                    , Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr (PiTyVarBinder -> Type
    piTyBinderType PiTyVarBinder
    ki_binder)
                                    , Subst -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Subst
    subst ])
                    ; let exp_kind :: Type
    exp_kind = HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst (Type -> Type) -> Type -> Type
    forall a b. (a -> b) -> a -> b
    $ PiTyVarBinder -> Type
    piTyBinderType PiTyVarBinder
    ki_binder
                    ; arg' <- ErrCtxtMsg -> TcM Type -> TcM Type
    forall a. ErrCtxtMsg -> TcM a -> TcM a
    addErrCtxt (FunAppCtxtFunArg -> Int -> ErrCtxtMsg
    FunAppCtxt (LHsType GhcRn -> LHsType GhcRn -> FunAppCtxtFunArg
    FunAppCtxtTy LHsType GhcRn
    orig_hs_ty LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    arg) Int
    n) (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
                              TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    arg Type
    exp_kind
                    ; traceTc "tcInferTyApps (vis normal app) 2" (ppr exp_kind)
                    ; (subst', fun') <- mkAppTyM subst fun ki_binder arg'
                    ; go (n+1) fun' subst' inner_ki args }

              -- no binder; try applying the substitution, or infer another arrow in fun kind
          (HsValArg XValArg GhcRn
    _ GenLocated SrcSpanAnnA (HsType GhcRn)
    _ : [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    _, Maybe (PiTyVarBinder, Type)
    Nothing)
            -> TcM (Type, Type) -> TcM (Type, Type)
    try_again_after_substing_or (TcM (Type, Type) -> TcM (Type, Type))
    -> TcM (Type, Type) -> TcM (Type, Type)
    forall a b. (a -> b) -> a -> b
    $
               do { let arrows_needed :: Int
    arrows_needed = [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> Int
    forall p tm ty. [HsArg p tm ty] -> Int
    n_initial_val_args HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    all_args
                  ; co <- TypedThing -> Int -> Type -> TcM Coercion
    matchExpectedFunKind (HsType GhcRn -> TypedThing
    HsTypeRnThing (HsType GhcRn -> TypedThing) -> HsType GhcRn -> TypedThing
    forall a b. (a -> b) -> a -> b
    $ GenLocated SrcSpanAnnA (HsType GhcRn) -> HsType GhcRn
    forall l e. GenLocated l e -> e
    unLoc LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    hs_ty) Int
    arrows_needed Type
    substed_fun_ki

                  ; fun' <- liftZonkM $ zonkTcType (fun `mkCastTy` co)
                         -- This zonk is essential, to expose the fruits
                         -- of matchExpectedFunKind to the 'go' loop

                  ; traceTc "tcInferTyApps (no binder)" $
                       vcat [ ppr fun <+> dcolon <+> ppr fun_ki
                            , ppr arrows_needed
                            , ppr co
                            , ppr fun' <+> dcolon <+> ppr (typeKind fun')]
                  ; go_init n fun' all_args }
                    -- Use go_init to establish go's INVARIANT
          where
            instantiate :: TyVar -> Type -> TcM (Type, Type)
    instantiate TyVar
    ki_binder Type
    inner_ki
              = do { String -> SDoc -> TcM ()
    traceTc String
    "tcInferTyApps (need to instantiate)"
                             ([SDoc] -> SDoc
    forall doc. IsDoc doc => [doc] -> doc
    vcat [ TyVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyVar
    ki_binder, Subst -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Subst
    subst])
                   ; (subst', arg') <- Subst -> TyVar -> TcM (Subst, Type)
    tcInstInvisibleTyBinder Subst
    subst TyVar
    ki_binder
                   ; go n (mkAppTy fun arg') subst' inner_ki all_args }
                     -- Because tcInvisibleTyBinder instantiate ki_binder,
                     -- the kind of arg' will have the same shape as the kind
                     -- of ki_binder.  So we don't need mkAppTyM here.

            try_again_after_substing_or :: TcM (Type, Type) -> TcM (Type, Type)
    try_again_after_substing_or TcM (Type, Type)
    fallthrough
              | Bool -> Bool
    not (Subst -> Bool
    isEmptyTCvSubst Subst
    subst)
              = Int
    -> Type -> Subst -> Type -> HsFamEqnPats GhcRn -> TcM (Type, Type)
    go Int
    n Type
    fun Subst
    zapped_subst Type
    substed_fun_ki HsFamEqnPats GhcRn
    all_args
              | Bool
    otherwise
              = TcM (Type, Type)
    fallthrough

            zapped_subst :: Subst
    zapped_subst   = Subst -> Subst
    zapSubst Subst
    subst
            substed_fun_ki :: Type
    substed_fun_ki = HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst Type
    fun_ki
            hs_ty :: LHsType GhcRn
    hs_ty          = LHsType GhcRn -> HsFamEqnPats GhcRn -> LHsType GhcRn
    appTypeToArg LHsType GhcRn
    orig_hs_ty (Int
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    -> [HsArg
          GhcRn
          (GenLocated SrcSpanAnnA (HsType GhcRn))
          (GenLocated SrcSpanAnnA (HsType GhcRn))]
    forall a. Int -> [a] -> [a]
    take (Int
    nInt -> Int -> Int
    forall a. Num a => a -> a -> a
    -Int
    1) HsFamEqnPats GhcRn
    [HsArg
       GhcRn
       (GenLocated SrcSpanAnnA (HsType GhcRn))
       (GenLocated SrcSpanAnnA (HsType GhcRn))]
    orig_hs_args)

        n_initial_val_args :: [HsArg p tm ty] -> Arity
        -- Count how many leading HsValArgs we have
        n_initial_val_args :: forall p tm ty. [HsArg p tm ty] -> Int
    n_initial_val_args (HsValArg {} : [HsArg p tm ty]
    args) = Int
    1 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + [HsArg p tm ty] -> Int
    forall p tm ty. [HsArg p tm ty] -> Int
    n_initial_val_args [HsArg p tm ty]
    args
        n_initial_val_args (HsArgPar {} : [HsArg p tm ty]
    args) = [HsArg p tm ty] -> Int
    forall p tm ty. [HsArg p tm ty] -> Int
    n_initial_val_args [HsArg p tm ty]
    args
        n_initial_val_args [HsArg p tm ty]
    _                    = Int
    0

        ty_app_err :: GenLocated SrcSpanAnnA (HsType GhcRn) -> Type -> TcRn a
    ty_app_err GenLocated SrcSpanAnnA (HsType GhcRn)
    arg Type
    ty
          = TcRnMessage -> TcRn a
    forall a. TcRnMessage -> TcRn a
    failWith (TcRnMessage -> TcRn a) -> TcRnMessage -> TcRn a
    forall a b. (a -> b) -> a -> b
    $ LHsType GhcRn -> Type -> TcRnMessage
    TcRnInvalidVisibleKindArgument LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    arg Type
    ty

    mkAppTyM :: Subst
             -> TcType -> PiTyBinder    -- fun, plus its top-level binder
             -> TcType                  -- arg
             -> TcM (Subst, TcType)  -- Extended subst, plus (fun arg)
    -- Precondition: the application (fun arg) is well-kinded after zonking
    --               That is, the application makes sense
    --
    -- Precondition: for (mkAppTyM subst fun bndr arg)
    --       typeKind fun  =  Pi bndr. body
    --  That is, fun always has a ForAllTy or FunTy at the top
    --           and 'bndr' is fun's pi-binder
    --
    -- Postcondition: if fun and arg satisfy (PKTI), the purely-kinded type
    --                invariant, then so does the result type (fun arg)
    --
    -- We do not require that
    --    typeKind arg = tyVarKind (binderVar bndr)
    -- This must be true after zonking (precondition 1), but it's not
    -- required for the (PKTI).
    mkAppTyM :: Subst -> Type -> PiTyVarBinder -> Type -> TcM (Subst, Type)
    mkAppTyM Subst
    subst Type
    fun PiTyVarBinder
    ki_binder Type
    arg
      | -- See Note [mkAppTyM]: Nasty case 2
        TyConApp TyCon
    tc [Type]
    args <- Type
    fun
      , TyCon -> Bool
    isTypeSynonymTyCon TyCon
    tc
      , [Type]
    args [Type] -> Int -> Bool
    forall a. [a] -> Int -> Bool
    `lengthIs` (TyCon -> Int
    tyConArity TyCon
    tc Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1)
      , (TyVar -> Bool) -> [TyVar] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any TyVar -> Bool
    isTrickyTvBinder (TyCon -> [TyVar]
    tyConTyVars TyCon
    tc) -- We could cache this in the synonym
      = do { (arg':args') <- ZonkM [Type] -> TcM [Type]
    forall a. ZonkM a -> TcM a
    liftZonkM (ZonkM [Type] -> TcM [Type]) -> ZonkM [Type] -> TcM [Type]
    forall a b. (a -> b) -> a -> b
    $ [Type] -> ZonkM [Type]
    zonkTcTypes (Type
    argType -> [Type] -> [Type]
    forall a. a -> [a] -> [a]
    :[Type]
    args)
           ; let subst' = case PiTyVarBinder
    ki_binder of
                            Anon {}           -> Subst
    subst
                            Named (Bndr TyVar
    tv ForAllTyFlag
    _) -> Subst -> TyVar -> Type -> Subst
    extendTvSubstAndInScope Subst
    subst TyVar
    tv Type
    arg'
           ; return (subst', mkTyConApp tc (args' ++ [arg'])) }

    mkAppTyM Subst
    subst Type
    fun (Anon {}) Type
    arg
       = (Subst, Type) -> TcM (Subst, Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Subst
    subst, Type -> Type -> Type
    mk_app_ty Type
    fun Type
    arg)

    mkAppTyM Subst
    subst Type
    fun (Named (Bndr TyVar
    tv ForAllTyFlag
    _)) Type
    arg
      = do { arg' <- if TyVar -> Bool
    isTrickyTvBinder TyVar
    tv
                     then -- See Note [mkAppTyM]: Nasty case 1
                          ZonkM Type -> TcM Type
    forall a. ZonkM a -> TcM a
    liftZonkM (ZonkM Type -> TcM Type) -> ZonkM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $ Type -> ZonkM Type
    zonkTcType Type
    arg
                     else Type -> TcM Type
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return     Type
    arg
           ; return ( extendTvSubstAndInScope subst tv arg'
                    , mk_app_ty fun arg' ) }

    mk_app_ty :: TcType -> TcType -> TcType
    -- This function just adds an ASSERT for mkAppTyM's precondition
    mk_app_ty :: Type -> Type -> Type
    mk_app_ty Type
    fun Type
    arg
      = Bool -> SDoc -> Type -> Type
    forall a. HasCallStack => Bool -> SDoc -> a -> a
    assertPpr (Type -> Bool
    isPiTy Type
    fun_kind)
                  (Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    fun SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SDoc
    dcolon SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    fun_kind SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    arg) (Type -> Type) -> Type -> Type
    forall a b. (a -> b) -> a -> b
    $
        Type -> Type -> Type
    mkAppTy Type
    fun Type
    arg
      where
        fun_kind :: Type
    fun_kind = HasDebugCallStack => Type -> Type
    Type -> Type
    typeKind Type
    fun

    isTrickyTvBinder :: TcTyVar -> Bool
    -- NB: isTrickyTvBinder is just an optimisation
    -- It would be absolutely sound to return True always
    isTrickyTvBinder :: TyVar -> Bool
    isTrickyTvBinder TyVar
    tv = Type -> Bool
    isPiTy (TyVar -> Type
    tyVarKind TyVar
    tv)

    {- Note [The Purely Kinded Type Invariant (PKTI)]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    During type inference, we maintain this invariant

     (PKTI) It is legal to call 'typeKind' on any Type ty,
            on any sub-term of ty, /without/ zonking ty

            Moreover, any such returned kind
            will itself satisfy (PKTI)

    By "legal to call typeKind" we mean "typeKind will not crash".
    The way in which typeKind can crash is in applications
        (a t1 t2 .. tn)
    if 'a' is a type variable whose kind doesn't have enough arrows
    or foralls.  (The crash is in piResultTys.)

    The loop in tcInferTyApps has to be very careful to maintain the (PKTI).
    For example, suppose
        kappa is a unification variable
        We have already unified kappa := Type
          yielding    co :: Refl (Type -> Type)
        a :: kappa
    then consider the type
        (a Int)
    If we call typeKind on that, we'll crash, because the (un-zonked)
    kind of 'a' is just kappa, not an arrow kind.  So we must zonk first.

    So the type inference engine is very careful when building applications.
    This happens in tcInferTyApps. Suppose we are kind-checking the type (a Int),
    where (a :: kappa).  Then in tcInferApps we'll run out of binders on
    a's kind, so we'll call matchExpectedFunKind, and unify
       kappa := kappa1 -> kappa2,  with evidence co :: kappa ~ (kappa1 ~ kappa2)
    At this point we must zonk the function type to expose the arrrow, so
    that (a Int) will satisfy (PKTI).

    The absence of this caused #14174 and #14520.

    The calls to mkAppTyM is the other place we are very careful; see Note [mkAppTyM].

    Wrinkle around FunTy:
    Note that the PKTI does *not* guarantee anything about the shape of FunTys.
    Specifically, when we have (FunTy vis mult arg res), it should be the case
    that arg :: TYPE rr1 and res :: TYPE rr2, for some rr1 and rr2. However, we
    might not have this. Example: if the user writes (a -> b), then we might
    invent a :: kappa1 and b :: kappa2. We soon will check whether kappa1 ~ TYPE rho1
    (for some rho1), and that will lead to kappa1 := TYPE rho1 (ditto for kappa2).
    However, when we build the FunTy, we might not have zonked `a`, and so the
    FunTy will be built without being able to purely extract the RuntimeReps.

    Because the PKTI does not guarantee that the RuntimeReps are available in a FunTy,
    we must be aware of this when splitting: splitTyConApp and splitAppTy will *not*
    split a FunTy if the RuntimeReps are not available. See also Note [Decomposing FunTy]
    in GHC.Tc.Solver.Equality.

    Note [mkAppTyM]
    ~~~~~~~~~~~~~~~
    mkAppTyM is trying to guarantee the Purely Kinded Type Invariant
    (PKTI) for its result type (fun arg).  There are two ways it can go wrong:

    * Nasty case 1: forall types (polykinds/T14174a)
        T :: forall (p :: *->*). p Int -> p Bool
      Now kind-check (T x), where x::kappa.
      Well, T and x both satisfy the PKTI, but
         T x :: x Int -> x Bool
      and (x Int) does /not/ satisfy the PKTI.

    * Nasty case 2: type synonyms
        type S f a = f a
      Even though (S ff aa) would satisfy the (PKTI) if S was a data type
      (i.e. nasty case 1 is dealt with), it might still not satisfy (PKTI)
      if S is a type synonym, because the /expansion/ of (S ff aa) is
      (ff aa), and /that/ does not satisfy (PKTI).  E.g. perhaps
      (ff :: kappa), where 'kappa' has already been unified with (*->*).

      We check for nasty case 2 on the final argument of a type synonym.

    Notice that in both cases the trickiness only happens if the
    bound variable has a pi-type.  Hence isTrickyTvBinder.
    -}

    saturateFamApp :: TcType -> TcKind -> TcM (TcType, TcKind)
    -- Precondition for (saturateFamApp ty kind):
    --     typeKind ty = kind
    --
    -- If 'ty' is an unsaturated family application with trailing
    -- invisible arguments, instantiate them.
    -- See Note [saturateFamApp]

    saturateFamApp :: Type -> Type -> TcM (Type, Type)
    saturateFamApp Type
    ty Type
    kind
      | Just (TyCon
    tc, [Type]
    args) <- HasDebugCallStack => Type -> Maybe (TyCon, [Type])
    Type -> Maybe (TyCon, [Type])
    tcSplitTyConApp_maybe Type
    ty
      , TyCon -> Bool
    tyConMustBeSaturated TyCon
    tc
      , let n_to_inst :: Int
    n_to_inst = TyCon -> Int
    tyConArity TyCon
    tc Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - [Type] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [Type]
    args
      = do { (extra_args, ki') <- Int -> Type -> TcM ([Type], Type)
    tcInstInvisibleTyBindersN Int
    n_to_inst Type
    kind
           ; return (ty `mkAppTys` extra_args, ki') }
      | Bool
    otherwise
      = (Type, Type) -> TcM (Type, Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type
    ty, Type
    kind)

    {- Note [saturateFamApp]
    ~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
       type family F :: Either j k
       type instance F @Type = Right Maybe
       type instance F @Type = Right Either```

    Then F :: forall {j,k}. Either j k

    The two type instances do a visible kind application that instantiates
    'j' but not 'k'.  But we want to end up with instances that look like
      type instance F @Type @(*->*) = Right @Type @(*->*) Maybe

    so that F has arity 2.  We must instantiate that trailing invisible
    binder. In general, Invisible binders precede Specified and Required,
    so this is only going to bite for apparently-nullary families.

    Note that
      type family F2 :: forall k. k -> *
    is quite different and really does have arity 0.

    It's not just type instances where we need to saturate those
    unsaturated arguments: see #11246.  Hence doing this in tcInferApps.
    -}

    appTypeToArg :: LHsType GhcRn -> [LHsTypeArg GhcRn] -> LHsType GhcRn
    appTypeToArg :: LHsType GhcRn -> HsFamEqnPats GhcRn -> LHsType GhcRn
    appTypeToArg LHsType GhcRn
    f []                       = LHsType GhcRn
    f
    appTypeToArg LHsType GhcRn
    f (HsValArg XValArg GhcRn
    _ LHsType GhcRn
    arg   : HsFamEqnPats GhcRn
    args) = LHsType GhcRn -> HsFamEqnPats GhcRn -> LHsType GhcRn
    appTypeToArg (LHsType GhcRn -> LHsType GhcRn -> LHsType GhcRn
    forall (p :: Pass).
    LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
    mkHsAppTy LHsType GhcRn
    f LHsType GhcRn
    arg) HsFamEqnPats GhcRn
    args
    appTypeToArg LHsType GhcRn
    f (HsArgPar XArgPar GhcRn
    _       : HsFamEqnPats GhcRn
    args) = LHsType GhcRn -> HsFamEqnPats GhcRn -> LHsType GhcRn
    appTypeToArg LHsType GhcRn
    f                 HsFamEqnPats GhcRn
    args
    appTypeToArg LHsType GhcRn
    f (HsTypeArg XTypeArg GhcRn
    _ LHsType GhcRn
    arg  : HsFamEqnPats GhcRn
    args)
      = LHsType GhcRn -> HsFamEqnPats GhcRn -> LHsType GhcRn
    appTypeToArg (XAppKindTy GhcRn -> LHsType GhcRn -> LHsType GhcRn -> LHsType GhcRn
    forall (p :: Pass).
    XAppKindTy (GhcPass p)
    -> LHsType (GhcPass p)
    -> LHsType (GhcPass p)
    -> LHsType (GhcPass p)
    mkHsAppKindTy XAppKindTy GhcRn
    NoExtField
    noExtField LHsType GhcRn
    f LHsType GhcRn
    arg) HsFamEqnPats GhcRn
    args

    {- *********************************************************************
    *                                                                      *
                    checkExpectedKind
    *                                                                      *
    ********************************************************************* -}

    -- | This instantiates invisible arguments for the type being checked if it must
    -- be saturated and is not yet saturated. It then calls and uses the result
    -- from checkExpectedKindX to build the final type
    checkExpectedKind :: HasDebugCallStack
                      => HsType GhcRn       -- ^ type we're checking (for printing)
                      -> TcType             -- ^ type we're checking
                      -> TcKind             -- ^ the known kind of that type
                      -> TcKind             -- ^ the expected kind
                      -> TcM TcType
    -- Just a convenience wrapper to save calls to 'ppr'
    checkExpectedKind :: HasDebugCallStack =>
    HsType GhcRn -> Type -> Type -> Type -> TcM Type
    checkExpectedKind HsType GhcRn
    hs_ty Type
    ty Type
    act_kind Type
    exp_kind
      = do { String -> SDoc -> TcM ()
    traceTc String
    "checkExpectedKind" (Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    ty SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    act_kind)

           ; (new_args, act_kind') <- Int -> Type -> TcM ([Type], Type)
    tcInstInvisibleTyBindersN Int
    n_to_inst Type
    act_kind

           ; let origin = TypeEqOrigin { uo_actual :: Type
    uo_actual   = Type
    act_kind'
                                       , uo_expected :: Type
    uo_expected = Type
    exp_kind
                                       , uo_thing :: Maybe TypedThing
    uo_thing    = TypedThing -> Maybe TypedThing
    forall a. a -> Maybe a
    Just (HsType GhcRn -> TypedThing
    HsTypeRnThing HsType GhcRn
    hs_ty)
                                       , uo_visible :: Bool
    uo_visible  = Bool
    True } -- the hs_ty is visible

           ; traceTc "checkExpectedKindX" $
             vcat [ ppr hs_ty
                  , text "act_kind':" <+> ppr act_kind'
                  , text "exp_kind:" <+> ppr exp_kind ]

           ; let res_ty = Type
    ty Type -> [Type] -> Type
    `mkAppTys` [Type]
    new_args

           ; if act_kind' `tcEqType` exp_kind
             then return res_ty  -- This is very common
             else do { co_k <- unifyTypeAndEmit KindLevel origin act_kind' exp_kind
                     ; traceTc "checkExpectedKind" (vcat [ ppr act_kind
                                                         , ppr exp_kind
                                                         , ppr co_k ])
                    ; return (res_ty `mkCastTy` co_k) } }
        where
          -- We need to make sure that both kinds have the same number of implicit
          -- foralls and constraints out front. If the actual kind has more, instantiate
          -- accordingly. Otherwise, just pass the type & kind through: the errors
          -- are caught in unifyType.
          n_exp_invis_bndrs :: Int
    n_exp_invis_bndrs = Type -> Int
    invisibleBndrCount Type
    exp_kind
          n_act_invis_bndrs :: Int
    n_act_invis_bndrs = Type -> Int
    invisibleBndrCount Type
    act_kind
          n_to_inst :: Int
    n_to_inst         = Int
    n_act_invis_bndrs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    n_exp_invis_bndrs

    -- tyr <- checkExpKind hs_ty ty (act_ki :: Kind) (exp_ki :: ExpKind)
    --     requires that `ty` has kind `act_ki`
    -- It checks that the actual kind `act_ki` matches the expected kind `exp_ki`
    -- and returns `tyr`, a possibly-casted form of `ty`, that has precisely kind `exp_ki`
    -- `hs_ty` is purely for error messages
    checkExpKind :: HsType GhcRn -> TcType -> TcKind -> ExpKind -> TcM TcType
    checkExpKind :: HsType GhcRn -> Type -> Type -> ExpSigmaType -> TcM Type
    checkExpKind HsType GhcRn
    rn_ty Type
    ty Type
    ki (Check Type
    ki') =
      HasDebugCallStack =>
    HsType GhcRn -> Type -> Type -> Type -> TcM Type
    HsType GhcRn -> Type -> Type -> Type -> TcM Type
    checkExpectedKind HsType GhcRn
    rn_ty Type
    ty Type
    ki Type
    ki'
    checkExpKind HsType GhcRn
    _rn_ty Type
    ty Type
    ki (Infer InferResult
    cell) = do
      -- NB: do not instantiate.
      -- See Note [Do not always instantiate eagerly in types]
      co <- Type -> InferResult -> TcM Coercion
    fillInferResultNoInst Type
    ki InferResult
    cell
      pure (ty `mkCastTy` co)

    ---------------------------

    tcHsContext :: Maybe (LHsContext GhcRn) -> TcM [PredType]
    tcHsContext :: Maybe (LHsContext GhcRn) -> TcM [Type]
    tcHsContext Maybe (LHsContext GhcRn)
    Nothing    = [Type] -> TcM [Type]
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return []
    tcHsContext (Just LHsContext GhcRn
    cxt) = TcTyMode -> LHsContext GhcRn -> TcM [Type]
    tc_hs_context TcTyMode
    typeLevelMode LHsContext GhcRn
    cxt

    tcLHsPredType :: LHsType GhcRn -> TcM PredType
    tcLHsPredType :: LHsType GhcRn -> TcM Type
    tcLHsPredType LHsType GhcRn
    pred = TcTyMode -> LHsType GhcRn -> TcM Type
    tc_lhs_pred TcTyMode
    typeLevelMode LHsType GhcRn
    pred

    tc_hs_context :: TcTyMode -> LHsContext GhcRn -> TcM [PredType]
    tc_hs_context :: TcTyMode -> LHsContext GhcRn -> TcM [Type]
    tc_hs_context TcTyMode
    mode LHsContext GhcRn
    ctxt = (GenLocated SrcSpanAnnA (HsType GhcRn) -> TcM Type)
    -> [GenLocated SrcSpanAnnA (HsType GhcRn)] -> TcM [Type]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (TcTyMode -> LHsType GhcRn -> TcM Type
    tc_lhs_pred TcTyMode
    mode) (GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcRn)]
    -> [GenLocated SrcSpanAnnA (HsType GhcRn)]
    forall l e. GenLocated l e -> e
    unLoc LHsContext GhcRn
    GenLocated SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType GhcRn)]
    ctxt)

    tc_lhs_pred :: TcTyMode -> LHsType GhcRn -> TcM PredType
    tc_lhs_pred :: TcTyMode -> LHsType GhcRn -> TcM Type
    tc_lhs_pred TcTyMode
    mode LHsType GhcRn
    pred = TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode LHsType GhcRn
    pred Type
    constraintKind

    ---------------------------
    tcTyVar :: Name -> TcM (TcType, TcKind)
    -- See Note [Type checking recursive type and class declarations]
    -- in GHC.Tc.TyCl
    -- This does not instantiate. See Note [Do not always instantiate eagerly in types]
    tcTyVar :: Name -> TcM (Type, Type)
    tcTyVar Name
    name         -- Could be a tyvar, a tycon, or a datacon
      = do { String -> SDoc -> TcM ()
    traceTc String
    "lk1" (Name -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Name
    name)
           ; thing <- Name -> TcM TcTyThing
    tcLookup Name
    name
           ; case thing of
               ATyVar Name
    _ TyVar
    tv -> (Type, Type) -> TcM (Type, Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (TyVar -> Type
    mkTyVarTy TyVar
    tv, TyVar -> Type
    tyVarKind TyVar
    tv)

               -- See Note [Recursion through the kinds]
               (TcTyThing -> Maybe TyCon
    tcTyThingTyCon_maybe -> Just TyCon
    tc) -- TyCon or TcTyCon
                 -> (Type, Type) -> TcM (Type, Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (TyCon -> Type
    mkTyConTy TyCon
    tc, TyCon -> Type
    tyConKind TyCon
    tc)

               AGlobal (AConLike (RealDataCon DataCon
    dc))
                 -> do { Bool -> TcM () -> TcM ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (TyCon -> Bool
    isFamInstTyCon (DataCon -> TyCon
    dataConTyCon DataCon
    dc)) (TcM () -> TcM ()) -> TcM () -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
                           -- see #15245
                           Name -> PromotionErr -> TcM ()
    forall a. Name -> PromotionErr -> TcM a
    promotionErr Name
    name PromotionErr
    FamDataConPE
                       ; let ([TyVar]
    _, [TyVar]
    _, [EqSpec]
    _, [Type]
    theta, [Scaled Type]
    _, Type
    _) = DataCon
    -> ([TyVar], [TyVar], [EqSpec], [Type], [Scaled Type], Type)
    dataConFullSig DataCon
    dc
                       ; String -> SDoc -> TcM ()
    traceTc String
    "tcTyVar" (DataCon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DataCon
    dc SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [Type] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [Type]
    theta)
                         -- promotionErr: Note [No constraints in kinds] in GHC.Tc.Validity
                       ; Bool -> TcM () -> TcM ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless ([Type] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Type]
    theta) (TcM () -> TcM ()) -> TcM () -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
                         Name -> PromotionErr -> TcM ()
    forall a. Name -> PromotionErr -> TcM a
    promotionErr Name
    name ([Type] -> PromotionErr
    ConstrainedDataConPE [Type]
    theta)
                       ; let tc :: TyCon
    tc = DataCon -> TyCon
    promoteDataCon DataCon
    dc
                       ; (Type, Type) -> TcM (Type, Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (TyCon -> [Type] -> Type
    mkTyConApp TyCon
    tc [], TyCon -> Type
    tyConKind TyCon
    tc) }

               AGlobal AnId{}    -> Name -> PromotionErr -> TcM (Type, Type)
    forall a. Name -> PromotionErr -> TcM a
    promotionErr Name
    name PromotionErr
    TermVariablePE
               ATcId{}           -> Name -> PromotionErr -> TcM (Type, Type)
    forall a. Name -> PromotionErr -> TcM a
    promotionErr Name
    name PromotionErr
    TermVariablePE
               APromotionErr PromotionErr
    err -> Name -> PromotionErr -> TcM (Type, Type)
    forall a. Name -> PromotionErr -> TcM a
    promotionErr Name
    name PromotionErr
    err

               TcTyThing
    _  -> WrongThingSort -> TcTyThing -> Name -> TcM (Type, Type)
    forall a. WrongThingSort -> TcTyThing -> Name -> TcM a
    wrongThingErr WrongThingSort
    WrongThingType TcTyThing
    thing Name
    name }

    {-
    Note [Recursion through the kinds]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider these examples

    Ticket #11554:
      data P (x :: k) = Q
      data A :: Type where
        MkA :: forall (a :: A). P a -> A

    Ticket #12174
      data V a
      data T = forall (a :: T). MkT (V a)

    The type is recursive (which is fine) but it is recursive /through the
    kinds/.  In earlier versions of GHC this caused a loop in the compiler
    (to do with knot-tying) but there is nothing fundamentally wrong with
    the code (kinds are types, and the recursive declarations are OK). But
    it's hard to distinguish "recursion through the kinds" from "recursion
    through the types". Consider this (also #11554):

      data PB k (x :: k) = Q
      data B :: Type where
        MkB :: P B a -> B

    Here the occurrence of B is not obviously in a kind position.

    So now GHC allows all these programs.  #12081 and #15942 are other
    examples.

    Note [Body kind of a HsForAllTy]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The body of a forall is usually a type.
    Because of representation polymorphism, it can be a TYPE r, for any r.
    (In fact, GHC can itself construct a function with an
    unboxed tuple inside a for-all via CPR analysis; see
    typecheck/should_compile/tc170).

    A forall can also be used in an instance head, then the body should
    be a constraint.

    Right now, we do not have any easy way to enforce that a type is
    either a TYPE something or CONSTRAINT something, so we accept any kind.
    This is unsound (#22063). We could fix this by implementing a TypeLike
    predicate, see #20000.

    For a forall with a required argument, we do not allow constraints;
    e.g. forall a -> Eq a is invalid. Therefore, we can enforce that the body
    is a TYPE something in this case (#24176).

    Note [Body kind of a HsQualTy]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    If ctxt is non-empty, the HsQualTy really is a /function/, so the
    kind of the result really is '*', and in that case the kind of the
    body-type can be lifted or unlifted.

    However, consider
        instance Eq a => Eq [a] where ...
    or
        f :: (Eq a => Eq [a]) => blah
    Here both body-kind and result kind of the HsQualTy is Constraint rather than *.
    Rather crudely we tell the difference by looking at exp_kind. It's
    very convenient to typecheck instance types like any other HsSigType.

    (BK1) How do we figure out the right body kind?

    Well, it's a bit of a kludge: I just look at the expected kind, `exp_kind`.
    If we are in checking mode (`exp_kind` = `Check k`), and the pushed-in kind
    `k` is `CONSTRAINT rep`, then we check that the body type has kind `Constraint` too.

    This is a kludge because it wouldn't work if any unification was
    involved to compute that result kind -- but it isn't.

    Note that in the kludgy "figure out whether we are in a type or constraint"
    check, we only check if `k` is a `CONSTRAINT rep`, not `Constraint`.
    That turns out to give a better error message in T25243.

    (BK2)

    Note that, once we are in the constraint case, we check that the body has
    kind Constraint; see the call to tc_check_lhs_type. (In contrast, for
    types we check that the body has kind TYPE kappa for some fresh unification
    variable kappa.)
    Reason: we don't yet have support for constraints that are not lifted: it's
    not possible to declare a class returning a different type than CONSTRAINT LiftedRep.
    Evidence is always lifted, the fat arrow c => t requires c to be
    a lifted constraint. In a far future, if we add support for non-lifted
    constraints, we could allow c1 => c2 where
    c1 :: CONSTRAINT rep1, c2 :: CONSTRAINT rep2
    have arbitrary representations rep1 and rep2.

    Note [Inferring tuple kinds]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Give a tuple type (a,b,c), which the parser labels as HsBoxedOrConstraintTuple,
    we try to figure out whether it's a tuple of kind * or Constraint.
      Step 1: look at the expected kind
      Step 2: infer argument kinds

    If after Step 2 it's not clear from the arguments that it's
    Constraint, then it must be *.  Once having decided that we re-check
    the arguments to give good error messages in
      e.g.  (Maybe, Maybe)

    Note that we will still fail to infer the correct kind in this case:

      type T a = ((a,a), D a)
      type family D :: Constraint -> Constraint

    While kind checking T, we do not yet know the kind of D, so we will default the
    kind of T to * -> *. It works if we annotate `a` with kind `Constraint`.

    Note [Desugaring types]
    ~~~~~~~~~~~~~~~~~~~~~~~
    The type desugarer is phase 2 of dealing with HsTypes.  Specifically:

      * It transforms from HsType to Type

      * It zonks any kinds.  The returned type should have no mutable kind
        or type variables (hence returning Type not TcType):
          - any unconstrained kind variables are defaulted to (Any @Type) just
            as in GHC.Tc.Zonk.Type.
          - there are no mutable type variables because we are
            kind-checking a type
        Reason: the returned type may be put in a TyCon or DataCon where
        it will never subsequently be zonked.

    You might worry about nested scopes:
            ..a:kappa in scope..
                let f :: forall b. T '[a,b] -> Int
    In this case, f's type could have a mutable kind variable kappa in it;
    and we might then default it to (Any @Type) when dealing with f's type
    signature.  But we don't expect this to happen because we can't get a
    lexically scoped type variable with a mutable kind variable in it.  A
    delicate point, this.  If it becomes an issue we might need to
    distinguish top-level from nested uses.

    Moreover
      * it cannot fail,
      * it does no unifications
      * it does no validity checking, except for structural matters, such as
            (a) spurious ! annotations.
            (b) a class used as a type

    Note [Kind of a type splice]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider these terms, each with TH type splice inside:
         [| e1 :: Maybe $(..blah..) |]
         [| e2 :: $(..blah..) |]
    When kind-checking the type signature, we'll kind-check the splice
    $(..blah..); we want to give it a kind that can fit in any context,
    as if $(..blah..) :: forall k. k.

    In the e1 example, the context of the splice fixes kappa to *.  But
    in the e2 example, we'll desugar the type, zonking the kind unification
    variables as we go.  When we encounter the unconstrained kappa, we
    want to default it to 'Type', not to (Any @Type).

    -}

    addTypeCtxt :: LHsType GhcRn -> TcM a -> TcM a
            -- Wrap a context around only if we want to show that contexts.
            -- Omit invisible ones and ones user's won't grok
    addTypeCtxt :: forall a. LHsType GhcRn -> TcM a -> TcM a
    addTypeCtxt (L SrcSpanAnnA
    _ (HsWildCardTy XWildCardTy GhcRn
    _)) TcM a
    thing = TcM a
    thing   -- "In the type '_'" just isn't helpful.
    addTypeCtxt LHsType GhcRn
    ty TcM a
    thing = ErrCtxtMsg -> TcM a -> TcM a
    forall a. ErrCtxtMsg -> TcM a -> TcM a
    addErrCtxt (LHsType GhcRn -> ErrCtxtMsg
    TypeCtxt LHsType GhcRn
    ty) TcM a
    thing

    {- *********************************************************************
    *                                                                      *
                    Type-variable binders
    *                                                                      *
    ********************************************************************* -}

    bindNamedWildCardBinders :: [Name]
                             -> ([(Name, TcTyVar)] -> TcM a)
                             -> TcM a
    -- Bring into scope the /named/ wildcard binders.  Remember that
    -- plain wildcards _ are anonymous and dealt with by HsWildCardTy
    -- Soe Note [The wildcard story for types] in GHC.Hs.Type
    bindNamedWildCardBinders :: forall a. HsQTvsRn -> ([(Name, TyVar)] -> TcM a) -> TcM a
    bindNamedWildCardBinders HsQTvsRn
    wc_names [(Name, TyVar)] -> TcM a
    thing_inside
      = do { wcs <- (Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar)
    -> HsQTvsRn -> TcM [TyVar]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    newNamedWildTyVar HsQTvsRn
    wc_names
           ; let wc_prs = HsQTvsRn
    wc_names HsQTvsRn -> [TyVar] -> [(Name, TyVar)]
    forall a b. [a] -> [b] -> [(a, b)]
    `zip` [TyVar]
    wcs
           ; tcExtendNameTyVarEnv wc_prs $
             thing_inside wc_prs }

    newNamedWildTyVar :: Name -> TcM TcTyVar
    -- ^ New unification variable '_' for a wildcard
    newNamedWildTyVar :: Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    newNamedWildTyVar Name
    _name   -- Currently ignoring the "_x" wildcard name used in the type
      = do { kind <- TcM Type
    newMetaKindVar
           ; details <- newMetaDetails TauTv
           ; wc_name <- newMetaTyVarName (fsLit "w")   -- See Note [Wildcard names]
           ; let tyvar = Name -> Type -> TcTyVarDetails -> TyVar
    mkTcTyVar Name
    wc_name Type
    kind TcTyVarDetails
    details
           ; traceTc "newWildTyVar" (ppr tyvar)
           ; return tyvar }

    ---------------------------
    tcAnonWildCardOcc :: IsExtraConstraint
                      -> TcTyMode -> HsType GhcRn -> Kind -> TcM TcType
    tcAnonWildCardOcc :: IsExtraConstraint -> TcTyMode -> HsType GhcRn -> Type -> TcM Type
    tcAnonWildCardOcc IsExtraConstraint
    is_extra (TcTyMode { mode_holes :: TcTyMode -> HoleInfo
    mode_holes = Just (TcLevel
    hole_lvl, HoleMode
    hole_mode) })
                      HsType GhcRn
    ty Type
    exp_kind
        -- hole_lvl: see Note [Checking partial type signatures]
        --           esp the bullet on nested forall types
      = do { kv_details <- TcLevel -> TcM TcTyVarDetails
    newTauTvDetailsAtLevel TcLevel
    hole_lvl
           ; kv_name    <- newMetaTyVarName (fsLit "k")
           ; wc_details <- newTauTvDetailsAtLevel hole_lvl
           ; wc_name    <- newMetaTyVarName wc_nm
           ; let kv      = Name -> Type -> TcTyVarDetails -> TyVar
    mkTcTyVar Name
    kv_name Type
    liftedTypeKind TcTyVarDetails
    kv_details
                 wc_kind = TyVar -> Type
    mkTyVarTy TyVar
    kv
                 wc_tv   = Name -> Type -> TcTyVarDetails -> TyVar
    mkTcTyVar Name
    wc_name Type
    wc_kind TcTyVarDetails
    wc_details

           ; traceTc "tcAnonWildCardOcc" (ppr hole_lvl <+> ppr emit_holes)
           ; when emit_holes $
             emitAnonTypeHole is_extra wc_tv
             -- Why the 'when' guard?
             -- See Note [Wildcards in visible kind application]

           -- You might think that this would always just unify
           -- wc_kind with exp_kind, so we could avoid even creating kv
           -- But the level numbers might not allow that unification,
           -- so we have to do it properly (T14140a)
           ; checkExpectedKind ty (mkTyVarTy wc_tv) wc_kind exp_kind }
      where
         -- See Note [Wildcard names]
         wc_nm :: FastString
    wc_nm = case HoleMode
    hole_mode of
                   HoleMode
    HM_Sig      -> String -> FastString
    fsLit String
    "w"
                   HoleMode
    HM_FamPat   -> String -> FastString
    fsLit String
    "_"
                   HoleMode
    HM_VTA      -> String -> FastString
    fsLit String
    "w"
                   HoleMode
    HM_TyAppPat -> String -> FastString
    fsLit String
    "_"

         emit_holes :: Bool
    emit_holes = case HoleMode
    hole_mode of
                         HoleMode
    HM_Sig     -> Bool
    True
                         HoleMode
    HM_FamPat  -> Bool
    False
                         HoleMode
    HM_VTA     -> Bool
    False
                         HoleMode
    HM_TyAppPat -> Bool
    False

    tcAnonWildCardOcc IsExtraConstraint
    is_extra TcTyMode
    _ HsType GhcRn
    _ Type
    _
    -- mode_holes is Nothing. This means we have an anonymous wildcard
    -- in an unexpected place. The renamer rejects these wildcards in 'checkAnonWildcard',
    -- but it is possible for a wildcard to be introduced by a Template Haskell splice,
    -- as per #15433. To account for this, we throw a generic catch-all error message.
      = TcRnMessage -> TcM Type
    forall a. TcRnMessage -> TcRn a
    failWith (TcRnMessage -> TcM Type) -> TcRnMessage -> TcM Type
    forall a b. (a -> b) -> a -> b
    $ Maybe Name -> BadAnonWildcardContext -> TcRnMessage
    TcRnIllegalWildcardInType Maybe Name
    forall a. Maybe a
    Nothing BadAnonWildcardContext
    reason
        where
          reason :: BadAnonWildcardContext
    reason =
            case IsExtraConstraint
    is_extra of
              IsExtraConstraint
    YesExtraConstraint ->
                SoleExtraConstraintWildcardAllowed -> BadAnonWildcardContext
    ExtraConstraintWildcardNotAllowed
                  SoleExtraConstraintWildcardAllowed
    SoleExtraConstraintWildcardNotAllowed
              IsExtraConstraint
    NoExtraConstraint  ->
                BadAnonWildcardContext
    WildcardsNotAllowedAtAll

    {- Note [Wildcard names]
    ~~~~~~~~~~~~~~~~~~~~~~~~
    So we hackily use the mode_holes flag to control the name used
    for wildcards:

    * For proper holes (whether in a visible type application (VTA) or no),
      we rename the '_' to 'w'. This is so that we see variables like 'w0'
      or 'w1' in error messages, a vast improvement upon '_0' and '_1'. For
      example, we prefer
           Found type wildcard ‘_’ standing for ‘w0’
      over
           Found type wildcard ‘_’ standing for ‘_1’

      Even in the VTA case, where we do not emit an error to be printed, we
      want to do the renaming, as the variables may appear in other,
      non-wildcard error messages.

    * However, holes in the left-hand sides of type families ("type
      patterns") stand for type variables which we do not care to name --
      much like the use of an underscore in an ordinary term-level
      pattern. When we spot these, we neither wish to generate an error
      message nor to rename the variable.  We don't rename the variable so
      that we can pretty-print a type family LHS as, e.g.,
        F _ Int _ = ...
      and not
         F w1 Int w2 = ...

      See also Note [Wildcards in family instances] in
      GHC.Rename.Module. The choice of HM_FamPat is made in
      tcFamTyPats. There is also some unsavory magic, relying on that
      underscore, in GHC.Core.Coercion.tidyCoAxBndrsForUser.

    Note [Wildcards in visible kind application]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    There are cases where users might want to pass in a wildcard as a visible kind
    argument, for instance:

    data T :: forall k1 k2. k1 → k2 → Type where
      MkT :: T a b
    x :: T @_ @Nat False n
    x = MkT

    So we should allow '@_' without emitting any hole constraints, and
    regardless of whether PartialTypeSignatures is enabled or not. But how
    would the typechecker know which '_' is being used in VKA and which is
    not when it calls emitNamedTypeHole in
    tcHsPartialSigType on all HsWildCardBndrs?  The solution is to neither
    rename nor include unnamed wildcards in HsWildCardBndrs, but instead
    give every anonymous wildcard a fresh wild tyvar in tcAnonWildCardOcc.

    And whenever we see a '@', we set mode_holes to HM_VKA, so that
    we do not call emitAnonTypeHole in tcAnonWildCardOcc.
    See related Note [Wildcards in visible type application] here and
    Note [The wildcard story for types] in GHC.Hs.Type
    -}

    {- *********************************************************************
    *                                                                      *
                 Kind inference for type declarations
    *                                                                      *
    ********************************************************************* -}

    -- See Note [kcCheckDeclHeader vs kcInferDeclHeader]
    data InitialKindStrategy
      = InitialKindCheck SAKS_or_CUSK
      | InitialKindInfer

    -- Does the declaration have a standalone kind signature (SAKS) or a complete
    -- user-supplied kind (CUSK)?
    data SAKS_or_CUSK
      = SAKS Kind  -- Standalone kind signature, fully zonked! (zonkTcTypeToType)
      | CUSK       -- Complete user-supplied kind (CUSK)

    instance Outputable SAKS_or_CUSK where
      ppr :: SAKS_or_CUSK -> SDoc
    ppr (SAKS Type
    k) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "SAKS" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    k
      ppr SAKS_or_CUSK
    CUSK = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "CUSK"

    -- See Note [kcCheckDeclHeader vs kcInferDeclHeader]
    kcDeclHeader
      :: InitialKindStrategy
      -> Name               -- ^ of the thing being checked
      -> TyConFlavour TyCon -- ^ What sort of 'TyCon' is being checked
      -> LHsQTyVars GhcRn   -- ^ Binders in the header
      -> TcM ContextKind    -- ^ The result kind
      -> TcM TcTyCon        -- ^ A suitably-kinded TcTyCon
    kcDeclHeader :: InitialKindStrategy
    -> Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcDeclHeader (InitialKindCheck SAKS_or_CUSK
    msig) = SAKS_or_CUSK
    -> Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcCheckDeclHeader SAKS_or_CUSK
    msig
    kcDeclHeader InitialKindStrategy
    InitialKindInfer = Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcInferDeclHeader

    {- Note [kcCheckDeclHeader vs kcInferDeclHeader]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    kcCheckDeclHeader and kcInferDeclHeader are responsible for getting the initial kind
    of a type constructor.

    * kcCheckDeclHeader: the TyCon has a standalone kind signature or a CUSK. In that
      case, find the full, final, poly-kinded kind of the TyCon.  It's very like a
      term-level binding where we have a complete type signature for the function.

    * kcInferDeclHeader: the TyCon has neither a standalone kind signature nor a
      CUSK. Find a monomorphic kind, with unification variables in it; they will be
      generalised later.  It's very like a term-level binding where we do not have a
      type signature (or, more accurately, where we have a partial type signature),
      so we infer the type and generalise.
    -}

    ------------------------------
    kcCheckDeclHeader
      :: SAKS_or_CUSK
      -> Name               -- ^ of the thing being checked
      -> TyConFlavour TyCon -- ^ What sort of 'TyCon' is being checked
      -> LHsQTyVars GhcRn   -- ^ Binders in the header
      -> TcM ContextKind    -- ^ The result kind. AnyKind == no result signature
      -> TcM PolyTcTyCon    -- ^ A suitably-kinded generalized TcTyCon
    kcCheckDeclHeader :: SAKS_or_CUSK
    -> Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcCheckDeclHeader (SAKS Type
    sig) = Type
    -> Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcCheckDeclHeader_sig Type
    sig
    kcCheckDeclHeader SAKS_or_CUSK
    CUSK       = Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcCheckDeclHeader_cusk

    kcCheckDeclHeader_cusk
      :: Name               -- ^ of the thing being checked
      -> TyConFlavour TyCon -- ^ What sort of 'TyCon' is being checked
      -> LHsQTyVars GhcRn   -- ^ Binders in the header
      -> TcM ContextKind    -- ^ The result kind
      -> TcM PolyTcTyCon    -- ^ A suitably-kinded generalized TcTyCon
    kcCheckDeclHeader_cusk :: Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcCheckDeclHeader_cusk Name
    name TyConFlavour TyCon
    flav
                  (HsQTvs { hsq_ext :: forall pass. LHsQTyVars pass -> XHsQTvs pass
    hsq_ext = XHsQTvs GhcRn
    kv_ns
                          , hsq_explicit :: forall pass.
    LHsQTyVars pass -> [LHsTyVarBndr (HsBndrVis pass) pass]
    hsq_explicit = [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    hs_tvs }) TcM ContextKind
    kc_res_ki
      -- CUSK case
      -- See Note [Required, Specified, and Inferred for types] in GHC.Tc.TyCl
      = ErrCtxtMsg -> TcM TyCon -> TcM TyCon
    forall a. ErrCtxtMsg -> TcM a -> TcM a
    addErrCtxt (Name -> TyConFlavour TyCon -> ErrCtxtMsg
    TyConDeclCtxt Name
    name TyConFlavour TyCon
    flav) (TcM TyCon -> TcM TyCon) -> TcM TyCon -> TcM TyCon
    forall a b. (a -> b) -> a -> b
    $
        do { skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
    forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
    mkSkolemInfo SkolemInfoAnon
    skol_info_anon
           ; (tclvl, wanted, (scoped_kvs, (tc_bndrs, res_kind)))
               <- pushLevelAndSolveEqualitiesX "kcCheckDeclHeader_cusk" $
                  bindImplicitTKBndrs_Q_Skol skol_info kv_ns                      $
                  bindExplicitTKBndrs_Q_Skol skol_info ctxt_kind hs_tvs           $
                  newExpectedKind =<< kc_res_ki

               -- Now, because we're in a CUSK,
               -- we quantify over the mentioned kind vars
           ; let spec_req_tkvs = [TyVar]
    scoped_kvs [TyVar] -> [TyVar] -> [TyVar]
    forall a. [a] -> [a] -> [a]
    ++ [VarBndr TyVar (HsBndrVis GhcRn)] -> [TyVar]
    forall tv argf. [VarBndr tv argf] -> [tv]
    binderVars [VarBndr TyVar (HsBndrVis GhcRn)]
    tc_bndrs
                 all_kinds     = Type
    res_kind Type -> [Type] -> [Type]
    forall a. a -> [a] -> [a]
    : (TyVar -> Type) -> [TyVar] -> [Type]
    forall a b. (a -> b) -> [a] -> [b]
    map TyVar -> Type
    tyVarKind [TyVar]
    spec_req_tkvs

           ; candidates <- candidateQTyVarsOfKinds all_kinds
                 -- 'candidates' are all the variables that we are going to
                 -- skolemise and then quantify over.  We do not include spec_req_tvs
                 -- because they are /already/ skolems

           ; inferred <- quantifyTyVars skol_info DefaultNonStandardTyVars $
                         candidates `delCandidates` spec_req_tkvs
                         -- NB: 'inferred' comes back sorted in dependency order

           ; (scoped_kvs, tc_bndrs, res_kind) <- liftZonkM $
              do { scoped_kvs <- mapM zonkTyCoVarKind scoped_kvs      -- scoped_kvs and tc_bndrs are skolems,
                 ; tc_bndrs   <- mapM zonkTyCoVarBndrKind tc_bndrs    -- so zonkTyCoVarBndrKind suffices
                 ; res_kind   <- zonkTcType res_kind
                 ; return (scoped_kvs, tc_bndrs, res_kind) }

           ; let mentioned_kv_set = CandidatesQTvs -> TyVarSet
    candidateKindVars CandidatesQTvs
    candidates
                 specified        = [TyVar] -> [TyVar]
    scopedSort [TyVar]
    scoped_kvs
                                    -- NB: maintain the L-R order of scoped_kvs

                 all_tcbs =  ForAllTyFlag -> [TyVar] -> [TyConBinder]
    mkNamedTyConBinders ForAllTyFlag
    Inferred  [TyVar]
    inferred
                          [TyConBinder] -> [TyConBinder] -> [TyConBinder]
    forall a. [a] -> [a] -> [a]
    ++ ForAllTyFlag -> [TyVar] -> [TyConBinder]
    mkNamedTyConBinders ForAllTyFlag
    Specified [TyVar]
    specified
                          [TyConBinder] -> [TyConBinder] -> [TyConBinder]
    forall a. [a] -> [a] -> [a]
    ++ (VarBndr TyVar (HsBndrVis GhcRn) -> TyConBinder)
    -> [VarBndr TyVar (HsBndrVis GhcRn)] -> [TyConBinder]
    forall a b. (a -> b) -> [a] -> [b]
    map (TyVarSet -> VarBndr TyVar (HsBndrVis GhcRn) -> TyConBinder
    mkExplicitTyConBinder TyVarSet
    mentioned_kv_set) [VarBndr TyVar (HsBndrVis GhcRn)]
    tc_bndrs

           -- Eta expand if necessary; we are building a PolyTyCon
           ; (eta_tcbs, res_kind) <- maybeEtaExpandAlgTyCon flav skol_info all_tcbs res_kind

           ; let all_tv_prs = [TyVar] -> [(Name, TyVar)]
    mkTyVarNamePairs ([TyVar]
    scoped_kvs [TyVar] -> [TyVar] -> [TyVar]
    forall a. [a] -> [a] -> [a]
    ++ [VarBndr TyVar (HsBndrVis GhcRn)] -> [TyVar]
    forall tv argf. [VarBndr tv argf] -> [tv]
    binderVars [VarBndr TyVar (HsBndrVis GhcRn)]
    tc_bndrs)
                 final_tcbs = [TyConBinder]
    all_tcbs [TyConBinder] -> [TyConBinder] -> [TyConBinder]
    forall a. [a] -> [a] -> [a]
    `chkAppend` [TyConBinder]
    eta_tcbs
                 tycon = Name
    -> [TyConBinder]
    -> Type
    -> [(Name, TyVar)]
    -> Bool
    -> TyConFlavour TyCon
    -> TyCon
    mkTcTyCon Name
    name [TyConBinder]
    final_tcbs Type
    res_kind [(Name, TyVar)]
    all_tv_prs
                                   Bool
    True -- Make a PolyTcTyCon, fully generalised
                                   TyConFlavour TyCon
    flav

           ; reportUnsolvedEqualities skol_info (binderVars final_tcbs)
                                      tclvl wanted

             -- If the ordering from
             -- Note [Required, Specified, and Inferred for types] in GHC.Tc.TyCl
             -- doesn't work, we catch it here, before an error cascade
           ; checkTyConTelescope tycon

           ; traceTc "kcCheckDeclHeader_cusk " $
             vcat [ text "name" <+> ppr name
                  , text "candidates" <+> ppr candidates
                  , text "mentioned_kv_set" <+> ppr mentioned_kv_set
                  , text "kv_ns" <+> ppr kv_ns
                  , text "hs_tvs" <+> ppr hs_tvs
                  , text "scoped_kvs" <+> ppr scoped_kvs
                  , text "spec_req_tvs" <+> pprTyVars spec_req_tkvs
                  , text "all_kinds" <+> ppr all_kinds
                  , text "tc_tvs" <+> pprTyVars (binderVars tc_bndrs)
                  , text "res_kind" <+> ppr res_kind
                  , text "inferred" <+> ppr inferred
                  , text "specified" <+> ppr specified
                  , text "final_tcbs" <+> ppr final_tcbs
                  , text "mkTyConKind final_tc_bndrs res_kind"
                    <+> ppr (mkTyConKind final_tcbs res_kind)
                  , text "all_tv_prs" <+> ppr all_tv_prs ]

           ; return tycon }
      where
        skol_info_anon :: SkolemInfoAnon
    skol_info_anon = TyConFlavour TyCon -> Name -> SkolemInfoAnon
    TyConSkol TyConFlavour TyCon
    flav Name
    name
        ctxt_kind :: ContextKind
    ctxt_kind | TyConFlavour TyCon -> Bool
    forall tc. TyConFlavour tc -> Bool
    tcFlavourIsOpen TyConFlavour TyCon
    flav = Type -> ContextKind
    TheKind Type
    liftedTypeKind
                  | Bool
    otherwise            = ContextKind
    AnyKind

    -- | Create a TyConBinder for a user-written type variable binder.
    mkExplicitTyConBinder :: TyCoVarSet -- variables that are used dependently
                          -> VarBndr TyVar (HsBndrVis GhcRn)
                          -> TyConBinder
    mkExplicitTyConBinder :: TyVarSet -> VarBndr TyVar (HsBndrVis GhcRn) -> TyConBinder
    mkExplicitTyConBinder TyVarSet
    dep_set (Bndr TyVar
    tv HsBndrVis GhcRn
    flag) =
      case HsBndrVis GhcRn
    flag of
        HsBndrRequired{}  -> TyVarSet -> TyVar -> TyConBinder
    mkRequiredTyConBinder TyVarSet
    dep_set TyVar
    tv
        HsBndrInvisible{} -> ForAllTyFlag -> TyVar -> TyConBinder
    mkNamedTyConBinder ForAllTyFlag
    Specified TyVar
    tv

    -- | Kind-check a 'LHsQTyVars'. Used in 'inferInitialKind' (for tycon kinds and
    -- other kinds).
    --
    -- This function does not do telescope checking.
    kcInferDeclHeader
      :: Name               -- ^ of the thing being checked
      -> TyConFlavour TyCon -- ^ What sort of 'TyCon' is being checked
      -> LHsQTyVars GhcRn
      -> TcM ContextKind    -- ^ The result kind
      -> TcM MonoTcTyCon    -- ^ A suitably-kinded non-generalized TcTyCon
    kcInferDeclHeader :: Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcInferDeclHeader Name
    name TyConFlavour TyCon
    flav
                  (HsQTvs { hsq_ext :: forall pass. LHsQTyVars pass -> XHsQTvs pass
    hsq_ext = XHsQTvs GhcRn
    kv_ns
                          , hsq_explicit :: forall pass.
    LHsQTyVars pass -> [LHsTyVarBndr (HsBndrVis pass) pass]
    hsq_explicit = [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    hs_bndrs }) TcM ContextKind
    kc_res_ki
      -- No standalone kind signature and no CUSK.
      -- See Note [Required, Specified, and Inferred for types] in GHC.Tc.TyCl
      = ErrCtxtMsg -> TcM TyCon -> TcM TyCon
    forall a. ErrCtxtMsg -> TcM a -> TcM a
    addErrCtxt (Name -> TyConFlavour TyCon -> ErrCtxtMsg
    TyConDeclCtxt Name
    name TyConFlavour TyCon
    flav) (TcM TyCon -> TcM TyCon) -> TcM TyCon -> TcM TyCon
    forall a b. (a -> b) -> a -> b
    $
        do { Name -> [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn] -> TcM ()
    rejectInvisibleBinders Name
    name [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    hs_bndrs
           ; (scoped_kvs, (tc_bndrs, res_kind))
               -- Why bindImplicitTKBndrs_Q_Tv which uses newTyVarTyVar?
               -- See Note [Inferring kinds for type declarations] in GHC.Tc.TyCl
               <- HsQTvsRn
    -> TcM ([VarBndr TyVar (HsBndrVis GhcRn)], Type)
    -> TcM ([TyVar], ([VarBndr TyVar (HsBndrVis GhcRn)], Type))
    forall a. HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrs_Q_Tv HsQTvsRn
    XHsQTvs GhcRn
    kv_ns              (TcM ([VarBndr TyVar (HsBndrVis GhcRn)], Type)
     -> TcM ([TyVar], ([VarBndr TyVar (HsBndrVis GhcRn)], Type)))
    -> TcM ([VarBndr TyVar (HsBndrVis GhcRn)], Type)
    -> TcM ([TyVar], ([VarBndr TyVar (HsBndrVis GhcRn)], Type))
    forall a b. (a -> b) -> a -> b
    $
                  ContextKind
    -> [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    -> TcM Type
    -> TcM ([VarBndr TyVar (HsBndrVis GhcRn)], Type)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    ContextKind
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrs_Q_Tv ContextKind
    ctxt_kind [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    hs_bndrs (TcM Type -> TcM ([VarBndr TyVar (HsBndrVis GhcRn)], Type))
    -> TcM Type -> TcM ([VarBndr TyVar (HsBndrVis GhcRn)], Type)
    forall a b. (a -> b) -> a -> b
    $
                  ContextKind -> TcM Type
    newExpectedKind (ContextKind -> TcM Type) -> TcM ContextKind -> TcM Type
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< TcM ContextKind
    kc_res_ki
                  -- Why "_Tv" not "_Skol"? See third wrinkle in
                  -- Note [Inferring kinds for type declarations] in GHC.Tc.TyCl,

           ; let   -- NB: Don't add scoped_kvs to tyConTyVars, because they
                   -- might unify with kind vars in other types in a mutually
                   -- recursive group.
                   -- See Note [Inferring kinds for type declarations] in GHC.Tc.TyCl

                 tc_tvs = [VarBndr TyVar (HsBndrVis GhcRn)] -> [TyVar]
    forall tv argf. [VarBndr tv argf] -> [tv]
    binderVars [VarBndr TyVar (HsBndrVis GhcRn)]
    tc_bndrs
                   -- Discard visibility flags. We made sure all of them are HsBndrRequired
                   -- by the call to rejectInvisibleBinders above.

                 tc_binders = [TyVar] -> [TyConBinder]
    mkAnonTyConBinders [TyVar]
    tc_tvs
                   -- This has to be mkAnonTyConBinder!
                   -- See Note [No polymorphic recursion in type decls] in GHC.Tc.TyCl
                   --
                   -- Also, note that tc_binders has the tyvars from only the
                   -- user-written type variable binders.
                   -- See S1 Note [TcTyCon, MonoTcTyCon, and PolyTcTyCon] in GHC.Tc.TyCl

                 all_tv_prs = [TyVar] -> [(Name, TyVar)]
    mkTyVarNamePairs ([TyVar]
    scoped_kvs [TyVar] -> [TyVar] -> [TyVar]
    forall a. [a] -> [a] -> [a]
    ++ [TyVar]
    tc_tvs)
                   -- NB: bindExplicitTKBndrs_Q_Tv does not clone;
                   --     ditto Implicit
                   -- See Note [Cloning for type variable binders]

                 tycon = Name
    -> [TyConBinder]
    -> Type
    -> [(Name, TyVar)]
    -> Bool
    -> TyConFlavour TyCon
    -> TyCon
    mkTcTyCon Name
    name [TyConBinder]
    tc_binders Type
    res_kind [(Name, TyVar)]
    all_tv_prs
                                   Bool
    False -- Make a MonoTcTyCon
                                   TyConFlavour TyCon
    flav

           ; traceTc "kcInferDeclHeader: not-cusk" $
             vcat [ ppr name, ppr kv_ns, ppr hs_bndrs
                  , ppr scoped_kvs
                  , ppr tc_tvs, ppr (mkTyConKind tc_binders res_kind) ]
           ; return tycon }
      where
        ctxt_kind :: ContextKind
    ctxt_kind | TyConFlavour TyCon -> Bool
    forall tc. TyConFlavour tc -> Bool
    tcFlavourIsOpen TyConFlavour TyCon
    flav = Type -> ContextKind
    TheKind Type
    liftedTypeKind
                  | Bool
    otherwise            = ContextKind
    AnyKind

    -- rejectInvisibleBinders is called on on the inference code path; there is
    -- no standalone kind signature, nor CUSK.
    -- See Note [No inference for invisible binders in type decls] in GHC.Tc.TyCl
    rejectInvisibleBinders :: Name -> [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn] -> TcM ()
    rejectInvisibleBinders :: Name -> [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn] -> TcM ()
    rejectInvisibleBinders Name
    name = (GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
     -> TcM ())
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    -> TcM ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ LHsTyVarBndr (HsBndrVis GhcRn) GhcRn -> TcM ()
    GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    -> TcM ()
    check_bndr_vis
      where
        check_bndr_vis :: LHsTyVarBndr (HsBndrVis GhcRn) GhcRn -> TcM ()
        check_bndr_vis :: LHsTyVarBndr (HsBndrVis GhcRn) GhcRn -> TcM ()
    check_bndr_vis LHsTyVarBndr (HsBndrVis GhcRn) GhcRn
    bndr =
          Bool -> TcM () -> TcM ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (HsBndrVis GhcRn -> Bool
    forall pass. HsBndrVis pass -> Bool
    isHsBndrInvisible (HsTyVarBndr (HsBndrVis GhcRn) GhcRn -> HsBndrVis GhcRn
    forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> flag
    hsTyVarBndrFlag (GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    -> HsTyVarBndr (HsBndrVis GhcRn) GhcRn
    forall l e. GenLocated l e -> e
    unLoc LHsTyVarBndr (HsBndrVis GhcRn) GhcRn
    GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    bndr))) (TcM () -> TcM ()) -> TcM () -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
            TcRnMessage -> TcM ()
    addErr (Name -> LHsTyVarBndr (HsBndrVis GhcRn) GhcRn -> TcRnMessage
    TcRnInvisBndrWithoutSig Name
    name LHsTyVarBndr (HsBndrVis GhcRn) GhcRn
    bndr)

    -- | Kind-check a declaration header against a standalone kind signature.
    -- See Note [kcCheckDeclHeader_sig]
    kcCheckDeclHeader_sig
      :: Kind               -- ^ Standalone kind signature, fully zonked! (zonkTcTypeToType)
      -> Name               -- ^ of the thing being checked
      -> TyConFlavour TyCon -- ^ What sort of 'TyCon' is being checked
      -> LHsQTyVars GhcRn   -- ^ Binders in the header
      -> TcM ContextKind    -- ^ The result kind. AnyKind == no result signature
      -> TcM PolyTcTyCon    -- ^ A suitably-kinded, fully generalised TcTyCon
    -- Postcondition to (kcCheckDeclHeader_sig sig_kind n f hs_tvs kc_res_ki):
    --   kind(returned PolyTcTyCon) = sig_kind
    --
    kcCheckDeclHeader_sig :: Type
    -> Name
    -> TyConFlavour TyCon
    -> LHsQTyVars GhcRn
    -> TcM ContextKind
    -> TcM TyCon
    kcCheckDeclHeader_sig Type
    sig_kind Name
    name TyConFlavour TyCon
    flav
              (HsQTvs { hsq_ext :: forall pass. LHsQTyVars pass -> XHsQTvs pass
    hsq_ext      = XHsQTvs GhcRn
    implicit_nms
                      , hsq_explicit :: forall pass.
    LHsQTyVars pass -> [LHsTyVarBndr (HsBndrVis pass) pass]
    hsq_explicit = [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    hs_tv_bndrs }) TcM ContextKind
    kc_res_ki
      = ErrCtxtMsg -> TcM TyCon -> TcM TyCon
    forall a. ErrCtxtMsg -> TcM a -> TcM a
    addErrCtxt (Name -> TyConFlavour TyCon -> ErrCtxtMsg
    TyConDeclCtxt Name
    name TyConFlavour TyCon
    flav) (TcM TyCon -> TcM TyCon) -> TcM TyCon -> TcM TyCon
    forall a b. (a -> b) -> a -> b
    $
        do { skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
    forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
    mkSkolemInfo (TyConFlavour TyCon -> Name -> SkolemInfoAnon
    TyConSkol TyConFlavour TyCon
    flav Name
    name)
           ; let avoid_occs = (Name -> OccName) -> HsQTvsRn -> [OccName]
    forall a b. (a -> b) -> [a] -> [b]
    map Name -> OccName
    nameOccName ([LHsTyVarBndr (HsBndrVis GhcRn) GhcRn] -> [IdP GhcRn]
    forall flag (p :: Pass).
    [LHsTyVarBndr flag (GhcPass p)] -> [IdP (GhcPass p)]
    hsLTyVarNames [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    hs_tv_bndrs)
           ; (sig_tcbs :: [TcTyConBinder], sig_res_kind :: Kind)
                 <- splitTyConKind skol_info emptyInScopeSet
                                   avoid_occs sig_kind

           ; traceTc "kcCheckDeclHeader_sig {" $
               vcat [ text "sig_kind:" <+> ppr sig_kind
                    , text "sig_tcbs:" <+> ppr sig_tcbs
                    , text "sig_res_kind:" <+> ppr sig_res_kind
                    , text "implict_nms:" <+> ppr implicit_nms
                    , text "hs_tv_bndrs:" <+> ppr hs_tv_bndrs ]

           ; (tclvl, wanted, (implicit_tvs, (skol_tcbs, skol_scoped_tvs, (extra_tcbs, tycon_res_kind))))
               <- pushLevelAndSolveEqualitiesX "kcCheckDeclHeader_sig" $  -- #16687
                  bindImplicitTKBndrs_Q_Tv implicit_nms                $  -- Q means don't clone
                  matchUpSigWithDecl name sig_tcbs sig_res_kind hs_tv_bndrs $ \ [TyConBinder]
    excess_sig_tcbs Type
    sig_res_kind ->
                  do { -- Kind-check the result kind annotation, if present:
                       --    data T a b :: res_ki where ...
                       --               ^^^^^^^^^
                       -- We do it here because at this point the environment has been
                       -- extended with both 'implicit_tcv_prs' and 'explicit_tv_prs'.
                       --
                       -- Also see Note [Arity of type families and type synonyms]
                     ; res_kind :: ContextKind <- TcM ContextKind
    kc_res_ki

                     ; let sig_res_kind' = [TyConBinder] -> Type -> Type
    mkTyConKind [TyConBinder]
    excess_sig_tcbs Type
    sig_res_kind

                     ; traceTc "kcCheckDeclHeader_sig 2" $
                        vcat [ text "excess_sig_tcbs" <+> ppr excess_sig_tcbs
                             , text "res_kind" <+> ppr res_kind
                             , text "sig_res_kind'" <+> ppr sig_res_kind'
                             ]

                     -- Unify res_ki (from the type declaration) with
                     -- sig_res_kind', the residual kind from the kind signature.
                     ; checkExpectedResKind sig_res_kind' res_kind

                     -- Add more binders for data/newtype, so the result kind has no arrows
                     -- See Note [Datatype return kinds]
                     ; if null excess_sig_tcbs || not (needsEtaExpansion flav)
                       then return ([],              sig_res_kind')
                       else return (excess_sig_tcbs, sig_res_kind)
              }

            -- Check that there are no unsolved equalities
            ; let all_tcbs = [TyConBinder]
    skol_tcbs [TyConBinder] -> [TyConBinder] -> [TyConBinder]
    forall a. [a] -> [a] -> [a]
    ++ [TyConBinder]
    extra_tcbs
            ; reportUnsolvedEqualities skol_info (binderVars all_tcbs) tclvl wanted

            -- Check that distinct binders map to distinct tyvars (see #20916). For example
            --    type T :: k -> k -> Type
            --    data T (a::p) (b::q) = ...
            -- Here p and q both map to the same kind variable k.  We don't allow this
            -- so we must check that they are distinct.  A similar thing happens
            -- in GHC.Tc.TyCl.swizzleTcTyConBinders during inference.
            --
            -- With visible dependent quantification, one of the binders involved
            -- may be explicit.  Consider #24604
            --    type UF :: forall zk -> zk -> Constraint
            --    class UF kk (xb :: k)
            -- Here `k` and `kk` both denote the same variable; but only `k` is implicit
            -- Hence we need to add skol_scoped_tvs
            ; implicit_tvs <- liftZonkM $ zonkTcTyVarsToTcTyVars implicit_tvs
            ; let implicit_prs = HsQTvsRn
    XHsQTvs GhcRn
    implicit_nms HsQTvsRn -> [TyVar] -> [(Name, TyVar)]
    forall a b. [a] -> [b] -> [(a, b)]
    `zip` [TyVar]
    implicit_tvs
                  dup_chk_prs  = [(Name, TyVar)]
    implicit_prs [(Name, TyVar)] -> [(Name, TyVar)] -> [(Name, TyVar)]
    forall a. [a] -> [a] -> [a]
    ++ [TyVar] -> [(Name, TyVar)]
    mkTyVarNamePairs [TyVar]
    skol_scoped_tvs
            ; unless (null implicit_nms) $  -- No need if no implicit tyvars
              checkForDuplicateScopedTyVars dup_chk_prs
            ; checkForDisconnectedScopedTyVars name flav all_tcbs implicit_prs

            -- Swizzle the Names so that the TyCon uses the user-declared implicit names
            -- E.g  type T :: k -> Type
            --      data T (a :: j) = ....
            -- We want the TyConBinders of T to be [j, a::j], not [k, a::k]
            -- Why? So that the TyConBinders of the TyCon will lexically scope over the
            -- associated types and methods of a class.
            ; let swizzle_env = [(TyVar, Name)] -> VarEnv Name
    forall a. [(TyVar, a)] -> VarEnv a
    mkVarEnv (((Name, TyVar) -> (TyVar, Name))
    -> [(Name, TyVar)] -> [(TyVar, Name)]
    forall a b. (a -> b) -> [a] -> [b]
    map (Name, TyVar) -> (TyVar, Name)
    forall a b. (a, b) -> (b, a)
    swap [(Name, TyVar)]
    implicit_prs)
                  (subst, swizzled_tcbs) = mapAccumL (swizzleTcb swizzle_env) emptySubst all_tcbs
                  swizzled_kind          = HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst Type
    tycon_res_kind
                  all_tv_prs             = [TyVar] -> [(Name, TyVar)]
    mkTyVarNamePairs ([TyConBinder] -> [TyVar]
    forall tv argf. [VarBndr tv argf] -> [tv]
    binderVars [TyConBinder]
    swizzled_tcbs)

            ; traceTc "kcCheckDeclHeader swizzle" $ vcat
              [ text "sig_tcbs ="       <+> ppr sig_tcbs
              , text "implicit_prs ="   <+> ppr implicit_prs
              , text "hs_tv_bndrs ="    <+> ppr hs_tv_bndrs
              , text "all_tcbs ="       <+> pprTyVars (binderVars all_tcbs)
              , text "swizzled_tcbs ="  <+> pprTyVars (binderVars swizzled_tcbs)
              , text "tycon_res_kind =" <+> ppr tycon_res_kind
              , text "swizzled_kind ="  <+> ppr swizzled_kind ]

            -- Build the final, generalized PolyTcTyCon
            -- NB: all_tcbs must bind the tyvars in the range of all_tv_prs
            --     because the tv_prs is used when (say) typechecking the RHS of
            --     a type synonym.
            ; let tc = Name
    -> [TyConBinder]
    -> Type
    -> [(Name, TyVar)]
    -> Bool
    -> TyConFlavour TyCon
    -> TyCon
    mkTcTyCon Name
    name [TyConBinder]
    swizzled_tcbs Type
    swizzled_kind [(Name, TyVar)]
    all_tv_prs
                                 Bool
    True -- Make a PolyTcTyCon, fully generalised
                                 TyConFlavour TyCon
    flav

            ; traceTc "kcCheckDeclHeader_sig }" $ vcat
              [ text "tyConName = " <+> ppr (tyConName tc)
              , text "sig_kind =" <+> debugPprType sig_kind
              , text "tyConKind =" <+> debugPprType (tyConKind tc)
              , text "tyConBinders = " <+> ppr (tyConBinders tc)
              , text "tyConResKind" <+> debugPprType (tyConResKind tc)
              ]
            ; return tc }

    -- | Check the result kind annotation on a type constructor against
    -- the corresponding section of the standalone kind signature.
    -- Drops invisible binders that interfere with unification.
    checkExpectedResKind :: TcKind       -- ^ the result kind from the separate kind signature
                         -> ContextKind  -- ^ the result kind from the declaration header
                         -> TcM ()
    checkExpectedResKind :: Type -> ContextKind -> TcM ()
    checkExpectedResKind Type
    _ ContextKind
    AnyKind
      = () -> TcM ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()  -- No signature in the declaration header
    checkExpectedResKind Type
    sig_kind ContextKind
    res_ki
      = do { actual_res_ki <- ContextKind -> TcM Type
    newExpectedKind ContextKind
    res_ki

           ; let -- Drop invisible binders from sig_kind until they match up
                 -- with res_ki.  By analogy with checkExpectedKind.
                 n_res_invis_bndrs = Type -> Int
    invisibleBndrCount Type
    actual_res_ki
                 n_sig_invis_bndrs = Type -> Int
    invisibleBndrCount Type
    sig_kind
                 n_to_inst         = Int
    n_sig_invis_bndrs Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    n_res_invis_bndrs

                 (_, sig_kind') = splitInvisPiTysN n_to_inst sig_kind

           ; discardResult $ unifyKind Nothing sig_kind' actual_res_ki }

    matchUpSigWithDecl
      :: Name                        -- Name of the type constructor for error messages
      -> [TcTyConBinder]             -- TcTyConBinders (with skolem TcTyVars) from the separate kind signature
      -> TcKind                      -- The tail end of the kind signature
      -> [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]     -- User-written binders in decl
      -> ([TcTyConBinder] -> TcKind -> TcM a)  -- All user-written binders are in scope
                                               --   Argument is excess TyConBinders and tail kind
      -> TcM ( [TcTyConBinder]       -- Skolemised binders, with TcTyVars
             , [TcTyVar]             -- Skolem tyvars brought into lexical scope by this matching-up
             , a )
    -- See Note [Matching a kind signature with a declaration]
    -- Invariant: Length of returned TyConBinders + length of excess TyConBinders
    --            = length of incoming TyConBinders
    matchUpSigWithDecl :: forall a.
    Name
    -> [TyConBinder]
    -> Type
    -> [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    -> ([TyConBinder] -> Type -> TcM a)
    -> TcM ([TyConBinder], [TyVar], a)
    matchUpSigWithDecl Name
    name [TyConBinder]
    sig_tcbs Type
    sig_res_kind [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    hs_bndrs [TyConBinder] -> Type -> TcM a
    thing_inside
      = Subst
    -> [TyConBinder]
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    go Subst
    emptySubst [TyConBinder]
    sig_tcbs [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    hs_bndrs
      where
        go :: Subst
    -> [TyConBinder]
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    go Subst
    subst [TyConBinder]
    tcbs []
          = do { let (Subst
    subst', [TyConBinder]
    tcbs') = Subst -> [TyConBinder] -> (Subst, [TyConBinder])
    substTyConBindersX Subst
    subst [TyConBinder]
    tcbs
               ; res <- [TyConBinder] -> Type -> TcM a
    thing_inside [TyConBinder]
    tcbs' (HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst' Type
    sig_res_kind)
               ; return ([], [], res) }

        go Subst
    _ [] [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    hs_bndrs
          = TcRnMessage
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    forall a. TcRnMessage -> TcRn a
    failWithTc (Type -> [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn] -> TcRnMessage
    TcRnTooManyBinders Type
    sig_res_kind [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn]
    [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    hs_bndrs)

        go Subst
    subst (TyConBinder
    tcb : [TyConBinder]
    tcbs') hs_bndrs :: [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    hs_bndrs@(GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    hs_bndr : [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    hs_bndrs')
          | TyConBndrVis -> HsBndrVis GhcRn -> Bool
    zippable (TyConBinder -> TyConBndrVis
    forall tv argf. VarBndr tv argf -> argf
    binderFlag TyConBinder
    tcb) (HsTyVarBndr (HsBndrVis GhcRn) GhcRn -> HsBndrVis GhcRn
    forall flag (pass :: Pass). HsTyVarBndr flag (GhcPass pass) -> flag
    hsTyVarBndrFlag (GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    -> HsTyVarBndr (HsBndrVis GhcRn) GhcRn
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    hs_bndr))
          = -- Visible TyConBinder, so match up with the hs_bndrs
            do { let Bndr TyVar
    tv TyConBndrVis
    vis = TyConBinder
    tcb
                     tv' :: TyVar
    tv' = (Type -> Type) -> TyVar -> TyVar
    updateTyVarKind (HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst) (TyVar -> TyVar) -> TyVar -> TyVar
    forall a b. (a -> b) -> a -> b
    $
                           TyVar -> (Name -> TyVar) -> Maybe Name -> TyVar
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe TyVar
    tv (TyVar -> Name -> TyVar
    setTyVarName TyVar
    tv) (LHsTyVarBndr (HsBndrVis GhcRn) GhcRn -> Maybe (IdP GhcRn)
    forall flag (p :: Pass).
    LHsTyVarBndr flag (GhcPass p) -> Maybe (IdP (GhcPass p))
    hsLTyVarName LHsTyVarBndr (HsBndrVis GhcRn) GhcRn
    GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    hs_bndr)
                       -- Give the skolem the Name of the HsTyVarBndr, so that if it
                       -- appears in an error message it has a name and binding site
                       -- that come from the type declaration, not the kind signature
                     subst' :: Subst
    subst' = Subst -> TyVar -> TyVar -> Subst
    extendTCvSubstWithClone Subst
    subst TyVar
    tv TyVar
    tv'
               ; HsTyVarBndr (HsBndrVis GhcRn) GhcRn -> Type -> TcM ()
    tc_hs_bndr (GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    -> HsTyVarBndr (HsBndrVis GhcRn) GhcRn
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    hs_bndr) (TyVar -> Type
    tyVarKind TyVar
    tv')
               ; String -> SDoc -> TcM ()
    traceTc String
    "musd1" (TyConBinder -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyConBinder
    tcb SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    hs_bndr SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ TyVar -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyVar
    tv')
               ; (tcbs', tvs, res) <- [TyVar]
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    forall r. [TyVar] -> TcM r -> TcM r
    tcExtendTyVarEnv [TyVar
    tv'] (IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
     -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a))
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    forall a b. (a -> b) -> a -> b
    $
                                      Subst
    -> [TyConBinder]
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    go Subst
    subst' [TyConBinder]
    tcbs' [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    hs_bndrs'
               ; return (Bndr tv' vis : tcbs', tv':tvs, res) }
                 -- We do a tcExtendTyVarEnv [tv'], so we return tv' in
                 -- the list of lexically-scoped skolem type variables

          | TyConBndrVis -> Bool
    skippable (TyConBinder -> TyConBndrVis
    forall tv argf. VarBndr tv argf -> argf
    binderFlag TyConBinder
    tcb)
          = -- Invisible TyConBinder, so do not consume one of the hs_bndrs
            do { let (Subst
    subst', TyConBinder
    tcb') = Subst -> TyConBinder -> (Subst, TyConBinder)
    substTyConBinderX Subst
    subst TyConBinder
    tcb
               ; String -> SDoc -> TcM ()
    traceTc String
    "musd2" (TyConBinder -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyConBinder
    tcb SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    hs_bndr SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ TyConBinder -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyConBinder
    tcb')
               ; (tcbs', tvs, res) <- Subst
    -> [TyConBinder]
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    go Subst
    subst' [TyConBinder]
    tcbs' [GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)]
    hs_bndrs
                       -- NB: pass on hs_bndrs unchanged; we do not consume a
                       --     HsTyVarBndr for an invisible TyConBinder
               ; return (tcb' : tcbs', tvs, res) }
                       -- Return `tvs`; no new lexically-scoped TyVars brought into scope

          | Bool
    otherwise =
              -- At this point we conclude that:
              --   * the quantifier (tcb) is visible: (ty -> ...), (forall a -> ...)
              --   * the binder (hs_bndr) is invisible: @t, @(t :: k)
              -- Any other combination should have been handled by the zippable/skippable clauses.
              TcRnMessage
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyConBinder], [TyVar], a)
    forall a. TcRnMessage -> TcRn a
    failWithTc (Name -> LHsTyVarBndr (HsBndrVis GhcRn) GhcRn -> TcRnMessage
    TcRnInvalidInvisTyVarBndr Name
    name LHsTyVarBndr (HsBndrVis GhcRn) GhcRn
    GenLocated SrcSpanAnnA (HsTyVarBndr (HsBndrVis GhcRn) GhcRn)
    hs_bndr)

        tc_hs_bndr :: HsTyVarBndr (HsBndrVis GhcRn) GhcRn -> TcKind -> TcM ()
        tc_hs_bndr :: HsTyVarBndr (HsBndrVis GhcRn) GhcRn -> Type -> TcM ()
    tc_hs_bndr (HsTvb { tvb_kind :: forall flag pass. HsTyVarBndr flag pass -> HsBndrKind pass
    tvb_kind = HsBndrNoKind XBndrNoKind GhcRn
    _ }) Type
    _ = () -> TcM ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
        tc_hs_bndr (HsTvb { tvb_kind :: forall flag pass. HsTyVarBndr flag pass -> HsBndrKind pass
    tvb_kind = HsBndrKind XBndrKind GhcRn
    _ LHsType GhcRn
    kind, tvb_var :: forall flag pass. HsTyVarBndr flag pass -> HsBndrVar pass
    tvb_var = HsBndrVar GhcRn
    bvar })
                   Type
    expected_kind
          = do { String -> SDoc -> TcM ()
    traceTc String
    "musd3:unifying" (GenLocated SrcSpanAnnA (HsType GhcRn) -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    kind SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    expected_kind)
               ; HsBndrVar GhcRn -> LHsType GhcRn -> Type -> TcM ()
    tcHsTvbKind HsBndrVar GhcRn
    bvar LHsType GhcRn
    kind Type
    expected_kind }

        -- See GHC Proposal #425, section "Kind checking",
        -- where zippable and skippable are defined.
        -- In particular: we match up if
        -- (a) HsBndr looks like @k, and TyCon binder is forall k. (NamedTCB Specified)
        -- (b) HsBndr looks like a,  and TyCon binder is forall k -> (NamedTCB Required)
        --                                            or k -> (AnonTCB)
        zippable :: TyConBndrVis -> HsBndrVis GhcRn -> Bool
        zippable :: TyConBndrVis -> HsBndrVis GhcRn -> Bool
    zippable TyConBndrVis
    vis (HsBndrInvisible XBndrInvisible GhcRn
    _) = TyConBndrVis -> Bool
    isInvisSpecTcbVis TyConBndrVis
    vis  -- (a)
        zippable TyConBndrVis
    vis (HsBndrRequired XBndrRequired GhcRn
    _)  = TyConBndrVis -> Bool
    isVisibleTcbVis TyConBndrVis
    vis    -- (b)

        -- See GHC Proposal #425, section "Kind checking",
        -- where zippable and skippable are defined.
        skippable :: TyConBndrVis -> Bool
        skippable :: TyConBndrVis -> Bool
    skippable TyConBndrVis
    vis = Bool -> Bool
    not (TyConBndrVis -> Bool
    isVisibleTcbVis TyConBndrVis
    vis)

    -- Check the kind of a type variable binder
    tcHsTvbKind :: HsBndrVar GhcRn -> LHsKind GhcRn -> TcKind -> TcM ()
    tcHsTvbKind :: HsBndrVar GhcRn -> LHsType GhcRn -> Type -> TcM ()
    tcHsTvbKind HsBndrVar GhcRn
    bvar LHsType GhcRn
    kind Type
    expected_kind =
      do { sig_kind <- UserTypeCtxt -> LHsType GhcRn -> TcM Type
    tcLHsKindSig UserTypeCtxt
    ctxt LHsType GhcRn
    kind
         ; traceTc "tcHsTvbKind:unifying" (ppr sig_kind $$ ppr expected_kind)
         ; discardResult $ -- See Note [discardResult in tcHsTvbKind]
           unifyKind mb_thing sig_kind expected_kind }
      where
        (UserTypeCtxt
    ctxt, Maybe TypedThing
    mb_thing) = case HsBndrVar GhcRn
    bvar of
          HsBndrVar XBndrVar GhcRn
    _ (L SrcSpanAnnN
    _ Name
    hs_nm) -> (Name -> UserTypeCtxt
    TyVarBndrKindCtxt Name
    hs_nm, TypedThing -> Maybe TypedThing
    forall a. a -> Maybe a
    Just (Name -> TypedThing
    NameThing Name
    hs_nm))
          HsBndrWildCard XBndrWildCard GhcRn
    _ -> (UserTypeCtxt
    KindSigCtxt, Maybe TypedThing
    forall a. Maybe a
    Nothing)

    substTyConBinderX :: Subst -> TyConBinder -> (Subst, TyConBinder)
    substTyConBinderX :: Subst -> TyConBinder -> (Subst, TyConBinder)
    substTyConBinderX Subst
    subst (Bndr TyVar
    tv TyConBndrVis
    vis)
      = (Subst
    subst', TyVar -> TyConBndrVis -> TyConBinder
    forall var argf. var -> argf -> VarBndr var argf
    Bndr TyVar
    tv' TyConBndrVis
    vis)
      where
        (Subst
    subst', TyVar
    tv') = HasDebugCallStack => Subst -> TyVar -> (Subst, TyVar)
    Subst -> TyVar -> (Subst, TyVar)
    substTyVarBndr Subst
    subst TyVar
    tv

    substTyConBindersX :: Subst -> [TyConBinder] -> (Subst, [TyConBinder])
    substTyConBindersX :: Subst -> [TyConBinder] -> (Subst, [TyConBinder])
    substTyConBindersX = (Subst -> TyConBinder -> (Subst, TyConBinder))
    -> Subst -> [TyConBinder] -> (Subst, [TyConBinder])
    forall (t :: * -> *) s a b.
    Traversable t =>
    (s -> a -> (s, b)) -> s -> t a -> (s, t b)
    mapAccumL Subst -> TyConBinder -> (Subst, TyConBinder)
    substTyConBinderX

    swizzleTcb :: VarEnv Name -> Subst -> TyConBinder -> (Subst, TyConBinder)
    swizzleTcb :: VarEnv Name -> Subst -> TyConBinder -> (Subst, TyConBinder)
    swizzleTcb VarEnv Name
    swizzle_env Subst
    subst (Bndr TyVar
    tv TyConBndrVis
    vis)
      = (Subst
    subst', TyVar -> TyConBndrVis -> TyConBinder
    forall var argf. var -> argf -> VarBndr var argf
    Bndr TyVar
    tv2 TyConBndrVis
    vis)
      where
        subst' :: Subst
    subst' = Subst -> TyVar -> TyVar -> Subst
    extendTCvSubstWithClone Subst
    subst TyVar
    tv TyVar
    tv2
        tv1 :: TyVar
    tv1 = (Type -> Type) -> TyVar -> TyVar
    updateTyVarKind (HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst) TyVar
    tv
        tv2 :: TyVar
    tv2 = case VarEnv Name -> TyVar -> Maybe Name
    forall a. VarEnv a -> TyVar -> Maybe a
    lookupVarEnv VarEnv Name
    swizzle_env TyVar
    tv of
                 Just Name
    user_name -> TyVar -> Name -> TyVar
    setTyVarName TyVar
    tv1 Name
    user_name
                 Maybe Name
    Nothing        -> TyVar
    tv1
        -- NB: the SrcSpan on an implicitly-bound name deliberately spans
        -- the whole declaration. e.g.
        --    data T (a :: k) (b :: Type -> k) = ....
        -- There is no single binding site for 'k'.
        -- See Note [Source locations for implicitly bound type variables]
        -- in GHC.Tc.Rename.HsType

    {- Note [kcCheckDeclHeader_sig]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Given a kind signature 'sig_kind' and a declaration header,
    kcCheckDeclHeader_sig verifies that the declaration conforms to the
    signature. The end result is a PolyTcTyCon 'tc' such that:
      tyConKind tc == sig_kind

    Basic plan is this:
      * splitTyConKind: Take the Kind from the separate kind signature, and
        decompose it all the way to a [TyConBinder] and a Kind in the corner.

        NB: these TyConBinders contain TyVars, not TcTyVars.

      * matchUpSigWithDecl: match the [TyConBinder] from the signature with
        the [LHsTyVarBndr (HsBndrVis GhcRn) GhcRn] from the declaration.  The latter are the
        explicit, user-written binders.  e.g.
            data T (a :: k) b = ....
        There may be more of the former than the latter, because the former
        include invisible binders.  matchUpSigWithDecl uses isVisibleTcbVis
        to decide which TyConBinders are visible.

      * matchUpSigWithDecl also skolemises the [TyConBinder] to produce
        a [TyConBinder], corresponding 1-1 with the consumed [TyConBinder].
        Each new TyConBinder
          - Uses the Name from the LHsTyVarBndr, if available, both because that's
            what the user expects, and because the binding site accurately comes
            from the data/type declaration.
          - Uses a skolem TcTyVar.  We need these to allow unification.

      * machUpSigWithDecl also unifies the user-supplied kind signature for each
        LHsTyVarBndr with the kind that comes from the TyConBinder (itself coming
        from the separate kind signature).

      * Finally, kcCheckDeclHeader_sig unifies the return kind of the separate
        signature with the kind signature (if any) in the data/type declaration.
        E.g.
               type S :: forall k. k -> k -> Type
               type family S (a :: j) :: j -> Type
        Here we match up the 'k ->' with (a :: j); and then must unify the leftover
        part of the signature (k -> Type) with the kind signature of the decl,
        (j -> Type).  This unification, done in kcCheckDeclHeader, needs TcTyVars.

    Note [Arity of type families and type synonyms]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider

      type F0 :: forall k. k -> k -> Type
      type family F0

      type F1 :: forall k. k -> k -> Type
      type family F1 @k

      type F2a :: forall k. k -> k -> Type
      type family F2a @k a

      type F2b :: forall k. k -> k -> Type
      type family F2b a

      type F3 :: forall k. k -> k -> Type
      type family F3 a b

    All five have the same /kind/, but what /arity/ do they have?
    For a type family, the arity is critical:
    * A type family must always appear saturated (up to its arity)
    * A type family can match only on `arity` arguments, not further ones
    * The arity is recorded by `tyConArity`, and is equal to the number of
      `TyConBinders` in the `TyCon`.
    * In this context "arity" includes both kind and type arguments.

    The arity is not determined by the kind signature (all five have the same signature).
    Rather, it is determined by the declaration of the family:
    * `F0` has arity 0.
    * `F1` has arity 1.
    * `F2a` has arity 2.
    * `F2b` also has arity 2: the kind argument is invisible.
    * `F3` has arity 3; again the kind argument is invisible.

    The matching-up of kind signature with the declaration itself is done by
    `matchUpWithSigDecl`.

    Note [discardResult in tcHsTvbKind]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    We use 'unifyKind' to check inline kind annotations in declaration headers
    against the signature.

      type T :: [i] -> Maybe j -> Type
      data T (a :: [k1]) (b :: Maybe k2) :: Type where ...

    Here, we will unify:

           [k1] ~ [i]
      Maybe k2  ~ Maybe j
          Type  ~ Type

    The end result is that we fill in unification variables k1, k2:

        k1  :=  i
        k2  :=  j

    We also validate that the user isn't confused:

      type T :: Type -> Type
      data T (a :: Bool) = ...

    This will report that (Type ~ Bool) failed to unify.

    Now, consider the following example:

      type family Id a where Id x = x
      type T :: Bool -> Type
      type T (a :: Id Bool) = ...

    We will unify (Bool ~ Id Bool), and this will produce a non-reflexive coercion.
    However, we are free to discard it, as the kind of 'T' is determined by the
    signature, not by the inline kind annotation:

          we have   T ::    Bool -> Type
      rather than   T :: Id Bool -> Type

    This (Id Bool) will not show up anywhere after we're done validating it, so we
    have no use for the produced coercion.

    Note [Kind variable ordering for associated types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    What should be the kind of `T` in the following example? (#15591)

      class C (a :: Type) where
        type T (x :: f a)

    As per Note [Ordering of implicit variables] in GHC.Rename.HsType, we want to quantify
    the kind variables in left-to-right order of first occurrence in order to
    support visible kind application. But we cannot perform this analysis on just
    T alone, since its variable `a` actually occurs /before/ `f` if you consider
    the fact that `a` was previously bound by the parent class `C`. That is to say,
    the kind of `T` should end up being:

      T :: forall a f. f a -> Type

    (It wouldn't necessarily be /wrong/ if the kind ended up being, say,
    forall f a. f a -> Type, but that would not be as predictable for users of
    visible kind application.)

    In contrast, if `T` were redefined to be a top-level type family, like `T2`
    below:

      type family T2 (x :: f (a :: Type))

    Then `a` first appears /after/ `f`, so the kind of `T2` should be:

      T2 :: forall f a. f a -> Type

    In order to make this distinction, we need to know (in kcCheckDeclHeader) which
    type variables have been bound by the parent class (if there is one). With
    the class-bound variables in hand, we can ensure that we always quantify
    these first.
    -}

    {- *********************************************************************
    *                                                                      *
                 Expected kinds
    *                                                                      *
    ********************************************************************* -}

    -- | Describes the kind expected in a certain context.
    data ContextKind = TheKind TcKind   -- ^ a specific kind
                     | AnyKind        -- ^ any kind will do
                     | OpenKind       -- ^ something of the form @TYPE _@

    -- debug only
    instance Outputable ContextKind where
      ppr :: ContextKind -> SDoc
    ppr ContextKind
    AnyKind = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "AnyKind"
      ppr ContextKind
    OpenKind = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "OpenKind"
      ppr (TheKind Type
    k) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "TheKind" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    k

    -----------------------
    newExpectedKind :: ContextKind -> TcM TcKind
    newExpectedKind :: ContextKind -> TcM Type
    newExpectedKind (TheKind Type
    k)   = Type -> TcM Type
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Type
    k
    newExpectedKind ContextKind
    AnyKind       = TcM Type
    newMetaKindVar
    newExpectedKind ContextKind
    OpenKind      = TcM Type
    newOpenTypeKind

    -----------------------
    expectedKindInCtxt :: UserTypeCtxt -> ContextKind
    -- Depending on the context, we might accept any kind (for instance, in a TH
    -- splice), or only certain kinds (like in type signatures).
    expectedKindInCtxt :: UserTypeCtxt -> ContextKind
    expectedKindInCtxt (TySynCtxt Name
    _)   = ContextKind
    AnyKind
    expectedKindInCtxt (GhciCtxt {})   = ContextKind
    AnyKind
    -- The types in a 'default' decl can have varying kinds
    -- See Note [Extended defaults]" in GHC.Tc.Utils.Env
    expectedKindInCtxt UserTypeCtxt
    DefaultDeclCtxt     = ContextKind
    AnyKind
    expectedKindInCtxt UserTypeCtxt
    DerivClauseCtxt     = ContextKind
    AnyKind
    expectedKindInCtxt UserTypeCtxt
    TypeAppCtxt         = ContextKind
    AnyKind
    expectedKindInCtxt (ForSigCtxt Name
    _)      = Type -> ContextKind
    TheKind Type
    liftedTypeKind
    expectedKindInCtxt (InstDeclCtxt {})   = Type -> ContextKind
    TheKind Type
    constraintKind
    expectedKindInCtxt UserTypeCtxt
    SpecInstCtxt        = Type -> ContextKind
    TheKind Type
    constraintKind
    expectedKindInCtxt UserTypeCtxt
    _                   = ContextKind
    OpenKind

    {- *********************************************************************
    *                                                                      *
              Scoped tyvars that map to the same thing
    *                                                                      *
    ********************************************************************* -}

    checkForDisconnectedScopedTyVars :: Name -> TyConFlavour TyCon -> [TcTyConBinder]
                                     -> [(Name,TcTyVar)] -> TcM ()
    -- See Note [Disconnected type variables]
    -- For the type synonym case see Note [Out of arity type variables]
    -- `scoped_prs` is the mapping gotten by unifying
    --    - the standalone kind signature for T, with
    --    - the header of the type/class declaration for T
    checkForDisconnectedScopedTyVars :: Name
    -> TyConFlavour TyCon -> [TyConBinder] -> [(Name, TyVar)] -> TcM ()
    checkForDisconnectedScopedTyVars Name
    name TyConFlavour TyCon
    flav [TyConBinder]
    all_tcbs [(Name, TyVar)]
    scoped_prs
             -- needsEtaExpansion: see wrinkle (DTV1) in Note [Disconnected type variables]
      | TyConFlavour TyCon -> Bool
    forall tc. TyConFlavour tc -> Bool
    needsEtaExpansion TyConFlavour TyCon
    flav     = ((Name, TyVar) -> TcM ()) -> [(Name, TyVar)] -> TcM ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Name, TyVar) -> TcM ()
    report_disconnected (((Name, TyVar) -> Bool) -> [(Name, TyVar)] -> [(Name, TyVar)]
    forall a. (a -> Bool) -> [a] -> [a]
    filterOut (Name, TyVar) -> Bool
    ok [(Name, TyVar)]
    scoped_prs)
      | TyConFlavour TyCon
    flav TyConFlavour TyCon -> TyConFlavour TyCon -> Bool
    forall a. Eq a => a -> a -> Bool
    == TyConFlavour TyCon
    forall tc. TyConFlavour tc
    TypeSynonymFlavour = ((Name, TyVar) -> TcM ()) -> [(Name, TyVar)] -> TcM ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Name, TyVar) -> TcM ()
    report_out_of_arity (((Name, TyVar) -> Bool) -> [(Name, TyVar)] -> [(Name, TyVar)]
    forall a. (a -> Bool) -> [a] -> [a]
    filterOut (Name, TyVar) -> Bool
    ok [(Name, TyVar)]
    scoped_prs)
      | Bool
    otherwise = () -> TcM ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ()
      where
        all_tvs :: TyVarSet
    all_tvs = [TyVar] -> TyVarSet
    mkVarSet ([TyConBinder] -> [TyVar]
    forall tv argf. [VarBndr tv argf] -> [tv]
    binderVars [TyConBinder]
    all_tcbs)
        ok :: (Name, TyVar) -> Bool
    ok (Name
    _, TyVar
    tc_tv) = TyVar
    tc_tv TyVar -> TyVarSet -> Bool
    `elemVarSet` TyVarSet
    all_tvs

        report_disconnected :: (Name,TcTyVar) -> TcM ()
        report_disconnected :: (Name, TyVar) -> TcM ()
    report_disconnected (Name
    nm, TyVar
    _)
          = SrcSpan -> TcM () -> TcM ()
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan (Name -> SrcSpan
    forall a. NamedThing a => a -> SrcSpan
    getSrcSpan Name
    nm) (TcM () -> TcM ()) -> TcM () -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
            TcRnMessage -> TcM ()
    addErrTc (TcRnMessage -> TcM ()) -> TcRnMessage -> TcM ()
    forall a b. (a -> b) -> a -> b
    $ Name -> TcRnMessage
    TcRnDisconnectedTyVar Name
    nm

        report_out_of_arity :: (Name,TcTyVar) -> TcM ()
        report_out_of_arity :: (Name, TyVar) -> TcM ()
    report_out_of_arity (Name
    tv_nm, TyVar
    _)
          = SrcSpan -> TcM () -> TcM ()
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan (Name -> SrcSpan
    forall a. NamedThing a => a -> SrcSpan
    getSrcSpan Name
    tv_nm) (TcM () -> TcM ()) -> TcM () -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
            TcRnMessage -> TcM ()
    addErrTc (TcRnMessage -> TcM ()) -> TcRnMessage -> TcM ()
    forall a b. (a -> b) -> a -> b
    $ Name -> Name -> TcRnMessage
    TcRnOutOfArityTyVar Name
    name Name
    tv_nm

    checkForDuplicateScopedTyVars :: [(Name,TcTyVar)] -> TcM ()
    -- Check for duplicates
    -- See Note [Aliasing in type and class declarations]
    checkForDuplicateScopedTyVars :: [(Name, TyVar)] -> TcM ()
    checkForDuplicateScopedTyVars [(Name, TyVar)]
    scoped_prs
      = Bool -> TcM () -> TcM ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless ([(Name, Name)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [(Name, Name)]
    err_prs) (TcM () -> TcM ()) -> TcM () -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
        do { ((Name, Name) -> TcM ()) -> [(Name, Name)] -> TcM ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ (Name, Name) -> TcM ()
    report_dup [(Name, Name)]
    err_prs; TcM ()
    forall env a. IOEnv env a
    failM }
      where
        -------------- Error reporting ------------
        err_prs :: [(Name,Name)]
        err_prs :: [(Name, Name)]
    err_prs = [ (Name
    n1,Name
    n2)
                  | NonEmpty (Name, TyVar)
    prs :: NonEmpty (Name,TyVar) <- ((Name, TyVar) -> (Name, TyVar) -> Bool)
    -> [(Name, TyVar)] -> [NonEmpty (Name, TyVar)]
    forall a. (a -> a -> Bool) -> [a] -> [NonEmpty a]
    findDupsEq (TyVar -> TyVar -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) (TyVar -> TyVar -> Bool)
    -> ((Name, TyVar) -> TyVar)
    -> (Name, TyVar)
    -> (Name, TyVar)
    -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` (Name, TyVar) -> TyVar
    forall a b. (a, b) -> b
    snd) [(Name, TyVar)]
    scoped_prs
                  , (Name
    n1,TyVar
    _) :| ((Name
    n2,TyVar
    _) : [(Name, TyVar)]
    _) <- [((Name, TyVar) -> (Name, TyVar) -> Bool)
    -> NonEmpty (Name, TyVar) -> NonEmpty (Name, TyVar)
    forall a. (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
    NE.nubBy (Name -> Name -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) (Name -> Name -> Bool)
    -> ((Name, TyVar) -> Name)
    -> (Name, TyVar)
    -> (Name, TyVar)
    -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` (Name, TyVar) -> Name
    forall a b. (a, b) -> a
    fst) NonEmpty (Name, TyVar)
    prs] ]
                  -- This nubBy avoids bogus error reports when we have
                  --    [("f", f), ..., ("f",f)....] in swizzle_prs
                  -- which happens with  class C f where { type T f }

        report_dup :: (Name,Name) -> TcM ()
        report_dup :: (Name, Name) -> TcM ()
    report_dup (Name
    n1,Name
    n2)
          = SrcSpan -> TcM () -> TcM ()
    forall a. SrcSpan -> TcRn a -> TcRn a
    setSrcSpan (Name -> SrcSpan
    forall a. NamedThing a => a -> SrcSpan
    getSrcSpan Name
    n2) (TcM () -> TcM ()) -> TcM () -> TcM ()
    forall a b. (a -> b) -> a -> b
    $
            TcRnMessage -> TcM ()
    addErrTc (TcRnMessage -> TcM ()) -> TcRnMessage -> TcM ()
    forall a b. (a -> b) -> a -> b
    $ Name -> Name -> TcRnMessage
    TcRnDifferentNamesForTyVar Name
    n1 Name
    n2

    {- Note [Aliasing in type and class declarations]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
      data SameKind (a::k) (b::k)
      data T1 (a::k1) (b::k2) c = MkT (SameKind a b) c
    We do not allow this, because `k1` and `k2` would both stand for the same type
    variable -- they are both aliases for `k`.

    Other examples
      data T2 (a::k1)                 = MkT2 (SameKind a Int) -- k1 stands for Type
      data T3 @k1 @k2 (a::k1) (b::k2) = MkT (SameKind a b)    -- k1 and k2 are aliases

      type UF :: forall zk. zk -> Constraint
      class UF @kk (xb :: k) where   -- kk and k are aliases
        op :: (xs::kk) -> Bool

    See #24604 for an example that crashed GHC.

    There is a design choice here. It would be possible to allow implicit type variables
    like `k1` and `k2` in T1's declartion to stand for /abitrary kinds/.  This is in fact
    the rule we use in /terms/ pattern signatures:
        f :: [Int] -> Int
        f ((x::a) : xs) = ...
    Here `a` stands for `Int`.  But in type /signatures/ we make a different choice:
        f1 :: forall (a::k1) (b::k2). SameKind a b -> blah
        f2 :: forall (a::k). SameKind a Int -> blah

    Here f1's signature is rejected because `k1` and `k2` are aliased; and f2's is
    rejected because `k` stands for `Int`.

    Our current choice is that type and class declarations behave more like signatures;
    we do not allow aliasing.  That is what `checkForDuplicateScopedTyVars` checks.
    See !12328 for some design discussion.

    Note [Disconnected type variables]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    This note applies when kind-checking the header of a type/class decl that has
    a separate, standalone kind signature.  See #24083.

    Consider:
       type S a = Type

       type C :: forall k. S k -> Constraint
       class C (a :: S kk) where
         op :: ...kk...

    Note that the class has a separate kind signature, so the elaborated decl should
    look like
       class C @kk (a :: S kk) where ...

    But how can we "connect up" the scoped variable `kk` with the skolem kind from the
    standalone kind signature for `C`?  In general we do this by unifying the two.
    For example
       type T k = (k,Type)
       type W :: forall k. T k -> Type
       data W (a :: (x,Type)) = ..blah blah..

    When we encounter (a :: (x,Type)) we unify the kind (x,Type) with the kind (T k)
    from the standalone kind signature.  Of course, unification looks through synonyms
    so we end up with the mapping [x :-> k] that connects the scoped type variable `x`
    with the kind from the signature.

    But in our earlier example this unification is ineffective -- because `S` is a
    phantom synonym that just discards its argument.  So our plan is this:

      if matchUpSigWithDecl fails to connect `kk with `k`, by unification,
      we give up and complain about a "disconnected" type variable.

    See #24083 for dicussion of alternatives, none satisfactory.  Also the fix is
    easy: just add an explicit `@kk` parameter to the declaration, to bind `kk`
    explicitly, rather than binding it implicitly via unification.

    (DTV1) We only want to make this check when there /are/ scoped type variables; and
      that is determined by needsEtaExpansion.  Examples:

         type C :: x -> y -> Constraint
         class C a :: b -> Constraint where { ... }
         -- The a,b scope over the "..."

         type D :: forall k. k -> Type
         data family D :: kk -> Type
         -- Nothing for `kk` to scope over!

      In the latter data-family case, the match-up stuff in kcCheckDeclHeader_sig will
      return [] for `extra_tcbs`, and in fact `all_tcbs` will be empty.  So if we do
      the check-for-disconnected-tyvars check we'll complain that `kk` is not bound
      to one of `all_tcbs` (see #24083, comments about the `singletons` package).

      The scoped-tyvar stuff is needed precisely for data/class/newtype declarations,
      where needsEtaExpansion is True.

    Note [Out of arity type variables]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    (Relevant ticket: #24470)
    Type synonyms have a special scoping rule that allows implicit quantification in
    the outermost kind signature:

      type P_e :: k -> Type
      type P_e @k = Proxy :: k -> Type     -- explicit binding

      type P_i    = Proxy :: k -> Type     -- implicit binding (relies on the special rule)

    This is a deprecated feature (warning flag: -Wimplicit-rhs-quantification) but
    we have to support it for a couple more releases. It is explained in more detail
    in Note [Implicit quantification in type synonyms] in GHC.Rename.HsType.

    Type synonyms `P_e` and `P_i` are equivalent.  Both of them have kind
    `forall k. k -> Type` and arity 1. (Recall that the arity of a type synonym is
    the number of arguments it requires at use sites; the arity matter because
    unsaturated application of type families and type synonyms is not allowed).

    We start to see problems when implicit RHS quantification (as in `P_i`) is
    combined with a standalone king signature (like the one that `P_e` has).
    That is:

      type P_i_sig :: k -> Type
      type P_i_sig = Proxy :: k -> Type

    Per GHC Proposal #425, the arity of `P_i_sig` is determined /by the LHS only/,
    which has no binders. So the arity of `P_i_sig` is 0.
    At the same time, the legacy implicit quantification rule dictates that `k` is
    brought into scope, as if there was a binder `@k` on the LHS.

    We end up with a `k` that is in scope on the RHS but cannot be bound implicitly
    on the LHS without affecting the arity. This led to #24470 (a compiler crash)

      GHC internal error: ‘k’ is not in scope during type checking,
                          but it passed the renamer

    This problem occurs only if the arity of the type synonym is insufficiently
    high to accommodate an implicit binding. It can be worked around by adding an
    unused binder on the LHS:

      type P_w :: k -> Type
      type P_w @_w = Proxy :: k -> Type

    The variable `_w` is unused. The only effect of the `@_w` binder is that the
    arity of `P_w` is changed from 0 to 1. However, bumping the arity is exactly
    what's needed to make the implicit binding of `k` possible.

    All this is a rather unfortunate bit of accidental complexity that will go away
    when GHC drops support for implicit RHS quantification. In the meantime, we
    ought to produce a proper error message instead of a compiler panic, and we do
    that with a check in checkForDisconnectedScopedTyVars:

      | flav == TypeSynonymFlavour = mapM_ report_out_of_arity (filterOut ok scoped_prs)

    -}

    {- *********************************************************************
    *                                                                      *
                 Bringing type variables into scope
    *                                                                      *
    ********************************************************************* -}

    --------------------------------------
    --    HsForAllTelescope
    --------------------------------------

    tcTKTelescope :: TcTyMode
                  -> HsForAllTelescope GhcRn
                  -> TcM a
                  -> TcM ([TcTyVarBinder], a)
    -- A HsForAllTelescope comes only from a HsForAllTy,
    -- an explicit, user-written forall type
    tcTKTelescope :: forall a.
    TcTyMode
    -> HsForAllTelescope GhcRn -> TcM a -> TcM ([TcTyVarBinder], a)
    tcTKTelescope TcTyMode
    mode HsForAllTelescope GhcRn
    tele TcM a
    thing_inside = case HsForAllTelescope GhcRn
    tele of
      HsForAllVis { hsf_vis_bndrs :: forall pass. HsForAllTelescope pass -> [LHsTyVarBndr () pass]
    hsf_vis_bndrs = [LHsTyVarBndr () GhcRn]
    bndrs }
        -> do { skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
    forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
    mkSkolemInfo (TyVarBndrs -> SkolemInfoAnon
    ForAllSkol ([HsTyVarBndr () GhcRn] -> TyVarBndrs
    forall flag.
    OutputableBndrFlag flag 'Renamed =>
    [HsTyVarBndr flag GhcRn] -> TyVarBndrs
    HsTyVarBndrsRn (GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)
    -> HsTyVarBndr () GhcRn
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)
     -> HsTyVarBndr () GhcRn)
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    -> [HsTyVarBndr () GhcRn]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [LHsTyVarBndr () GhcRn]
    [GenLocated SrcSpanAnnA (HsTyVarBndr () GhcRn)]
    bndrs)))
              ; let skol_mode = SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_holes = mode_holes mode
                                          , sm_tvtv = SMDSkolemTv skol_info }
              ; (req_tv_bndrs, thing) <- tcExplicitTKBndrsX skol_mode bndrs thing_inside
                -- req_tv_bndrs :: [VarBndr TyVar ()],
                -- but we want [VarBndr TyVar ForAllTyFlag]
              ; return (tyVarReqToBinders req_tv_bndrs, thing) }

      HsForAllInvis { hsf_invis_bndrs :: forall pass.
    HsForAllTelescope pass -> [LHsTyVarBndr Specificity pass]
    hsf_invis_bndrs = [LHsTyVarBndr Specificity GhcRn]
    bndrs }
        -> do { skol_info <- SkolemInfoAnon -> IOEnv (Env TcGblEnv TcLclEnv) SkolemInfo
    forall (m :: * -> *). MonadIO m => SkolemInfoAnon -> m SkolemInfo
    mkSkolemInfo (TyVarBndrs -> SkolemInfoAnon
    ForAllSkol ([HsTyVarBndr Specificity GhcRn] -> TyVarBndrs
    forall flag.
    OutputableBndrFlag flag 'Renamed =>
    [HsTyVarBndr flag GhcRn] -> TyVarBndrs
    HsTyVarBndrsRn (GenLocated SrcSpanAnnA (HsTyVarBndr Specificity GhcRn)
    -> HsTyVarBndr Specificity GhcRn
    forall l e. GenLocated l e -> e
    unLoc (GenLocated SrcSpanAnnA (HsTyVarBndr Specificity GhcRn)
     -> HsTyVarBndr Specificity GhcRn)
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr Specificity GhcRn)]
    -> [HsTyVarBndr Specificity GhcRn]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [LHsTyVarBndr Specificity GhcRn]
    [GenLocated SrcSpanAnnA (HsTyVarBndr Specificity GhcRn)]
    bndrs)))
              ; let skol_mode = SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_holes = mode_holes mode
                                          , sm_tvtv = SMDSkolemTv skol_info }
              ; (inv_tv_bndrs, thing) <- tcExplicitTKBndrsX skol_mode bndrs thing_inside
                -- inv_tv_bndrs :: [VarBndr TyVar Specificity],
                -- but we want [VarBndr TyVar ForAllTyFlag]
              ; return (tyVarSpecToBinders inv_tv_bndrs, thing) }

    --------------------------------------
    --    HsOuterTyVarBndrs
    --------------------------------------

    bindOuterTKBndrsX :: OutputableBndrFlag flag 'Renamed  -- Only to support traceTc
                      => SkolemMode
                      -> HsOuterTyVarBndrs flag GhcRn
                      -> TcM a
                      -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    bindOuterTKBndrsX :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    bindOuterTKBndrsX SkolemMode
    skol_mode HsOuterTyVarBndrs flag GhcRn
    outer_bndrs TcM a
    thing_inside
      = case HsOuterTyVarBndrs flag GhcRn
    outer_bndrs of
          HsOuterImplicit{hso_ximplicit :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> XHsOuterImplicit pass
    hso_ximplicit = XHsOuterImplicit GhcRn
    imp_tvs} ->
            do { (imp_tvs', thing) <- SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    forall a. SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrsX SkolemMode
    skol_mode HsQTvsRn
    XHsOuterImplicit GhcRn
    imp_tvs TcM a
    thing_inside
               ; return ( HsOuterImplicit{hso_ximplicit = imp_tvs'}
                        , thing) }
          HsOuterExplicit{hso_bndrs :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> [LHsTyVarBndr flag (NoGhcTc pass)]
    hso_bndrs = [LHsTyVarBndr flag (NoGhcTc GhcRn)]
    exp_bndrs} ->
            do { (exp_tvs', thing) <- SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrsX SkolemMode
    skol_mode [LHsTyVarBndr flag (NoGhcTc GhcRn)]
    [LHsTyVarBndr flag GhcRn]
    exp_bndrs TcM a
    thing_inside
               ; return ( HsOuterExplicit { hso_xexplicit = exp_tvs'
                                          , hso_bndrs     = exp_bndrs }
                        , thing) }

    ---------------
    outerTyVars :: HsOuterTyVarBndrs flag GhcTc -> [TcTyVar]
    -- The returned [TcTyVar] is not necessarily in dependency order
    -- at least for the HsOuterImplicit case
    outerTyVars :: forall flag. HsOuterTyVarBndrs flag GhcTc -> [TyVar]
    outerTyVars (HsOuterImplicit { hso_ximplicit :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> XHsOuterImplicit pass
    hso_ximplicit = XHsOuterImplicit GhcTc
    tvs })  = [TyVar]
    XHsOuterImplicit GhcTc
    tvs
    outerTyVars (HsOuterExplicit { hso_xexplicit :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> XHsOuterExplicit pass flag
    hso_xexplicit = XHsOuterExplicit GhcTc flag
    tvbs }) = [VarBndr TyVar flag] -> [TyVar]
    forall tv argf. [VarBndr tv argf] -> [tv]
    binderVars [VarBndr TyVar flag]
    XHsOuterExplicit GhcTc flag
    tvbs

    ---------------
    outerTyVarBndrs :: HsOuterTyVarBndrs Specificity GhcTc -> [InvisTVBinder]
    outerTyVarBndrs :: HsOuterTyVarBndrs Specificity GhcTc -> [VarBndr TyVar Specificity]
    outerTyVarBndrs (HsOuterImplicit{hso_ximplicit :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> XHsOuterImplicit pass
    hso_ximplicit = XHsOuterImplicit GhcTc
    imp_tvs}) = [TyVar -> Specificity -> VarBndr TyVar Specificity
    forall var argf. var -> argf -> VarBndr var argf
    Bndr TyVar
    tv Specificity
    SpecifiedSpec | TyVar
    tv <- [TyVar]
    XHsOuterImplicit GhcTc
    imp_tvs]
    outerTyVarBndrs (HsOuterExplicit{hso_xexplicit :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> XHsOuterExplicit pass flag
    hso_xexplicit = XHsOuterExplicit GhcTc Specificity
    exp_tvs}) = [VarBndr TyVar Specificity]
    XHsOuterExplicit GhcTc Specificity
    exp_tvs

    ---------------
    scopedSortOuter :: HsOuterTyVarBndrs flag GhcTc -> TcM (HsOuterTyVarBndrs flag GhcTc)
    -- Sort any /implicit/ binders into dependency order
    --     (zonking first so we can see the dependencies)
    -- /Explicit/ ones are already in the right order
    scopedSortOuter :: forall flag.
    HsOuterTyVarBndrs flag GhcTc -> TcM (HsOuterTyVarBndrs flag GhcTc)
    scopedSortOuter (HsOuterImplicit{hso_ximplicit :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> XHsOuterImplicit pass
    hso_ximplicit = XHsOuterImplicit GhcTc
    imp_tvs})
      = do { imp_tvs <- [TyVar] -> TcM [TyVar]
    zonkAndScopedSort [TyVar]
    XHsOuterImplicit GhcTc
    imp_tvs
           ; return (HsOuterImplicit { hso_ximplicit = imp_tvs }) }
    scopedSortOuter bndrs :: HsOuterTyVarBndrs flag GhcTc
    bndrs@(HsOuterExplicit{})
      = -- No need to dependency-sort (or zonk) explicit quantifiers
        HsOuterTyVarBndrs flag GhcTc
    -> IOEnv (Env TcGblEnv TcLclEnv) (HsOuterTyVarBndrs flag GhcTc)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return HsOuterTyVarBndrs flag GhcTc
    bndrs

    ---------------
    bindOuterSigTKBndrs_Tv :: HsOuterSigTyVarBndrs GhcRn
                           -> TcM a -> TcM (HsOuterSigTyVarBndrs GhcTc, a)
    bindOuterSigTKBndrs_Tv :: forall a.
    HsOuterSigTyVarBndrs GhcRn
    -> TcM a -> TcM (HsOuterTyVarBndrs Specificity GhcTc, a)
    bindOuterSigTKBndrs_Tv
      = SkolemMode
    -> HsOuterSigTyVarBndrs GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs Specificity GhcTc, a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    bindOuterTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = True, sm_tvtv = SMDTyVarTv })

    bindOuterSigTKBndrs_Tv_M :: TcTyMode
                             -> HsOuterSigTyVarBndrs GhcRn
                             -> TcM a -> TcM (HsOuterSigTyVarBndrs GhcTc, a)
    -- Do not push level; do not make implication constraint; use Tvs
    -- Two major clients of this "bind-only" path are:
    --    Note [Using TyVarTvs for kind-checking GADTs] in GHC.Tc.TyCl
    --    Note [Checking partial type signatures]
    bindOuterSigTKBndrs_Tv_M :: forall a.
    TcTyMode
    -> HsOuterSigTyVarBndrs GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs Specificity GhcTc, a)
    bindOuterSigTKBndrs_Tv_M TcTyMode
    mode
      = SkolemMode
    -> HsOuterSigTyVarBndrs GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs Specificity GhcTc, a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    bindOuterTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = True, sm_tvtv = SMDTyVarTv
                                     , sm_holes = mode_holes mode })

    bindOuterFamEqnTKBndrs_Q_Tv :: HsOuterFamEqnTyVarBndrs GhcRn
                                -> TcM a
                                -> TcM (HsOuterFamEqnTyVarBndrs GhcTc, a)
    bindOuterFamEqnTKBndrs_Q_Tv :: forall a.
    HsOuterFamEqnTyVarBndrs GhcRn
    -> TcM a -> TcM (HsOuterFamEqnTyVarBndrs GhcTc, a)
    bindOuterFamEqnTKBndrs_Q_Tv HsOuterFamEqnTyVarBndrs GhcRn
    hs_bndrs TcM a
    thing_inside
      = SkolemMode
    -> HsOuterFamEqnTyVarBndrs GhcRn
    -> TcM a
    -> TcM (HsOuterFamEqnTyVarBndrs GhcTc, a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    bindOuterTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_parent = True
                                     , sm_tvtv = SMDTyVarTv })
                          HsOuterFamEqnTyVarBndrs GhcRn
    hs_bndrs TcM a
    thing_inside
        -- sm_clone=False: see Note [Cloning for type variable binders]

    bindOuterFamEqnTKBndrs :: SkolemInfo
                           -> HsOuterFamEqnTyVarBndrs GhcRn
                           -> TcM a
                           -> TcM (HsOuterFamEqnTyVarBndrs GhcTc, a)
    bindOuterFamEqnTKBndrs :: forall a.
    SkolemInfo
    -> HsOuterFamEqnTyVarBndrs GhcRn
    -> TcM a
    -> TcM (HsOuterFamEqnTyVarBndrs GhcTc, a)
    bindOuterFamEqnTKBndrs SkolemInfo
    skol_info
      = SkolemMode
    -> HsOuterFamEqnTyVarBndrs GhcRn
    -> TcM a
    -> TcM (HsOuterFamEqnTyVarBndrs GhcTc, a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    bindOuterTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_parent = True
                                     , sm_tvtv = SMDSkolemTv skol_info })
        -- sm_clone=False: see Note [Cloning for type variable binders]

    ---------------
    tcOuterTKBndrs :: OutputableBndrFlag flag 'Renamed   -- Only to support traceTc
                   => SkolemInfo
                   -> HsOuterTyVarBndrs flag GhcRn
                   -> TcM a -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    tcOuterTKBndrs :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemInfo
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    tcOuterTKBndrs SkolemInfo
    skol_info
      = SkolemMode
    -> SkolemInfo
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> SkolemInfo
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    tcOuterTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False
                                   , sm_tvtv = SMDSkolemTv skol_info })
                        SkolemInfo
    skol_info
      -- Do not clone the outer binders
      -- See Note [Cloning for type variable binders] under "must not"

    tcOuterTKBndrsX :: OutputableBndrFlag flag 'Renamed   -- Only to support traceTc
                    => SkolemMode -> SkolemInfo
                    -> HsOuterTyVarBndrs flag GhcRn
                    -> TcM a -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    -- Push level, capture constraints, make implication
    tcOuterTKBndrsX :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> SkolemInfo
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    tcOuterTKBndrsX SkolemMode
    skol_mode SkolemInfo
    skol_info HsOuterTyVarBndrs flag GhcRn
    outer_bndrs TcM a
    thing_inside
      = case HsOuterTyVarBndrs flag GhcRn
    outer_bndrs of
          HsOuterImplicit{hso_ximplicit :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> XHsOuterImplicit pass
    hso_ximplicit = XHsOuterImplicit GhcRn
    imp_tvs} ->
            do { (imp_tvs', thing) <- SkolemMode -> SkolemInfo -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    forall a.
    SkolemMode -> SkolemInfo -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    tcImplicitTKBndrsX SkolemMode
    skol_mode SkolemInfo
    skol_info HsQTvsRn
    XHsOuterImplicit GhcRn
    imp_tvs TcM a
    thing_inside
               ; return ( HsOuterImplicit{hso_ximplicit = imp_tvs'}
                        , thing) }
          HsOuterExplicit{hso_bndrs :: forall flag pass.
    HsOuterTyVarBndrs flag pass -> [LHsTyVarBndr flag (NoGhcTc pass)]
    hso_bndrs = [LHsTyVarBndr flag (NoGhcTc GhcRn)]
    exp_bndrs} ->
            do { (exp_tvs', thing) <- SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    tcExplicitTKBndrsX SkolemMode
    skol_mode [LHsTyVarBndr flag (NoGhcTc GhcRn)]
    [LHsTyVarBndr flag GhcRn]
    exp_bndrs TcM a
    thing_inside
               ; return ( HsOuterExplicit { hso_xexplicit = exp_tvs'
                                          , hso_bndrs     = exp_bndrs }
                        , thing) }

    ---------------
    tcGadtConTyVarBndrs :: SkolemInfo
                        -> HsOuterSigTyVarBndrs GhcRn
                        -> [HsForAllTelescope GhcRn]
                        -> TcM a -> TcM ([TcTyVarBinder], a)
    tcGadtConTyVarBndrs :: forall a.
    SkolemInfo
    -> HsOuterSigTyVarBndrs GhcRn
    -> [HsForAllTelescope GhcRn]
    -> TcM a
    -> TcM ([TcTyVarBinder], a)
    tcGadtConTyVarBndrs SkolemInfo
    skol_info HsOuterSigTyVarBndrs GhcRn
    outer [HsForAllTelescope GhcRn]
    inner TcM a
    thing_inside
      = do { (outer_bndrs, (inner_tvbs, a)) <-
                SkolemInfo
    -> HsOuterSigTyVarBndrs GhcRn
    -> TcM ([TcTyVarBinder], a)
    -> TcM (HsOuterTyVarBndrs Specificity GhcTc, ([TcTyVarBinder], a))
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemInfo
    -> HsOuterTyVarBndrs flag GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs flag GhcTc, a)
    tcOuterTKBndrs SkolemInfo
    skol_info HsOuterSigTyVarBndrs GhcRn
    outer (TcM ([TcTyVarBinder], a)
     -> TcM (HsOuterTyVarBndrs Specificity GhcTc, ([TcTyVarBinder], a)))
    -> TcM ([TcTyVarBinder], a)
    -> TcM (HsOuterTyVarBndrs Specificity GhcTc, ([TcTyVarBinder], a))
    forall a b. (a -> b) -> a -> b
    $
                SkolemInfo
    -> [LHsTyVarBndr ForAllTyFlag GhcRn]
    -> TcM a
    -> TcM ([TcTyVarBinder], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemInfo
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    tcExplicitTKBndrs SkolemInfo
    skol_info ((HsForAllTelescope GhcRn
     -> [GenLocated SrcSpanAnnA (HsTyVarBndr ForAllTyFlag GhcRn)])
    -> [HsForAllTelescope GhcRn]
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr ForAllTyFlag GhcRn)]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap HsForAllTelescope GhcRn -> [LHsTyVarBndr ForAllTyFlag GhcRn]
    HsForAllTelescope GhcRn
    -> [GenLocated SrcSpanAnnA (HsTyVarBndr ForAllTyFlag GhcRn)]
    forall (p :: Pass).
    HsForAllTelescope (GhcPass p)
    -> [LHsTyVarBndr ForAllTyFlag (GhcPass p)]
    hsForAllTelescopeBndrs [HsForAllTelescope GhcRn]
    inner) (TcM a -> TcM ([TcTyVarBinder], a))
    -> TcM a -> TcM ([TcTyVarBinder], a)
    forall a b. (a -> b) -> a -> b
    $
                TcM a
    thing_inside
           ; outer_bndrs <- scopedSortOuter outer_bndrs
           ; let outer_tvbs = [VarBndr TyVar Specificity] -> [TcTyVarBinder]
    forall a. [VarBndr a Specificity] -> [VarBndr a ForAllTyFlag]
    tyVarSpecToBinders (HsOuterTyVarBndrs Specificity GhcTc -> [VarBndr TyVar Specificity]
    outerTyVarBndrs HsOuterTyVarBndrs Specificity GhcTc
    outer_bndrs)
           ; return (outer_tvbs ++ inner_tvbs, a) }

    --------------------------------------
    --    Explicit tyvar binders
    --------------------------------------

    tcExplicitTKBndrs :: OutputableBndrFlag flag 'Renamed    -- Only to suppor traceTc
                      => SkolemInfo
                      -> [LHsTyVarBndr flag GhcRn]
                      -> TcM a
                      -> TcM ([VarBndr TyVar flag], a)
    tcExplicitTKBndrs :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemInfo
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    tcExplicitTKBndrs SkolemInfo
    skol_info
      = SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> IOEnv (Env TcGblEnv TcLclEnv) a
    -> IOEnv (Env TcGblEnv TcLclEnv) ([VarBndr TyVar flag], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    tcExplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = True, sm_tvtv = SMDSkolemTv skol_info })

    tcExplicitTKBndrsX :: OutputableBndrFlag flag 'Renamed    -- Only to suppor traceTc
                       => SkolemMode
                       -> [LHsTyVarBndr flag GhcRn]
                       -> TcM a
                       -> TcM ([VarBndr TyVar flag], a)
    -- Push level, capture constraints, and emit an implication constraint.
    -- The implication constraint has a ForAllSkol ic_info,
    --   so that it is subject to a telescope test.
    tcExplicitTKBndrsX :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    tcExplicitTKBndrsX SkolemMode
    skol_mode [LHsTyVarBndr flag GhcRn]
    bndrs TcM a
    thing_inside = case [GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)]
    -> Maybe
         (NonEmpty (GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)))
    forall a. [a] -> Maybe (NonEmpty a)
    nonEmpty [LHsTyVarBndr flag GhcRn]
    [GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)]
    bndrs of
        Maybe (NonEmpty (GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)))
    Nothing -> do
           { res <- TcM a
    thing_inside
           ; return ([], res) }

        Just NonEmpty (GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn))
    bndrs1 -> do
           { (tclvl, wanted, (skol_tvs, res))
                 <- TcM ([VarBndr TyVar flag], a)
    -> TcM (TcLevel, WantedConstraints, ([VarBndr TyVar flag], a))
    forall a. TcM a -> TcM (TcLevel, WantedConstraints, a)
    pushLevelAndCaptureConstraints (TcM ([VarBndr TyVar flag], a)
     -> TcM (TcLevel, WantedConstraints, ([VarBndr TyVar flag], a)))
    -> TcM ([VarBndr TyVar flag], a)
    -> TcM (TcLevel, WantedConstraints, ([VarBndr TyVar flag], a))
    forall a b. (a -> b) -> a -> b
    $
                    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrsX SkolemMode
    skol_mode [LHsTyVarBndr flag GhcRn]
    bndrs (TcM a -> TcM ([VarBndr TyVar flag], a))
    -> TcM a -> TcM ([VarBndr TyVar flag], a)
    forall a b. (a -> b) -> a -> b
    $
                    TcM a
    thing_inside

           -- Set up SkolemInfo for telescope test
           ; let bndr_1 = NonEmpty (GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn))
    -> GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)
    forall a. NonEmpty a -> a
    NE.head NonEmpty (GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn))
    bndrs1; bndr_n = NonEmpty (GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn))
    -> GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)
    forall a. NonEmpty a -> a
    NE.last NonEmpty (GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn))
    bndrs1
           ; skol_info <- mkSkolemInfo (ForAllSkol (HsTyVarBndrsRn  (unLoc <$> bndrs)))
             -- Notice that we use ForAllSkol here, ignoring the enclosing
             -- skol_info unlike tcImplicitTKBndrs, because the bad-telescope
             -- test applies only to ForAllSkol

           ; setSrcSpan (combineSrcSpans (getLocA bndr_1) (getLocA bndr_n))
           $ emitResidualTvConstraint skol_info (binderVars skol_tvs) tclvl wanted

           ; return (skol_tvs, res) }

    ----------------
    -- | Skolemise the 'HsTyVarBndr's in an 'HsForAllTelescope' with the supplied
    -- 'TcTyMode'.
    bindExplicitTKBndrs_Skol
        :: (OutputableBndrFlag flag 'Renamed)      -- Only to suppor traceTc
        => SkolemInfo
        -> [LHsTyVarBndr flag GhcRn]
        -> TcM a
        -> TcM ([VarBndr TyVar flag], a)

    bindExplicitTKBndrs_Tv
        :: (OutputableBndrFlag flag 'Renamed)    -- Only to suppor traceTc
        => [LHsTyVarBndr flag GhcRn]
        -> TcM a
        -> TcM ([VarBndr TyVar flag], a)

    bindExplicitTKBndrs_Skol :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemInfo
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrs_Skol SkolemInfo
    skol_info = SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> IOEnv (Env TcGblEnv TcLclEnv) a
    -> IOEnv (Env TcGblEnv TcLclEnv) ([VarBndr TyVar flag], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_tvtv = SMDSkolemTv skol_info })
    bindExplicitTKBndrs_Tv :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    [LHsTyVarBndr flag GhcRn] -> TcM a -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrs_Tv   = SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> IOEnv (Env TcGblEnv TcLclEnv) a
    -> IOEnv (Env TcGblEnv TcLclEnv) ([VarBndr TyVar flag], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = True, sm_tvtv = SMDTyVarTv })
       -- sm_clone: see Note [Cloning for type variable binders]

    bindExplicitTKBndrs_Q_Skol
        :: (OutputableBndrFlag flag 'Renamed)   -- Only to support traceTc
        => SkolemInfo
        -> ContextKind
        -> [LHsTyVarBndr flag GhcRn]
        -> TcM a
        -> TcM ([VarBndr TyVar flag], a)

    bindExplicitTKBndrs_Q_Tv
        :: (OutputableBndrFlag flag 'Renamed)   -- Only to support traceTc
        => ContextKind
        -> [LHsTyVarBndr flag GhcRn]
        -> TcM a
        -> TcM ([VarBndr TyVar flag], a)
    -- These do not clone: see Note [Cloning for type variable binders]
    bindExplicitTKBndrs_Q_Skol :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemInfo
    -> ContextKind
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrs_Q_Skol SkolemInfo
    skol_info ContextKind
    ctxt_kind [LHsTyVarBndr flag GhcRn]
    hs_bndrs TcM a
    thing_inside
      = SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_parent = True
                                        , sm_kind = ctxt_kind, sm_tvtv = SMDSkolemTv skol_info })
                             [LHsTyVarBndr flag GhcRn]
    hs_bndrs TcM a
    thing_inside
        -- sm_clone=False: see Note [Cloning for type variable binders]

    bindExplicitTKBndrs_Q_Tv :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    ContextKind
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrs_Q_Tv  ContextKind
    ctxt_kind [LHsTyVarBndr flag GhcRn]
    hs_bndrs TcM a
    thing_inside
      = SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_parent = True
                                        , sm_tvtv = SMDTyVarTv, sm_kind = ctxt_kind })
                             [LHsTyVarBndr flag GhcRn]
    hs_bndrs TcM a
    thing_inside
        -- sm_clone=False: see Note [Cloning for type variable binders]

    bindExplicitTKBndrsX
        :: (OutputableBndrFlag flag 'Renamed)   -- Only to support traceTc
        => SkolemMode
        -> [LHsTyVarBndr flag GhcRn]
        -> TcM a
        -> TcM ([VarBndr TyVar flag], a)  -- Returned [TcTyVar] are in 1-1 correspondence
                                          -- with the passed-in [LHsTyVarBndr]
    bindExplicitTKBndrsX :: forall flag a.
    OutputableBndrFlag flag 'Renamed =>
    SkolemMode
    -> [LHsTyVarBndr flag GhcRn]
    -> TcM a
    -> TcM ([VarBndr TyVar flag], a)
    bindExplicitTKBndrsX skol_mode :: SkolemMode
    skol_mode@(SM { sm_parent :: SkolemMode -> Bool
    sm_parent = Bool
    check_parent, sm_kind :: SkolemMode -> ContextKind
    sm_kind = ContextKind
    ctxt_kind
                                       , sm_holes :: SkolemMode -> HoleInfo
    sm_holes = HoleInfo
    hole_info })
                         [LHsTyVarBndr flag GhcRn]
    hs_tvs TcM a
    thing_inside
      = do { String -> SDoc -> TcM ()
    traceTc String
    "bindExplicitTKBndrs" ([GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [LHsTyVarBndr flag GhcRn]
    [GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)]
    hs_tvs)
           ; [GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ([VarBndr TyVar flag], a)
    go [LHsTyVarBndr flag GhcRn]
    [GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)]
    hs_tvs }
      where
        tc_ki_mode :: TcTyMode
    tc_ki_mode = TcTyMode { mode_tyki :: TypeOrKind
    mode_tyki = TypeOrKind
    KindLevel, mode_holes :: HoleInfo
    mode_holes = HoleInfo
    hole_info }
                     -- Inherit the HoleInfo from the context

        go :: [GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)]
    -> IOEnv (Env TcGblEnv TcLclEnv) ([VarBndr TyVar flag], a)
    go [] = do { res <- TcM a
    thing_inside
                   ; return ([], res) }
        go (L SrcSpanAnnA
    _ HsTyVarBndr flag GhcRn
    hs_tv : [GenLocated SrcSpanAnnA (HsTyVarBndr flag GhcRn)]
    hs_tvs)
           = do { lcl_env <- TcM (NameEnv TcTyThing)
    getLclTypeEnv
                ; tv <- tc_hs_bndr lcl_env hs_tv
                -- Extend the environment as we go, in case a binder
                -- is mentioned in the kind of a later binder
                --   e.g. forall k (a::k). blah
                -- NB: tv's Name may differ from hs_tv's
                -- See Note [Cloning for type variable binders]
                ; (tvs,res) <- tcExtendNameTyVarEnv (mk_tvb_pairs hs_tv tv) $
                               go hs_tvs
                ; return (Bndr tv (hsTyVarBndrFlag hs_tv):tvs, res) }

        tc_hs_bndr :: TcTypeEnv -> HsTyVarBndr flag GhcRn -> TcM TcTyVar
        tc_hs_bndr :: forall flag.
    NameEnv TcTyThing
    -> HsTyVarBndr flag GhcRn -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    tc_hs_bndr NameEnv TcTyThing
    lcl_env (HsTvb { tvb_var :: forall flag pass. HsTyVarBndr flag pass -> HsBndrVar pass
    tvb_var = HsBndrVar GhcRn
    bvar, tvb_kind :: forall flag pass. HsTyVarBndr flag pass -> HsBndrKind pass
    tvb_kind = HsBndrKind GhcRn
    kind })
          | Bool
    check_parent
          , HsBndrVar XBndrVar GhcRn
    _ (L SrcSpanAnnN
    _ Name
    name) <- HsBndrVar GhcRn
    bvar
          , Just (ATyVar Name
    _ TyVar
    tv) <- NameEnv TcTyThing -> Name -> Maybe TcTyThing
    forall a. NameEnv a -> Name -> Maybe a
    lookupNameEnv NameEnv TcTyThing
    lcl_env Name
    name
          = do { Name -> Type -> HsBndrKind GhcRn -> TcM ()
    check_hs_bndr_kind Name
    name (TyVar -> Type
    tyVarKind TyVar
    tv) HsBndrKind GhcRn
    kind
               ; TyVar -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return TyVar
    tv }
          | Bool
    otherwise
          = do { name <- HsBndrVar GhcRn -> TcM Name
    tcHsBndrVarName HsBndrVar GhcRn
    bvar
               ; kind' <- tc_hs_bndr_kind name kind
               ; newTyVarBndr skol_mode name kind' }

        tc_hs_bndr_kind :: Name -> HsBndrKind GhcRn -> TcM Kind
        tc_hs_bndr_kind :: Name -> HsBndrKind GhcRn -> TcM Type
    tc_hs_bndr_kind Name
    _    (HsBndrNoKind XBndrNoKind GhcRn
    _)    = ContextKind -> TcM Type
    newExpectedKind ContextKind
    ctxt_kind
        tc_hs_bndr_kind Name
    name (HsBndrKind XBndrKind GhcRn
    _ LHsType GhcRn
    kind) = TcTyMode -> UserTypeCtxt -> LHsType GhcRn -> TcM Type
    tc_lhs_kind_sig TcTyMode
    tc_ki_mode (Name -> UserTypeCtxt
    TyVarBndrKindCtxt Name
    name) LHsType GhcRn
    kind

        -- Check the HsBndrKind against the kind of the parent type variable,
        -- e.g. the following is rejected:
        --   class C (m :: * -> *) where
        --     type F (m :: *) = ...
        check_hs_bndr_kind :: Name -> Kind -> HsBndrKind GhcRn -> TcM ()
        check_hs_bndr_kind :: Name -> Type -> HsBndrKind GhcRn -> TcM ()
    check_hs_bndr_kind Name
    _    Type
    _           (HsBndrNoKind XBndrNoKind GhcRn
    _)    = () -> TcM ()
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
        check_hs_bndr_kind Name
    name Type
    parent_kind (HsBndrKind XBndrKind GhcRn
    _ LHsType GhcRn
    kind) =
          do { kind' <- TcTyMode -> UserTypeCtxt -> LHsType GhcRn -> TcM Type
    tc_lhs_kind_sig TcTyMode
    tc_ki_mode (Name -> UserTypeCtxt
    TyVarBndrKindCtxt Name
    name) LHsType GhcRn
    kind
             ; discardResult $
               unifyKind (Just $ NameThing name) kind' parent_kind }

    tcHsBndrVarName :: HsBndrVar GhcRn -> TcM Name
    tcHsBndrVarName :: HsBndrVar GhcRn -> TcM Name
    tcHsBndrVarName (HsBndrVar XBndrVar GhcRn
    _ (L SrcSpanAnnN
    _ Name
    name)) = Name -> TcM Name
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name
    tcHsBndrVarName (HsBndrWildCard XBndrWildCard GhcRn
    _) = OccName -> TcM Name
    forall gbl lcl. OccName -> TcRnIf gbl lcl Name
    newSysName (String -> OccName
    mkTyVarOcc String
    "_")

    mk_tvb_pairs :: HsTyVarBndr flag GhcRn -> TcTyVar -> [(Name, TcTyVar)]
    mk_tvb_pairs :: forall flag. HsTyVarBndr flag GhcRn -> TyVar -> [(Name, TyVar)]
    mk_tvb_pairs HsTyVarBndr flag GhcRn
    tvb TyVar
    tv =
      case HsTyVarBndr flag GhcRn -> Maybe (IdP GhcRn)
    forall flag (p :: Pass).
    HsTyVarBndr flag (GhcPass p) -> Maybe (IdP (GhcPass p))
    hsTyVarName HsTyVarBndr flag GhcRn
    tvb of
        Maybe (IdP GhcRn)
    Nothing -> []
        Just IdP GhcRn
    nm -> [(IdP GhcRn
    Name
    nm, TyVar
    tv)]

    newTyVarBndr :: SkolemMode -> Name -> Kind -> TcM TcTyVar
    newTyVarBndr :: SkolemMode -> Name -> Type -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    newTyVarBndr (SM { sm_clone :: SkolemMode -> Bool
    sm_clone = Bool
    clone, sm_tvtv :: SkolemMode -> SkolemModeDetails
    sm_tvtv = SkolemModeDetails
    tvtv }) Name
    name Type
    kind
      = do { name <- case Bool
    clone of
                  Bool
    True -> do { uniq <- TcRnIf TcGblEnv TcLclEnv Unique
    forall gbl lcl. TcRnIf gbl lcl Unique
    newUnique
                             ; return (setNameUnique name uniq) }
                  Bool
    False -> Name -> TcM Name
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    name
           ; details <- case tvtv of
                     SkolemModeDetails
    SMDTyVarTv  -> MetaInfo -> TcM TcTyVarDetails
    newMetaDetails MetaInfo
    TyVarTv
                     SMDSkolemTv SkolemInfo
    skol_info ->
                      do { lvl <- TcM TcLevel
    getTcLevel
                         ; return (SkolemTv skol_info lvl False) }
           ; return (mkTcTyVar name kind details) }

    --------------------------------------
    --    Implicit tyvar binders
    --------------------------------------

    tcImplicitTKBndrsX :: SkolemMode -> SkolemInfo
                       -> [Name]
                       -> TcM a
                       -> TcM ([TcTyVar], a)
    -- The workhorse:
    --    push level, capture constraints, and emit an implication constraint
    tcImplicitTKBndrsX :: forall a.
    SkolemMode -> SkolemInfo -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    tcImplicitTKBndrsX SkolemMode
    skol_mode SkolemInfo
    skol_info HsQTvsRn
    bndrs TcM a
    thing_inside
      | HsQTvsRn -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null HsQTvsRn
    bndrs  -- Short-cut the common case with no quantifiers
                    -- E.g. f :: Int -> Int
                    --      makes a HsOuterImplicit with empty bndrs,
                    --      and tcOuterTKBndrsX goes via here
      = do { res <- TcM a
    thing_inside; return ([], res) }
      | Bool
    otherwise
      = do { (tclvl, wanted, (skol_tvs, res))
                 <- IOEnv (Env TcGblEnv TcLclEnv) ([TyVar], a)
    -> TcM (TcLevel, WantedConstraints, ([TyVar], a))
    forall a. TcM a -> TcM (TcLevel, WantedConstraints, a)
    pushLevelAndCaptureConstraints       (IOEnv (Env TcGblEnv TcLclEnv) ([TyVar], a)
     -> TcM (TcLevel, WantedConstraints, ([TyVar], a)))
    -> IOEnv (Env TcGblEnv TcLclEnv) ([TyVar], a)
    -> TcM (TcLevel, WantedConstraints, ([TyVar], a))
    forall a b. (a -> b) -> a -> b
    $
                    SkolemMode
    -> HsQTvsRn -> TcM a -> IOEnv (Env TcGblEnv TcLclEnv) ([TyVar], a)
    forall a. SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrsX SkolemMode
    skol_mode HsQTvsRn
    bndrs (TcM a -> IOEnv (Env TcGblEnv TcLclEnv) ([TyVar], a))
    -> TcM a -> IOEnv (Env TcGblEnv TcLclEnv) ([TyVar], a)
    forall a b. (a -> b) -> a -> b
    $
                    TcM a
    thing_inside

           ; emitResidualTvConstraint skol_info skol_tvs tclvl wanted

           ; return (skol_tvs, res) }

    ------------------
    bindImplicitTKBndrs_Skol,
      bindImplicitTKBndrs_Q_Skol :: SkolemInfo -> [Name] -> TcM a -> TcM ([TcTyVar], a)

    bindImplicitTKBndrs_Tv, bindImplicitTKBndrs_Q_Tv :: [Name] -> TcM a -> TcM ([TcTyVar], a)
    bindImplicitTKBndrs_Skol :: forall a. SkolemInfo -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrs_Skol SkolemInfo
    skol_info = SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    forall a. SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = True, sm_tvtv = SMDSkolemTv skol_info })
    bindImplicitTKBndrs_Tv :: forall a. HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrs_Tv   = SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    forall a. SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = True, sm_tvtv = SMDTyVarTv })
    bindImplicitTKBndrs_Q_Skol :: forall a. SkolemInfo -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrs_Q_Skol SkolemInfo
    skol_info = SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    forall a. SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_parent = True, sm_tvtv = SMDSkolemTv skol_info })
    bindImplicitTKBndrs_Q_Tv :: forall a. HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrs_Q_Tv = SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    forall a. SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrsX (SkolemMode
    HasDebugCallStack => SkolemMode
    smVanilla { sm_clone = False, sm_parent = True, sm_tvtv = SMDTyVarTv })

    bindImplicitTKBndrsX
       :: SkolemMode
       -> [Name]               -- Generated by renamer; not in dependency order
       -> TcM a
       -> TcM ([TcTyVar], a)   -- Returned [TcTyVar] are in 1-1 correspondence
                               -- with the passed in [Name]
    bindImplicitTKBndrsX :: forall a. SkolemMode -> HsQTvsRn -> TcM a -> TcM ([TyVar], a)
    bindImplicitTKBndrsX skol_mode :: SkolemMode
    skol_mode@(SM { sm_parent :: SkolemMode -> Bool
    sm_parent = Bool
    check_parent, sm_kind :: SkolemMode -> ContextKind
    sm_kind = ContextKind
    ctxt_kind })
                         HsQTvsRn
    tv_names TcM a
    thing_inside
      = do { lcl_env <- TcM (NameEnv TcTyThing)
    getLclTypeEnv
           ; tkvs <- mapM (new_tv lcl_env) tv_names
           ; traceTc "bindImplicitTKBndrsX" (ppr tv_names $$ ppr tkvs)
           ; res <- tcExtendNameTyVarEnv (tv_names `zip` tkvs)
                    thing_inside
           ; return (tkvs, res) }
      where
        new_tv :: NameEnv TcTyThing -> Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    new_tv NameEnv TcTyThing
    lcl_env Name
    name
          | Bool
    check_parent
          , Just (ATyVar Name
    _ TyVar
    tv) <- NameEnv TcTyThing -> Name -> Maybe TcTyThing
    forall a. NameEnv a -> Name -> Maybe a
    lookupNameEnv NameEnv TcTyThing
    lcl_env Name
    name
          = TyVar -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return TyVar
    tv
          | Bool
    otherwise
          = do { kind <- ContextKind -> TcM Type
    newExpectedKind ContextKind
    ctxt_kind
               ; newTyVarBndr skol_mode name kind }

    --------------------------------------
    --           SkolemMode
    --------------------------------------

    -- | 'SkolemMode' describes how to typecheck an explicit ('HsTyVarBndr') or
    -- implicit ('Name') binder in a type. It is just a record of flags
    -- that describe what sort of 'TcTyVar' to create.
    data SkolemMode
      = SM { SkolemMode -> Bool
    sm_parent :: Bool    -- True <=> check the in-scope parent type variable
                                  -- Used only for asssociated types

           , SkolemMode -> Bool
    sm_clone  :: Bool    -- True <=> fresh unique
                                  -- See Note [Cloning for type variable binders]

           , SkolemMode -> SkolemModeDetails
    sm_tvtv   :: SkolemModeDetails    -- True <=> use a TyVarTv, rather than SkolemTv
                                  -- Why?  See Note [Inferring kinds for type declarations]
                                  -- in GHC.Tc.TyCl, and (in this module)
                                  -- Note [Checking partial type signatures]

           , SkolemMode -> ContextKind
    sm_kind   :: ContextKind  -- Use this for the kind of any new binders

           , SkolemMode -> HoleInfo
    sm_holes  :: HoleInfo     -- What to do for wildcards in the kind
           }

    data SkolemModeDetails
      = SMDTyVarTv
      | SMDSkolemTv SkolemInfo

    smVanilla :: HasDebugCallStack => SkolemMode
    smVanilla :: HasDebugCallStack => SkolemMode
    smVanilla = SM { sm_clone :: Bool
    sm_clone  = String -> Bool
    forall a. HasCallStack => String -> a
    panic String
    "sm_clone"  -- We always override this
                   , sm_parent :: Bool
    sm_parent = Bool
    False
                   , sm_tvtv :: SkolemModeDetails
    sm_tvtv   = String -> SDoc -> SkolemModeDetails
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "sm_tvtv" SDoc
    HasCallStack => SDoc
    callStackDoc -- We always override this
                   , sm_kind :: ContextKind
    sm_kind   = ContextKind
    AnyKind
                   , sm_holes :: HoleInfo
    sm_holes  = HoleInfo
    forall a. Maybe a
    Nothing }

    {- Note [Cloning for type variable binders]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Sometimes we must clone the Name of a type variable binder (written in
    the source program); and sometimes we must not. This is controlled by
    the sm_clone field of SkolemMode.

    In some cases it doesn't matter whether or not we clone. Perhaps
    it'd be better to use MustClone/MayClone/MustNotClone.

    When we /must not/ clone
    * In the binders of a type signature (tcOuterTKBndrs)
          f :: forall a{27}. blah
          f = rhs
      Then 'a' scopes over 'rhs'. When we kind-check the signature (tcHsSigType),
      we must get the type (forall a{27}. blah) for the Id f, because
      we bring that type variable into scope when we typecheck 'rhs'.

    * In the binders of a data family instance (bindOuterFamEqnTKBndrs)
         data instance
           forall p q. D (p,q) = D1 p | D2 q
      We kind-check the LHS in tcDataFamInstHeader, and then separately
      (in tcDataFamInstDecl) bring p,q into scope before looking at the
      the constructor decls.

    * bindExplicitTKBndrs_Q_Tv/bindImplicitTKBndrs_Q_Tv do not clone
      We take advantage of this in kcInferDeclHeader:
         all_tv_prs = mkTyVarNamePairs (scoped_kvs ++ tc_tvs)
      If we cloned, we'd need to take a bit more care here; not hard.

    * bindExplicitTKBndrs_Q_Skol, bindExplicitTKBndrs_Skol, do not clone.
      There is no need, I think.

      The payoff here is that avoiding gratuitous cloning means that we can
      almost always take the fast path in swizzleTcTyConBndrs.

    When we /must/ clone.
    * bindOuterSigTKBndrs_Tv, bindExplicitTKBndrs_Tv do cloning

      This for a narrow and tricky reason which, alas, I couldn't find a
      simpler way round.  #16221 is the poster child:

         data SameKind :: k -> k -> *
         data T a = forall k2 (b :: k2). MkT (SameKind a b) !Int

      When kind-checking T, we give (a :: kappa1). Then:

      - In kcConDecl we make a TyVarTv unification variable kappa2 for k2
        (as described in Note [Using TyVarTvs for kind-checking GADTs],
        even though this example is an existential)
      - So we get (b :: kappa2) via bindExplicitTKBndrs_Tv
      - We end up unifying kappa1 := kappa2, because of the (SameKind a b)

      Now we generalise over kappa2. But if kappa2's Name is precisely k2
      (i.e. we did not clone) we'll end up giving T the utterly final kind
        T :: forall k2. k2 -> *
      Nothing directly wrong with that but when we typecheck the data constructor
      we have k2 in scope; but then it's brought into scope /again/ when we find
      the forall k2.  This is chaotic, and we end up giving it the type
        MkT :: forall k2 (a :: k2) k2 (b :: k2).
               SameKind @k2 a b -> Int -> T @{k2} a
      which is bogus -- because of the shadowing of k2, we can't
      apply T to the kind or a!

      And there no reason /not/ to clone the Name when making a unification
      variable.  So that's what we do.
    -}

    --------------------------------------
    -- Binding type/class variables in the
    -- kind-checking and typechecking phases
    --------------------------------------

    bindTyClTyVars :: Name -> ([TcTyConBinder] -> TcKind -> TcM a) -> TcM a
    -- ^ Bring into scope the binders of a PolyTcTyCon
    -- Used for the type variables of a type or class decl
    -- in the "kind checking" and "type checking" pass,
    -- but not in the initial-kind run.
    bindTyClTyVars :: forall a. Name -> ([TyConBinder] -> Type -> TcM a) -> TcM a
    bindTyClTyVars Name
    tycon_name [TyConBinder] -> Type -> TcM a
    thing_inside
      = do { tycon <- HasDebugCallStack => Name -> TcM TyCon
    Name -> TcM TyCon
    tcLookupTcTyCon Name
    tycon_name     -- The tycon is a PolyTcTyCon
           ; let res_kind   = TyCon -> Type
    tyConResKind TyCon
    tycon
                 binders    = TyCon -> [TyConBinder]
    tyConBinders TyCon
    tycon
           ; traceTc "bindTyClTyVars" (ppr tycon_name $$ ppr binders)
           ; tcExtendTyVarEnv (binderVars binders) $
             thing_inside binders res_kind }

    bindTyClTyVarsAndZonk :: Name -> ([TyConBinder] -> Kind -> TcM a) -> TcM a
    -- Like bindTyClTyVars, but in addition
    -- zonk the skolem TcTyVars of a PolyTcTyCon to TyVars
    -- We always do this same zonking after a call to bindTyClTyVars, but
    -- here we do it right away because there are no more unifications to come
    bindTyClTyVarsAndZonk :: forall a. Name -> ([TyConBinder] -> Type -> TcM a) -> TcM a
    bindTyClTyVarsAndZonk Name
    tycon_name [TyConBinder] -> Type -> TcM a
    thing_inside
      = Name -> ([TyConBinder] -> Type -> TcM a) -> TcM a
    forall a. Name -> ([TyConBinder] -> Type -> TcM a) -> TcM a
    bindTyClTyVars Name
    tycon_name (([TyConBinder] -> Type -> TcM a) -> TcM a)
    -> ([TyConBinder] -> Type -> TcM a) -> TcM a
    forall a b. (a -> b) -> a -> b
    $ \ [TyConBinder]
    tc_bndrs Type
    tc_kind ->
        do { (bndrs, kind) <- ZonkFlexi
    -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) ([TyConBinder], Type)
    -> TcM ([TyConBinder], Type)
    forall (m :: * -> *) b. MonadIO m => ZonkFlexi -> ZonkT m b -> m b
    initZonkEnv ZonkFlexi
    NoFlexi (ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) ([TyConBinder], Type)
     -> TcM ([TyConBinder], Type))
    -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) ([TyConBinder], Type)
    -> TcM ([TyConBinder], Type)
    forall a b. (a -> b) -> a -> b
    $
              ZonkBndrT (IOEnv (Env TcGblEnv TcLclEnv)) [TyConBinder]
    -> forall r.
       ([TyConBinder] -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) r)
       -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) r
    forall (m :: * -> *) a.
    ZonkBndrT m a -> forall r. (a -> ZonkT m r) -> ZonkT m r
    runZonkBndrT ([TyConBinder]
    -> ZonkBndrT (IOEnv (Env TcGblEnv TcLclEnv)) [TyConBinder]
    forall vis. [VarBndr TyVar vis] -> ZonkBndrTcM [VarBndr TyVar vis]
    zonkTyVarBindersX [TyConBinder]
    tc_bndrs) (([TyConBinder]
      -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) ([TyConBinder], Type))
     -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) ([TyConBinder], Type))
    -> ([TyConBinder]
        -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) ([TyConBinder], Type))
    -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) ([TyConBinder], Type)
    forall a b. (a -> b) -> a -> b
    $ \ [TyConBinder]
    bndrs ->
                do { kind <- Type -> ZonkT (IOEnv (Env TcGblEnv TcLclEnv)) Type
    zonkTcTypeToTypeX Type
    tc_kind
                   ; return (bndrs, kind) }
           ; thing_inside bndrs kind }

    {- *********************************************************************
    *                                                                      *
                 Kind generalisation
    *                                                                      *
    ********************************************************************* -}

    zonkAndScopedSort :: [TcTyVar] -> TcM [TcTyVar]
    zonkAndScopedSort :: [TyVar] -> TcM [TyVar]
    zonkAndScopedSort [TyVar]
    spec_tkvs
      = do { spec_tkvs <- ZonkM [TyVar] -> TcM [TyVar]
    forall a. ZonkM a -> TcM a
    liftZonkM (ZonkM [TyVar] -> TcM [TyVar]) -> ZonkM [TyVar] -> TcM [TyVar]
    forall a b. (a -> b) -> a -> b
    $ [TyVar] -> ZonkM [TyVar]
    HasDebugCallStack => [TyVar] -> ZonkM [TyVar]
    zonkTcTyVarsToTcTyVars [TyVar]
    spec_tkvs
             -- Zonk the kinds, to we can do the dependency analysis

           -- Do a stable topological sort, following
           -- Note [Ordering of implicit variables] in GHC.Rename.HsType
           ; return (scopedSort spec_tkvs) }

    -- | Generalize some of the free variables in the given type.
    -- All such variables should be *kind* variables; any type variables
    -- should be explicitly quantified (with a `forall`) before now.
    --
    -- The WantedConstraints are un-solved kind constraints. Generally
    -- they'll be reported as errors later, but meanwhile we refrain
    -- from quantifying over any variable free in these unsolved
    -- constraints. See Note [Failure in local type signatures].
    --
    -- But in all cases, generalize only those variables whose TcLevel is
    -- strictly greater than the ambient level. This "strictly greater
    -- than" means that you likely need to push the level before creating
    -- whatever type gets passed here.
    --
    -- Any variable whose level is greater than the ambient level but is
    -- not selected to be generalized will be promoted. (See [Promoting
    -- unification variables] in "GHC.Tc.Solver" and Note [Recipe for
    -- checking a signature].)
    --
    -- The resulting KindVar are the variables to quantify over, in the
    -- correct, well-scoped order. They should generally be Inferred, not
    -- Specified, but that's really up to the caller of this function.
    kindGeneralizeSome :: SkolemInfo
                       -> WantedConstraints
                       -> TcType    -- ^ needn't be zonked
                       -> TcM [KindVar]
    kindGeneralizeSome :: SkolemInfo -> WantedConstraints -> Type -> TcM [TyVar]
    kindGeneralizeSome SkolemInfo
    skol_info WantedConstraints
    wanted Type
    kind_or_type
      = do { -- Use the "Kind" variant here, as any types we see
             -- here will already have all type variables quantified;
             -- thus, every free variable is really a kv, never a tv.
           ; dvs <- Type -> TcM CandidatesQTvs
    candidateQTyVarsOfKind Type
    kind_or_type
           ; filtered_dvs <- filterConstrainedCandidates wanted dvs
           ; traceTc "kindGeneralizeSome" $
             vcat [ text "type:" <+> ppr kind_or_type
                  , text "dvs:" <+> ppr dvs
                  , text "filtered_dvs:" <+> ppr filtered_dvs ]
           ; quantifyTyVars skol_info DefaultNonStandardTyVars filtered_dvs }

    filterConstrainedCandidates
      :: WantedConstraints    -- Don't quantify over variables free in these
                              --   Not necessarily fully zonked
      -> CandidatesQTvs       -- Candidates for quantification
      -> TcM CandidatesQTvs
    -- filterConstrainedCandidates removes any candidates that are free in
    -- 'wanted'; instead, it promotes them.  This bit is very much like
    -- decidePromotedTyVars in GHC.Tc.Solver, but constraints are so much
    -- simpler in kinds, it is much easier here. (In particular, we never
    -- quantify over a constraint in a type.)
    filterConstrainedCandidates :: WantedConstraints -> CandidatesQTvs -> TcM CandidatesQTvs
    filterConstrainedCandidates WantedConstraints
    wanted CandidatesQTvs
    dvs
      | WantedConstraints -> Bool
    isEmptyWC WantedConstraints
    wanted   -- Fast path for a common case
      = CandidatesQTvs -> TcM CandidatesQTvs
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return CandidatesQTvs
    dvs
      | Bool
    otherwise
      = do { wc_tvs <- ZonkM TyVarSet -> TcM TyVarSet
    forall a. ZonkM a -> TcM a
    liftZonkM (ZonkM TyVarSet -> TcM TyVarSet) -> ZonkM TyVarSet -> TcM TyVarSet
    forall a b. (a -> b) -> a -> b
    $ TyVarSet -> ZonkM TyVarSet
    zonkTyCoVarsAndFV (WantedConstraints -> TyVarSet
    tyCoVarsOfWC WantedConstraints
    wanted)
           ; let (to_promote, dvs') = partitionCandidates dvs (`elemVarSet` wc_tvs)
           ; _ <- promoteTyVarSet to_promote
           ; return dvs' }

    -- |- Specialised version of 'kindGeneralizeSome', but with empty
    -- WantedConstraints, so no filtering is needed
    -- i.e.   kindGeneraliseAll = kindGeneralizeSome emptyWC
    kindGeneralizeAll :: SkolemInfo -> TcType -> TcM [KindVar]
    kindGeneralizeAll :: SkolemInfo -> Type -> TcM [TyVar]
    kindGeneralizeAll SkolemInfo
    skol_info Type
    kind_or_type
      = do { String -> SDoc -> TcM ()
    traceTc String
    "kindGeneralizeAll" (Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    kind_or_type)
           ; dvs <- Type -> TcM CandidatesQTvs
    candidateQTyVarsOfKind Type
    kind_or_type
           ; quantifyTyVars skol_info DefaultNonStandardTyVars dvs }

    -- | Specialized version of 'kindGeneralizeSome', but where no variables
    -- can be generalized, but perhaps some may need to be promoted.
    -- Use this variant when it is unknowable whether metavariables might
    -- later be constrained.
    --
    -- To see why this promotion is needed, see
    -- Note [Recipe for checking a signature], and especially
    -- Note [Promotion in signatures].
    kindGeneralizeNone :: TcType  -- needn't be zonked
                       -> TcM ()
    kindGeneralizeNone :: Type -> TcM ()
    kindGeneralizeNone Type
    kind_or_type
      = do { String -> SDoc -> TcM ()
    traceTc String
    "kindGeneralizeNone" (Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    kind_or_type)
           ; dvs <- Type -> TcM CandidatesQTvs
    candidateQTyVarsOfKind Type
    kind_or_type
           ; _ <- promoteTyVarSet (candidateKindVars dvs)
           ; return () }

    {- Note [Levels and generalisation]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
      f x = e
    with no type signature. We are currently at level i.
    We must
      * Push the level to level (i+1)
      * Allocate a fresh alpha[i+1] for the result type
      * Check that e :: alpha[i+1], gathering constraint WC
      * Solve WC as far as possible
      * Zonking the result type alpha[i+1], say to beta[i-1] -> gamma[i]
      * Find the free variables with level > i, in this case gamma[i]
      * Skolemise those free variables and quantify over them, giving
           f :: forall g. beta[i-1] -> g
      * Emit the residual constraint wrapped in an implication for g,
        thus   forall g. WC

    All of this happens for types too.  Consider
      f :: Int -> (forall a. Proxy a -> Int)

    Note [Kind generalisation]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~
    We do kind generalisation only at the outer level of a type signature.
    For example, consider
      T :: forall k. k -> *
      f :: (forall a. T a -> Int) -> Int
    When kind-checking f's type signature we generalise the kind at
    the outermost level, thus:
      f1 :: forall k. (forall (a:k). T k a -> Int) -> Int  -- YES!
    and *not* at the inner forall:
      f2 :: (forall k. forall (a:k). T k a -> Int) -> Int  -- NO!
    Reason: same as for HM inference on value level declarations,
    we want to infer the most general type.  The f2 type signature
    would be *less applicable* than f1, because it requires a more
    polymorphic argument.

    NB: There are no explicit kind variables written in f's signature.
    When there are, the renamer adds these kind variables to the list of
    variables bound by the forall, so you can indeed have a type that's
    higher-rank in its kind. But only by explicit request.

    Note [Kinds of quantified type variables]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    tcTyVarBndrsGen quantifies over a specified list of type variables,
    *and* over the kind variables mentioned in the kinds of those tyvars.

    Note that we must zonk those kinds (obviously) but less obviously, we
    must return type variables whose kinds are zonked too. Example
        (a :: k7)  where  k7 := k9 -> k9
    We must return
        [k9, a:k9->k9]
    and NOT
        [k9, a:k7]
    Reason: we're going to turn this into a for-all type,
       forall k9. forall (a:k7). blah
    which the type checker will then instantiate, and instantiate does not
    look through unification variables!

    Hence using zonked_kinds when forming tvs'.

    -}

    -----------------------------------
    maybeEtaExpandAlgTyCon :: TyConFlavour tc  -> SkolemInfo
                      -> [TcTyConBinder] -> Kind
                      -> TcM ([TcTyConBinder], Kind)
    maybeEtaExpandAlgTyCon :: forall tc.
    TyConFlavour tc
    -> SkolemInfo -> [TyConBinder] -> Type -> TcM ([TyConBinder], Type)
    maybeEtaExpandAlgTyCon TyConFlavour tc
    flav SkolemInfo
    skol_info [TyConBinder]
    tcbs Type
    res_kind
      | TyConFlavour tc -> Bool
    forall tc. TyConFlavour tc -> Bool
    needsEtaExpansion TyConFlavour tc
    flav
      = SkolemInfo -> [TyConBinder] -> Type -> TcM ([TyConBinder], Type)
    etaExpandAlgTyCon SkolemInfo
    skol_info [TyConBinder]
    tcbs Type
    res_kind
      | Bool
    otherwise
      = ([TyConBinder], Type) -> TcM ([TyConBinder], Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([], Type
    res_kind)

    etaExpandAlgTyCon :: SkolemInfo
                      -> [TcTyConBinder] -> Kind
                      -> TcM ([TcTyConBinder], Kind)
    etaExpandAlgTyCon :: SkolemInfo -> [TyConBinder] -> Type -> TcM ([TyConBinder], Type)
    etaExpandAlgTyCon SkolemInfo
    skol_info [TyConBinder]
    tcbs Type
    res_kind
      = SkolemInfo
    -> InScopeSet -> [OccName] -> Type -> TcM ([TyConBinder], Type)
    splitTyConKind SkolemInfo
    skol_info InScopeSet
    in_scope [OccName]
    avoid_occs Type
    res_kind
      where
        tyvars :: [TyVar]
    tyvars     = [TyConBinder] -> [TyVar]
    forall tv argf. [VarBndr tv argf] -> [tv]
    binderVars [TyConBinder]
    tcbs
        in_scope :: InScopeSet
    in_scope   = [TyVar] -> InScopeSet
    mkInScopeSetList [TyVar]
    tyvars
        avoid_occs :: [OccName]
    avoid_occs = (TyVar -> OccName) -> [TyVar] -> [OccName]
    forall a b. (a -> b) -> [a] -> [b]
    map TyVar -> OccName
    forall a. NamedThing a => a -> OccName
    getOccName [TyVar]
    tyvars

    needsEtaExpansion :: TyConFlavour tc -> Bool
    needsEtaExpansion :: forall tc. TyConFlavour tc -> Bool
    needsEtaExpansion TyConFlavour tc
    NewtypeFlavour  = Bool
    True
    needsEtaExpansion TyConFlavour tc
    DataTypeFlavour = Bool
    True
    needsEtaExpansion TyConFlavour tc
    ClassFlavour    = Bool
    True
    needsEtaExpansion TyConFlavour tc
    _               = Bool
    False

    splitTyConKind :: SkolemInfo
                   -> InScopeSet
                   -> [OccName]  -- Avoid these OccNames
                   -> Kind       -- Must be zonked
                   -> TcM ([TcTyConBinder], TcKind)
    -- GADT decls can have a (perhaps partial) kind signature
    --      e.g.  data T a :: * -> * -> * where ...
    -- This function makes up suitable (kinded) TyConBinders for the
    -- argument kinds.  E.g. in this case it might return
    --   ([b::*, c::*], *)
    -- Skolemises the type as it goes, returning skolem TcTyVars
    -- Never emits constraints.
    -- It's a little trickier than you might think: see Note [splitTyConKind]
    -- See also Note [Datatype return kinds] in GHC.Tc.TyCl
    splitTyConKind :: SkolemInfo
    -> InScopeSet -> [OccName] -> Type -> TcM ([TyConBinder], Type)
    splitTyConKind SkolemInfo
    skol_info InScopeSet
    in_scope [OccName]
    avoid_occs Type
    kind
      = do  { loc     <- TcRn SrcSpan
    getSrcSpanM
            ; new_uniqs <- getUniquesM
            ; rdr_env <- getLocalRdrEnv
            ; lvl     <- getTcLevel
            ; let new_occs = (OccName -> Bool) -> Infinite OccName -> Infinite OccName
    forall a. (a -> Bool) -> Infinite a -> Infinite a
    Inf.filter (\ OccName
    occ ->
                      Maybe Name -> Bool
    forall a. Maybe a -> Bool
    isNothing (LocalRdrEnv -> OccName -> Maybe Name
    lookupLocalRdrOcc LocalRdrEnv
    rdr_env OccName
    occ) Bool -> Bool -> Bool
    &&
                      -- Note [Avoid name clashes for associated data types]
                      Bool -> Bool
    not (OccName
    occ OccName -> [OccName] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [OccName]
    avoid_occs)) (Infinite OccName -> Infinite OccName)
    -> Infinite OccName -> Infinite OccName
    forall a b. (a -> b) -> a -> b
    $ NameSpace -> String -> OccName
    mkOccName NameSpace
    tvName (String -> OccName) -> Infinite String -> Infinite OccName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Infinite String
    allNameStrings
                  subst = InScopeSet -> Subst
    mkEmptySubst InScopeSet
    in_scope
                  details = SkolemInfo -> TcLevel -> Bool -> TcTyVarDetails
    SkolemTv SkolemInfo
    skol_info (TcLevel -> TcLevel
    pushTcLevel TcLevel
    lvl) Bool
    False
                            -- As always, allocate skolems one level in

                  go Infinite OccName
    occs [Unique]
    uniqs Subst
    subst [TyConBinder]
    acc Type
    kind
                    = case Type -> Maybe (PiTyVarBinder, Type)
    splitPiTy_maybe Type
    kind of
                        Maybe (PiTyVarBinder, Type)
    Nothing -> ([TyConBinder] -> [TyConBinder]
    forall a. [a] -> [a]
    reverse [TyConBinder]
    acc, HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst Type
    kind)

                        Just (Anon Scaled Type
    arg FunTyFlag
    af, Type
    kind')
                          -> Bool -> ([TyConBinder], Type) -> ([TyConBinder], Type)
    forall a. HasCallStack => Bool -> a -> a
    assert (FunTyFlag
    af FunTyFlag -> FunTyFlag -> Bool
    forall a. Eq a => a -> a -> Bool
    == FunTyFlag
    FTF_T_T) (([TyConBinder], Type) -> ([TyConBinder], Type))
    -> ([TyConBinder], Type) -> ([TyConBinder], Type)
    forall a b. (a -> b) -> a -> b
    $
                             Infinite OccName
    -> [Unique]
    -> Subst
    -> [TyConBinder]
    -> Type
    -> ([TyConBinder], Type)
    go Infinite OccName
    occs' [Unique]
    uniqs' Subst
    subst' (TyConBinder
    tcb TyConBinder -> [TyConBinder] -> [TyConBinder]
    forall a. a -> [a] -> [a]
    : [TyConBinder]
    acc) Type
    kind'
                          where
                            tcb :: TyConBinder
    tcb    = TyVar -> TyConBndrVis -> TyConBinder
    forall var argf. var -> argf -> VarBndr var argf
    Bndr TyVar
    tv TyConBndrVis
    AnonTCB
                            arg' :: Type
    arg'   = HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst (Scaled Type -> Type
    forall a. Scaled a -> a
    scaledThing Scaled Type
    arg)
                            name :: Name
    name   = Unique -> OccName -> SrcSpan -> Name
    mkInternalName Unique
    uniq OccName
    occ SrcSpan
    loc
                            tv :: TyVar
    tv     = Name -> Type -> TcTyVarDetails -> TyVar
    mkTcTyVar Name
    name Type
    arg' TcTyVarDetails
    details
                            subst' :: Subst
    subst' = Subst -> TyVar -> Subst
    extendSubstInScope Subst
    subst TyVar
    tv
                            (Unique
    uniq,[Unique]
    uniqs') = case [Unique]
    uniqs of
                                Unique
    uniq:[Unique]
    uniqs' -> (Unique
    uniq,[Unique]
    uniqs')
                                [Unique]
    _           -> String -> (Unique, [Unique])
    forall a. HasCallStack => String -> a
    panic String
    "impossible"
                            Inf OccName
    occ Infinite OccName
    occs' = Infinite OccName
    occs

                        Just (Named (Bndr TyVar
    tv ForAllTyFlag
    vis), Type
    kind')
                          -> Infinite OccName
    -> [Unique]
    -> Subst
    -> [TyConBinder]
    -> Type
    -> ([TyConBinder], Type)
    go Infinite OccName
    occs [Unique]
    uniqs Subst
    subst' (TyConBinder
    tcb TyConBinder -> [TyConBinder] -> [TyConBinder]
    forall a. a -> [a] -> [a]
    : [TyConBinder]
    acc) Type
    kind'
                          where
                            tcb :: TyConBinder
    tcb           = TyVar -> TyConBndrVis -> TyConBinder
    forall var argf. var -> argf -> VarBndr var argf
    Bndr TyVar
    tv' (ForAllTyFlag -> TyConBndrVis
    NamedTCB ForAllTyFlag
    vis)
                            tc_tyvar :: TyVar
    tc_tyvar      = Name -> Type -> TcTyVarDetails -> TyVar
    mkTcTyVar (TyVar -> Name
    tyVarName TyVar
    tv) (TyVar -> Type
    tyVarKind TyVar
    tv) TcTyVarDetails
    details
                            (Subst
    subst', TyVar
    tv') = HasDebugCallStack => Subst -> TyVar -> (Subst, TyVar)
    Subst -> TyVar -> (Subst, TyVar)
    substTyVarBndr Subst
    subst TyVar
    tc_tyvar

            ; return (go new_occs new_uniqs subst [] kind) }

    isAllowedDataResKind :: AllowedDataResKind -> Kind -> Bool
    isAllowedDataResKind :: AllowedDataResKind -> Type -> Bool
    isAllowedDataResKind AllowedDataResKind
    AnyTYPEKind  Type
    kind = Type -> Bool
    isTypeLikeKind     Type
    kind
    isAllowedDataResKind AllowedDataResKind
    AnyBoxedKind Type
    kind = Type -> Bool
    tcIsBoxedTypeKind  Type
    kind
    isAllowedDataResKind AllowedDataResKind
    LiftedKind   Type
    kind = Type -> Bool
    tcIsLiftedTypeKind Type
    kind

    -- | Checks that the return kind in a data declaration's kind signature is
    -- permissible. There are three cases:
    --
    -- If dealing with a @data@, @newtype@, @data instance@, or @newtype instance@
    -- declaration, check that the return kind is @Type@.
    --
    -- If the declaration is a @newtype@ or @newtype instance@ and the
    -- @UnliftedNewtypes@ extension is enabled, this check is slightly relaxed so
    -- that a return kind of the form @TYPE r@ (for some @r@) is permitted.
    -- See @Note [Implementation of UnliftedNewtypes]@ in "GHC.Tc.TyCl".
    --
    -- If dealing with a @data family@ declaration, check that the return kind is
    -- either of the form:
    --
    -- 1. @TYPE r@ (for some @r@), or
    --
    -- 2. @k@ (where @k@ is a bare kind variable; see #12369)
    --
    -- See also Note [Datatype return kinds] in "GHC.Tc.TyCl"
    checkDataKindSig :: DataSort -> Kind  -- any arguments in the kind are stripped off
                     -> TcM ()
    checkDataKindSig :: DataSort -> Type -> TcM ()
    checkDataKindSig DataSort
    data_sort Type
    kind
      = do { dflags <- IOEnv (Env TcGblEnv TcLclEnv) DynFlags
    forall (m :: * -> *). HasDynFlags m => m DynFlags
    getDynFlags
           ; traceTc "checkDataKindSig" (ppr kind)
           ; checkTc (tYPE_ok dflags || is_kind_var)
                     (err_msg dflags) }
      where
        res_kind :: Type
    res_kind = ([PiTyVarBinder], Type) -> Type
    forall a b. (a, b) -> b
    snd (Type -> ([PiTyVarBinder], Type)
    tcSplitPiTys Type
    kind)
           -- Look for the result kind after
           -- peeling off any foralls and arrows

        is_newtype :: Bool
        is_newtype :: Bool
    is_newtype =
          case DataSort
    data_sort of
            DataDeclSort     NewOrData
    new_or_data -> NewOrData
    new_or_data NewOrData -> NewOrData -> Bool
    forall a. Eq a => a -> a -> Bool
    == NewOrData
    NewType
            DataInstanceSort NewOrData
    new_or_data -> NewOrData
    new_or_data NewOrData -> NewOrData -> Bool
    forall a. Eq a => a -> a -> Bool
    == NewOrData
    NewType
            DataSort
    DataFamilySort               -> Bool
    False

        is_datatype :: Bool
        is_datatype :: Bool
    is_datatype =
          case DataSort
    data_sort of
            DataDeclSort     NewOrData
    DataType -> Bool
    True
            DataInstanceSort NewOrData
    DataType -> Bool
    True
            DataSort
    _                         -> Bool
    False

        is_data_family :: Bool
        is_data_family :: Bool
    is_data_family =
          case DataSort
    data_sort of
            DataDeclSort{}     -> Bool
    False
            DataInstanceSort{} -> Bool
    False
            DataSort
    DataFamilySort     -> Bool
    True

        allowed_kind :: DynFlags -> AllowedDataResKind
        allowed_kind :: DynFlags -> AllowedDataResKind
    allowed_kind DynFlags
    dflags
          | Bool
    is_newtype Bool -> Bool -> Bool
    && Extension -> DynFlags -> Bool
    xopt Extension
    LangExt.UnliftedNewtypes DynFlags
    dflags
            -- With UnliftedNewtypes, we allow kinds other than Type, but they
            -- must still be of the form `TYPE r` since we don't want to accept
            -- Constraint or Nat.
            -- See Note [Implementation of UnliftedNewtypes] in GHC.Tc.TyCl.
          = AllowedDataResKind
    AnyTYPEKind
          | Bool
    is_data_family
            -- If this is a `data family` declaration, we don't need to check if
            -- UnliftedNewtypes is enabled, since data family declarations can
            -- have return kind `TYPE r` unconditionally (#16827).
          = AllowedDataResKind
    AnyTYPEKind
          | Bool
    is_datatype Bool -> Bool -> Bool
    && Extension -> DynFlags -> Bool
    xopt Extension
    LangExt.UnliftedDatatypes DynFlags
    dflags
            -- With UnliftedDatatypes, we allow kinds other than Type, but they
            -- must still be of the form `TYPE (BoxedRep l)`, so that we don't
            -- accept result kinds like `TYPE IntRep`.
            -- See Note [Implementation of UnliftedDatatypes] in GHC.Tc.TyCl.
          = AllowedDataResKind
    AnyBoxedKind
          | Bool
    otherwise
          = AllowedDataResKind
    LiftedKind

        tYPE_ok :: DynFlags -> Bool
        tYPE_ok :: DynFlags -> Bool
    tYPE_ok DynFlags
    dflags = AllowedDataResKind -> Type -> Bool
    isAllowedDataResKind (DynFlags -> AllowedDataResKind
    allowed_kind DynFlags
    dflags) Type
    res_kind

        -- In the particular case of a data family, permit a return kind of the
        -- form `:: k` (where `k` is a bare kind variable).
        is_kind_var :: Bool
        is_kind_var :: Bool
    is_kind_var | Bool
    is_data_family = Maybe (TyVar, Coercion) -> Bool
    forall a. Maybe a -> Bool
    isJust (Type -> Maybe (TyVar, Coercion)
    getCastedTyVar_maybe Type
    res_kind)
                    | Bool
    otherwise      = Bool
    False

        err_msg :: DynFlags -> TcRnMessage
        err_msg :: DynFlags -> TcRnMessage
    err_msg DynFlags
    dflags =
          DataSort
    -> AllowedDataResKind
    -> Type
    -> Maybe SuggestUnliftedTypes
    -> TcRnMessage
    TcRnInvalidReturnKind DataSort
    data_sort (DynFlags -> AllowedDataResKind
    allowed_kind DynFlags
    dflags) Type
    kind (DynFlags -> Maybe SuggestUnliftedTypes
    ext_hint DynFlags
    dflags)

        ext_hint :: DynFlags -> Maybe SuggestUnliftedTypes
    ext_hint DynFlags
    dflags
          | Type -> Bool
    isTypeLikeKind Type
    kind
          , Bool
    is_newtype
          , Bool -> Bool
    not (Extension -> DynFlags -> Bool
    xopt Extension
    LangExt.UnliftedNewtypes DynFlags
    dflags)
          = SuggestUnliftedTypes -> Maybe SuggestUnliftedTypes
    forall a. a -> Maybe a
    Just SuggestUnliftedTypes
    SuggestUnliftedNewtypes
          | Type -> Bool
    tcIsBoxedTypeKind Type
    kind
          , Bool
    is_datatype
          , Bool -> Bool
    not (Extension -> DynFlags -> Bool
    xopt Extension
    LangExt.UnliftedDatatypes DynFlags
    dflags)
          = SuggestUnliftedTypes -> Maybe SuggestUnliftedTypes
    forall a. a -> Maybe a
    Just SuggestUnliftedTypes
    SuggestUnliftedDatatypes
          | Bool
    otherwise
          = Maybe SuggestUnliftedTypes
    forall a. Maybe a
    Nothing

    -- | Checks that the result kind of a class is exactly `Constraint`, rejecting
    -- type synonyms and type families that reduce to `Constraint`. See #16826.
    checkClassKindSig :: Kind -> TcM ()
    checkClassKindSig :: Type -> TcM ()
    checkClassKindSig Type
    kind = Bool -> TcRnMessage -> TcM ()
    checkTc (Type -> Bool
    isConstraintKind Type
    kind) TcRnMessage
    err_msg
      where
        err_msg :: TcRnMessage
        err_msg :: TcRnMessage
    err_msg = Type -> TcRnMessage
    TcRnClassKindNotConstraint Type
    kind

    tcbVisibilities :: TyCon -> [Type] -> [TyConBndrVis]
    -- Result is in 1-1 correspondence with orig_args
    tcbVisibilities :: TyCon -> [Type] -> [TyConBndrVis]
    tcbVisibilities TyCon
    tc [Type]
    orig_args
      = Type -> Subst -> [Type] -> [TyConBndrVis]
    go (TyCon -> Type
    tyConKind TyCon
    tc) Subst
    init_subst [Type]
    orig_args
      where
        init_subst :: Subst
    init_subst = InScopeSet -> Subst
    mkEmptySubst (TyVarSet -> InScopeSet
    mkInScopeSet ([Type] -> TyVarSet
    tyCoVarsOfTypes [Type]
    orig_args))
        go :: Type -> Subst -> [Type] -> [TyConBndrVis]
    go Type
    _ Subst
    _ []
          = []

        go Type
    fun_kind Subst
    subst all_args :: [Type]
    all_args@(Type
    arg : [Type]
    args)
          | Just (PiTyVarBinder
    tcb, Type
    inner_kind) <- Type -> Maybe (PiTyVarBinder, Type)
    splitPiTy_maybe Type
    fun_kind
          = case PiTyVarBinder
    tcb of
              Anon Scaled Type
    _ FunTyFlag
    af           -> Bool -> [TyConBndrVis] -> [TyConBndrVis]
    forall a. HasCallStack => Bool -> a -> a
    assert (FunTyFlag
    af FunTyFlag -> FunTyFlag -> Bool
    forall a. Eq a => a -> a -> Bool
    == FunTyFlag
    FTF_T_T) ([TyConBndrVis] -> [TyConBndrVis])
    -> [TyConBndrVis] -> [TyConBndrVis]
    forall a b. (a -> b) -> a -> b
    $
                                     TyConBndrVis
    AnonTCB      TyConBndrVis -> [TyConBndrVis] -> [TyConBndrVis]
    forall a. a -> [a] -> [a]
    : Type -> Subst -> [Type] -> [TyConBndrVis]
    go Type
    inner_kind Subst
    subst  [Type]
    args
              Named (Bndr TyVar
    tv ForAllTyFlag
    vis) -> ForAllTyFlag -> TyConBndrVis
    NamedTCB ForAllTyFlag
    vis TyConBndrVis -> [TyConBndrVis] -> [TyConBndrVis]
    forall a. a -> [a] -> [a]
    : Type -> Subst -> [Type] -> [TyConBndrVis]
    go Type
    inner_kind Subst
    subst' [Type]
    args
                     where
                        subst' :: Subst
    subst' = Subst -> TyVar -> Type -> Subst
    extendTCvSubst Subst
    subst TyVar
    tv Type
    arg

          | Bool -> Bool
    not (Subst -> Bool
    isEmptyTCvSubst Subst
    subst)
          = Type -> Subst -> [Type] -> [TyConBndrVis]
    go (HasDebugCallStack => Subst -> Type -> Type
    Subst -> Type -> Type
    substTy Subst
    subst Type
    fun_kind) Subst
    init_subst [Type]
    all_args

          | Bool
    otherwise
          = String -> SDoc -> [TyConBndrVis]
    forall a. HasCallStack => String -> SDoc -> a
    pprPanic String
    "addTcbVisibilities" (TyCon -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr TyCon
    tc SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> [Type] -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [Type]
    orig_args)

    {- Note [splitTyConKind]
    ~~~~~~~~~~~~~~~~~~~~~~~~
    Given
      data T (a::*) :: * -> forall k. k -> *
    we want to generate the extra TyConBinders for T, so we finally get
      (a::*) (b::*) (k::*) (c::k)
    The function splitTyConKind generates these extra TyConBinders from
    the result kind signature.  The same function is also used by
    kcCheckDeclHeader_sig to get the [TyConBinder] from the Kind of
    the TyCon given in a standalone kind signature.  E.g.
      type T :: forall (a::*). * -> forall k. k -> *

    We need to take care to give the TyConBinders
      (a) Uniques that are fresh: the TyConBinders of a TyCon
          must have distinct uniques.

      (b) Preferably, OccNames that are fresh. If we happen to re-use
          OccNames that are other TyConBinders, we'll get a TyCon with
          TyConBinders like [a_72, a_53]; same OccName, different Uniques.
          Then when pretty-printing (e.g. in GHCi :info) we'll see
              data T a a0
          whereas we'd prefer
              data T a b
          (NB: the tidying happens in the conversion to Iface syntax,
          which happens as part of pretty-printing a TyThing.)

          Using fresh OccNames is not essential; it's cosmetic.
          And also see Note [Avoid name clashes for associated data types].

    For (a) perhaps surprisingly, duplicated uniques can happen, even if
    we use fresh uniques for Anon arrows.  Consider
       data T :: forall k. k -> forall k. k -> *
    where the two k's are identical even up to their uniques.  Surprisingly,
    this can happen: see #14515, #19092,3,4.  Then if we use those k's in
    as TyConBinders we'll get duplicated uniques.

    For (b) we'd like to avoid OccName clashes with the tyvars declared by
    the user before the "::"; in the above example that is 'a'.

    It's reasonably easy to solve all this; just run down the list with a
    substitution; hence the recursive 'go' function.  But for the Uniques
    it has to be done.

    Note [Avoid name clashes for associated data types]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider    class C a b where
                   data D b :: * -> *
    When typechecking the decl for D, we'll invent an extra type variable
    for D, to fill out its kind.  Ideally we don't want this type variable
    to be 'a', because when pretty printing we'll get
                class C a b where
                   data D b a0
    (NB: the tidying happens in the conversion to Iface syntax, which happens
    as part of pretty-printing a TyThing.)

    That's why we look in the LocalRdrEnv to see what's in scope. This is
    important only to get nice-looking output when doing ":info C" in GHCi.
    It isn't essential for correctness.

    ************************************************************************
    *                                                                      *
                 Partial signatures
    *                                                                      *
    ************************************************************************

    -}

    tcHsPartialSigType
      :: UserTypeCtxt
      -> LHsSigWcType GhcRn       -- The type signature
      -> TcM ( [(Name, TcTyVar)]  -- Wildcards
             , Maybe TcType       -- Extra-constraints wildcard
             , [(Name,InvisTVBinder)] -- Original tyvar names, in correspondence with
                                  --   the implicitly and explicitly bound type variables
             , TcThetaType        -- Theta part
             , TcType )           -- Tau part
    -- See Note [Checking partial type signatures]
    tcHsPartialSigType :: UserTypeCtxt
    -> LHsSigWcType GhcRn
    -> TcM
         ([(Name, TyVar)], Maybe Type, [(Name, VarBndr TyVar Specificity)],
          [Type], Type)
    tcHsPartialSigType UserTypeCtxt
    ctxt LHsSigWcType GhcRn
    sig_ty
      | HsWC { hswc_ext :: forall pass thing. HsWildCardBndrs pass thing -> XHsWC pass thing
    hswc_ext  = XHsWC GhcRn (LHsSigType GhcRn)
    sig_wcs, hswc_body :: forall pass thing. HsWildCardBndrs pass thing -> thing
    hswc_body = LHsSigType GhcRn
    sig_ty } <- LHsSigWcType GhcRn
    sig_ty
      , L SrcSpanAnnA
    _ (HsSig{sig_bndrs :: forall pass. HsSigType pass -> HsOuterSigTyVarBndrs pass
    sig_bndrs = HsOuterSigTyVarBndrs GhcRn
    hs_outer_bndrs, sig_body :: forall pass. HsSigType pass -> LHsType pass
    sig_body = LHsType GhcRn
    body_ty}) <- LHsSigType GhcRn
    sig_ty
      , (Maybe (LHsContext GhcRn)
    hs_ctxt, LHsType GhcRn
    hs_tau) <- LHsType GhcRn -> (Maybe (LHsContext GhcRn), LHsType GhcRn)
    forall (pass :: Pass).
    LHsType (GhcPass pass)
    -> (Maybe (LHsContext (GhcPass pass)), LHsType (GhcPass pass))
    splitLHsQualTy LHsType GhcRn
    body_ty
      = UserTypeCtxt
    -> UserSigType GhcRn
    -> TcM
         ([(Name, TyVar)], Maybe Type, [(Name, VarBndr TyVar Specificity)],
          [Type], Type)
    -> TcM
         ([(Name, TyVar)], Maybe Type, [(Name, VarBndr TyVar Specificity)],
          [Type], Type)
    forall a. UserTypeCtxt -> UserSigType GhcRn -> TcM a -> TcM a
    addSigCtxt UserTypeCtxt
    ctxt (LHsSigType GhcRn -> UserSigType GhcRn
    forall p. LHsSigType p -> UserSigType p
    UserLHsSigType LHsSigType GhcRn
    sig_ty) (TcM
       ([(Name, TyVar)], Maybe Type, [(Name, VarBndr TyVar Specificity)],
        [Type], Type)
     -> TcM
          ([(Name, TyVar)], Maybe Type, [(Name, VarBndr TyVar Specificity)],
           [Type], Type))
    -> TcM
         ([(Name, TyVar)], Maybe Type, [(Name, VarBndr TyVar Specificity)],
          [Type], Type)
    -> TcM
         ([(Name, TyVar)], Maybe Type, [(Name, VarBndr TyVar Specificity)],
          [Type], Type)
    forall a b. (a -> b) -> a -> b
    $
        do { mode <- TypeOrKind -> HoleMode -> TcM TcTyMode
    mkHoleMode TypeOrKind
    TypeLevel HoleMode
    HM_Sig
           ; (outer_bndrs, (wcs, wcx, theta, tau))
                <- solveEqualities "tcHsPartialSigType" $
                   -- See Note [Failure in local type signatures]
                   bindNamedWildCardBinders sig_wcs             $ \ [(Name, TyVar)]
    wcs ->
                   TcTyMode
    -> HsOuterSigTyVarBndrs GhcRn
    -> TcM ([(Name, TyVar)], Maybe Type, [Type], Type)
    -> TcM
         (HsOuterTyVarBndrs Specificity GhcTc,
          ([(Name, TyVar)], Maybe Type, [Type], Type))
    forall a.
    TcTyMode
    -> HsOuterSigTyVarBndrs GhcRn
    -> TcM a
    -> TcM (HsOuterTyVarBndrs Specificity GhcTc, a)
    bindOuterSigTKBndrs_Tv_M TcTyMode
    mode HsOuterSigTyVarBndrs GhcRn
    hs_outer_bndrs (TcM ([(Name, TyVar)], Maybe Type, [Type], Type)
     -> TcM
          (HsOuterTyVarBndrs Specificity GhcTc,
           ([(Name, TyVar)], Maybe Type, [Type], Type)))
    -> TcM ([(Name, TyVar)], Maybe Type, [Type], Type)
    -> TcM
         (HsOuterTyVarBndrs Specificity GhcTc,
          ([(Name, TyVar)], Maybe Type, [Type], Type))
    forall a b. (a -> b) -> a -> b
    $
                   do {   -- Instantiate the type-class context; but if there
                          -- is an extra-constraints wildcard, just discard it here
                        (theta, wcx) <- TcTyMode -> Maybe (LHsContext GhcRn) -> TcM ([Type], Maybe Type)
    tcPartialContext TcTyMode
    mode Maybe (LHsContext GhcRn)
    hs_ctxt

                      ; ek <- newOpenTypeKind
                      ; tau <- -- Don't do (addTypeCtxt hs_tau) here else we get
                               --   In the type <blah>
                               --   In the type signature: foo :: <blah>
                               tc_check_lhs_type mode hs_tau ek

                      ; return (wcs, wcx, theta, tau) }

           ; traceTc "tcHsPartialSigType 2" empty
           ; outer_bndrs <- scopedSortOuter outer_bndrs
           ; let outer_tv_bndrs = HsOuterTyVarBndrs Specificity GhcTc -> [VarBndr TyVar Specificity]
    outerTyVarBndrs HsOuterTyVarBndrs Specificity GhcTc
    outer_bndrs
           ; traceTc "tcHsPartialSigType 3" empty

             -- No kind-generalization here:
           ; kindGeneralizeNone (mkInvisForAllTys outer_tv_bndrs $
                                 tcMkPhiTy theta $
                                 tau)

           -- Spit out the wildcards (including the extra-constraints one)
           -- as "hole" constraints, so that they'll be reported if necessary
           -- See Note [Extra-constraint holes in partial type signatures]
           ; mapM_ emitNamedTypeHole wcs

             -- The "tau" from tcHsPartialSigType might very well have some foralls
             -- at the top, hidden behind a type synonym. Instantiate them! E.g.
             --    type T x = forall b. x -> b -> b
             --    f :: forall a. T (a,_)
             -- We must instantiate the `forall b` just as we do the `forall a`!
             -- Missing this led to #21667.
           ; (tv_prs', theta', tau) <- tcInstTypeBndrs tau

             -- We return a proper (Name,InvisTVBinder) environment, to be sure that
             -- we bring the right name into scope in the function body.
             -- Test case: partial-sigs/should_compile/LocalDefinitionBug
           ; let outer_bndr_names :: [Name]
                 outer_bndr_names = HsOuterSigTyVarBndrs GhcRn -> HsQTvsRn
    forall flag. HsOuterTyVarBndrs flag GhcRn -> HsQTvsRn
    hsOuterTyVarNames HsOuterSigTyVarBndrs GhcRn
    hs_outer_bndrs
                 tv_prs :: [(Name,InvisTVBinder)]
                 tv_prs = HsQTvsRn
    outer_bndr_names HsQTvsRn
    -> [VarBndr TyVar Specificity]
    -> [(Name, VarBndr TyVar Specificity)]
    forall a b. [a] -> [b] -> [(a, b)]
    `zip` [VarBndr TyVar Specificity]
    outer_tv_bndrs

           -- Zonk, so that any nested foralls can "see" their occurrences
           -- See Note [Checking partial type signatures], and in particular
           -- Note [Levels for wildcards]
           ; (tv_prs, theta, tau) <- liftZonkM $
             do { tv_prs <- mapSndM zonkInvisTVBinder (tv_prs ++ tv_prs')
                ; theta  <- mapM    zonkTcType        (theta ++ theta')
                ; tau    <- zonkTcType                tau
                ; return (tv_prs, theta, tau) }

          -- NB: checkValidType on the final inferred type will be
          --     done later by checkInferredPolyId.  We can't do it
          --     here because we don't have a complete type to check

           ; traceTc "tcHsPartialSigType" (ppr tv_prs)
           ; return (wcs, wcx, tv_prs, theta, tau) }

    tcPartialContext :: TcTyMode -> Maybe (LHsContext GhcRn) -> TcM (TcThetaType, Maybe TcType)
    tcPartialContext :: TcTyMode -> Maybe (LHsContext GhcRn) -> TcM ([Type], Maybe Type)
    tcPartialContext TcTyMode
    _ Maybe (LHsContext GhcRn)
    Nothing = ([Type], Maybe Type) -> TcM ([Type], Maybe Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([], Maybe Type
    forall a. Maybe a
    Nothing)
    tcPartialContext TcTyMode
    mode (Just (L SrcSpanAnnC
    _ [GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_theta))
      | Just ([GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_theta1, GenLocated SrcSpanAnnA (HsType GhcRn)
    hs_ctxt_last) <- [GenLocated SrcSpanAnnA (HsType GhcRn)]
    -> Maybe
         ([GenLocated SrcSpanAnnA (HsType GhcRn)],
          GenLocated SrcSpanAnnA (HsType GhcRn))
    forall a. [a] -> Maybe ([a], a)
    snocView [GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_theta
      , L SrcSpanAnnA
    wc_loc ty :: HsType GhcRn
    ty@(HsWildCardTy XWildCardTy GhcRn
    _) <- LHsType GhcRn -> LHsType GhcRn
    forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p)
    ignoreParens LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    hs_ctxt_last
      = do { wc_tv_ty <- SrcSpanAnnA -> TcM Type -> TcM Type
    forall ann a. EpAnn ann -> TcRn a -> TcRn a
    setSrcSpanA SrcSpanAnnA
    wc_loc (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
                         IsExtraConstraint -> TcTyMode -> HsType GhcRn -> Type -> TcM Type
    tcAnonWildCardOcc IsExtraConstraint
    YesExtraConstraint TcTyMode
    mode HsType GhcRn
    ty Type
    constraintKind
           ; theta <- mapM (tc_lhs_pred mode) hs_theta1
           ; return (theta, Just wc_tv_ty) }
      | Bool
    otherwise
      = do { theta <- (GenLocated SrcSpanAnnA (HsType GhcRn) -> TcM Type)
    -> [GenLocated SrcSpanAnnA (HsType GhcRn)] -> TcM [Type]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (TcTyMode -> LHsType GhcRn -> TcM Type
    tc_lhs_pred TcTyMode
    mode) [GenLocated SrcSpanAnnA (HsType GhcRn)]
    hs_theta
           ; return (theta, Nothing) }

    {- Note [Checking partial type signatures]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    This Note is about tcHsPartialSigType.  See also
    Note [Recipe for checking a signature]

    When we have a partial signature like
       f :: forall a. a -> _
    we do the following

    * tcHsPartialSigType does not make quantified type (forall a. blah)
      and then instantiate it -- it makes no sense to instantiate a type
      with wildcards in it.  Rather, tcHsPartialSigType just returns the
      'a' and the 'blah' separately.

      Nor, for the same reason, do we push a level in tcHsPartialSigType.

    * We instantiate 'a' to a unification variable, a TyVarTv, and /not/
      a skolem; hence the "_Tv" in bindExplicitTKBndrs_Tv.  Consider
        f :: forall a. a -> _
        g :: forall b. _ -> b
        f = g
        g = f
      They are typechecked as a recursive group, with monomorphic types,
      so 'a' and 'b' will get unified together.  Very like kind inference
      for mutually recursive data types (sans CUSKs or SAKS); see
      Note [Cloning for type variable binders]

    * In GHC.Tc.Gen.Sig.tcUserSigType we return a PartialSig, which (unlike
      the companion CompleteSig) contains the original, as-yet-unchecked
      source-code LHsSigWcType

    * Then, for f and g /separately/, we call tcInstSig, which in turn
      call tcHsPartialSig (defined near this Note).  It kind-checks the
      LHsSigWcType, creating fresh unification variables for each "_"
      wildcard.  It's important that the wildcards for f and g are distinct
      because they might get instantiated completely differently.  E.g.
         f,g :: forall a. a -> _
         f x = a
         g x = True
      It's really as if we'd written two distinct signatures.

    * Nested foralls. See Note [Levels for wildcards]

    * Just as for ordinary signatures, we must solve local equalities and
      zonk the type after kind-checking it, to ensure that all the nested
      forall binders can "see" their occurrences

      Just as for ordinary signatures, this zonk also gets any Refl casts
      out of the way of instantiation.  Example: #18008 had
           foo :: (forall a. (Show a => blah) |> Refl) -> _
      and that Refl cast messed things up.  See #18062.

    Note [Levels for wildcards]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
         f :: forall b. (forall a. a -> _) -> b
    We do /not/ allow the "_" to be instantiated to 'a'; although we do
    (as before) allow it to be instantiated to the (top level) 'b'.
    Why not?  Suppose
       f x = (x True, x 'c')

    During typecking the RHS we must instantiate that (forall a. a -> _),
    so we must know /precisely/ where all the a's are; they must not be
    hidden under (possibly-not-yet-filled-in) unification variables!

    We achieve this as follows:

    - For /named/ wildcards such sas
         g :: forall b. (forall la. a -> _x) -> b
      there is no problem: we create them at the outer level (ie the
      ambient level of the signature itself), and push the level when we
      go inside a forall.  So now the unification variable for the "_x"
      can't unify with skolem 'a'.

    - For /anonymous/ wildcards, such as 'f' above, we carry the ambient
      level of the signature to the hole in the TcLevel part of the
      mode_holes field of TcTyMode.  Then, in tcAnonWildCardOcc we us that
      level (and /not/ the level ambient at the occurrence of "_") to
      create the unification variable for the wildcard.  That is the sole
      purpose of the TcLevel in the mode_holes field: to transport the
      ambient level of the signature down to the anonymous wildcard
      occurrences.

    Note [Extra-constraint holes in partial type signatures]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    Consider
      f :: (_) => a -> a
      f x = ...

    * The renamer leaves '_' untouched.

    * Then, in tcHsPartialSigType, we make a new hole TcTyVar, in
      tcWildCardBinders.

    * GHC.Tc.Gen.Bind.chooseInferredQuantifiers fills in that hole TcTyVar
      with the inferred constraints, e.g. (Eq a, Show a)

    * GHC.Tc.Errors.mkHoleError finally reports the error.

    An annoying difficulty happens if there are more than 64 inferred
    constraints. Then we need to fill in the TcTyVar with (say) a 70-tuple.
    Where do we find the TyCon?  For good reasons we only have constraint
    tuples up to 62 (see Note [How tuples work] in GHC.Builtin.Types).  So how
    can we make a 70-tuple?  This was the root cause of #14217.

    It's incredibly tiresome, because we only need this type to fill
    in the hole, to communicate to the error reporting machinery.  Nothing
    more.  So I use a HACK:

    * I make an /ordinary/ tuple of the constraints, in
      GHC.Tc.Gen.Bind.chooseInferredQuantifiers. This is ill-kinded because
      ordinary tuples can't contain constraints, but it works fine. And for
      ordinary tuples we don't have the same limit as for constraint
      tuples (which need selectors and an associated class).

    * Because it is ill-kinded (unifying something of kind Constraint with
      something of kind Type), it should trip an assert in writeMetaTyVarRef.

    Result works fine, but it may eventually bite us.

    See also Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver for
    information about how these are printed.

    ************************************************************************
    *                                                                      *
          Pattern signatures (i.e signatures that occur in patterns)
    *                                                                      *
    ********************************************************************* -}

    tcHsPatSigType :: UserTypeCtxt
                   -> HoleMode -- HM_Sig when in a SigPat, HM_TyAppPat when in a ConPat checking type applications.
                   -> HsPatSigType GhcRn          -- The type signature
                   -> ContextKind                -- What kind is expected
                   -> TcM ( [(Name, TcTyVar)]     -- Wildcards
                          , [(Name, TcTyVar)]     -- The new bit of type environment, binding
                                                  -- the scoped type variables
                          , TcType)       -- The type
    -- Used for type-checking type signatures in
    -- (a) patterns           e.g  f (x::Int) = e
    -- (b) RULE forall bndrs  e.g. forall (x::Int). f x = x
    -- See Note [Pattern signature binders and scoping] in GHC.Hs.Type
    --
    -- This may emit constraints
    -- See Note [Recipe for checking a signature]
    tcHsPatSigType :: UserTypeCtxt
    -> HoleMode
    -> HsPatSigType GhcRn
    -> ContextKind
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tcHsPatSigType UserTypeCtxt
    ctxt HoleMode
    hole_mode
      (HsPS { hsps_ext :: forall pass. HsPatSigType pass -> XHsPS pass
    hsps_ext  = HsPSRn { hsps_nwcs :: HsPSRn -> HsQTvsRn
    hsps_nwcs = HsQTvsRn
    sig_wcs, hsps_imp_tvs :: HsPSRn -> HsQTvsRn
    hsps_imp_tvs = HsQTvsRn
    sig_ns }
            , hsps_body :: forall pass. HsPatSigType pass -> LHsType pass
    hsps_body = LHsType GhcRn
    hs_ty })
      ContextKind
    ctxt_kind
      = UserTypeCtxt
    -> Maybe SkolemInfo
    -> HoleMode
    -> LHsType GhcRn
    -> HsQTvsRn
    -> HsQTvsRn
    -> ContextKind
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tc_type_in_pat UserTypeCtxt
    ctxt Maybe SkolemInfo
    forall a. Maybe a
    Nothing HoleMode
    hole_mode LHsType GhcRn
    hs_ty HsQTvsRn
    sig_wcs HsQTvsRn
    sig_ns ContextKind
    ctxt_kind

    tcRuleBndrSig :: Name
                  -> SkolemInfo
                  -> HsPatSigType GhcRn          -- The type signature
                  -> TcM ( [(Name, TcTyVar)]     -- Wildcards
                         , [(Name, TcTyVar)]     -- The new bit of type environment, binding
                                                 -- the scoped type variables
                         , TcType)       -- The type
    -- Used for type-checking type signatures in
    --     RULE forall bndrs  e.g. forall (x::Int). f x = x
    -- See Note [Pattern signature binders and scoping] in GHC.Hs.Type
    --
    -- This may emit constraints
    -- See Note [Recipe for checking a signature]
    tcRuleBndrSig :: Name
    -> SkolemInfo
    -> HsPatSigType GhcRn
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tcRuleBndrSig Name
    name SkolemInfo
    skol_info
        (HsPS { hsps_ext :: forall pass. HsPatSigType pass -> XHsPS pass
    hsps_ext  = HsPSRn { hsps_nwcs :: HsPSRn -> HsQTvsRn
    hsps_nwcs = HsQTvsRn
    sig_wcs, hsps_imp_tvs :: HsPSRn -> HsQTvsRn
    hsps_imp_tvs = HsQTvsRn
    sig_ns }
              , hsps_body :: forall pass. HsPatSigType pass -> LHsType pass
    hsps_body = LHsType GhcRn
    hs_ty })
      = UserTypeCtxt
    -> Maybe SkolemInfo
    -> HoleMode
    -> LHsType GhcRn
    -> HsQTvsRn
    -> HsQTvsRn
    -> ContextKind
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tc_type_in_pat (Name -> UserTypeCtxt
    RuleBndrTypeCtxt Name
    name) (SkolemInfo -> Maybe SkolemInfo
    forall a. a -> Maybe a
    Just SkolemInfo
    skol_info)
                       HoleMode
    HM_Sig LHsType GhcRn
    hs_ty HsQTvsRn
    sig_wcs HsQTvsRn
    sig_ns ContextKind
    OpenKind

    -- Typecheck type patterns, in data constructor patterns, e.g
    --    f (MkT @a @(Maybe b) ...) = ...
    --
    -- We have two completely separate typing rules,
    --   one for binder type patterns  (handled by `tc_bndr_in_pat`)
    --   one for unifier type patterns (handled by `tc_type_in_pat`)
    -- The two cases are distinguished by `tyPatToBndr`.
    -- See Note [Type patterns: binders and unifiers]
    tcHsTyPat :: HsTyPat GhcRn               -- The type pattern
              -> Kind                        -- What kind is expected
              -> TcM ( [(Name, TcTyVar)]     -- Wildcards
                     , [(Name, TcTyVar)]     -- The new bit of type environment, binding
                                             -- the scoped type variables
                     , TcType)               -- The type
    tcHsTyPat :: HsTyPat GhcRn
    -> Type -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tcHsTyPat hs_pat :: HsTyPat GhcRn
    hs_pat@(HsTP{hstp_ext :: forall pass. HsTyPat pass -> XHsTP pass
    hstp_ext = XHsTP GhcRn
    hstp_rn, hstp_body :: forall pass. HsTyPat pass -> LHsType pass
    hstp_body = LHsType GhcRn
    hs_ty}) Type
    expected_kind
      = case HsTyPat GhcRn -> Maybe (HsTyVarBndr () GhcRn)
    tyPatToBndr HsTyPat GhcRn
    hs_pat of
        Maybe (HsTyVarBndr () GhcRn)
    Nothing   -> GenLocated SrcSpanAnnA (HsType GhcRn)
    -> HsQTvsRn
    -> HsQTvsRn
    -> ContextKind
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tc_unif_in_pat LHsType GhcRn
    GenLocated SrcSpanAnnA (HsType GhcRn)
    hs_ty HsQTvsRn
    wcs HsQTvsRn
    all_ns (Type -> ContextKind
    TheKind Type
    expected_kind)
        Just HsTyVarBndr () GhcRn
    bndr -> HsTyVarBndr () GhcRn
    -> HsQTvsRn
    -> HsQTvsRn
    -> Type
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    forall flag.
    HsTyVarBndr flag GhcRn
    -> HsQTvsRn
    -> HsQTvsRn
    -> Type
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tc_bndr_in_pat HsTyVarBndr () GhcRn
    bndr  HsQTvsRn
    wcs HsQTvsRn
    imp_ns  Type
    expected_kind
      where
        all_ns :: HsQTvsRn
    all_ns = HsQTvsRn
    imp_ns HsQTvsRn -> HsQTvsRn -> HsQTvsRn
    forall a. [a] -> [a] -> [a]
    ++ HsQTvsRn
    exp_ns
        HsTPRn{hstp_nwcs :: HsTyPatRn -> HsQTvsRn
    hstp_nwcs = HsQTvsRn
    wcs, hstp_imp_tvs :: HsTyPatRn -> HsQTvsRn
    hstp_imp_tvs = HsQTvsRn
    imp_ns, hstp_exp_tvs :: HsTyPatRn -> HsQTvsRn
    hstp_exp_tvs = HsQTvsRn
    exp_ns} = XHsTP GhcRn
    hstp_rn
        tc_unif_in_pat :: LHsType GhcRn
    -> HsQTvsRn
    -> HsQTvsRn
    -> ContextKind
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tc_unif_in_pat = UserTypeCtxt
    -> Maybe SkolemInfo
    -> HoleMode
    -> LHsType GhcRn
    -> HsQTvsRn
    -> HsQTvsRn
    -> ContextKind
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tc_type_in_pat UserTypeCtxt
    TypeAppCtxt Maybe SkolemInfo
    forall a. Maybe a
    Nothing HoleMode
    HM_TyAppPat

    -- `tc_bndr_in_pat` is used in type patterns to handle the binders case.
    -- See Note [Type patterns: binders and unifiers]
    tc_bndr_in_pat :: HsTyVarBndr flag GhcRn
                   -> [Name]  -- All named wildcards in type
                   -> [Name]  -- Implicit (but not explicit) binders in type
                   -> Kind    -- Expected kind
                   -> TcM ( [(Name, TcTyVar)]     -- Wildcards
                          , [(Name, TcTyVar)]     -- The new bit of type environment, binding
                                                  -- the scoped type variables
                          , TcType)               -- The type
    tc_bndr_in_pat :: forall flag.
    HsTyVarBndr flag GhcRn
    -> HsQTvsRn
    -> HsQTvsRn
    -> Type
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tc_bndr_in_pat HsTyVarBndr flag GhcRn
    bndr HsQTvsRn
    wcs HsQTvsRn
    imp_ns Type
    expected_kind = do
      let HsTvb { tvb_var :: forall flag pass. HsTyVarBndr flag pass -> HsBndrVar pass
    tvb_var = HsBndrVar GhcRn
    bvar, tvb_kind :: forall flag pass. HsTyVarBndr flag pass -> HsBndrKind pass
    tvb_kind = HsBndrKind GhcRn
    bkind } = HsTyVarBndr flag GhcRn
    bndr
      String -> SDoc -> TcM ()
    traceTc String
    "tc_bndr_in_pat 1" (Type -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Type
    expected_kind)
      name <- HsBndrVar GhcRn -> TcM Name
    tcHsBndrVarName HsBndrVar GhcRn
    bvar
      tv <- newPatTyVar name expected_kind
      case bkind of
        HsBndrNoKind XBndrNoKind GhcRn
    _ ->
          ([(Name, TyVar)], [(Name, TyVar)], Type)
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ([], HsTyVarBndr flag GhcRn -> TyVar -> [(Name, TyVar)]
    forall flag. HsTyVarBndr flag GhcRn -> TyVar -> [(Name, TyVar)]
    mk_tvb_pairs HsTyVarBndr flag GhcRn
    bndr TyVar
    tv, TyVar -> Type
    mkTyVarTy TyVar
    tv)
        HsBndrKind XBndrKind GhcRn
    _ LHsType GhcRn
    ki -> do
          tkv_prs <- (Name -> IOEnv (Env TcGblEnv TcLclEnv) (Name, TyVar))
    -> HsQTvsRn -> IOEnv (Env TcGblEnv TcLclEnv) [(Name, TyVar)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Name -> IOEnv (Env TcGblEnv TcLclEnv) (Name, TyVar)
    new_implicit_tv HsQTvsRn
    imp_ns
          wcs <- addTypeCtxt ki              $
                 solveEqualities "tc_bndr_in_pat" $
                   -- See Note [Failure in local type signatures]
                   -- and c.f #16033
                 bindNamedWildCardBinders wcs $ \ [(Name, TyVar)]
    wcs ->
                 [(Name, TyVar)]
    -> IOEnv (Env TcGblEnv TcLclEnv) [(Name, TyVar)]
    -> IOEnv (Env TcGblEnv TcLclEnv) [(Name, TyVar)]
    forall r. [(Name, TyVar)] -> TcM r -> TcM r
    tcExtendNameTyVarEnv [(Name, TyVar)]
    tkv_prs (IOEnv (Env TcGblEnv TcLclEnv) [(Name, TyVar)]
     -> IOEnv (Env TcGblEnv TcLclEnv) [(Name, TyVar)])
    -> IOEnv (Env TcGblEnv TcLclEnv) [(Name, TyVar)]
    -> IOEnv (Env TcGblEnv TcLclEnv) [(Name, TyVar)]
    forall a b. (a -> b) -> a -> b
    $
                 do { HsBndrVar GhcRn -> LHsType GhcRn -> Type -> TcM ()
    tcHsTvbKind HsBndrVar GhcRn
    bvar LHsType GhcRn
    ki Type
    expected_kind
                    ; [(Name, TyVar)] -> IOEnv (Env TcGblEnv TcLclEnv) [(Name, TyVar)]
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure [(Name, TyVar)]
    wcs }

          mapM_ emitNamedTypeHole wcs

          traceTc "tc_bndr_in_pat 2" $ vcat
            [ text "expected_kind" <+> ppr expected_kind
            , text "wcs" <+> ppr wcs
            , text "(name,tv)" <+>  ppr (name,tv)
            , text "tkv_prs" <+> ppr tkv_prs]

          let tvb_prs = HsTyVarBndr flag GhcRn -> TyVar -> [(Name, TyVar)]
    forall flag. HsTyVarBndr flag GhcRn -> TyVar -> [(Name, TyVar)]
    mk_tvb_pairs HsTyVarBndr flag GhcRn
    bndr TyVar
    tv
          pure (wcs, tvb_prs ++ tkv_prs, mkTyVarTy tv)
      where
        new_implicit_tv :: Name -> IOEnv (Env TcGblEnv TcLclEnv) (Name, TyVar)
    new_implicit_tv Name
    name
          = do { kind <- TcM Type
    newMetaKindVar
               ; tv   <- newPatTyVar name kind
                 -- NB: tv's Name is fresh
               ; return (name, tv) }

    -- * In type patterns `tc_type_in_pat` is used to handle the unifiers case.
    --   See Note [Type patterns: binders and unifiers]
    --
    -- * In patterns `tc_type_in_pat` is used to check pattern signatures.
    tc_type_in_pat :: UserTypeCtxt
                   -> Maybe SkolemInfo    -- Just sk for RULE and SPECIALISE pragmas only
                   -> HoleMode -- HM_Sig when in a SigPat, HM_TyAppPat when in a ConPat checking type applications.
                   -> LHsType GhcRn          -- The type in pattern
                   -> [Name]                 -- All named wildcards in type
                   -> [Name]                 -- All binders in type
                   -> ContextKind                -- What kind is expected
                   -> TcM ( [(Name, TcTyVar)]     -- Wildcards
                          , [(Name, TcTyVar)]     -- The new bit of type environment, binding
                                                  -- the scoped type variables
                          , TcType)       -- The type
    tc_type_in_pat :: UserTypeCtxt
    -> Maybe SkolemInfo
    -> HoleMode
    -> LHsType GhcRn
    -> HsQTvsRn
    -> HsQTvsRn
    -> ContextKind
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    tc_type_in_pat UserTypeCtxt
    ctxt Maybe SkolemInfo
    mb_skol HoleMode
    hole_mode LHsType GhcRn
    hs_ty HsQTvsRn
    wcs HsQTvsRn
    ns ContextKind
    ctxt_kind
      = UserTypeCtxt
    -> UserSigType GhcRn
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    forall a. UserTypeCtxt -> UserSigType GhcRn -> TcM a -> TcM a
    addSigCtxt UserTypeCtxt
    ctxt (LHsType GhcRn -> UserSigType GhcRn
    forall p. LHsType p -> UserSigType p
    UserLHsType LHsType GhcRn
    hs_ty) (TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
     -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type))
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    -> TcM ([(Name, TyVar)], [(Name, TyVar)], Type)
    forall a b. (a -> b) -> a -> b
    $
        do { tkvs <- (Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar)
    -> HsQTvsRn -> TcM [TyVar]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    new_implicit_tv HsQTvsRn
    ns
           ; let tkv_prs = HsQTvsRn
    ns HsQTvsRn -> [TyVar] -> [(Name, TyVar)]
    forall a b. [a] -> [b] -> [(a, b)]
    `zip` [TyVar]
    tkvs
           ; mode <- mkHoleMode TypeLevel hole_mode
           ; (wcs, ty)
                <- addTypeCtxt hs_ty                $
                   solveEqualities "tc_type_in_pat" $
                     -- See Note [Failure in local type signatures]
                     -- and c.f #16033
                   bindNamedWildCardBinders wcs $ \ [(Name, TyVar)]
    wcs ->
                   [(Name, TyVar)]
    -> TcM ([(Name, TyVar)], Type) -> TcM ([(Name, TyVar)], Type)
    forall r. [(Name, TyVar)] -> TcM r -> TcM r
    tcExtendNameTyVarEnv [(Name, TyVar)]
    tkv_prs (TcM ([(Name, TyVar)], Type) -> TcM ([(Name, TyVar)], Type))
    -> TcM ([(Name, TyVar)], Type) -> TcM ([(Name, TyVar)], Type)
    forall a b. (a -> b) -> a -> b
    $
                   do { ek <- ContextKind -> TcM Type
    newExpectedKind ContextKind
    ctxt_kind
                      ; ty <- tc_check_lhs_type mode hs_ty ek
                      ; return (wcs, ty) }

            ; mapM_ emitNamedTypeHole wcs

              -- ty might have tyvars that are at a higher TcLevel (if hs_ty
              -- contains a forall). Promote these.
              -- Ex: f (x :: forall a. Proxy a -> ()) = ... x ...
              -- When we instantiate x, we have to compare the kind of the argument
              -- to a's kind, which will be a metavariable.
              -- kindGeneralizeNone does this:
            ; kindGeneralizeNone ty
            ; ty <- liftZonkM $ zonkTcType ty
            ; checkValidType ctxt ty

            ; traceTc "tc_type_in_pat" (ppr tkv_prs)
            ; return (wcs, tkv_prs, ty) }
      where
        new_implicit_tv :: Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    new_implicit_tv Name
    name
          = do { kind <- TcM Type
    newMetaKindVar
               ; case mb_skol of
                    Just SkolemInfo
    skol_info -> SkolemInfo -> Name -> Type -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    newSkolemTyVar SkolemInfo
    skol_info Name
    name Type
    kind
                    Maybe SkolemInfo
    Nothing        -> Name -> Type -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
    newPatTyVar Name
    name Type
    kind }
                    -- See Note [Typechecking pattern signature binders]
                    -- NB: tv's Name may be fresh (in the case of newPatTyVar)

    -- See Note [Type patterns: binders and unifiers]
    tyPatToBndr :: HsTyPat GhcRn -> Maybe (HsTyVarBndr () GhcRn)
    tyPatToBndr :: HsTyPat GhcRn -> Maybe (HsTyVarBndr () GhcRn)
    tyPatToBndr HsTP{hstp_body :: forall pass. HsTyPat pass -> LHsType pass
    hstp_body = (L SrcSpanAnnA
    _ HsType GhcRn
    hs_ty)} = HsType GhcRn -> Maybe (HsTyVarBndr () GhcRn)
    go HsType GhcRn
    hs_ty where
      go :: HsType GhcRn -> Maybe (HsTyVarBndr () GhcRn)
      go :: HsType GhcRn -> Maybe (HsTyVarBndr () GhcRn)
    go (HsParTy XParTy GhcRn
    _ (L SrcSpanAnnA
    _ HsType GhcRn
    ty)) = HsType GhcRn -> Maybe (HsTyVarBndr () GhcRn)
    go HsType GhcRn
    ty
      go (HsKindSig XKindSig GhcRn
    _ (L SrcSpanAnnA
    _ HsType GhcRn
    ty) LHsType GhcRn
    ki) = do
        bvar <- HsType GhcRn -> Maybe (HsBndrVar GhcRn)
    go_bvar HsType GhcRn
    ty
        let bkind = XBndrKind GhcRn -> LHsType GhcRn -> HsBndrKind GhcRn
    forall pass. XBndrKind pass -> LHsKind pass -> HsBndrKind pass
    HsBndrKind NoExtField
    XBndrKind GhcRn
    noExtField LHsType GhcRn
    ki
        Just (HsTvb noAnn () bvar bkind)
      go HsType GhcRn
    ty = do
        bvar <- HsType GhcRn -> Maybe (HsBndrVar GhcRn)
    go_bvar HsType GhcRn
    ty
        let bkind = XBndrNoKind GhcRn -> HsBndrKind GhcRn
    forall pass. XBndrNoKind pass -> HsBndrKind pass
    HsBndrNoKind NoExtField
    XBndrNoKind GhcRn
    noExtField
        Just (HsTvb noAnn () bvar bkind)

      go_bvar :: HsType GhcRn -> Maybe (HsBndrVar GhcRn)
      go_bvar :: HsType GhcRn -> Maybe (HsBndrVar GhcRn)
    go_bvar (HsTyVar XTyVar GhcRn
    _ PromotionFlag
    _ LIdOccP GhcRn
    tv)
        | Name -> Bool
    isTyVarName (GenLocated SrcSpanAnnN (WithUserRdr Name) -> Name
    forall a. NamedThing a => a -> Name
    getName LIdOccP GhcRn
    GenLocated SrcSpanAnnN (WithUserRdr Name)
    tv)
        = HsBndrVar GhcRn -> Maybe (HsBndrVar GhcRn)
    forall a. a -> Maybe a
    Just (XBndrVar GhcRn -> LIdP GhcRn -> HsBndrVar GhcRn
    forall pass. XBndrVar pass -> LIdP pass -> HsBndrVar pass
    HsBndrVar NoExtField
    XBndrVar GhcRn
    noExtField ((WithUserRdr Name -> Name)
    -> GenLocated SrcSpanAnnN (WithUserRdr Name)
    -> GenLocated SrcSpanAnnN Name
    forall a b.
    (a -> b) -> GenLocated SrcSpanAnnN a -> GenLocated SrcSpanAnnN b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap WithUserRdr Name -> Name
    forall a. NamedThing a => a -> Name
    getName LIdOccP GhcRn
    GenLocated SrcSpanAnnN (WithUserRdr Name)
    tv))
      go_bvar (HsWildCardTy XWildCardTy GhcRn
    _)
        = HsBndrVar GhcRn -> Maybe (HsBndrVar GhcRn)
    forall a. a -> Maybe a
    Just (XBndrWildCard GhcRn -> HsBndrVar GhcRn
    forall pass. XBndrWildCard pass -> HsBndrVar pass
    HsBndrWildCard NoExtField
    XBndrWildCard GhcRn
    noExtField)
      go_bvar HsType GhcRn
    _ = Maybe (HsBndrVar GhcRn)
    forall a. Maybe a
    Nothing

    {- Note [Type patterns: binders and unifiers]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    A type pattern, of type `HsTyPat`, represents a type argument in a data
    constructor pattern.  For example
        f (MkT @a @(Maybe b) p q) = ...
    Here the `@a` and `@(Maybe b)` are type patterns.  In general, then a
    `HsTyPat` is represented by a `HsType`.

    However, for /typechecking/ purposes (only) we distinguish two categories of
    type pattern:
    * Binder type patterns
    * Unifier type patterns

    Binder type patterns are a subset of type patterns described by the following grammar:

      bvar ::= tv  | '_'        -- type variable or wildcard
      tp_bndr ::=
          bvar                  -- plain binder
        | bvar '::' kind        -- binder with kind annotation
        | '(' tp_bndr ')'       -- parentheses

    This subset of HsTyPat can be represented by HsTyVarBndr, which is also used
    in foralls and type declaration headers.

    Unifier type patterns include all other forms of type patterns, such as `Maybe x`.
    This distinction allows the typechecker to accept more programs.
    Consider this example from #18986:

      data T where
        MkT :: forall (f :: forall k. k -> Type).
          f Int -> f Maybe -> T

      k :: T -> ()
      k (MkT @f (x :: f Int) (y :: f Maybe)) = ()

    In general case (if we treat `f` as a unifier) we would create a metavariable for its kind:
      f :: kappa
    Checking `x :: f Int` would unify
      kappa := Type -> Type
    and then checking `y :: f Maybe` would unify
      kappa := (Type -> Type) -> Type
    leading to a type error:
        • Expecting one more argument to ‘Maybe’
          Expected a type, but ‘Maybe’ has kind ‘* -> *’

    However, `@f` is a simple type variable binder, we don't need a metavariable for its kind, we
    can add it directly to the context with its polymorphic kind:
      f :: forall k . k -> Type
    This way both `f Int` and `f Maybe` can be accepted because `k` can be instantiated differently at
    each call site.

    Note [Typechecking pattern signature binders]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    See also Note [Type variables in the type environment] in GHC.Tc.Utils.
    Consider

      data T where
        MkT :: forall a. a -> (a -> Int) -> T

      f :: T -> ...
      f (MkT x (f :: b -> c)) = <blah>

    Here
     * The pattern (MkT p1 p2) creates a *skolem* type variable 'a_sk',
       It must be a skolem so that it retains its identity, and
       GHC.Tc.Errors.getSkolemInfo can thereby find the binding site for the skolem.

     * The type signature pattern (f :: b -> c) makes fresh meta-tyvars
       beta and gamma (TauTvs), and binds "b" :-> beta, "c" :-> gamma in the
       environment

     * Then unification makes beta := a_sk, gamma := Int
       That's why we must make beta and gamma a MetaTv,
       not a SkolemTv, so that it can unify to a_sk (or Int, respectively).

     * Finally, in '<blah>' we have the envt "b" :-> beta, "c" :-> gamma,
       so we return the pairs ("b" :-> beta, "c" :-> gamma) from tcHsPatSigType,

    Another example (#13881):
       fl :: forall (l :: [a]). Sing l -> Sing l
       fl (SNil :: Sing (l :: [y])) = SNil
    When we reach the pattern signature, 'l' is in scope from the
    outer 'forall':
       "a" :-> a_sk :: *
       "l" :-> l_sk :: [a_sk]
    We make up a fresh meta-TauTv, y_sig, for 'y', and kind-check
    the pattern signature
       Sing (l :: [y])
    That unifies y_sig := a_sk.  We return from tcHsPatSigType with
    the pair ("y" :-> y_sig).

    For RULE binders, though, things are a bit different (yuk).
      RULE "foo" forall (x::a) (y::[a]).  f x y = ...
    Here this really is the binding site of the type variable so we'd like
    to use a skolem, so that we get a complaint if we unify two of them
    together.  Hence the new_implicit_tv function in tcHsPatSigType.

    ************************************************************************
    *                                                                      *
            Checking kinds
    *                                                                      *
    ************************************************************************

    -}

    unifyKinds :: [LHsType GhcRn] -> [(TcType, TcKind)] -> TcM ([TcType], TcKind)
    unifyKinds :: [LHsType GhcRn] -> [(Type, Type)] -> TcM ([Type], Type)
    unifyKinds [LHsType GhcRn]
    rn_tys [(Type, Type)]
    act_kinds
      = do { kind <- TcM Type
    newMetaKindVar
           ; let check GenLocated SrcSpanAnnA (HsType GhcRn)
    rn_ty (Type
    ty, Type
    act_kind)
                   = HasDebugCallStack =>
    HsType GhcRn -> Type -> Type -> Type -> TcM Type
    HsType GhcRn -> Type -> Type -> Type -> TcM Type
    checkExpectedKind (GenLocated SrcSpanAnnA (HsType GhcRn) -> HsType GhcRn
    forall l e. GenLocated l e -> e
    unLoc GenLocated SrcSpanAnnA (HsType GhcRn)
    rn_ty) Type
    ty Type
    act_kind Type
    kind
           ; tys' <- zipWithM check rn_tys act_kinds
           ; return (tys', kind) }

    {-
    ************************************************************************
    *                                                                      *
            Sort checking kinds
    *                                                                      *
    ************************************************************************

    tcLHsKindSig converts a user-written kind to an internal, sort-checked kind.
    It does sort checking and desugaring at the same time, in one single pass.
    -}

    tcLHsKindSig :: UserTypeCtxt -> LHsKind GhcRn -> TcM Kind
    tcLHsKindSig :: UserTypeCtxt -> LHsType GhcRn -> TcM Type
    tcLHsKindSig UserTypeCtxt
    ctxt LHsType GhcRn
    hs_kind
      = TcTyMode -> UserTypeCtxt -> LHsType GhcRn -> TcM Type
    tc_lhs_kind_sig TcTyMode
    kindLevelMode UserTypeCtxt
    ctxt LHsType GhcRn
    hs_kind

    tc_lhs_kind_sig :: TcTyMode -> UserTypeCtxt -> LHsKind GhcRn -> TcM Kind
    tc_lhs_kind_sig :: TcTyMode -> UserTypeCtxt -> LHsType GhcRn -> TcM Type
    tc_lhs_kind_sig TcTyMode
    mode UserTypeCtxt
    ctxt LHsType GhcRn
    hs_kind
    -- See  Note [Recipe for checking a signature] in GHC.Tc.Gen.HsType
    -- Result is zonked
      = do { kind <- ErrCtxtMsg -> TcM Type -> TcM Type
    forall a. ErrCtxtMsg -> TcM a -> TcM a
    addErrCtxt (LHsType GhcRn -> ErrCtxtMsg
    KindCtxt LHsType GhcRn
    hs_kind) (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
                     String -> TcM Type -> TcM Type
    forall a. String -> TcM a -> TcM a
    solveEqualities String
    "tcLHsKindSig" (TcM Type -> TcM Type) -> TcM Type -> TcM Type
    forall a b. (a -> b) -> a -> b
    $
                     TcTyMode -> LHsType GhcRn -> Type -> TcM Type
    tc_check_lhs_type TcTyMode
    mode LHsType GhcRn
    hs_kind Type
    liftedTypeKind
           ; traceTc "tcLHsKindSig" (ppr hs_kind $$ ppr kind)
           -- No generalization:
           ; kindGeneralizeNone kind
           ; kind <- liftZonkM $ zonkTcType kind
             -- This zonk is very important in the case of higher rank kinds
             -- E.g. #13879    f :: forall (p :: forall z (y::z). <blah>).
             --                          <more blah>
             --      When instantiating p's kind at occurrences of p in <more blah>
             --      it's crucial that the kind we instantiate is fully zonked,
             --      else we may fail to substitute properly

           ; checkValidType ctxt kind
           ; traceTc "tcLHsKindSig2" (ppr kind)
           ; return kind }

    promotionErr :: Name -> PromotionErr -> TcM a
    promotionErr :: forall a. Name -> PromotionErr -> TcM a
    promotionErr Name
    name PromotionErr
    err
      = TcRnMessage -> TcM a
    forall a. TcRnMessage -> TcRn a
    failWithTc (TcRnMessage -> TcM a) -> TcRnMessage -> TcM a
    forall a b. (a -> b) -> a -> b
    $ Name -> PromotionErr -> TcRnMessage
    TcRnUnpromotableThing Name
    name PromotionErr
    err

    {-
    ************************************************************************
    *                                                                      *
              Utils for constructing TyLit
    *                                                                      *
    ************************************************************************
    -}

    tyLitFromLit :: HsLit GhcRn -> Maybe (HsTyLit GhcRn)
    tyLitFromLit :: HsLit GhcRn -> Maybe (HsTyLit GhcRn)
    tyLitFromLit (HsString XHsString GhcRn
    x FastString
    str) = HsTyLit GhcRn -> Maybe (HsTyLit GhcRn)
    forall a. a -> Maybe a
    Just (XStrTy GhcRn -> FastString -> HsTyLit GhcRn
    forall pass. XStrTy pass -> FastString -> HsTyLit pass
    HsStrTy XStrTy GhcRn
    XHsString GhcRn
    x FastString
    str)
    tyLitFromLit (HsMultilineString XHsMultilineString GhcRn
    x FastString
    str) = HsTyLit GhcRn -> Maybe (HsTyLit GhcRn)
    forall a. a -> Maybe a
    Just (XStrTy GhcRn -> FastString -> HsTyLit GhcRn
    forall pass. XStrTy pass -> FastString -> HsTyLit pass
    HsStrTy XStrTy GhcRn
    XHsMultilineString GhcRn
    x FastString
    str)
    tyLitFromLit (HsChar XHsChar GhcRn
    x Char
    char) = HsTyLit GhcRn -> Maybe (HsTyLit GhcRn)
    forall a. a -> Maybe a
    Just (XCharTy GhcRn -> Char -> HsTyLit GhcRn
    forall pass. XCharTy pass -> Char -> HsTyLit pass
    HsCharTy XCharTy GhcRn
    XHsChar GhcRn
    x Char
    char)
    tyLitFromLit HsLit GhcRn
    _ = Maybe (HsTyLit GhcRn)
    forall a. Maybe a
    Nothing

    tyLitFromOverloadedLit :: OverLitVal -> Maybe (HsTyLit GhcRn)
    tyLitFromOverloadedLit :: OverLitVal -> Maybe (HsTyLit GhcRn)
    tyLitFromOverloadedLit (HsIntegral IntegralLit
    n) = HsTyLit GhcRn -> Maybe (HsTyLit GhcRn)
    forall a. a -> Maybe a
    Just (HsTyLit GhcRn -> Maybe (HsTyLit GhcRn))
    -> HsTyLit GhcRn -> Maybe (HsTyLit GhcRn)
    forall a b. (a -> b) -> a -> b
    $ XNumTy GhcRn -> Integer -> HsTyLit GhcRn
    forall pass. XNumTy pass -> Integer -> HsTyLit pass
    HsNumTy XNumTy GhcRn
    SourceText
    NoSourceText (IntegralLit -> Integer
    il_value IntegralLit
    n)
    tyLitFromOverloadedLit (HsIsString SourceText
    _ FastString
    s) = HsTyLit GhcRn -> Maybe (HsTyLit GhcRn)
    forall a. a -> Maybe a
    Just (HsTyLit GhcRn -> Maybe (HsTyLit GhcRn))
    -> HsTyLit GhcRn -> Maybe (HsTyLit GhcRn)
    forall a b. (a -> b) -> a -> b
    $ XStrTy GhcRn -> FastString -> HsTyLit GhcRn
    forall pass. XStrTy pass -> FastString -> HsTyLit pass
    HsStrTy XStrTy GhcRn
    SourceText
    NoSourceText FastString
    s
    tyLitFromOverloadedLit HsFractional{} = Maybe (HsTyLit GhcRn)
    forall a. Maybe a
    Nothing