content: {-# LANGUAGE DeriveGeneric       #-}
  {-# LANGUAGE FlexibleContexts    #-}
  {-# LANGUAGE ScopedTypeVariables #-}
  {-# LANGUAGE TupleSections       #-}
  {-# LANGUAGE MagicHash           #-}
  {-# LANGUAGE MultiWayIf          #-}
  
  {-
  (c) The University of Glasgow 2006
  (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
  
  -}
  
  -- | Types used in the typechecker
  --
  -- This module provides the Type interface for front-end parts of the
  -- compiler.  These parts
  --
  -- * treat "source types" as opaque:
  --         newtypes, and predicates are meaningful.
  -- * look through usage types
  --
  module GHC.Tc.Utils.TcType (
    --------------------------------
    -- Types
    TcType, TcSigmaType, TcTypeFRR, TcSigmaTypeFRR,
    TcRhoType, TcRhoTypeFRR, TcTauType, TcPredType, TcThetaType,
    TcTyVar, TcTyVarSet, TcDTyVarSet, TcTyCoVarSet, TcDTyCoVarSet,
    TcKind, TcCoVar, TcTyCoVar, TcTyVarBinder, TcInvisTVBinder, TcReqTVBinder,
    TcTyCon, MonoTcTyCon, PolyTcTyCon, TcTyConBinder, KnotTied,
  
    ExpType(..), ExpKind, InferResult(..), InferInstFlag(..), InferFRRFlag(..),
    ExpTypeFRR, ExpSigmaType, ExpSigmaTypeFRR,
    ExpRhoType, ExpRhoTypeFRR,
    mkCheckExpType,
    checkingExpType_maybe, checkingExpType,
  
    ExpPatType(..), mkCheckExpFunPatTy, mkInvisExpPatType,
    isVisibleExpPatType, isExpFunPatType,
  
    SyntaxOpType(..), synKnownType, mkSynFunTys,
  
    --------------------------------
    -- TcLevel
    TcLevel(..), topTcLevel, pushTcLevel, isTopTcLevel,
    strictlyDeeperThan, deeperThanOrSame, sameDepthAs,
    tcTypeLevel, tcTyVarLevel, maxTcLevel, minTcLevel,
  
    --------------------------------
    -- MetaDetails
    TcTyVarDetails(..), pprTcTyVarDetails, vanillaSkolemTvUnk,
    MetaDetails(Flexi, Indirect), MetaInfo(..), skolemSkolInfo,
    isImmutableTyVar, isSkolemTyVar, isMetaTyVar,  isMetaTyVarTy, isTyVarTy,
    tcIsTcTyVar, isTyVarTyVar, isOverlappableTyVar,  isTyConableTyVar,
    ConcreteTvOrigin(..), isConcreteTyVar_maybe, isConcreteTyVar,
    isConcreteTyVarTy, isConcreteTyVarTy_maybe, concreteInfo_maybe,
    ConcreteTyVars, noConcreteTyVars,
    isAmbiguousTyVar, isCycleBreakerTyVar, metaTyVarRef, metaTyVarInfo,
    isFlexi, isIndirect, isRuntimeUnkSkol,
    isQLInstTyVar, isRuntimeUnkTyVar,
    metaTyVarTcLevel, setMetaTyVarTcLevel, metaTyVarTcLevel_maybe,
    isTouchableMetaTyVar, isPromotableMetaTyVar,
    findDupTyVarTvs, mkTyVarNamePairs,
  
    --------------------------------
    -- Builders
    mkInfSigmaTy, mkSpecSigmaTy, mkSigmaTy, mkPhiTy, tcMkPhiTy,
    tcMkDFunSigmaTy, tcMkDFunPhiTy,
  
    --------------------------------
    -- Splitters
    getTyVar, getTyVar_maybe, getCastedTyVar_maybe,
    tcSplitForAllTyVarBinder_maybe, tcSplitForAllTyVarsReqTVBindersN,
    tcSplitForAllTyVars, tcSplitForAllInvisTyVars, tcSplitSomeForAllTyVars,
    tcSplitForAllReqTVBinders, tcSplitForAllInvisTVBinders,
    tcSplitPiTys, tcSplitPiTy_maybe, tcSplitForAllTyVarBinders,
    tcSplitPhiTy, tcSplitPredFunTy_maybe,
    tcSplitFunTy_maybe, tcSplitFunTys, tcFunArgTy, tcFunResultTy, tcFunResultTyN,
    tcSplitFunTysN,
    tcSplitTyConApp, tcSplitTyConApp_maybe,
    tcTyConAppTyCon, tcTyConAppTyCon_maybe, tcTyConAppArgs,
    tcSplitAppTy_maybe, tcSplitAppTy, tcSplitAppTys, tcSplitAppTyNoView_maybe,
    tcSplitSigmaTy, tcSplitSigmaTyBndrs, tcSplitNestedSigmaTys, tcSplitIOType_maybe,
  
    ---------------------------------
    -- Predicates.
    -- Again, newtypes are opaque
    isSigmaTy, isRhoTy, isRhoExpTy, isOverloadedTy,
    isFloatingPrimTy, isDoubleTy, isFloatTy, isIntTy, isWordTy, isStringTy,
    isIntegerTy, isNaturalTy,
    isBoolTy, isUnitTy, isAnyTy, isZonkAnyTy, isCharTy,
    isTauTy, isTauTyCon, tcIsTyVarTy,
    isPredTy, isSimplePredTy, isTyVarClassPred,
    checkValidClsArgs, hasTyVarHead,
    isRigidTy, anyTy_maybe,
  
  
    -- Re-exported from GHC.Core.TyCo.Compare
    -- mainly just for back-compat reasons
    eqType, eqTypes, nonDetCmpType, eqTypeX,
    pickyEqType, tcEqType, tcEqKind, tcEqTypeNoKindCheck,
    mayLookIdentical, pprWithInvisibleBits, InvisibleBit(..), InvisibleBits,
    tcEqTyConApps, eqForAllVis, eqVarBndrs,
  
    ---------------------------------
    -- Misc type manipulators
  
    deNoteType,
    getDFunTyKey, evVarPred,
    ambigTkvsOfTy,
  
    ---------------------------------
    -- Predicate types
    mkMinimalBySCs, transSuperClasses,
    pickCapturedPreds,
    immSuperClasses, boxEqPred,
    isImprovementPred,
  
    -- * Finding type instances
    tcTyFamInsts, tcTyFamInstsAndVis, tcTyConAppTyFamInstsAndVis, isTyFamFree,
  
    -- * Finding "exact" (non-dead) type variables
    exactTyCoVarsOfType, exactTyCoVarsOfTypes,
    anyRewritableTyVar, anyRewritableTyFamApp, UnderFam,
  
    ---------------------------------
    -- Patersons sizes
    PatersonSize(..), PatersonCondFailure(..),
    PatersonCondFailureContext(..),
    ltPatersonSize,
    pSizeZero, pSizeOne,
    pSizeType, pSizeTypeX, pSizeTypes,
    pSizeClassPred, pSizeClassPredX,
    pSizeTyConApp, pSizeHead,
    noMoreTyVars, allDistinctTyVars,
    TypeSize, sizeType, sizeTypes, scopedSort,
    isTerminatingClass, isStuckTypeFamily,
  
    --------------------------------
    -- Reexported from Kind
    Kind, liftedTypeKind, constraintKind,
    isLiftedTypeKind, isUnliftedTypeKind, isTYPEorCONSTRAINT,
  
    --------------------------------
    -- Reexported from Type
    Type, PredType, ThetaType, PiTyBinder,
    ForAllTyFlag(..), FunTyFlag(..),
  
    mkForAllTy, mkForAllTys, mkInvisForAllTys, mkTyCoInvForAllTys,
    mkSpecForAllTys, mkTyCoInvForAllTy,
    mkInfForAllTy, mkInfForAllTys,
    mkVisFunTy, mkVisFunTyMany, mkVisFunTysMany,
    mkScaledFunTys,
    mkInvisFunTy, mkInvisFunTys,
    mkTyConApp, mkAppTy, mkAppTys,
    mkTyConTy, mkTyVarTy, mkTyVarTys,
    mkTyCoVarTy, mkTyCoVarTys,
  
    isClassPred, isEqPred, couldBeIPLike, isEqClassPred,
    isEqualityClass, mkClassPred,
    tcSplitQuantPredTy, tcSplitDFunTy, tcSplitDFunHead, tcSplitMethodTy,
    isRuntimeRepVar, isFixedRuntimeRepKind,
    isVisiblePiTyBinder, isInvisiblePiTyBinder,
  
    -- Type substitutions
    Subst(..),         -- Representation visible to a few friends
    TvSubstEnv, emptySubst, mkEmptySubst,
    zipTvSubst,
    mkTvSubstPrs, notElemSubst, unionSubst,
    getTvSubstEnv, substInScopeSet, extendSubstInScope,
    extendSubstInScopeList, extendSubstInScopeSet, extendTvSubstAndInScope,
    Type.lookupTyVar, Type.extendTCvSubst, Type.substTyVarBndr,
    Type.extendTvSubst,
    isInScope, mkTCvSubst, mkTvSubst, zipTyEnv, zipCoEnv,
    Type.substTy, substTys, substScaledTys, substTyWith, substTyWithCoVars,
    substTyAddInScope,
    substTyUnchecked, substTysUnchecked, substScaledTyUnchecked,
    substThetaUnchecked,
    substTyWithUnchecked,
    substTheta,
  
    isUnliftedType,
    isUnboxedTupleType,
    isPrimitiveType,
  
    coreView,
  
    tyCoVarsOfType, tyCoVarsOfTypes, closeOverKinds,
    tyCoFVsOfType, tyCoFVsOfTypes,
    tyCoVarsOfTypeDSet, tyCoVarsOfTypesDSet, closeOverKindsDSet,
    tyCoVarsOfTypeList, tyCoVarsOfTypesList,
    noFreeVarsOfType,
  
    --------------------------------
    pprKind, pprParendKind, pprSigmaType,
    pprType, pprParendType, pprTypeApp,
    pprTheta, pprParendTheta, pprThetaArrowTy, pprClassPred,
    pprTCvBndr, pprTCvBndrs,
  
    ---------------------------------
    -- argument visibility
    tyConVisibilities, isNextTyConArgVisible, isNextArgVisible
  
    ) where
  
  -- friends:
  import GHC.Prelude
  
  import GHC.Core.TyCo.Rep
  import GHC.Core.TyCo.Subst ( mkTvSubst, substTyWithCoVars )
  import GHC.Core.TyCo.Compare
  import GHC.Core.TyCo.FVs
  import GHC.Core.TyCo.Ppr
  import GHC.Core.Class
  import GHC.Types.Var
  import GHC.Types.Var.Set
  import GHC.Core.Coercion
  import GHC.Core.Type as Type
  import GHC.Core.Predicate
  import GHC.Core.TyCon
  
  import {-# SOURCE #-} GHC.Tc.Types.Origin
    ( SkolemInfo, unkSkol
    , FixedRuntimeRepOrigin, FixedRuntimeRepContext )
  
  -- others:
  import GHC.Types.Name as Name
              -- We use this to make dictionaries for type literals.
              -- Perhaps there's a better way to do this?
  import GHC.Types.Name.Env
  import GHC.Types.Name.Set
  import GHC.Builtin.Names
  import GHC.Builtin.Types ( coercibleClass, eqClass, heqClass, unitTyConKey
                           , listTyCon, constraintKind )
  import GHC.Types.Basic
  import GHC.Utils.Misc
  import GHC.Data.Maybe
  import GHC.Data.List.SetOps ( getNth, findDupsEq )
  import GHC.Utils.Outputable
  import GHC.Utils.Panic
  
  import Data.IORef ( IORef )
  import Data.List.NonEmpty( NonEmpty(..) )
  import Data.List ( partition, nub, (\\) )
  
  {-
  ************************************************************************
  *                                                                      *
                Types
  *                                                                      *
  ************************************************************************
  
  The type checker divides the generic Type world into the
  following more structured beasts:
  
  sigma ::= forall tyvars. phi
          -- A sigma type is a qualified type
          --
          -- Note that even if 'tyvars' is empty, theta
          -- may not be: e.g.   (?x::Int) => Int
  
          -- Note that 'sigma' is in prenex form:
          -- all the foralls are at the front.
          -- A 'phi' type has no foralls to the right of
          -- an arrow
  
  phi :: theta => rho
  
  rho ::= sigma -> rho
       |  tau
  
  -- A 'tau' type has no quantification anywhere
  -- Note that the args of a type constructor must be taus
  tau ::= tyvar
       |  tycon tau_1 .. tau_n
       |  tau_1 tau_2
       |  tau_1 -> tau_2
  
  -- In all cases, a (saturated) type synonym application is legal,
  -- provided it expands to the required form.
  
  Note [TcTyVars and TyVars in the typechecker]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  The typechecker uses a lot of type variables with special properties,
  notably being a unification variable with a mutable reference.  These
  use the 'TcTyVar' variant of Var.Var.
  
  Note, though, that a /bound/ type variable can (and probably should)
  be a TyVar.  E.g
      forall a. a -> a
  Here 'a' is really just a deBruijn-number; it certainly does not have
  a significant TcLevel (as every TcTyVar does).  So a forall-bound type
  variable should be TyVars; and hence a TyVar can appear free in a TcType.
  
  The type checker and constraint solver can also encounter /free/ type
  variables that use the 'TyVar' variant of Var.Var, for a couple of
  reasons:
  
    - When typechecking a class decl, say
         class C (a :: k) where
            foo :: T a -> Int
      We have first kind-check the header; fix k and (a:k) to be
      TyVars, bring 'k' and 'a' into scope, and kind check the
      signature for 'foo'.  In doing so we call solveEqualities to
      solve any kind equalities in foo's signature.  So the solver
      may see free occurrences of 'k'.
  
      See calls to tcExtendTyVarEnv for other places that ordinary
      TyVars are bought into scope, and hence may show up in the types
      and kinds generated by GHC.Tc.Gen.HsType.
  
    - The pattern-match overlap checker calls the constraint solver,
      long after TcTyVars have been zonked away
  
  It's convenient to simply treat these TyVars as skolem constants,
  which of course they are.  We give them a level number of "outermost",
  so they behave as global constants.  Specifically:
  
  * Var.tcTyVarDetails succeeds on a TyVar, returning
    vanillaSkolemTv, as well as on a TcTyVar.
  
  * tcIsTcTyVar returns True for both TyVar and TcTyVar variants
    of Var.Var.  The "tc" prefix means "a type variable that can be
    encountered by the typechecker".
  
  This is a bit of a change from an earlier era when we remorselessly
  insisted on real TcTyVars in the type checker.  But that seems
  unnecessary (for skolems, TyVars are fine) and it's now very hard
  to guarantee, with the advent of kind equalities.
  
  Note [Coercion variables in free variable lists]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  There are several places in the GHC codebase where functions like
  tyCoVarsOfType, tyCoVarsOfCt, et al. are used to compute the free type
  variables of a type. The "Co" part of these functions' names shouldn't be
  dismissed, as it is entirely possible that they will include coercion variables
  in addition to type variables! As a result, there are some places in GHC.Tc.Utils.TcType
  where we must take care to check that a variable is a _type_ variable (using
  isTyVar) before calling tcTyVarDetails--a partial function that is not defined
  for coercion variables--on the variable. Failing to do so led to
  GHC #12785.
  -}
  
  -- See Note [TcTyVars and TyVars in the typechecker]
  type TcCoVar = CoVar    -- Used only during type inference
  type TcType = Type      -- A TcType can have mutable type variables
  type TcTyCoVar = Var    -- Either a TcTyVar or a CoVar
  
  -- | A type which has a syntactically fixed RuntimeRep as per
  -- Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.
  type TcTypeFRR = TcType
    -- TODO: consider making this a newtype.
  
  type TcTyVarBinder     = TyVarBinder
  type TcInvisTVBinder   = InvisTVBinder
  type TcReqTVBinder     = ReqTVBinder
  
  -- See Note [TcTyCon, MonoTcTyCon, and PolyTcTyCon] in GHC.Tc.TyCl
  type TcTyCon       = TyCon
  type MonoTcTyCon   = TcTyCon
  type PolyTcTyCon   = TcTyCon
  type TcTyConBinder = TyConBinder -- With skolem TcTyVars
  
  -- These types do not have boxy type variables in them
  type TcPredType     = PredType
  type TcThetaType    = ThetaType
  type TcSigmaType    = TcType
  
  -- | A 'TcSigmaTypeFRR' is a 'TcSigmaType' which has a syntactically
  --  fixed 'RuntimeRep' in the sense of Note [Fixed RuntimeRep]
  -- in GHC.Tc.Utils.Concrete.
  --
  -- In particular, this means that:
  --
  -- - 'GHC.Types.RepType.typePrimRep' does not panic,
  -- - 'GHC.Core.typeLevity_maybe' does not return 'Nothing'.
  --
  -- This property is important in functions such as 'matchExpectedFunTys', where
  -- we want to provide argument types which have a known runtime representation.
  -- See Note [Return arguments with a fixed RuntimeRep.
  type TcSigmaTypeFRR = TcSigmaType
      -- TODO: consider making this a newtype.
  type TcRhoTypeFRR = TcRhoType
  
  type TcRhoType      = TcType  -- Note [TcRhoType]
  type TcTauType      = TcType
  type TcKind         = Kind
  type TcTyVarSet     = TyVarSet
  type TcTyCoVarSet   = TyCoVarSet
  type TcDTyVarSet    = DTyVarSet
  type TcDTyCoVarSet  = DTyCoVarSet
  
  
  {- *********************************************************************
  *                                                                      *
            ExpType: an "expected type" in the type checker
  *                                                                      *
  ********************************************************************* -}
  
  -- | An expected type to check against during type-checking.
  -- See Note [ExpType] in "GHC.Tc.Utils.TcMType", where you'll also find manipulators.
  data ExpType = Check TcType
               | Infer !InferResult
  
  data InferResult
    = IR { ir_uniq :: Unique
            -- ^ This 'Unique' is for debugging only
  
         , ir_lvl  :: TcLevel
           -- ^ See Note [TcLevel of ExpType] in GHC.Tc.Utils.TcMType
  
         , ir_frr  :: InferFRRFlag
           -- ^ See Note [FixedRuntimeRep context in ExpType] in GHC.Tc.Utils.TcMType
  
         , ir_inst :: InferInstFlag
           -- ^ True <=> when DeepSubsumption is on, deeply instantiate before filling,
           -- See Note [Instantiation of InferResult] in GHC.Tc.Utils.Unify
  
         , ir_ref  :: IORef (Maybe TcType) }
           -- ^ The type that fills in this hole should be a @Type@,
           -- that is, its kind should be @TYPE rr@ for some @rr :: RuntimeRep@.
           --
           -- Additionally, if the 'ir_frr' field is @Just frr_orig@ then
           -- @rr@ must be concrete, in the sense of Note [Concrete types]
           -- in GHC.Tc.Utils.Concrete.
  
  data InferFRRFlag
    = IFRR_Check                -- Check that the result type has a fixed runtime rep
        FixedRuntimeRepContext  -- Typically used for function arguments and lambdas
  
    | IFRR_Any                  -- No need to check for fixed runtime-rep
  
  data InferInstFlag  -- Specifies whether the inference should return an uninstantiated
                      -- SigmaType, or a (possibly deeply) instantiated RhoType
                      -- See Note [Instantiation of InferResult] in GHC.Tc.Utils.Unify
  
    = IIF_Sigma       -- Trying to infer a SigmaType
                      -- Don't instantiate at all, regardless of DeepSubsumption
                      -- Typically used when inferring the type of a pattern
  
    | IIF_ShallowRho  -- Trying to infer a shallow RhoType (no foralls or => at the top)
                      -- Top-instantiate (only, regardless of DeepSubsumption) before filling the hole
                      -- Typically used when inferring the type of an expression
  
    | IIF_DeepRho     -- Trying to infer a possibly-deep RhoType (depending on DeepSubsumption)
                      -- If DeepSubsumption is off, same as IIF_ShallowRho
                      -- If DeepSubsumption is on, instantiate deeply before filling the hole
  
  type ExpSigmaType = ExpType
  type ExpRhoType   = ExpType
        -- Invariant: in ExpRhoType, if -XDeepSubsumption is on,
        --            and we are in checking mode (i.e. the ExpRhoType is (Check rho)),
        --            then the `rho` is deeply skolemised
  
  -- | An 'ExpType' which has a fixed RuntimeRep.
  --
  -- For a 'Check' 'ExpType', the stored 'TcType' must have
  -- a fixed RuntimeRep. For an 'Infer' 'ExpType', the 'ir_frr'
  -- field must be of the form @IFRR_Check frr_orig@.
  type ExpTypeFRR = ExpType
  
  -- | Like 'TcSigmaTypeFRR', but for an expected type.
  --
  -- See 'ExpTypeFRR'.
  type ExpSigmaTypeFRR = ExpTypeFRR
  type ExpRhoTypeFRR   = ExpTypeFRR
    -- TODO: consider making this a newtype.
  
  -- | Like 'ExpType', but on kind level
  type ExpKind = ExpType
  
  instance Outputable ExpType where
    ppr (Check ty) = text "Check" <> braces (ppr ty)
    ppr (Infer ir) = ppr ir
  
  instance Outputable InferResult where
    ppr (IR { ir_uniq = u, ir_lvl = lvl, ir_frr = mb_frr, ir_inst = inst })
      = text "Infer" <> parens (pp_inst <> pp_frr)
                     <> braces (ppr u <> comma <> ppr lvl)
      where
       pp_inst = case inst of
                  IIF_Sigma      -> text "Sigma"
                  IIF_ShallowRho -> text "ShallowRho"
                  IIF_DeepRho    -> text "DeepRho"
       pp_frr = case mb_frr of
                  IFRR_Check {} -> text ",FRR"
                  IFRR_Any      -> empty
  
  -- | Make an 'ExpType' suitable for checking.
  mkCheckExpType :: TcType -> ExpType
  mkCheckExpType = Check
  
  -- | Returns the expected type when in checking mode.
  checkingExpType_maybe :: ExpType -> Maybe TcType
  checkingExpType_maybe (Check ty) = Just ty
  checkingExpType_maybe (Infer {}) = Nothing
  
  -- | Returns the expected type when in checking mode.
  --   Panics if in inference mode.
  checkingExpType :: ExpType -> TcType
  checkingExpType (Check ty)    = ty
  checkingExpType et@(Infer {}) = pprPanic "checkingExpType" (ppr et)
  
  -- Expected type of a pattern in a lambda or a function left-hand side.
  data ExpPatType =
      ExpFunPatTy    (Scaled ExpSigmaTypeFRR)   -- the type A of a function A -> B
    | ExpForAllPatTy ForAllTyBinder             -- the binder (a::A) of  forall (a::A) -> B or forall (a :: A). B
  
  mkCheckExpFunPatTy :: Scaled TcType -> ExpPatType
  mkCheckExpFunPatTy (Scaled mult ty) = ExpFunPatTy (Scaled mult (mkCheckExpType ty))
  
  mkInvisExpPatType :: InvisTyBinder -> ExpPatType
  mkInvisExpPatType (Bndr tv spec) = ExpForAllPatTy (Bndr tv (Invisible spec))
  
  isVisibleExpPatType :: ExpPatType -> Bool
  isVisibleExpPatType (ExpForAllPatTy (Bndr _ vis)) = isVisibleForAllTyFlag vis
  isVisibleExpPatType (ExpFunPatTy {})              = True
  
  isExpFunPatType :: ExpPatType -> Bool
  isExpFunPatType ExpFunPatTy{}    = True
  isExpFunPatType ExpForAllPatTy{} = False
  
  instance Outputable ExpPatType where
    ppr (ExpFunPatTy t) = ppr t
    ppr (ExpForAllPatTy tv) = text "forall" <+> ppr tv
  
  {- *********************************************************************
  *                                                                      *
            SyntaxOpType
  *                                                                      *
  ********************************************************************* -}
  
  -- | What to expect for an argument to a rebindable-syntax operator.
  -- Quite like 'Type', but allows for holes to be filled in by tcSyntaxOp.
  -- The callback called from tcSyntaxOp gets a list of types; the meaning
  -- of these types is determined by a left-to-right depth-first traversal
  -- of the 'SyntaxOpType' tree. So if you pass in
  --
  -- > SynAny `SynFun` (SynList `SynFun` SynType Int) `SynFun` SynAny
  --
  -- you'll get three types back: one for the first 'SynAny', the /element/
  -- type of the list, and one for the last 'SynAny'. You don't get anything
  -- for the 'SynType', because you've said positively that it should be an
  -- Int, and so it shall be.
  --
  -- You'll also get three multiplicities back: one for each function arrow. See
  -- also Note [Linear types] in Multiplicity.
  --
  -- This is defined here to avoid defining it in "GHC.Tc.Gen.Expr" boot file.
  data SyntaxOpType
    = SynAny     -- ^ Any type
    | SynRho     -- ^ A rho type, skolemised or instantiated as appropriate
    | SynList    -- ^ A list type. You get back the element type of the list
    | SynFun SyntaxOpType SyntaxOpType
                 -- ^ A function.
    | SynType ExpType   -- ^ A known type.
  infixr 0 `SynFun`
  
  -- | Like 'SynType' but accepts a regular TcType
  synKnownType :: TcType -> SyntaxOpType
  synKnownType = SynType . mkCheckExpType
  
  -- | Like 'mkFunTys' but for 'SyntaxOpType'
  mkSynFunTys :: [SyntaxOpType] -> ExpType -> SyntaxOpType
  mkSynFunTys arg_tys res_ty = foldr SynFun (SynType res_ty) arg_tys
  
  
  {-
  Note [TcRhoType]
  ~~~~~~~~~~~~~~~~
  A TcRhoType has no foralls or contexts at the top
    NO     forall a. a ->  Int
    NO     Eq a => a -> a
    YES    a -> a
    YES    (forall a. a->a) -> Int
    YES    Int -> forall a. a -> Int
  
  
  ************************************************************************
  *                                                                      *
          TyVarDetails, MetaDetails, MetaInfo
  *                                                                      *
  ************************************************************************
  
  TyVarDetails gives extra info about type variables, used during type
  checking.  It's attached to mutable type variables only.
  It's knot-tied back to "GHC.Types.Var".  There is no reason in principle
  why "GHC.Types.Var" shouldn't actually have the definition, but it "belongs" here.
  
  Note [TyVars and TcTyVars during type checking]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  The Var type has constructors TyVar and TcTyVar.  They are used
  as follows:
  
  * TcTyVar: used /only/ during type checking.  Should never appear
    afterwards.  May contain a mutable field, in the MetaTv case.
  
  * TyVar: is never seen by the constraint solver, except locally
    inside a type like (forall a. [a] ->[a]), where 'a' is a TyVar.
    We instantiate these with TcTyVars before exposing the type
    to the constraint solver.
  
  I have swithered about the latter invariant, excluding TyVars from the
  constraint solver.  It's not strictly essential, and indeed
  (historically but still there) Var.tcTyVarDetails returns
  vanillaSkolemTv for a TyVar.
  
  But ultimately I want to separate Type from TcType, and in that case
  we would need to enforce the separation.
  
  Note [Keeping SkolemInfo inside a SkolemTv]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  A SkolemTv contains a SkolemInfo, which describes the binding side of that
  TcTyVar.  This is very convenient to a consumer of a SkolemTv, but it is
  a bit awkward for the /producer/.  Why? Because sometimes we can't produce
  the SkolemInfo until we have the TcTyVars!
  
  Example: in `GHC.Tc.Utils.Unify.tcSkolemise` we create SkolemTvs whose
  `SkolemInfo` is `SigSkol`, whose arguments in turn mention the newly-created
  SkolemTvs.  So we a RecrusiveDo idiom, like this:
  
    rec { (wrap, tv_prs, given, rho_ty) <- skolemise skol_info expected_ty
        ; skol_info <- mkSkolemInfo (SigSkol ctxt expected_ty tv_prs) }
  
  Note that the `skol_info` can't be created until we have the `tv_prs` returned
  by `skolemise`. Note also that `skolemise` had better be lazy in `skol_info`.
  
  All uses of this idiom should be flagged with a reference to this Note.
  -}
  
  -- A TyVarDetails is inside a TyVar
  -- See Note [TyVars and TcTyVars during type checking]
  data TcTyVarDetails
    = SkolemTv      -- A skolem
         SkolemInfo -- See Note [Keeping SkolemInfo inside a SkolemTv]
         TcLevel    -- Level of the implication that binds it
                    -- See GHC.Tc.Utils.Unify Note [Deeper level on the left] for
                    --     how this level number is used
         Bool       -- True <=> this skolem type variable can be overlapped
                    --          when looking up instances
                    -- See Note [Super skolems: binding when looking up instances]
                    --     in GHC.Core.InstEnv
  
    | RuntimeUnk    -- Stands for an as-yet-unknown type in the GHCi
                    -- interactive context
  
    | MetaTv { mtv_info  :: MetaInfo
             , mtv_ref   :: IORef MetaDetails
             , mtv_tclvl :: TcLevel }  -- See Note [TcLevel invariants]
  
  vanillaSkolemTvUnk :: HasDebugCallStack => TcTyVarDetails
  vanillaSkolemTvUnk = SkolemTv unkSkol topTcLevel False
  
  instance Outputable TcTyVarDetails where
    ppr = pprTcTyVarDetails
  
  pprTcTyVarDetails :: TcTyVarDetails -> SDoc
  -- For debugging
  pprTcTyVarDetails (RuntimeUnk {})      = text "rt"
  pprTcTyVarDetails (SkolemTv _sk lvl True)  = text "ssk" <> colon <> ppr lvl
  pprTcTyVarDetails (SkolemTv _sk lvl False) = text "sk"  <> colon <> ppr lvl
  pprTcTyVarDetails (MetaTv { mtv_info = info, mtv_tclvl = tclvl })
    = ppr info <> colon <> ppr tclvl
  
  -----------------------------
  data MetaDetails
    = Flexi  -- Flexi type variables unify to become Indirects
    | Indirect TcType
  
  -- | What restrictions are on this metavariable around unification?
  -- These are checked in GHC.Tc.Utils.Unify.checkTopShape
  data MetaInfo
     = TauTv         -- ^ This MetaTv is an ordinary unification variable
                     -- A TauTv is always filled in with a tau-type, which
                     -- never contains any ForAlls.
  
     | TyVarTv       -- ^ A variant of TauTv, except that it should not be
                     --   unified with a type, only with a type variable
                     -- See Note [TyVarTv] in GHC.Tc.Utils.TcMType
  
     | RuntimeUnkTv  -- ^ A unification variable used in the GHCi debugger.
                     -- It /is/ allowed to unify with a polytype, unlike TauTv
  
     | CycleBreakerTv  -- ^ Used to fix occurs-check problems in Givens
                       -- See Note [Type equality cycles] in
                       -- GHC.Tc.Solver.Equality
  
     | ConcreteTv ConcreteTvOrigin
          -- ^ A unification variable that can only be unified
          -- with a concrete type, in the sense of
          -- Note [Concrete types] in GHC.Tc.Utils.Concrete.
          -- See Note [ConcreteTv] in GHC.Tc.Utils.Concrete.
          -- See also Note [The Concrete mechanism] in GHC.Tc.Utils.Concrete
          -- for an overview of how this works in context.
  
  instance Outputable MetaDetails where
    ppr Flexi         = text "Flexi"
    ppr (Indirect ty) = text "Indirect" <+> ppr ty
  
  instance Outputable MetaInfo where
    ppr TauTv           = text "tau"
    ppr TyVarTv         = text "tyv"
    ppr RuntimeUnkTv    = text "rutv"
    ppr CycleBreakerTv  = text "cbv"
    ppr (ConcreteTv {}) = text "conc"
  
  -- | What caused us to create a 'ConcreteTv' metavariable?
  -- See Note [ConcreteTv] in GHC.Tc.Utils.Concrete.
  data ConcreteTvOrigin
     -- | A 'ConcreteTv' used to enforce the representation-polymorphism invariants.
     --
     -- See 'FixedRuntimeRepOrigin' for more information.
    = ConcreteFRR FixedRuntimeRepOrigin
  
  -- | A mapping from skolem type variable 'Name' to concreteness information,
  --
  -- See Note [Representation-polymorphism checking built-ins] in GHC.Tc.Utils.Concrete.
  type ConcreteTyVars = NameEnv ConcreteTvOrigin
  -- | The 'Id' has no outer forall'd type variables which must be instantiated
  -- to concrete types.
  noConcreteTyVars :: ConcreteTyVars
  noConcreteTyVars = emptyNameEnv
  
  {- *********************************************************************
  *                                                                      *
                  Untouchable type variables
  *                                                                      *
  ********************************************************************* -}
  
  data TcLevel = TcLevel {-# UNPACK #-} !Int
               | QLInstVar
    -- See Note [TcLevel invariants] for what this Int is
    -- See also Note [TcLevel assignment]
    -- See also Note [The QLInstVar TcLevel]
  
  {-
  Note [TcLevel invariants]
  ~~~~~~~~~~~~~~~~~~~~~~~~~
  * Each unification variable (MetaTv)
    and skolem (SkolemTv)
    and each Implication
    has a level number (of type TcLevel)
  
  * INVARIANT (KindInv) Given a type variable (tv::ki) at at level L,
                        the free vars of `ki` all have level <= L
  
  * INVARIANTS.  In a tree of Implications,
  
      (ImplicInv) The level number (ic_tclvl) of an Implication is
                  STRICTLY GREATER THAN that of its parent
  
      (SkolInv)   The level number of the skolems (ic_skols) of an
                  Implication is equal to the level of the implication
                  itself (ic_tclvl)
  
      (GivenInv)  The level number of a unification variable appearing
                  in the 'ic_given' of an implication I should be
                  STRICTLY LESS THAN the ic_tclvl of I
                  See Note [GivenInv]
  
      (WantedInv) The level number of a unification variable appearing
                  in the 'ic_wanted' of an implication I should be
                  LESS THAN OR EQUAL TO the ic_tclvl of I
                  See Note [WantedInv]
  
  The level of a MetaTyVar also governs its untouchability.  See
  Note [Unification preconditions] in GHC.Tc.Utils.Unify.
  
    -- See also Note [The QLInstVar TcLevel]
  
  Note [TcLevel assignment]
  ~~~~~~~~~~~~~~~~~~~~~~~~~
  We arrange the TcLevels like this
  
     0          Top level
     1          First-level implication constraints
     2          Second-level implication constraints
     ...etc...
     QLInstVar  The level for QuickLook instantiation variables
                See Note [The QLInstVar TcLevel]
  
  Note [The QLInstVar TcLevel]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  QuickLook instantiation variables are identified by having a TcLevel
  of QLInstVar.  See Note [Quick Look overview] in GHC.Tc.Gen.App.
  
  The QLInstVar level behaves like infinity: it is greater than any
  other TcLevel.  See `strictlyDeeperThan` and friends in this module.
  That ensures that we never unify an ordinary unification variable
  with a QL instantiation variable, e.g.
        alpha[tau:3] := Maybe beta[tau:qlinstvar]
  (This is an immediate consequence of our general rule that we never
  unify a variable with a type mentioning deeper variables; the skolem
  escape check.)
  
  QL instantation variables are eventually turned into ordinary unificaiton
  variables; see (QL3) in Note [Quick Look overview].
  
  Note [GivenInv]
  ~~~~~~~~~~~~~~~
  Invariant (GivenInv) is not essential, but it is easy to guarantee, and
  it is a useful extra piece of structure.  It ensures that the Givens of
  an implication don't change because of unifications /at the same level/
  caused by Wanteds.  (Wanteds can also cause unifications at an outer
  level, but that will iterate the entire implication; see GHC.Tc.Solver.Monad
  Note [The Unification Level Flag].)
  
  Givens can certainly contain meta-tyvars from /outer/ levels.  E.g.
     data T a where
       MkT :: Eq a => a -> MkT a
  
     f x = case x of MkT y -> y && True
  
  Then we'll infer (x :: T alpha[1]).  The Givens from the implication
  arising from the pattern match will look like this:
  
     forall[2] . Eq alpha[1] => (alpha[1] ~ Bool)
  
  But if we unify alpha (which in this case we will), we'll iterate
  the entire implication via Note [The Unification Level Flag] in
  GHC.Tc.Solver.Monad.  That isn't true of unifications at the /ambient/
  level.
  
  It would be entirely possible to weaken (GivenInv), to LESS THAN OR
  EQUAL TO, but we'd need to think carefully about
    - kick-out for Givens
    - GHC.Tc.Solver.Monad.isOuterTyVar
  But in fact (GivenInv) is automatically true, so we're adhering to
  it for now.  See #18929.
  
  * If a tyvar tv has level n, then the levels of all variables free
    in tv's kind are <= n. Consequence: if tv is untouchable, so are
    all variables in tv's kind.
  
  Note [WantedInv]
  ~~~~~~~~~~~~~~~~
  Why is WantedInv important?  Consider this implication, where
  the constraint (C alpha[3]) disobeys WantedInv:
  
     forall[2] a. blah => (C alpha[3])
                          (forall[3] b. alpha[3] ~ b)
  
  We can unify alpha:=b in the inner implication, because 'alpha' is
  touchable; but then 'b' has escaped its scope into the outer implication.
  -}
  
  maxTcLevel :: TcLevel -> TcLevel -> TcLevel
  maxTcLevel (TcLevel a) (TcLevel b)
    | a > b      = TcLevel a
    | otherwise  = TcLevel b
  maxTcLevel _ _ = QLInstVar
  
  minTcLevel :: TcLevel -> TcLevel -> TcLevel
  minTcLevel tcla@(TcLevel a) tclb@(TcLevel b)
    | a < b                              = tcla
    | otherwise                          = tclb
  minTcLevel tcla@(TcLevel {}) QLInstVar = tcla
  minTcLevel QLInstVar tclb@(TcLevel {}) = tclb
  minTcLevel QLInstVar QLInstVar         = QLInstVar
  
  topTcLevel :: TcLevel
  -- See Note [TcLevel assignment]
  topTcLevel = TcLevel 0   -- 0 = outermost level
  
  isTopTcLevel :: TcLevel -> Bool
  isTopTcLevel (TcLevel 0) = True
  isTopTcLevel _            = False
  
  pushTcLevel :: TcLevel -> TcLevel
  -- See Note [TcLevel assignment]
  pushTcLevel (TcLevel us) = TcLevel (us + 1)
  pushTcLevel QLInstVar    = QLInstVar
  
  strictlyDeeperThan :: TcLevel -> TcLevel -> Bool
  -- See Note [The QLInstVar TcLevel]
  strictlyDeeperThan (TcLevel tv_tclvl) (TcLevel ctxt_tclvl)
    = tv_tclvl > ctxt_tclvl
  strictlyDeeperThan QLInstVar (TcLevel {})  = True
  strictlyDeeperThan _ _                     = False
  
  deeperThanOrSame :: TcLevel -> TcLevel -> Bool
  -- See Note [The QLInstVar TcLevel]
  deeperThanOrSame (TcLevel tv_tclvl) (TcLevel ctxt_tclvl)
    = tv_tclvl >= ctxt_tclvl
  deeperThanOrSame (TcLevel {}) QLInstVar  = False
  deeperThanOrSame QLInstVar    _           = True
  
  sameDepthAs :: TcLevel -> TcLevel -> Bool
  sameDepthAs (TcLevel ctxt_tclvl) (TcLevel tv_tclvl)
    = ctxt_tclvl == tv_tclvl
      -- NB: invariant ctxt_tclvl >= tv_tclvl
      --     So <= would be equivalent
  sameDepthAs QLInstVar QLInstVar = True
  sameDepthAs _         _         = False
  
  checkTcLevelInvariant :: TcLevel -> TcLevel -> Bool
  -- Checks (WantedInv) from Note [TcLevel invariants]
  checkTcLevelInvariant ctxt_tclvl tv_tclvl
    = ctxt_tclvl `deeperThanOrSame` tv_tclvl
  
  -- Returns topTcLevel for non-TcTyVars
  tcTyVarLevel :: TcTyVar -> TcLevel
  tcTyVarLevel tv
    = case tcTyVarDetails tv of
            MetaTv { mtv_tclvl = tv_lvl } -> tv_lvl
            SkolemTv _ tv_lvl _           -> tv_lvl
            RuntimeUnk                    -> topTcLevel
  
  
  tcTypeLevel :: TcType -> TcLevel
  -- Max level of any free var of the type
  tcTypeLevel ty
    = nonDetStrictFoldDVarSet add topTcLevel (tyCoVarsOfTypeDSet ty)
      -- It's safe to use a non-deterministic fold because `maxTcLevel` is
      -- commutative.
    where
      add v lvl
        | isTcTyVar v = lvl `maxTcLevel` tcTyVarLevel v
        | otherwise = lvl
  
  instance Outputable TcLevel where
    ppr (TcLevel n) = ppr n
    ppr QLInstVar   = text "qlinst"
  
  {- *********************************************************************
  *                                                                      *
      Finding type family instances
  *                                                                      *
  ************************************************************************
  -}
  
  -- | Finds outermost type-family applications occurring in a type,
  -- after expanding synonyms.  In the list (F, tys) that is returned
  -- we guarantee that tys matches F's arity.  For example, given
  --    type family F a :: * -> *    (arity 1)
  -- calling tcTyFamInsts on (Maybe (F Int Bool) will return
  --     (F, [Int]), not (F, [Int,Bool])
  --
  -- This is important for its use in deciding termination of type
  -- instances (see #11581).  E.g.
  --    type instance G [Int] = ...(F Int \<big type>)...
  -- we don't need to take \<big type> into account when asking if
  -- the calls on the RHS are smaller than the LHS
  tcTyFamInsts :: Type -> [(TyCon, [Type])]
  tcTyFamInsts = map (\(_,b,c) -> (b,c)) . tcTyFamInstsAndVis
  
  -- | Like 'tcTyFamInsts', except that the output records whether the
  -- type family and its arguments occur as an /invisible/ argument in
  -- some type application. This information is useful because it helps GHC know
  -- when to turn on @-fprint-explicit-kinds@ during error reporting so that
  -- users can actually see the type family being mentioned.
  --
  -- As an example, consider:
  --
  -- @
  -- class C a
  -- data T (a :: k)
  -- type family F a :: k
  -- instance C (T @(F Int) (F Bool))
  -- @
  --
  -- There are two occurrences of the type family `F` in that `C` instance, so
  -- @'tcTyFamInstsAndVis' (C (T \@(F Int) (F Bool)))@ will return:
  --
  -- @
  -- [ ('True',  F, [Int])
  -- , ('False', F, [Bool]) ]
  -- @
  --
  -- @F Int@ is paired with 'True' since it appears as an /invisible/ argument
  -- to @C@, whereas @F Bool@ is paired with 'False' since it appears an a
  -- /visible/ argument to @C@.
  --
  -- See also Note [Showing invisible bits of types in error messages]
  -- in "GHC.Tc.Errors.Ppr".
  tcTyFamInstsAndVis :: Type -> [(Bool, TyCon, [Type])]
  tcTyFamInstsAndVis = tcTyFamInstsAndVisX False
  
  tcTyFamInstsAndVisX
    :: Bool -- ^ Is this an invisible argument to some type application?
    -> Type -> [(Bool, TyCon, [Type])]
  tcTyFamInstsAndVisX = go
    where
      go is_invis_arg ty
        | Just exp_ty <- coreView ty     = go is_invis_arg exp_ty
      go _ (TyVarTy _)                   = []
      go is_invis_arg (TyConApp tc tys)
        | isTypeFamilyTyCon tc
        = [(is_invis_arg, tc, take (tyConArity tc) tys)]
        | otherwise
        = tcTyConAppTyFamInstsAndVisX is_invis_arg tc tys
      go _            (LitTy {})         = []
      go is_invis_arg (ForAllTy bndr ty) = go is_invis_arg (binderType bndr)
                                           ++ go is_invis_arg ty
      go is_invis_arg (FunTy _ w ty1 ty2)  = go is_invis_arg w
                                           ++ go is_invis_arg ty1
                                           ++ go is_invis_arg ty2
      go is_invis_arg ty@(AppTy _ _)     =
        let (ty_head, ty_args) = splitAppTys ty
            ty_arg_flags       = appTyForAllTyFlags ty_head ty_args
        in go is_invis_arg ty_head
           ++ concat (zipWith (\flag -> go (isInvisibleForAllTyFlag flag))
                              ty_arg_flags ty_args)
      go is_invis_arg (CastTy ty _)      = go is_invis_arg ty
      go _            (CoercionTy _)     = [] -- don't count tyfams in coercions,
                                              -- as they never get normalized,
                                              -- anyway
  
  -- | In an application of a 'TyCon' to some arguments, find the outermost
  -- occurrences of type family applications within the arguments. This function
  -- will not consider the 'TyCon' itself when checking for type family
  -- applications.
  --
  -- See 'tcTyFamInstsAndVis' for more details on how this works (as this
  -- function is called inside of 'tcTyFamInstsAndVis').
  tcTyConAppTyFamInstsAndVis :: TyCon -> [Type] -> [(Bool, TyCon, [Type])]
  tcTyConAppTyFamInstsAndVis = tcTyConAppTyFamInstsAndVisX False
  
  tcTyConAppTyFamInstsAndVisX
    :: Bool -- ^ Is this an invisible argument to some type application?
    -> TyCon -> [Type] -> [(Bool, TyCon, [Type])]
  tcTyConAppTyFamInstsAndVisX is_invis_arg tc tys =
    let (invis_tys, vis_tys) = partitionInvisibleTypes tc tys
    in concat $ map (tcTyFamInstsAndVisX True)         invis_tys
             ++ map (tcTyFamInstsAndVisX is_invis_arg) vis_tys
  
  isTyFamFree :: Type -> Bool
  -- ^ Check that a type does not contain any type family applications.
  isTyFamFree = null . tcTyFamInsts
  
  type UnderFam = Bool   -- True <=> we are in the argument of a type family application
  
  any_rewritable :: EqRel   -- Ambient role
                 -> (UnderFam -> EqRel -> TcTyVar -> Bool)           -- Check tyvar
                 -> (UnderFam -> EqRel -> TyCon -> [TcType] -> Bool) -- Check type family application
                 -> TcType -> Bool
  -- Checks every tyvar and tyconapp (not including FunTys) within a type,
  -- ORing the results of the predicates above together
  -- Do not look inside casts and coercions
  -- See Note [anyRewritableTyVar must be role-aware]
  --
  -- This looks like it should use foldTyCo, but that function is
  -- role-agnostic, and this one must be role-aware. We could make
  -- foldTyCon role-aware, but that may slow down more common usages.
  --
  -- See Note [Rewritable] in GHC.Tc.Solver.InertSet for a specification for this function.
  {-# INLINE any_rewritable #-} -- this allows specialization of predicates
  any_rewritable role tv_pred tc_pred ty
    = go False emptyVarSet role ty
    where
      go_tv uf bvs rl tv | tv `elemVarSet` bvs = False
                         | otherwise           = tv_pred uf rl tv
  
      go :: UnderFam -> VarSet -> EqRel -> TcType -> Bool
      go under_fam bvs rl (TyConApp tc tys)
  
        -- Expand synonyms, unless (a) we are at Nominal role and (b) the synonym
        -- is type-family-free; then it suffices just to look at the args
        | isTypeSynonymTyCon tc
        , case rl of { NomEq -> not (isFamFreeTyCon tc); ReprEq -> True }
        , Just ty' <- expandSynTyConApp_maybe tc tys
        = go under_fam bvs rl ty'
  
        -- Check if we are going under a type family application
        | case rl of
             NomEq  -> isTypeFamilyTyCon tc
             ReprEq -> isFamilyTyCon     tc
        = if | tc_pred under_fam rl tc tys -> True
             | otherwise                   -> go_fam under_fam (tyConArity tc) bvs tys
  
        | otherwise
        = go_tc under_fam bvs rl tc tys
  
      go uf bvs rl (TyVarTy tv)        = go_tv uf bvs rl tv
      go _  _    _ (LitTy {})          = False
      go uf bvs rl (AppTy fun arg)     = go uf bvs rl fun || go uf bvs NomEq arg
      go uf bvs rl (FunTy _ w arg res) = go uf bvs NomEq arg_rep || go uf bvs NomEq res_rep ||
                                         go uf bvs rl arg || go uf bvs rl res || go uf bvs NomEq w
        where arg_rep = getRuntimeRep arg -- forgetting these causes #17024
              res_rep = getRuntimeRep res
      go uf bvs rl (ForAllTy tv ty)   = go uf (bvs `extendVarSet` binderVar tv) rl ty
      go uf bvs rl (CastTy ty _)      = go uf bvs rl ty
      go _  _   _  (CoercionTy _)     = False
  
      go_tc :: UnderFam -> VarSet -> EqRel -> TyCon -> [TcType] -> Bool
      go_tc uf bvs NomEq  _  tys = any (go uf bvs NomEq) tys
      go_tc uf bvs ReprEq tc tys = any2 (go_arg uf bvs) tys (tyConRoleListRepresentational tc)
  
      go_arg uf bvs ty Nominal          = go uf bvs NomEq ty
      go_arg uf bvs ty Representational = go uf bvs ReprEq ty
      go_arg _   _  _  Phantom          = False  -- We never rewrite with phantoms
  
      -- For a type-family or data-family application (F t1 .. tn), all arguments
      --   have Nominal role (whether in F's arity or, if over-saturated, beyond it)
      -- Switch on under_fam for arguments <= arity
      go_fam uf 0 bvs tys      = any (go uf bvs NomEq) tys   -- Like AppTy
      go_fam _  _ _   []       = False
      go_fam uf n bvs (ty:tys) = go True bvs NomEq ty || go_fam uf (n-1) bvs tys
                                 -- True <=> switch on under_fam
  
  anyRewritableTyVar :: EqRel    -- Ambient role
                     -> (UnderFam -> EqRel -> TcTyVar -> Bool)  -- check tyvar
                     -> TcType -> Bool
  -- See Note [Rewritable] in GHC.Tc.Solver.InertSet for a specification for this function.
  anyRewritableTyVar role check_tv
    = any_rewritable role
        check_tv
        (\ _ _ _ _ -> False) -- No special check for tyconapps
                             -- (this False is ORed with other results,
                             --  so it really means "do nothing special";
                             --  the arguments are still inspected)
  
  anyRewritableTyFamApp :: EqRel   -- Ambient role
                        -> (UnderFam -> EqRel -> TyCon -> [TcType] -> Bool)
                           -- Check a type-family application
                        -> TcType -> Bool
    -- always ignores casts & coercions
  -- See Note [Rewritable] in GHC.Tc.Solver.InertSet for a specification for this function.
  anyRewritableTyFamApp role check_tyconapp
    = any_rewritable role (\ _ _ _ -> False) check_tyconapp
  
  {- Note [anyRewritableTyVar must be role-aware]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  anyRewritableTyVar is used during kick-out from the inert set,
  to decide if, given a new equality (a ~ ty), we should kick out
  a constraint C.  Rather than gather free variables and see if 'a'
  is among them, we instead pass in a predicate; this is just efficiency.
  
  Moreover, consider
    work item:   [G] a ~R f b
    inert item:  [G] b ~R f a
  We use anyRewritableTyVar to decide whether to kick out the inert item,
  on the grounds that the work item might rewrite it. Well, 'a' is certainly
  free in [G] b ~R f a.  But because the role of a type variable ('f' in
  this case) is nominal, the work item can't actually rewrite the inert item.
  Moreover, if we were to kick out the inert item the exact same situation
  would re-occur and we end up with an infinite loop in which each kicks
  out the other (#14363).
  
  -}
  
  {- *********************************************************************
  *                                                                      *
            The "exact" free variables of a type
  *                                                                      *
  ********************************************************************* -}
  
  {- Note [Silly type synonym]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  Consider
    type T a = Int
  What are the free tyvars of (T x)?  Empty, of course!
  
  exactTyCoVarsOfType is used by the type checker to figure out exactly
  which type variables are mentioned in a type.  It only matters
  occasionally -- see the calls to exactTyCoVarsOfType.
  
  We place this function here in GHC.Tc.Utils.TcType, not in GHC.Core.TyCo.FVs,
  because we want to "see" coreView (efficiency issue only).
  -}
  
  exactTyCoVarsOfType  :: Type   -> TyCoVarSet
  exactTyCoVarsOfTypes :: [Type] -> TyCoVarSet
  -- Find the free type variables (of any kind)
  -- but *expand* type synonyms.  See Note [Silly type synonym] above.
  
  exactTyCoVarsOfType  ty  = runTyCoVars (exact_ty ty)
  exactTyCoVarsOfTypes tys = runTyCoVars (exact_tys tys)
  
  exact_ty  :: Type       -> Endo TyCoVarSet
  exact_tys :: [Type]     -> Endo TyCoVarSet
  (exact_ty, exact_tys, _, _) = foldTyCo exactTcvFolder emptyVarSet
  
  exactTcvFolder :: TyCoFolder TyCoVarSet (Endo TyCoVarSet)
  exactTcvFolder = deepTcvFolder { tcf_view = coreView }
                   -- This is the key line
  
  {-
  ************************************************************************
  *                                                                      *
                  Predicates
  *                                                                      *
  ************************************************************************
  -}
  
  tcIsTcTyVar :: TcTyVar -> Bool
  -- See Note [TcTyVars and TyVars in the typechecker]
  tcIsTcTyVar tv = isTyVar tv
  
  isPromotableMetaTyVar :: TcTyVar -> Bool
  -- True is this is a meta-tyvar that can be
  -- promoted to an outer level
  isPromotableMetaTyVar tv
    | isTyVar tv -- See Note [Coercion variables in free variable lists]
    , MetaTv { mtv_info = info } <- tcTyVarDetails tv
    = isTouchableInfo info   -- Can't promote cycle breakers
    | otherwise
    = False
  
  isTouchableMetaTyVar :: TcLevel -> TcTyVar -> Bool
  isTouchableMetaTyVar ctxt_tclvl tv
    | isTyVar tv -- See Note [Coercion variables in free variable lists]
    , MetaTv { mtv_tclvl = tv_tclvl, mtv_info = info } <- tcTyVarDetails tv
    , isTouchableInfo info
    = assertPpr (checkTcLevelInvariant ctxt_tclvl tv_tclvl)
                (ppr tv $$ ppr tv_tclvl $$ ppr ctxt_tclvl) $
      tv_tclvl `sameDepthAs` ctxt_tclvl
  
    | otherwise = False
  
  isImmutableTyVar :: TyVar -> Bool
  isImmutableTyVar tv = isSkolemTyVar tv
  
  isTyConableTyVar, isSkolemTyVar, isOverlappableTyVar,
    isMetaTyVar, isAmbiguousTyVar, isCycleBreakerTyVar :: TcTyVar -> Bool
  
  isTyConableTyVar tv
          -- True of a meta-type variable that can be filled in
          -- with a type constructor application; in particular,
          -- not a TyVarTv
    | isTyVar tv -- See Note [Coercion variables in free variable lists]
    = case tcTyVarDetails tv of
          MetaTv { mtv_info = TyVarTv } -> False
          _                             -> True
    | otherwise = True
  
  isSkolemTyVar tv
    = assertPpr (tcIsTcTyVar tv) (ppr tv) $
      case tcTyVarDetails tv of
          MetaTv {} -> False
          _other    -> True
  
  skolemSkolInfo :: TcTyVar -> SkolemInfo
  skolemSkolInfo tv
    = assert (isSkolemTyVar tv) $
      case tcTyVarDetails tv of
        SkolemTv skol_info _ _ -> skol_info
        RuntimeUnk -> panic "RuntimeUnk"
        MetaTv {} -> panic "skolemSkolInfo"
  
  
  isOverlappableTyVar tv
    | isTyVar tv -- See Note [Coercion variables in free variable lists]
    = case tcTyVarDetails tv of
          SkolemTv _ _ overlappable -> overlappable
          _                       -> False
    | otherwise = False
  
  isMetaTyVar tv
    | isTyVar tv -- See Note [Coercion variables in free variable lists]
    = case tcTyVarDetails tv of
          MetaTv {} -> True
          _         -> False
    | otherwise = False
  
  -- isAmbiguousTyVar is used only when reporting type errors
  -- It picks out variables that are unbound, namely meta
  -- type variables and the RuntimeUnk variables created by
  -- GHC.Runtime.Heap.Inspect.zonkRTTIType.  These are "ambiguous" in
  -- the sense that they stand for an as-yet-unknown type
  isAmbiguousTyVar tv
    | isTyVar tv -- See Note [Coercion variables in free variable lists]
    = case tcTyVarDetails tv of
          MetaTv {}     -> True
          RuntimeUnk {} -> True
          _             -> False
    | otherwise = False
  
  isQLInstTyVar :: TcTyVar -> Bool
  isQLInstTyVar tv
    = case tcTyVarDetails tv of
        MetaTv { mtv_tclvl = QLInstVar } -> True
        _                                -> False
  
  isRuntimeUnkTyVar :: TcTyVar -> Bool
  isRuntimeUnkTyVar tv
    = case tcTyVarDetails tv of
        MetaTv { mtv_info = RuntimeUnkTv } -> True
        _                                  -> False
  
  isCycleBreakerTyVar tv
    | isTyVar tv -- See Note [Coercion variables in free variable lists]
    , MetaTv { mtv_info = CycleBreakerTv } <- tcTyVarDetails tv
    = True
  
    | otherwise
    = False
  
  -- | Is this type variable a concrete type variable, i.e.
  -- it is a metavariable with 'ConcreteTv' 'MetaInfo'?
  --
  -- Returns the 'ConcreteTvOrigin' stored in the type variable
  -- if so, or 'Nothing' otherwise.
  isConcreteTyVar_maybe :: TcTyVar -> Maybe ConcreteTvOrigin
  isConcreteTyVar_maybe tv
    | isTcTyVar tv
    , MetaTv { mtv_info = ConcreteTv conc_orig } <- tcTyVarDetails tv
    = Just conc_orig
    | otherwise
    = Nothing
  
  concreteInfo_maybe :: MetaInfo -> Maybe ConcreteTvOrigin
  concreteInfo_maybe (ConcreteTv conc_orig) = Just conc_orig
  concreteInfo_maybe _                      = Nothing
  
  -- | Is this type variable a concrete type variable, i.e.
  -- it is a metavariable with 'ConcreteTv' 'MetaInfo'?
  isConcreteTyVar :: TcTyVar -> Bool
  isConcreteTyVar = isJust . isConcreteTyVar_maybe
  
  -- | Is this type concrete type variable, i.e.
  -- a metavariable with 'ConcreteTv' 'MetaInfo'?
  isConcreteTyVarTy :: TcType -> Bool
  isConcreteTyVarTy = isJust . isConcreteTyVarTy_maybe
  
  -- | Is this type a concrete type variable? If so, return
  -- the associated 'TcTyVar' and 'ConcreteTvOrigin'.
  isConcreteTyVarTy_maybe :: TcType -> Maybe (TcTyVar, ConcreteTvOrigin)
  isConcreteTyVarTy_maybe (TyVarTy tv) = (tv, ) <$> isConcreteTyVar_maybe tv
  isConcreteTyVarTy_maybe _            = Nothing
  
  isMetaTyVarTy :: TcType -> Bool
  isMetaTyVarTy (TyVarTy tv) = isMetaTyVar tv
  isMetaTyVarTy _            = False
  
  metaTyVarInfo :: TcTyVar -> MetaInfo
  metaTyVarInfo tv
    = case tcTyVarDetails tv of
        MetaTv { mtv_info = info } -> info
        _ -> pprPanic "metaTyVarInfo" (ppr tv)
  
  isTouchableInfo :: MetaInfo -> Bool
  isTouchableInfo info
    | CycleBreakerTv <- info = False
    | otherwise              = True
  
  metaTyVarTcLevel :: TcTyVar -> TcLevel
  metaTyVarTcLevel tv
    = case tcTyVarDetails tv of
        MetaTv { mtv_tclvl = tclvl } -> tclvl
        _ -> pprPanic "metaTyVarTcLevel" (ppr tv)
  
  metaTyVarTcLevel_maybe :: TcTyVar -> Maybe TcLevel
  metaTyVarTcLevel_maybe tv
    = case tcTyVarDetails tv of
        MetaTv { mtv_tclvl = tclvl } -> Just tclvl
        _                            -> Nothing
  
  metaTyVarRef :: TyVar -> IORef MetaDetails
  metaTyVarRef tv
    = case tcTyVarDetails tv of
          MetaTv { mtv_ref = ref } -> ref
          _ -> pprPanic "metaTyVarRef" (ppr tv)
  
  setMetaTyVarTcLevel :: TcTyVar -> TcLevel -> TcTyVar
  setMetaTyVarTcLevel tv tclvl
    = case tcTyVarDetails tv of
        details@(MetaTv {}) -> setTcTyVarDetails tv (details { mtv_tclvl = tclvl })
        _ -> pprPanic "metaTyVarTcLevel" (ppr tv)
  
  isTyVarTyVar :: Var -> Bool
  isTyVarTyVar tv
    = case tcTyVarDetails tv of
          MetaTv { mtv_info = TyVarTv } -> True
          _                             -> False
  
  isFlexi, isIndirect :: MetaDetails -> Bool
  isFlexi Flexi = True
  isFlexi _     = False
  
  isIndirect (Indirect _) = True
  isIndirect _            = False
  
  isRuntimeUnkSkol :: TyVar -> Bool
  -- Called only in GHC.Tc.Errors; see Note [Runtime skolems] there
  isRuntimeUnkSkol x
    | RuntimeUnk <- tcTyVarDetails x = True
    | otherwise                      = False
  
  mkTyVarNamePairs :: [TyVar] -> [(Name,TyVar)]
  -- Just pair each TyVar with its own name
  mkTyVarNamePairs tvs = [(tyVarName tv, tv) | tv <- tvs]
  
  findDupTyVarTvs :: [(Name,TcTyVar)] -> [(Name,Name)]
  -- If we have [...(x1,tv)...(x2,tv)...]
  -- return (x1,x2) in the result list
  findDupTyVarTvs prs
    = concatMap mk_result_prs $
      findDupsEq eq_snd prs
    where
      eq_snd (_,tv1) (_,tv2) = tv1 == tv2
      mk_result_prs ((n1,_) :| xs) = map (\(n2,_) -> (n1,n2)) xs
  
  -- | Returns the (kind, type) variables in a type that are
  -- as-yet-unknown: metavariables and RuntimeUnks
  ambigTkvsOfTy :: TcType -> ([Var],[Var])
  ambigTkvsOfTy ty
    = partition (`elemVarSet` dep_tkv_set) ambig_tkvs
    where
      tkvs        = tyCoVarsOfTypeList ty
      ambig_tkvs  = filter isAmbiguousTyVar tkvs
      dep_tkv_set = tyCoVarsOfTypes (map tyVarKind tkvs)
  
  {-
  ************************************************************************
  *                                                                      *
     Tau, sigma and rho
  *                                                                      *
  ************************************************************************
  -}
  
  -- | Make a sigma ty where all type variables are 'Inferred'. That is,
  -- they cannot be used with visible type application.
  mkInfSigmaTy :: HasDebugCallStack => [TyCoVar] -> [PredType] -> Type -> Type
  mkInfSigmaTy tyvars theta ty = mkSigmaTy (mkForAllTyBinders Inferred tyvars) theta ty
  
  -- | Make a sigma ty where all type variables are "specified". That is,
  -- they can be used with visible type application
  mkSpecSigmaTy :: HasDebugCallStack => [TyVar] -> [PredType] -> Type -> Type
  mkSpecSigmaTy tyvars preds ty = mkSigmaTy (mkForAllTyBinders Specified tyvars) preds ty
  
  mkSigmaTy :: HasDebugCallStack => [ForAllTyBinder] -> [PredType] -> Type -> Type
  -- Result is TypeLike
  mkSigmaTy bndrs theta tau = mkForAllTys bndrs (mkPhiTy theta tau)
  
  tcMkDFunSigmaTy :: [TyVar] -> ThetaType -> Type -> Type
  tcMkDFunSigmaTy tvs theta res_ty
   = mkForAllTys (mkForAllTyBinders Specified tvs) $
     tcMkDFunPhiTy theta res_ty
  
  mkPhiTy :: HasDebugCallStack => [PredType] -> Type -> Type
  -- Result type is TypeLike
  mkPhiTy = mkInvisFunTys
  
  tcMkPhiTy :: HasDebugCallStack => [PredType] -> Type -> Type
  -- Like mkPhiTy, but with no assertion checks; it is called
  -- by the type checker and the result kind may not be zonked yet
  -- But the result kind is TypeLike
  tcMkPhiTy tys ty = foldr (tcMkInvisFunTy TypeLike) ty tys
  
  tcMkDFunPhiTy :: HasDebugCallStack => [PredType] -> Type -> Type
  -- Just like tcMkPhiTy, but result type is ConstraintLike
  tcMkDFunPhiTy preds res = foldr (tcMkInvisFunTy ConstraintLike) res preds
  
  ---------------
  getDFunTyKey :: Type -> OccName -- Get some string from a type, to be used to
                                  -- construct a dictionary function name
  getDFunTyKey ty | Just ty' <- coreView ty = getDFunTyKey ty'
  getDFunTyKey (TyVarTy tv)            = getOccName tv
  getDFunTyKey (TyConApp tc _)         = getOccName tc
  getDFunTyKey (LitTy x)               = getDFunTyLitKey x
  getDFunTyKey (AppTy fun _)           = getDFunTyKey fun
  getDFunTyKey (FunTy { ft_af = af })  = getOccName (funTyFlagTyCon af)
  getDFunTyKey (ForAllTy _ t)          = getDFunTyKey t
  getDFunTyKey (CastTy ty _)           = getDFunTyKey ty
  getDFunTyKey t@(CoercionTy _)        = pprPanic "getDFunTyKey" (ppr t)
  
  getDFunTyLitKey :: TyLit -> OccName
  getDFunTyLitKey (NumTyLit n) = mkOccName Name.varName (show n)
  getDFunTyLitKey (StrTyLit n) = mkOccName Name.varName (show n)  -- hm
  getDFunTyLitKey (CharTyLit n) = mkOccName Name.varName (show n)
  
  {-
  ************************************************************************
  *                                                                      *
     Expanding and splitting
  *                                                                      *
  ************************************************************************
  -}
  
  -- | Splits a forall type into a list of 'PiTyVarBinder's and the inner type.
  -- Always succeeds, even if it returns an empty list.
  tcSplitPiTys :: Type -> ([PiTyVarBinder], Type)
  tcSplitPiTys ty
    = assert (all isTyBinder (fst sty))   -- No CoVar binders here
      sty
    where sty = splitPiTys ty
  
  -- | Splits a type into a PiTyVarBinder and a body, if possible.
  tcSplitPiTy_maybe :: Type -> Maybe (PiTyVarBinder, Type)
  tcSplitPiTy_maybe ty
    = assert (isMaybeTyBinder sty)  -- No CoVar binders here
      sty
    where
      sty = splitPiTy_maybe ty
      isMaybeTyBinder (Just (t,_)) = isTyBinder t
      isMaybeTyBinder _            = True
  
  tcSplitForAllTyVarBinder_maybe :: Type -> Maybe (TyVarBinder, Type)
  tcSplitForAllTyVarBinder_maybe ty | Just ty' <- coreView ty = tcSplitForAllTyVarBinder_maybe ty'
  tcSplitForAllTyVarBinder_maybe (ForAllTy tv ty) = assert (isTyVarBinder tv ) Just (tv, ty)
  tcSplitForAllTyVarBinder_maybe _                = Nothing
  
  -- | Like 'tcSplitPiTys', but splits off only named binders,
  -- returning just the tyvars.
  tcSplitForAllTyVars :: Type -> ([TyVar], Type)
  tcSplitForAllTyVars ty
    = assert (all isTyVar (fst sty)) sty
    where sty = splitForAllTyCoVars ty
  
  -- | Like 'tcSplitForAllTyVars', but only splits 'ForAllTy's with 'Invisible'
  -- type variable binders.
  tcSplitForAllInvisTyVars :: Type -> ([TyVar], Type)
  tcSplitForAllInvisTyVars ty = tcSplitSomeForAllTyVars isInvisibleForAllTyFlag ty
  
  -- | Like 'tcSplitForAllTyVars', but only splits a 'ForAllTy' if @argf_pred argf@
  -- is 'True', where @argf@ is the visibility of the @ForAllTy@'s binder and
  -- @argf_pred@ is a predicate over visibilities provided as an argument to this
  -- function.
  tcSplitSomeForAllTyVars :: (ForAllTyFlag -> Bool) -> Type -> ([TyVar], Type)
  tcSplitSomeForAllTyVars argf_pred ty
    = split ty ty []
    where
      split _ (ForAllTy (Bndr tv argf) ty) tvs
        | argf_pred argf                             = split ty ty (tv:tvs)
      split orig_ty ty tvs | Just ty' <- coreView ty = split orig_ty ty' tvs
      split orig_ty _                            tvs = (reverse tvs, orig_ty)
  
  tcSplitForAllTyVarsReqTVBindersN :: Arity -> Type -> (Arity, [ForAllTyBinder], Type)
  -- Split off at most N /required/ (aka visible) binders, plus any invisible ones
  -- in the way, /and/ any trailing invisible ones
  tcSplitForAllTyVarsReqTVBindersN n_req ty
    = split n_req ty ty []
    where
      split n_req _orig_ty (ForAllTy b@(Bndr _ argf) ty) bs
        | isVisibleForAllTyFlag argf, n_req > 0  -- Split off a visible forall
        = split (n_req - 1) ty ty (b:bs)
        | isInvisibleForAllTyFlag argf           -- Split off an invisible forall,
        = split n_req       ty ty (b:bs)         -- even if n_req=0, i.e. the trailing ones
      split n_req orig_ty ty bs | Just ty' <- coreView ty = split n_req orig_ty ty' bs
      split n_req orig_ty _ty bs                          = (n_req, reverse bs, orig_ty)
  
  -- | Like 'tcSplitForAllTyVars', but only splits 'ForAllTy's with 'Required' type
  -- variable binders. All split tyvars are annotated with '()'.
  tcSplitForAllReqTVBinders :: Type -> ([TcReqTVBinder], Type)
  tcSplitForAllReqTVBinders ty = assert (all isTyVarBinder (fst sty) ) sty
    where sty = splitForAllReqTyBinders ty
  
  -- | Like 'tcSplitForAllTyVars', but only splits 'ForAllTy's with 'Invisible' type
  -- variable binders. All split tyvars are annotated with their 'Specificity'.
  tcSplitForAllInvisTVBinders :: Type -> ([TcInvisTVBinder], Type)
  tcSplitForAllInvisTVBinders ty = assert (all (isTyVar . binderVar) (fst sty)) sty
    where sty = splitForAllInvisTyBinders ty
  
  -- | Like 'tcSplitForAllTyVars', but splits off only named binders.
  tcSplitForAllTyVarBinders :: Type -> ([TyVarBinder], Type)
  tcSplitForAllTyVarBinders ty = assert (all isTyVarBinder (fst sty)) sty
    where sty = splitForAllForAllTyBinders ty
  
  tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)
  -- Split off the first predicate argument from a type
  tcSplitPredFunTy_maybe ty
    | Just ty' <- coreView ty = tcSplitPredFunTy_maybe ty'
  tcSplitPredFunTy_maybe (FunTy { ft_af = af, ft_arg = arg, ft_res = res })
    | isInvisibleFunArg af
    = Just (arg, res)
  tcSplitPredFunTy_maybe _
    = Nothing
  
  tcSplitPhiTy :: Type -> (ThetaType, Type)
  tcSplitPhiTy ty
    = split ty []
    where
      split ty ts
        = case tcSplitPredFunTy_maybe ty of
            Just (pred, ty) -> split ty (pred:ts)
            Nothing         -> (reverse ts, ty)
  
  -- | Split a sigma type into its parts. This only splits /invisible/ type
  -- variable binders, as these are the only forms of binder that the typechecker
  -- will implicitly instantiate.
  tcSplitSigmaTy :: Type -> ([TyVar], ThetaType, Type)
  tcSplitSigmaTy ty = case tcSplitForAllInvisTyVars ty of
                          (tvs, rho) -> case tcSplitPhiTy rho of
                                          (theta, tau) -> (tvs, theta, tau)
  
  tcSplitSigmaTyBndrs :: Type -> ([TcInvisTVBinder], ThetaType, Type)
  tcSplitSigmaTyBndrs ty = case tcSplitForAllInvisTVBinders ty of
                          (tvs, rho) -> case tcSplitPhiTy rho of
                                          (theta, tau) -> (tvs, theta, tau)
  
  -- | Split a sigma type into its parts, going underneath as many arrows
  -- and foralls as possible. See Note [tcSplitNestedSigmaTys]
  tcSplitNestedSigmaTys :: Type -> ([TyVar], ThetaType, Type)
  -- See Note [tcSplitNestedSigmaTys]
  -- NB: This is basically a pure version of deeplyInstantiate (from Unify) that
  --     doesn't compute an HsWrapper.
  tcSplitNestedSigmaTys ty
      -- If there's a forall, split it apart and try splitting the rho type
      -- underneath it.
    | (arg_tys, body_ty)   <- tcSplitFunTys ty
    , (tvs1, theta1, rho1) <- tcSplitSigmaTy body_ty
    , not (null tvs1 && null theta1)
    = let (tvs2, theta2, rho2) = tcSplitNestedSigmaTys rho1
      in (tvs1 ++ tvs2, theta1 ++ theta2, mkScaledFunTys arg_tys rho2)
  
      -- If there's no forall, we're done.
    | otherwise = ([], [], ty)
  
  {- Note [tcSplitNestedSigmaTys]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  tcSplitNestedSigmaTys splits out all the /nested/ foralls and constraints,
  including under function arrows.  E.g. given this type synonym:
    type Traversal s t a b = forall f. Applicative f => (a -> f b) -> s -> f t
  
  then
    tcSplitNestedSigmaTys (forall s t a b. C s t a b => Int -> Traversal s t a b)
  
  will return
    ( [s,t,a,b,f]
    , [C s t a b, Applicative f]
    , Int -> (a -> f b) -> s -> f t)@.
  
  This function is used in these places:
  * Improving error messages in GHC.Tc.Gen.Head.addFunResCtxt
  * Validity checking for default methods: GHC.Tc.TyCl.checkValidClass
  * A couple of calls in the GHCi debugger: GHC.Runtime.Heap.Inspect
  
  In other words, just in validity checking and error messages; hence
  no wrappers or evidence generation.
  
  Notice that tcSplitNestedSigmaTys even looks under function arrows;
  doing so is the Right Thing even with simple subsumption, not just
  with deep subsumption.
  -}
  
  -----------------------
  tcTyConAppTyCon :: Type -> TyCon
  tcTyConAppTyCon ty
    = case tcTyConAppTyCon_maybe ty of
        Just tc -> tc
        Nothing -> pprPanic "tcTyConAppTyCon" (pprType ty)
  
  -- | Like 'tcRepSplitTyConApp_maybe', but only returns the 'TyCon'.
  tcTyConAppTyCon_maybe :: Type -> Maybe TyCon
  tcTyConAppTyCon_maybe ty | Just ty' <- coreView ty = tcTyConAppTyCon_maybe ty'
  tcTyConAppTyCon_maybe (TyConApp tc _)              = Just tc
  tcTyConAppTyCon_maybe (FunTy { ft_af = af })       = Just (funTyFlagTyCon af)
  tcTyConAppTyCon_maybe _                            = Nothing
  
  tcTyConAppArgs :: Type -> [Type]
  tcTyConAppArgs ty = case tcSplitTyConApp_maybe ty of
                          Just (_, args) -> args
                          Nothing        -> pprPanic "tcTyConAppArgs" (pprType ty)
  
  -----------------------
  tcSplitFunTys :: Type -> ([Scaled Type], Type)
  tcSplitFunTys ty = case tcSplitFunTy_maybe ty of
                          Nothing        -> ([], ty)
                          Just (arg,res) -> (arg:args, res')
                                         where
                                            (args,res') = tcSplitFunTys res
  
  tcSplitFunTy_maybe :: Type -> Maybe (Scaled Type, Type)
  -- Only splits function (->) and (-=>), not (=>) or (==>)
  tcSplitFunTy_maybe ty
    | Just ty' <- coreView ty = tcSplitFunTy_maybe ty'
  tcSplitFunTy_maybe (FunTy { ft_af = af, ft_mult = w, ft_arg = arg, ft_res = res })
    | isVisibleFunArg af = Just (Scaled w arg, res)
  tcSplitFunTy_maybe _   = Nothing
          -- Note the isVisibleFunArg guard
          -- Consider     (?x::Int) => Bool
          -- We don't want to treat this as a function type!
          -- A concrete example is test tc230:
          --      f :: () -> (?p :: ()) => () -> ()
          --
          --      g = f () ()
  
  tcSplitFunTysN :: Arity                      -- n: Number of desired args
                 -> TcRhoType
                 -> Either Arity               -- Number of missing arrows
                          ([Scaled TcSigmaType],-- Arg types (always N types)
                           TcSigmaType)        -- The rest of the type
  -- ^ Split off exactly the specified number argument types
  -- Returns
  --  (Left m) if there are 'm' missing arrows in the type
  --  (Right (tys,res)) if the type looks like t1 -> ... -> tn -> res
  tcSplitFunTysN n ty
   | n == 0
   = Right ([], ty)
   | Just (arg,res) <- tcSplitFunTy_maybe ty
   = case tcSplitFunTysN (n-1) res of
       Left m            -> Left m
       Right (args,body) -> Right (arg:args, body)
   | otherwise
   = Left n
  
  tcSplitFunTy :: Type -> (Scaled Type, Type)
  tcSplitFunTy  ty = expectJust (tcSplitFunTy_maybe ty)
  
  tcFunArgTy :: Type -> Scaled Type
  tcFunArgTy ty = fst (tcSplitFunTy ty)
  
  tcFunResultTy :: Type -> Type
  tcFunResultTy ty = snd (tcSplitFunTy ty)
  
  -- | Strips off n *visible* arguments and returns the resulting type
  tcFunResultTyN :: HasDebugCallStack => Arity -> Type -> Type
  tcFunResultTyN n ty
    | Right (_, res_ty) <- tcSplitFunTysN n ty
    = res_ty
    | otherwise
    = pprPanic "tcFunResultTyN" (ppr n <+> ppr ty)
  
  -----------------------
  tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)
  tcSplitAppTy_maybe ty | Just ty' <- coreView ty = tcSplitAppTy_maybe ty'
  tcSplitAppTy_maybe ty = tcSplitAppTyNoView_maybe ty
  
  tcSplitAppTy :: Type -> (Type, Type)
  tcSplitAppTy ty = case tcSplitAppTy_maybe ty of
                      Just stuff -> stuff
                      Nothing    -> pprPanic "tcSplitAppTy" (pprType ty)
  
  tcSplitAppTys :: Type -> (Type, [Type])
  tcSplitAppTys ty
    = go ty []
    where
      go ty args = case tcSplitAppTy_maybe ty of
                     Just (ty', arg) -> go ty' (arg:args)
                     Nothing         -> (ty,args)
  
  -----------------------
  tcIsTyVarTy :: Type -> Bool
  tcIsTyVarTy ty | Just ty' <- coreView ty = tcIsTyVarTy ty'
  tcIsTyVarTy (CastTy ty _) = tcIsTyVarTy ty  -- look through casts, as
                                              -- this is only used for
                                              -- e.g., FlexibleContexts
  tcIsTyVarTy (TyVarTy _)   = True
  tcIsTyVarTy _             = False
  
  -----------------------
  tcSplitQuantPredTy :: Type -> ([TyVar], [Type], PredType)
  -- Split up the type of a quantified predicate
  --    forall tys, theta => head
  -- NB splitFunTys, not tcSplitFunTys;
  -- the latter specifically stops at PredTy arguments,
  -- and we don't want to do that here
  tcSplitQuantPredTy ty
    = case tcSplitForAllInvisTyVars ty of { (tvs, rho)    ->
      case splitFunTys rho             of { (theta, head) ->
      (tvs, map scaledThing theta, head) }}
  
  tcSplitDFunTy :: Type -> ([TyVar], [Type], Class, [Type])
  -- Split the type of a dictionary function
  tcSplitDFunTy ty
    = case tcSplitQuantPredTy ty of { (tvs, theta, head)  ->
      case tcSplitDFunHead head  of { (clas, tys)   ->
      (tvs, theta, clas, tys) }}
  
  tcSplitDFunHead :: Type -> (Class, [Type])
  tcSplitDFunHead = getClassPredTys
  
  tcSplitMethodTy :: Type -> ([TyVar], PredType, Type)
  -- A class method (selector) always has a type like
  --   forall as. C as => blah
  -- So if the class looks like
  --   class C a where
  --     op :: forall b. (Eq a, Ix b) => a -> b
  -- the class method type looks like
  --  op :: forall a. C a => forall b. (Eq a, Ix b) => a -> b
  --
  -- tcSplitMethodTy just peels off the outer forall and
  -- that first predicate
  tcSplitMethodTy ty
    | (sel_tyvars,sel_rho) <- tcSplitForAllInvisTyVars ty
    , Just (first_pred, local_meth_ty) <- tcSplitPredFunTy_maybe sel_rho
    = (sel_tyvars, first_pred, local_meth_ty)
    | otherwise
    = pprPanic "tcSplitMethodTy" (ppr ty)
  
  
  {- *********************************************************************
  *                                                                      *
                         Predicate types
  *                                                                      *
  ************************************************************************
  
  Deconstructors and tests on predicate types
  
  Note [Kind polymorphic type classes]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      class C f where...   -- C :: forall k. k -> Constraint
      g :: forall (f::*). C f => f -> f
  
  Here the (C f) in the signature is really (C * f), and we
  don't want to complain that the * isn't a type variable!
  -}
  
  isTyVarClassPred :: PredType -> Bool
  isTyVarClassPred ty = case getClassPredTys_maybe ty of
      Just (_, tys) -> all isTyVarTy tys
      _             -> False
  
  -------------------------
  checkValidClsArgs :: Bool -> Class -> [KindOrType] -> Bool
  -- If the Bool is True (flexible contexts), return True (i.e. ok)
  -- Otherwise, check that the type (not kind) args are all headed by a tyvar
  --   E.g. (Eq a) accepted, (Eq (f a)) accepted, but (Eq Int) rejected
  -- This function is here in GHC.Tc.Utils.TcType, rather than in GHC.Tc.Validity,
  -- because it is called from GHC.Tc.Solver, which itself is imported by GHC.Tc.Validity
  checkValidClsArgs flexible_contexts cls kts
    | flexible_contexts = True
    | otherwise         = all hasTyVarHead tys
    where
      tys = filterOutInvisibleTypes (classTyCon cls) kts
  
  hasTyVarHead :: Type -> Bool
  -- Returns true of (a t1 .. tn), where 'a' is a type variable
  hasTyVarHead ty                 -- Haskell 98 allows predicates of form
    | tcIsTyVarTy ty = True       --      C (a ty1 .. tyn)
    | otherwise                   -- where a is a type variable
    = case tcSplitAppTy_maybe ty of
         Just (ty, _) -> hasTyVarHead ty
         Nothing      -> False
  
  evVarPred :: EvVar -> PredType
  evVarPred var = varType var
    -- Historical note: I used to have an ASSERT here,
    -- checking (isPredTy (varType var)).  But with something like
    --   f :: c => _ -> _
    -- we end up with (c :: kappa), and (kappa ~ Constraint).  Until
    -- we solve and zonk (which there is no particular reason to do for
    -- partial signatures, (isPredTy kappa) will return False. But
    -- nothing is wrong.  So I just removed the ASSERT.
  
  ---------------------------
  boxEqPred :: EqRel -> Type -> Type -> Maybe (Class, [Type])
  -- Given (t1 ~# t2) or (t1 ~R# t2) return the boxed version
  --       (t1 ~ t2)  or (t1 `Coercible` t2)
  boxEqPred eq_rel ty1 ty2
    = case eq_rel of
        NomEq  | homo_kind -> Just (eqClass,        [k1,     ty1, ty2])
               | otherwise -> Just (heqClass,       [k1, k2, ty1, ty2])
        ReprEq | homo_kind -> Just (coercibleClass, [k1,     ty1, ty2])
               | otherwise -> Nothing -- Sigh: we do not have heterogeneous Coercible
                                      --       so we can't abstract over it
                                      -- Nothing fundamental: we could add it
   where
     k1 = typeKind ty1
     k2 = typeKind ty2
     homo_kind = k1 `tcEqType` k2
  
  pickCapturedPreds
    :: TyVarSet           -- Quantifying over these
    -> TcThetaType        -- Proposed constraints to quantify
    -> TcThetaType        -- A subset that we can actually quantify
  -- A simpler version of pickQuantifiablePreds, used to winnow down
  -- the inferred constraints of a group of bindings, into those for
  -- one particular identifier
  pickCapturedPreds qtvs theta
    = filter captured theta
    where
      captured pred = couldBeIPLike pred || (tyCoVarsOfType pred `intersectsVarSet` qtvs)
  
  
  -- Superclasses
  
  type PredWithSCs a = (PredType, [PredType], a)
  
  mkMinimalBySCs :: forall a. (a -> PredType) -> [a] -> [a]
  -- Remove predicates that
  --
  --   - are the same as another predicate
  --
  --   - can be deduced from another by superclasses,
  --
  --   - are a reflexive equality (e.g  * ~ *)
  --     (see Note [Remove redundant provided dicts] in GHC.Tc.TyCl.PatSyn)
  --
  -- The result is a subset of the input.
  -- The 'a' is just paired up with the PredType;
  --   typically it might be a dictionary Id
  mkMinimalBySCs get_pred xs = go preds_with_scs []
   where
     preds_with_scs :: [PredWithSCs a]
     preds_with_scs = [ (pred, implicants pred, x)
                      | x <- xs
                      , let pred = get_pred x ]
  
     go :: [PredWithSCs a]   -- Work list
        -> [PredWithSCs a]   -- Accumulating result
        -> [a]
     go [] min_preds
       = reverse (map thdOf3 min_preds)
         -- The 'reverse' isn't strictly necessary, but it
         -- means that the results are returned in the same
         -- order as the input, which is generally saner
     go (work_item@(p,_,_) : work_list) min_preds
       | EqPred _ t1 t2 <- classifyPredType p
       , t1 `tcEqType` t2   -- See GHC.Tc.TyCl.PatSyn
                            -- Note [Remove redundant provided dicts]
       = go work_list min_preds
       | p `in_cloud` work_list || p `in_cloud` min_preds
         -- Why look at work-list too?  Suppose work_item is Eq a,
         -- and work-list contains Ord a
       = go work_list min_preds
       | otherwise
       = go work_list (work_item : min_preds)
  
     in_cloud :: PredType -> [PredWithSCs a] -> Bool
     in_cloud p ps = or [ p `tcEqType` p' | (_, scs, _) <- ps, p' <- scs ]
  
     implicants pred
       = pred : eq_extras pred ++ transSuperClasses pred
  
     -- Combine (a ~ b) and (b ~ a); no need to have both in one context
     -- These can arise when dealing with partial type signatures (e.g. T14715)
     eq_extras pred
       = case classifyPredType pred of
           EqPred r t1 t2               -> [mkEqPred r t2 t1]
           ClassPred cls [k1,k2,t1,t2]
             | cls `hasKey` heqTyConKey -> [mkClassPred cls [k2, k1, t2, t1]]
           ClassPred cls [k,t1,t2]
             | cls `hasKey` eqTyConKey  -> [mkClassPred cls [k, t2, t1]]
           _ -> []
  
  transSuperClasses :: PredType -> [PredType]
  -- (transSuperClasses p) returns (p's superclasses) not including p
  -- Stop if you encounter the same class again
  -- See Note [Expanding superclasses]
  transSuperClasses p
    = go emptyNameSet p
    where
      go :: NameSet -> PredType -> [PredType]
      go rec_clss p
         | ClassPred cls tys <- classifyPredType p
         , let cls_nm = className cls
         , not (cls_nm `elemNameSet` rec_clss)
         , let rec_clss' | isCTupleClass cls = rec_clss
                         | otherwise         = rec_clss `extendNameSet` cls_nm
         = [ p' | sc <- immSuperClasses cls tys
                , p'  <- sc : go rec_clss' sc ]
         | otherwise
         = []
  
  immSuperClasses :: Class -> [Type] -> [PredType]
  immSuperClasses cls tys
    = substTheta (zipTvSubst tyvars tys) sc_theta
    where
      (tyvars,sc_theta,_,_) = classBigSig cls
  
  isImprovementPred :: PredType -> Bool
  -- Either it's an equality, or has some functional dependency
  isImprovementPred ty
    = case classifyPredType ty of
        EqPred NomEq t1 t2 -> not (t1 `tcEqType` t2)
        EqPred ReprEq _ _  -> False
        ClassPred cls _    -> classHasFds cls
        IrredPred {}       -> True -- Might have equalities after reduction?
        ForAllPred {}      -> False
  
  {- Note [Expanding superclasses]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  When we expand superclasses, we use the following algorithm:
  
  transSuperClasses( C tys ) returns the transitive superclasses
                             of (C tys), not including C itself
  
  For example
    class C a b => D a b
    class D b a => C a b
  
  Then
    transSuperClasses( Ord ty )  = [Eq ty]
    transSuperClasses( C ta tb ) = [D tb ta, C tb ta]
  
  Notice that in the recursive-superclass case we include C again at
  the end of the chain.  One could exclude C in this case, but
  the code is more awkward and there seems no good reason to do so.
  (However C.f. GHC.Tc.Solver.Dict.mk_strict_superclasses, which /does/
  appear to do so.)
  
  The algorithm is expand( so_far, pred ):
  
   1. If pred is not a class constraint, return empty set
         Otherwise pred = C ts
   2. If C is in so_far, return empty set (breaks loops)
   3. Find the immediate superclasses constraints of (C ts)
   4. For each such sc_pred, return (sc_pred : expand( so_far+C, D ss )
  
  Notice that
  
   * With normal Haskell-98 classes, the loop-detector will never bite,
     so we'll get all the superclasses.
  
   * We need the loop-breaker in case we have UndecidableSuperClasses on
  
   * Since there is only a finite number of distinct classes, expansion
     must terminate.
  
   * The loop breaking is a bit conservative. Notably, a tuple class
     could contain many times without threatening termination:
        (Eq a, (Ord a, Ix a))
     And this is try of any class that we can statically guarantee
     as non-recursive (in some sense).  For now, we just make a special
     case for tuples.  Something better would be cool.
  
  See also GHC.Tc.TyCl.Utils.checkClassCycles.
  
  ************************************************************************
  *                                                                      *
        Classifying types
  *                                                                      *
  ************************************************************************
  -}
  
  isSigmaTy :: TcType -> Bool
  -- isSigmaTy returns true of any type with /invisible/ quantifiers at the top:
  --     forall a. blah
  --     Eq a => blah
  --     ?x::Int => blah
  -- But NOT
  --     forall a -> blah
  isSigmaTy (ForAllTy (Bndr _ af) _)     = isInvisibleForAllTyFlag af
  isSigmaTy (FunTy { ft_af = af })       = isInvisibleFunArg af
  isSigmaTy ty | Just ty' <- coreView ty = isSigmaTy ty'
  isSigmaTy _                            = False
  
  
  isRhoTy :: TcType -> Bool   -- True of TcRhoTypes; see Note [TcRhoType]
  isRhoTy ty = not (isSigmaTy ty)
  
  -- | Like 'isRhoTy', but also says 'True' for 'Infer' types
  isRhoExpTy :: ExpType -> Bool
  isRhoExpTy (Check ty) = isRhoTy ty
  isRhoExpTy (Infer {}) = True
  
  isOverloadedTy :: Type -> Bool
  -- Yes for a type of a function that might require evidence-passing
  -- Used by bindLocalMethods and for -fprof-late-overloaded
  isOverloadedTy ty | Just ty' <- coreView ty = isOverloadedTy ty'
  isOverloadedTy (ForAllTy _  ty)             = isOverloadedTy ty
  isOverloadedTy (FunTy { ft_af = af })       = isInvisibleFunArg af
  isOverloadedTy _                            = False
  
  isFloatTy, isDoubleTy,
      isFloatPrimTy, isDoublePrimTy,
      isIntegerTy, isNaturalTy,
      isIntTy, isWordTy, isBoolTy,
      isUnitTy, isAnyTy, isZonkAnyTy, isCharTy :: Type -> Bool
  isFloatTy      = is_tc floatTyConKey
  isDoubleTy     = is_tc doubleTyConKey
  isFloatPrimTy  = is_tc floatPrimTyConKey
  isDoublePrimTy = is_tc doublePrimTyConKey
  isIntegerTy    = is_tc integerTyConKey
  isNaturalTy    = is_tc naturalTyConKey
  isIntTy        = is_tc intTyConKey
  isWordTy       = is_tc wordTyConKey
  isBoolTy       = is_tc boolTyConKey
  isUnitTy       = is_tc unitTyConKey
  isAnyTy        = is_tc anyTyConKey
  isZonkAnyTy    = is_tc zonkAnyTyConKey
  isCharTy       = is_tc charTyConKey
  
  -- | Check whether the type is of the form @Any :: k@,
  -- returning the kind @k@.
  anyTy_maybe :: Type -> Maybe Kind
  anyTy_maybe ty
    | Just (tc, [k]) <- splitTyConApp_maybe ty
    , getUnique tc == anyTyConKey
    = Just k
    | otherwise
    = Nothing
  
  -- | Is the type inhabited by machine floating-point numbers?
  --
  -- Used to check that we don't use floating-point literal patterns
  -- in Core.
  --
  -- See #9238 and Note [Rules for floating-point comparisons]
  -- in GHC.Core.Opt.ConstantFold.
  isFloatingPrimTy :: Type -> Bool
  isFloatingPrimTy ty = isFloatPrimTy ty || isDoublePrimTy ty
  
  -- | Is a type 'String'?
  isStringTy :: Type -> Bool
  isStringTy ty
    = case tcSplitTyConApp_maybe ty of
        Just (tc, [arg_ty]) -> tc == listTyCon && isCharTy arg_ty
        _                   -> False
  
  is_tc :: Unique -> Type -> Bool
  -- Newtypes are opaque to this
  is_tc uniq ty = case tcSplitTyConApp_maybe ty of
                          Just (tc, _) -> uniq == getUnique tc
                          Nothing      -> False
  
  isRigidTy :: TcType -> Bool
  isRigidTy ty
    | Just (tc,_) <- tcSplitTyConApp_maybe ty = isGenerativeTyCon tc Nominal
    | Just {} <- tcSplitAppTy_maybe ty        = True
    | isForAllTy ty                           = True
    | Just {} <- isLitTy ty                   = True
    | otherwise                               = False
  
  {-
  ************************************************************************
  *                                                                      *
     Misc
  *                                                                      *
  ************************************************************************
  
  Note [Visible type application]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  GHC implements a generalisation of the algorithm described in the
  "Visible Type Application" paper (available from
  http://www.cis.upenn.edu/~sweirich/publications.html). A key part
  of that algorithm is to distinguish user-specified variables from inferred
  variables. For example, the following should typecheck:
  
    f :: forall a b. a -> b -> b
    f = const id
  
    g = const id
  
    x = f @Int @Bool 5 False
    y = g 5 @Bool False
  
  The idea is that we wish to allow visible type application when we are
  instantiating a specified, fixed variable. In practice, specified, fixed
  variables are either written in a type signature (or
  annotation), OR are imported from another module. (We could do better here,
  for example by doing SCC analysis on parts of a module and considering any
  type from outside one's SCC to be fully specified, but this is very confusing to
  users. The simple rule above is much more straightforward and predictable.)
  
  So, both of f's quantified variables are specified and may be instantiated.
  But g has no type signature, so only id's variable is specified (because id
  is imported). We write the type of g as forall {a}. a -> forall b. b -> b.
  Note that the a is in braces, meaning it cannot be instantiated with
  visible type application.
  
  Tracking specified vs. inferred variables is done conveniently by a field
  in PiTyVarBinder.
  
  -}
  
  deNoteType :: Type -> Type
  -- Remove all *outermost* type synonyms and other notes
  deNoteType ty | Just ty' <- coreView ty = deNoteType ty'
  deNoteType ty = ty
  
  {-
  Find the free tycons and classes of a type.  This is used in the front
  end of the compiler.
  -}
  
  {-
  ************************************************************************
  *                                                                      *
     External types
  *                                                                      *
  ************************************************************************
  
  The compiler's foreign function interface supports the passing of a
  restricted set of types as arguments and results (the restricting factor
  being the )
  -}
  
  tcSplitIOType_maybe :: Type -> Maybe (TyCon, Type)
  -- (tcSplitIOType_maybe t) returns Just (IO,t')
  --              if t = IO t'
  --              returns Nothing otherwise
  tcSplitIOType_maybe ty
    = case tcSplitTyConApp_maybe ty of
          Just (io_tycon, [io_res_ty])
           | io_tycon `hasKey` ioTyConKey ->
              Just (io_tycon, io_res_ty)
          _ ->
              Nothing
  
  
  {-
  ************************************************************************
  *                                                                      *
          Visiblities
  *                                                                      *
  ************************************************************************
  -}
  
  -- | For every arg a tycon can take, the returned list says True if the argument
  -- is taken visibly, and False otherwise. Ends with an infinite tail of Trues to
  -- allow for oversaturation.
  tyConVisibilities :: TyCon -> [Bool]
  tyConVisibilities tc = tc_binder_viss ++ tc_return_kind_viss ++ repeat True
    where
      tc_binder_viss      = map isVisibleTyConBinder (tyConBinders tc)
      tc_return_kind_viss = map isVisiblePiTyBinder (fst $ tcSplitPiTys (tyConResKind tc))
  
  -- | If the tycon is applied to the types, is the next argument visible?
  isNextTyConArgVisible :: TyCon -> [Type] -> Bool
  isNextTyConArgVisible tc tys
    = tyConVisibilities tc `getNth` length tys
  
  -- | Should this type be applied to a visible argument?
  -- E.g. (s t): is `t` a visible argument of `s`?
  isNextArgVisible :: TcType -> Bool
  isNextArgVisible ty
    | Just (bndr, _) <- tcSplitPiTy_maybe (typeKind ty) = isVisiblePiTyBinder bndr
    | otherwise                                         = True
      -- this second case might happen if, say, we have an unzonked TauTv.
      -- But TauTvs can't range over types that take invisible arguments
  
  {-
  ************************************************************************
  *                                                                      *
                       Paterson sizes
  *                                                                      *
  ************************************************************************
  -}
  
  {- Note [The PatersonSize of a type]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  The PatersonSize of type is something we can compare, with `ltPatersonSize`,
  to determine if the Paterson conditions are satisfied for an instance
  declaration.  See Note [Paterson conditions] in GHC.Tc.Validity.
  
  There are some wrinkles
  
  (PS1) Once we get into an implicit parameter or equality we
        can't get back to a class constraint, so it's safe
        to say "size 0".  See #4200.
  
        We do this with isTerminatingClass
  
  Note [Invisible arguments and termination]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  When checking the ​Paterson conditions for termination an instance
  declaration, we check for the number of "constructors and variables"
  in the instance head and constraints. Question: Do we look at
  
   * All the arguments, visible or invisible?
   * Just the visible arguments?
  
  I think both will ensure termination, provided we are consistent.
  Currently we are /not/ consistent, which is really a bug.  It's
  described in #15177, which contains a number of examples.
  The suspicious bits are the calls to filterOutInvisibleTypes.
  See also #11833.
  
  Note [Stuck type families]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~
  A type-family application generally has infinite size (PS_TyFam);
  see (PC3) in Note [Paterson conditions] in GHC.Tc.Validity.
  
  But a couple of built-in type families have no axioms, and can never
  expand into anything else.  They are:
  
  * (TypeError "stuff").  E.g. consider
  
       type family F a where
         F Int  = Bool
         F Bool = Char
         F _    = TypeError "Bad"
  
    We don't want to complain about possible non-termination of F, in
    GHC.Tc.Validity.checkFamInstRhs.  cf indexed-types/should_fail/T13271
  
  * (Any @k).
  
  For now we treat them as being size zero, but (#22696) I think we should
  actually treat them as big (like any other ype family) because we don't
  want to abstract over them in e.g. validDerivPred.
  
  The type-family termination test, in GHC.Tc.Validity.checkFamInstRhs, already
  has a separate call to isStuckTypeFamily, so the `F` above will still be accepted.
  -}
  
  -- | Why did the Paterson conditions fail; that is, why
  -- was the context P not Paterson-smaller than the head H?
  --
  -- See Note [Paterson conditions] in GHC.Tc.Validity.
  data PatersonCondFailure
    -- | Some type variables occur more often in P than in H.
    -- See (PC1) in Note [Paterson conditions] in GHC.Tc.Validity.
    = PCF_TyVar
      [TyVar]  -- ^ the type variables which appear more often in the context
    -- | P is not smaller in size than H.
    -- See (PC2) in Note [Paterson conditions] in GHC.Tc.Validity.
    | PCF_Size
    -- | P contains a type family.
    -- See (PC3) in Note [Paterson conditions] in GHC.Tc.Validity.
    | PCF_TyFam
      TyCon  -- ^ the type constructor of the type family
  
  -- | Indicates whether a Paterson condition failure occurred in an instance declaration or a type family equation.
  -- Useful for differentiating context in error messages.
  data PatersonCondFailureContext
    = InInstanceDecl
    | InTyFamEquation
  
  --------------------------------------
  
  -- | The Paterson size of a given type, in the sense of
  -- Note [Paterson conditions] in GHC.Tc.Validity
  --
  --   - after expanding synonyms,
  --   - ignoring coercions (as they are not user written).
  data PatersonSize
    -- | The type mentions a type family, so the size could be anything.
    = PS_TyFam TyCon
    -- | The type does not mention a type family.
    | PS_Vanilla { ps_tvs :: [TyVar]  -- ^ free tyvars, including repetitions;
                 , ps_size :: Int     -- ^ number of type constructors and variables
      }
    -- ToDo: ignore invisible arguments?  See Note [Invisible arguments and termination]
  
  instance Outputable PatersonSize where
    ppr (PS_TyFam tc) = text "PS_TyFam" <+> ppr tc
    ppr (PS_Vanilla { ps_tvs = tvs, ps_size = size })
      = text "PS_Vanilla" <> braces (sep [ text "ps_tvs =" <+> ppr tvs <> comma
                                         , text "ps_size =" <+> int size ])
  
  pSizeZero, pSizeOne :: PatersonSize
  pSizeZero = PS_Vanilla { ps_tvs = [], ps_size = 0 }
  pSizeOne  = PS_Vanilla { ps_tvs = [], ps_size = 1 }
  
  -- | @ltPatersonSize ps1 ps2@ returns:
  --
  --  - @Nothing@ iff @ps1@ is definitely strictly smaller than @ps2@,
  --  - @Just ps_fail@ otherwise; @ps_fail@ says what went wrong.
  ltPatersonSize :: PatersonSize
                 -> PatersonSize
                 -> Maybe PatersonCondFailure
  ltPatersonSize (PS_Vanilla { ps_tvs = tvs1, ps_size = s1 })
                 (PS_Vanilla { ps_tvs = tvs2, ps_size = s2 })
    | s1 >= s2                                = Just PCF_Size
    | bad_tvs@(_:_) <- noMoreTyVars tvs1 tvs2 = Just (PCF_TyVar bad_tvs)
    | otherwise                               = Nothing -- OK!
  ltPatersonSize (PS_TyFam tc) _ = Just (PCF_TyFam tc)
  ltPatersonSize _ (PS_TyFam tc) = Just (PCF_TyFam tc)
    -- NB: this last equation is never taken when checking instances, because
    -- type families are disallowed in instance heads.
    --
    -- However, this function is also used in the logic for solving superclass
    -- constraints (see Note [Solving superclass constraints] in GHC.Tc.TyCl.Instance),
    -- in which case we might well hit this case (see e.g. T23171).
  
  noMoreTyVars :: [TyVar]  -- Free vars (with repetitions) of the constraint C
               -> [TyVar]  -- Free vars (with repetitions) of the head H
               -> [TyVar]  -- TyVars that appear more often in C than H;
                           --   no repetitions in this list
  noMoreTyVars tvs head_tvs
    = nub (tvs \\ head_tvs)  -- The (\\) is list difference; e.g.
                             --   [a,b,a,a] \\ [a,a] = [b,a]
                             -- So we are counting repetitions
  
  addPSize :: PatersonSize -> PatersonSize -> PatersonSize
  addPSize ps1@(PS_TyFam {}) _ = ps1
  addPSize _ ps2@(PS_TyFam {}) = ps2
  addPSize (PS_Vanilla { ps_tvs = tvs1, ps_size = s1 })
           (PS_Vanilla { ps_tvs = tvs2, ps_size = s2 })
    = PS_Vanilla { ps_tvs = tvs1 ++ tvs2, ps_size = s1 + s2 }
      -- (++) is not very performant, but the types
      -- are user-written and never large
  
  pSizeType :: Type -> PatersonSize
  pSizeType = pSizeTypeX emptyVarSet
  
  pSizeTypes :: [Type] -> PatersonSize
  pSizeTypes = pSizeTypesX emptyVarSet pSizeZero
  
  -- Paterson size of a type, retaining repetitions, and expanding synonyms
  -- This ignores coercions, as coercions aren't user-written
  pSizeTypeX :: VarSet -> Type -> PatersonSize
  pSizeTypeX bvs ty | Just exp_ty <- coreView ty = pSizeTypeX bvs exp_ty
  pSizeTypeX bvs (TyVarTy tv)
    | tv `elemVarSet` bvs                  = pSizeOne
    | otherwise                            = PS_Vanilla { ps_tvs = [tv], ps_size = 1 }
  pSizeTypeX _   (LitTy {})                = pSizeOne
  pSizeTypeX bvs (TyConApp tc tys)         = pSizeTyConAppX bvs tc tys
  pSizeTypeX bvs (AppTy fun arg)           = pSizeTypeX bvs fun `addPSize` pSizeTypeX bvs arg
  pSizeTypeX bvs (FunTy _ w arg res)       = pSizeTypeX bvs w `addPSize` pSizeTypeX bvs arg `addPSize`
                                             pSizeTypeX bvs res
  pSizeTypeX bvs (ForAllTy (Bndr tv _) ty) = pSizeTypeX bvs (tyVarKind tv) `addPSize`
                                             pSizeTypeX (bvs `extendVarSet` tv) ty
  pSizeTypeX bvs (CastTy ty _)             = pSizeTypeX bvs ty
  pSizeTypeX _   (CoercionTy {})           = pSizeOne
  
  pSizeTypesX :: VarSet -> PatersonSize -> [Type] -> PatersonSize
  pSizeTypesX bvs sz tys = foldr (addPSize . pSizeTypeX bvs) sz tys
  
  pSizeTyConApp :: TyCon -> [Type] -> PatersonSize
  pSizeTyConApp = pSizeTyConAppX emptyVarSet
  
  pSizeTyConAppX :: VarSet -> TyCon -> [Type] -> PatersonSize
  -- Open question: do we count all args, or just the visible ones?
  -- See Note [Invisible arguments and termination]
  pSizeTyConAppX bvs tc tys
    | isTypeFamilyTyCon tc = pSizeTyFamApp tc
    | otherwise            = pSizeTypesX bvs pSizeOne tys
  
  pSizeTyFamApp :: TyCon -> PatersonSize
  -- See Note [Stuck type families]
  pSizeTyFamApp tc
   | isStuckTypeFamily tc = pSizeZero
   | otherwise            = PS_TyFam tc
  
  pSizeHead :: PredType -> PatersonSize
  -- Getting the size of an instance head is a bit horrible
  -- because of the special treament for class predicates
  pSizeHead pred = case classifyPredType pred of
                        ClassPred cls tys -> pSizeClassPred cls tys
                        _                 -> pSizeType pred
  
  pSizeClassPred :: Class -> [Type] -> PatersonSize
  pSizeClassPred = pSizeClassPredX emptyVarSet
  
  pSizeClassPredX :: VarSet -> Class -> [Type] -> PatersonSize
  pSizeClassPredX bvs cls tys
    | isTerminatingClass cls -- See (PS1) in Note [The PatersonSize of a type]
    = pSizeZero
    | otherwise
    = pSizeTypesX bvs pSizeOne $
      filterOutInvisibleTypes (classTyCon cls) tys
      -- filterOutInvisibleTypes Yuk!  See Note [Invisible arguments and termination]
  
  isStuckTypeFamily :: TyCon -> Bool
  -- See Note [Stuck type families]
  isStuckTypeFamily tc
    =  tc `hasKey` errorMessageTypeErrorFamKey
    || tc `hasKey` anyTyConKey
  
  -- | When this says "True", ignore this class constraint during
  -- a termination check
  -- See (PS1) in Note [The PatersonSize of a type]
  isTerminatingClass :: Class -> Bool
  isTerminatingClass cls
    = isIPClass cls    -- Implicit parameter constraints always terminate because
                       -- there are no instances for them --- they are only solved
                       -- by "local instances" in expressions
      || isEqualityClass cls
      || cls `hasKey` typeableClassKey
              -- Typeable constraints are bigger than they appear due
              -- to kind polymorphism, but we can never get instance divergence this way
      || cls `hasKey` unsatisfiableClassNameKey
  
  allDistinctTyVars :: TyVarSet -> [KindOrType] -> Bool
  -- (allDistinctTyVars tvs tys) returns True if tys are
  -- a) all tyvars
  -- b) all distinct
  -- c) disjoint from tvs
  allDistinctTyVars _    [] = True
  allDistinctTyVars tkvs (ty : tys)
    = case getTyVar_maybe ty of
        Nothing -> False
        Just tv | tv `elemVarSet` tkvs -> False
                | otherwise -> allDistinctTyVars (tkvs `extendVarSet` tv) tys
  
  -----------------------
  type TypeSize = IntWithInf
  
  sizeType :: Type -> TypeSize
  -- Size of a type: the number of variables and constructors
  sizeType ty = toTypeSize (pSizeType ty)
  
  sizeTypes :: [Type] -> TypeSize
  sizeTypes tys = toTypeSize (foldr (addPSize . pSizeType) pSizeZero tys)
  
  toTypeSize :: PatersonSize -> TypeSize
  toTypeSize (PS_TyFam {})                   =  infinity
  toTypeSize (PS_Vanilla { ps_size = size }) = mkIntWithInf size
  