anyTyConKey :: Unique

 anyTyConKey = mkPreludeTyConUnique 171

 -- Custom user type-errors

 errorMessageTypeErrorFamKey :: Unique

         cTupleSelId, cTupleSelIdName,

         -- * Any

         -- * Recovery TyCon

         makeRecoveryTyCon,

                 , soloTyCon

                 , anyTyCon

                 , boolTyCon

                 , charTyCon

                 , stringTyCon

 {-

 Note [Any types]

 ~~~~~~~~~~~~~~~~

 They are used when we want a type of a particular kind, but we don't really care

 un-constrained type variables after type checking. For example, consider the

 term (length [] :: Int), where

   length @alpha ([] @alpha)

 where `alpha` is an un-constrained unification variable.  The "zonking" process zaps

 Wrinkles:

    (see #959 for examples).

 (Any2) They are /closed/ type families, with no instances.  For example, suppose that

    with  alpha :: '(k1, k2)  we add a given coercion

              g :: alpha ~ (Fst alpha, Snd alpha)

    side and '(,) on the other. See also #9097 and #9636.

    See #25244 for a suggestion that we instead use an /open/ type family for which

    the code generator, because the code gen may /enter/ a data value

    but never enters a function value.

    types (#24817).  Consider

      data SBool a where { STrue :: SBool True; SFalse :: SBool False }

    Now, what are `alpha` and `beta`? If we zonk both of them to the same type

    `Any @Type`, the pattern-match checker will (wrongly) report that the first

    branch is inaccessible.  So we zonk them to two /different/ types:

    (The actual numbers are arbitrary; they just need to differ.)

    The unique-name generation comes from field `tcg_zany_n` of `TcGblEnv`; and

    make up a fresh type.

    If this example seems unconvincing (e.g. in this case foo must be bottom)

    see #24817 for larger but more compelling examples.

     don't have a name environment (e.g. see Rules.matchRule for one example)

 (Any6) `Any` is defined in library module ghc-prim:GHC.Types, and exported so that

     wired-in type:

       - has a fixed unique, anyTyConKey,

       - lives in the global name cache

 (Any7) Properties of `Any`:

   * When `Any` is instantiated at a lifted type it is inhabited by at least one value,

     See examples in ghc-prim:GHC.Types

 The Any tycon used to be quite magic, but we have since been able to

 implement it merely with an empty kind polymorphic type family. See #10886 for a

 bit of history.

 anyTypeOfKind :: Kind -> Type

 anyTypeOfKind kind = mkTyConApp anyTyCon [kind]

 -- See Note [Any types]

                          Nothing

                          (ClosedSynFamilyTyCon Nothing)

                          Nothing

                          NotInjective

   where

 -- | Make a fake, recovery 'TyCon' from an existing one.

 -- Used when recovering from errors in type declarations

        ; when (warn_unused || warn_wrong) $

     do { fam_inst_envs <- dsGetFamInstEnvs

        ; let norm_elt_ty = topNormaliseType fam_inst_envs elt_ty

          then diagnosticDs (DsUnusedDoBind rhs elt_ty)

          else

 -}

 {-# LANGUAGE LambdaCase #-}

 module GHC.Iface.Type (

         IfExtName,

     sdocOption sdocPrintExplicitKinds $ \print_kinds ->

     sdocOption sdocPrintTypeAbbreviations $ \print_type_abbreviations ->

     getPprDebug $ \debug ->

     if | ifaceTyConName tc `hasKey` ipClassKey

        , IA_Arg (IfaceLitTy (IfaceStrTyLit n))

        | Just doc <- ppr_equality ctxt_prec tc (appArgsIfaceTypes tys)

        -> doc

        | otherwise

        -> ppr_iface_tc_app ppr_app_arg ctxt_prec tc $

           appArgsIfaceTypesForAllTyFlags $ stripInvisArgs (PrintExplicitKinds print_kinds) tys

    True  -> maybeParen ctxt_prec starPrec $

               unicodeSyntax (char '★') (char '*')

 -- | Pretty-print a type-level equality.

 -- Returns (Just doc) if the argument is a /saturated/ application

 -- of   eqTyCon          (~)

          0 -> return IfaceNormalTyCon

          1 -> IfaceTupleTyCon <$> get bh <*> get bh

          2 -> IfaceSumTyCon <$> get bh

 instance Binary IfaceTyConInfo where

    put_ bh (IfaceTyConInfo i s) = put_ bh i >> put_ bh s

           -- ^ Allows us to choose unique DFun names.

         tcg_zany_n :: TcRef Integer,

           -- See Note [Any types] in GHC.Builtin.Types, wrinkle (Any4)

         tcg_merged :: [(Module, Fingerprint)],

   getCCIndexM, getCCIndexTcM,

   -- * Zonking

   -- * Complete matches

   localAndImportedCompleteMatches, getCompleteMatchesTcM,

 import GHC.Builtin.Names

 import GHC.Tc.Errors.Types

 import GHC.Tc.Types     -- Re-export all

 import GHC.Core.Multiplicity

 import GHC.Core.InstEnv

 import GHC.Core.FamInstEnv

 import GHC.Driver.Env

 import GHC.Driver.Session

      ; writeTcRef dfun_n_var (extendOccSet set occ)

      ; return occ }

 -- See Note [Any types] in GHC.Builtin.Types, wrinkle (Any4)

   = do { env <- getGblEnv

        ; let zany_n_var = tcg_zany_n env

        ; i <- readTcRef zany_n_var

        ; let !i2 = i+1

        ; writeTcRef zany_n_var i2

 getConstraintVar :: TcM (TcRef WantedConstraints)

 getConstraintVar = do { env <- getLclEnv; return (tcl_lie env) }

   isSigmaTy, isRhoTy, isRhoExpTy, isOverloadedTy,

   isFloatingPrimTy, isDoubleTy, isFloatTy, isIntTy, isWordTy, isStringTy,

   isIntegerTy, isNaturalTy,

   isTauTy, isTauTyCon, tcIsTyVarTy,

   isPredTy, isTyVarClassPred,

   checkValidClsArgs, hasTyVarHead,

     isFloatPrimTy, isDoublePrimTy,

     isIntegerTy, isNaturalTy,

     isIntTy, isWordTy, isBoolTy,

 isFloatTy      = is_tc floatTyConKey

 isDoubleTy     = is_tc doubleTyConKey

 isFloatPrimTy  = is_tc floatPrimTyConKey

 isWordTy       = is_tc wordTyConKey

 isBoolTy       = is_tc boolTyConKey

 isUnitTy       = is_tc unitTyConKey

 isCharTy       = is_tc charTyConKey

 -- | Check whether the type is of the form @Any :: k@,

 {-# LANGUAGE GADTs #-}

 {-

 import GHC.Tc.TyCl.Build ( TcMethInfo, MethInfo )

 import GHC.Tc.Utils.Env ( tcLookupGlobalOnly )

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Types.Constraint

 import GHC.Tc.Types.Evidence

 import GHC.Tc.Errors.Types

            | otherwise

            -> do { traceTc "Defaulting flexi tyvar to ZonkAny:" (pprTyVar tv)

                    -- See Note [Any types] in GHC.Builtin.Types, esp wrinkle (Any4)

          RuntimeUnkFlexi

            -> do { traceTc "Defaulting flexi tyvar to RuntimeUnk:" (pprTyVar tv)