-- See Note [Free vars and synonyms]

 tyCoFVsOfType (LitTy {})         f bound_vars acc = emptyFV f bound_vars acc

 tyCoFVsOfType (AppTy fun arg)    f bound_vars acc = (tyCoFVsOfType fun `unionFV` tyCoFVsOfType arg) f bound_vars acc

 tyCoFVsOfType (ForAllTy bndr ty) f bound_vars acc = tyCoFVsBndr bndr (tyCoFVsOfType ty)  f bound_vars acc

 tyCoFVsOfType (CastTy ty co)     f bound_vars acc = (tyCoFVsOfType ty `unionFV` tyCoFVsOfCo co) f bound_vars acc

 tyCoFVsOfType (CoercionTy co)    f bound_vars acc = tyCoFVsOfCo co f bound_vars acc

                           = go ty'

     go (TyVarTy v)        = go (tyVarKind v)

     go (AppTy f a)        = go f `unionFV` go a

     go (TyConApp tc tys)  = tyCoFVsOfTypes invisibles `unionFV`

                             invisibleVarsOfTypes visibles

       where (invisibles, visibles) = partitionInvisibleTypes tc tys

     go_ty _   (LitTy {})        = mempty

     go_ty env (CastTy ty co)    = go_ty env ty `mappend` go_co env co

     go_ty env (CoercionTy co)   = go_co env co

     go_ty env (TyConApp _ tys)  = go_tys env tys

     go_ty env (ForAllTy (Bndr tv vis) inner)

       = let !env' = tycobinder env tv vis  -- Avoid building a thunk here

     -- Uses accumulating-parameter style

     go dv (AppTy t1 t2)       = foldlM go dv [t1, t2]

     go dv (TyConApp tc tys)   = go_tc_args dv (tyConBinders tc) tys

     go dv (LitTy {})          = return dv

     go dv (CastTy ty co)      = do { dv1 <- go dv ty

                                    ; collect_cand_qtvs_co orig_ty cur_lvl bound dv1 co }

     go _            (LitTy {})         = []

     go is_invis_arg (ForAllTy bndr ty) = go is_invis_arg (binderType bndr)

                                          ++ go is_invis_arg ty

                                          ++ go is_invis_arg ty2

     go is_invis_arg ty@(AppTy _ _)     =

       let (ty_head, ty_args) = splitAppTys ty

 import Control.DeepSeq (force)

 import Data.Either (lefts, partitionEithers, rights)

 import GHC.Builtin.Names

   ( boxedRepDataConKey

   , eqTyConKey

                         hsq_explicit $

                           fdTyVars fd

                   , feqn_fixity = fdFixity fd

                   }

             extractAtItem

                     noLocA (MinimalSig (noAnn, NoSourceText) . noLocA $ classMinimalDef cl)

                       : [ noLocA tcdSig

                         | clsOp <- classOpItems cl

                         ]

                 , tcdMeths = [] -- ignore default method definitions, they don't affect signature

                 -- class associated-types are a subset of TyCon:

 synifyAxBranch tc (CoAxBranch{cab_tvs = tkvs, cab_lhs = args, cab_rhs = rhs}) =

   let name = synifyNameN tc

       args_types_only = filterOutInvisibleTypes tc args

       annot_typats = zipWith3 annotHsType args_poly args_types_only typats

       outer_bndrs = HsOuterImplicit{hso_ximplicit = map tyVarName tkvs}

    in -- TODO: this must change eventually

       FamEqn

           , tcdLName = synifyNameN tc

           , tcdTyVars = synifyTyVars (tyConVisibleTyVars tc)

           , tcdFixity = synifyFixity tc

           }

   -- (closed) newtype and data

   | otherwise = do

     linear_tys =

       zipWith

         ( \(Scaled mult ty) (HsSrcBang st unp str) ->

             in CDF (noAnn, st) unp str multSyn tySyn Nothing

         )

         arg_tys

               , con_inner_bndrs = inner_bndrs

               , con_mb_cxt = ctx

               , con_g_args = hat

               , con_doc = Nothing

               }

       else do

   -> SynifyTypeState

   -- ^ what to do with a 'forall'

   -> [TyVar]

   -> Id

   -- ^ the 'Id' from which to get the type signature

   -> Sig GhcRn

   where

     !n = force $ synifyNameN i

     t = defaultType prr (varType i)

 -- | Turn a 'ClassOpItem' into a list of signatures. The list returned is going

 -- to contain the synified 'ClassOpSig' as well (when appropriate) a default

 -- 'ClassOpSig'.

   [ClassOpSig noAnn False [synifyNameN i] (mainSig (varType i))]

     ++ [ ClassOpSig noAnn True [noLocA dn] (defSig dt)

        | Just (dn, GenericDM dt) <- [dm]

        ]

   where

 synifyCtx :: [PredType] -> LHsContext GhcRn

 synifyTyVars :: [TyVar] -> LHsQTyVars GhcRn

 synifyTyVars ktvs =

 synifyTyVarBndr' no_kinds (Bndr tv spec) = synify_ty_var no_kinds spec tv

 -- | Like 'synifyTyVarBndr', but accepts a set of variables for which to omit kind

 synify_ty_var :: VarSet -> flag -> TyVar -> LHsTyVarBndr flag GhcRn

 synify_ty_var no_kinds flag tv =

   noLocA (HsTvb noAnn flag bndr_var bndr_kind)

 annotHsType True ty hs_ty

   | not $ isEmptyVarSet $ filterVarSet isTyVar $ tyCoVarsOfType ty =

       let ki = typeKind ty

        in noLocA (HsKindSig noAnn hs_ty hs_ki)

 annotHsType _ _ hs_ty = hs_ty

     --   the defining class gets to quantify all its functions for free!

     DeleteTopLevelQuantification

 -- The use of mkEmptySigType (which uses empty binders in OuterImplicit)

 -- is a bit suspicious; what if the type has free variables?

 synifySigWcType :: SynifyTypeState -> [TyVar] -> Type -> LHsSigWcType GhcRn

 -- Ditto (see synifySigType)

 synifyPatSynSigType :: PatSyn -> LHsSigType GhcRn

 -- Ditto (see synifySigType)

 synifyType

   :: SynifyTypeState

   -- ^ what to do with a 'forall'

   -> Type

   -- ^ the type to convert

   -> LHsType GhcRn

 synifyType _ _ (TyVarTy tv) = noLocA $ HsTyVar noAnn NotPromoted $ noLocA (noUserRdr $ getName tv)

   maybe_sig res_ty

   where

     res_ty :: LHsType GhcRn

                   ConstraintTuple -> HsBoxedOrConstraintTuple

                   UnboxedTuple -> HsUnboxedTuple

               )

       | isUnboxedSumTyCon tc =

       | Just dc <- isPromotedDataCon_maybe tc

       , isTupleDataCon dc

       , dataConSourceArity dc == length vis_tys =

       -- ditto for lists

       | getName tc == listTyConName

       , [ty] <- vis_tys =

       | tc == promotedNilDataCon

       , [] <- vis_tys =

           noLocA $ HsExplicitListTy noExtField IsPromoted []

       | tc == promotedConsDataCon

       , [ty1, ty2] <- vis_tys =

                 tTy

                   | L _ (HsExplicitListTy _ IsPromoted tTy') <- stripKindSig tTy ->

                       noLocA $ HsExplicitListTy noExtField IsPromoted (hTy : tTy')

       | tc `hasKey` ipClassKey

       , [name, ty] <- tys

       , Just x <- isStrLitTy name =

       -- and equalities

       | tc `hasKey` eqTyConKey

       , [ty1, ty2] <- tys =

             HsOpTy

               noExtField

               NotPromoted

               (noLocA $ noUserRdr eqTyConName)

       -- and infix type operators

       | isSymOcc (nameOccName (getName tc))

       , ty1 : ty2 : tys_rest <- vis_tys =

             ( HsOpTy

                 noExtField

                 prom

                 (noLocA $ noUserRdr $ getName tc)

             )

             tys_rest

       -- Most TyCons:

           foldl

             (\t1 t2 -> noLocA $ HsAppTy noExtField t1 t2)

             (noLocA ty_app)

                 filterOut isCoercionTy ty_args

             )

     maybe_sig ty'

       | tyConAppNeedsKindSig False tc tys_len =

           let full_kind = typeKind (mkTyConApp tc tys)

            in noLocA $ HsKindSig noAnn ty' full_kind'

       | otherwise = ty'

   let

     (ty_head, ty_args) = splitAppTys ty

     ty_args' =

         filterOut isCoercionTy $

           filterByList

             (map isVisibleForAllTyFlag $ appTyForAllTyFlags ty_head ty_args)

             ty_args

    in

     foldl (\t1 t2 -> noLocA $ HsAppTy noExtField t1 t2) ty_head' ty_args'

   | otherwise = noLocA $ HsFunTy noExtField w' s1 s2

   where

   case argf of

 synifyType _ _ (LitTy t) = noLocA $ HsTyLit noExtField $ synifyTyLit t

 synifyType _ _ (CoercionTy{}) = error "synifyType:Coercion"

 -- | Process a 'Type' which starts with a visible @forall@ into an 'HsType'

 synifyVisForAllType

   -> Type

   -- ^ the forall type to convert

   -> LHsType GhcRn

   let (tvs, rho) = tcSplitForAllTysReqPreserveSynonyms ty

       -- Figure out what the type variable order would be inferred in the

       -- absence of an explicit forall

    in noLocA $

         HsForAllTy

           { hst_tele = mkHsForAllVisTele noAnn sTvs

           , hst_xforall = noExtField

           }

 -- | Process a 'Type' which starts with an invisible @forall@ or a constraint

 synifySigmaType

   :: SynifyTypeState

   -- ^ what to do with the 'forall'

   -> Type

   -- ^ the forall type to convert

   -> LHsType GhcRn

   let (tvs, ctx, tau) = tcSplitSigmaTyPreserveSynonyms ty

       sPhi =

         HsQualTy

           { hst_ctxt = synifyCtx ctx

           , hst_xqual = noExtField

           }

       sTy =

           , hst_body = noLocA sPhi

           }

       -- Figure out what the type variable order would be inferred in the

       -- absence of an explicit forall

    in case s of

         -- Put a forall in if there are any type variables

         WithinType

           | not (null tvs) -> noLocA sTy

           | otherwise -> noLocA sPhi

 implicitForAll

   -> [InvisTVBinder]

   -- ^ type variable binders in the forall

   -> ThetaType

   -- ^ constraints right after the forall

   -- ^ how to convert the inner type

   -> Type

   -- ^ inner type

   -> LHsType GhcRn

   where

     sPhi

       | null ctx = unLoc sRho

       | otherwise =

           HsQualTy

             { hst_ctxt = synifyCtx ctx

             , hst_xqual = noExtField

             }

     sTy =

       HsForAllTy

         , hst_body = noLocA sPhi

         }

     -- Figure out what the type variable order would be inferred in the

     -- absence of an explicit forall

 --

 --

   -- ^ type to inspect

   -> VarSet

   OneTy -> HsLinearAnn noExtField

   ManyTy -> HsUnannotated noExtField

   OneTy -> HsUnannotated noExtField

 synifyPatSynType :: PatSyn -> LHsType GhcRn

 synifyPatSynType ps =

       req_theta'

         | null req_theta

             [unitTy]

         | otherwise = req_theta

    in implicitForAll

         req_theta'

         (mkScaledFunTys arg_tys res_ty)

 synifyTyLit :: TyLit -> HsTyLit GhcRn

 synifyTyLit (CharTyLit c) = HsCharTy NoSourceText c

 synifyKindSig :: Kind -> LHsKind GhcRn

 stripKindSig :: LHsType GhcRn -> LHsType GhcRn

 stripKindSig (L _ (HsKindSig _ t _)) = t

     , ihdTypes = map unLoc annot_ts

     , ihdInstType =

         ClassInst

           , clsiTyVars = synifyTyVars (tyConVisibleTyVars cls_tycon)

           , clsiSigs = map synifyClsIdSig $ specialized_class_methods

           , clsiAssocTys =

   where

     cls_tycon = classTyCon cls

     ts = filterOutInvisibleTypes cls_tycon types

     annot_ts = zipWith3 annotHsType args_poly ts ts'

     args_poly = tyConArgsPolyKinded cls_tycon

     synifyClsIdSig = synifyIdSig ShowRuntimeRep DeleteTopLevelQuantification vs

   where

     ityp SynFamilyInst | opaque = return $ TypeInst Nothing

     ityp SynFamilyInst =

     ityp (DataFamilyInst c) =

       DataInst <$> synifyTyCon HideRuntimeRep (Just $ famInstAxiom fi) c

     fam_tc = famInstTyCon fi

           fam_lhs

     ts = filterOutInvisibleTypes fam_tc eta_expanded_lhs

     ts' = synifyTypes ts

     annot_ts = zipWith3 annotHsType args_poly ts ts'

     args_poly = tyConArgsPolyKinded fam_tc

 tyCoFVsOfType' (LitTy{}) a b c = emptyFV a b c

 tyCoFVsOfType' (AppTy fun arg) a b c = (tyCoFVsOfType' arg `unionFV` tyCoFVsOfType' fun) a b c

 tyCoFVsOfType' (FunTy _ w arg res) a b c =