-- Synonyms are retained in the interface type

 toIfaceTypeX fr (TyVarTy tv)   -- See Note [Free TyVars and CoVars in IfaceType] in GHC.Iface.Type

   | tv `elemVarSet` fr         = IfaceFreeTyVar tv

   | otherwise                  = IfaceTyVar (toIfaceTyVar tv)

 toIfaceTypeX fr ty@(AppTy {})  =

   -- Flatten as many argument AppTys as possible, then turn them into an

   -- IfaceAppArgs list.

   where

     go (HTyVarTy n) = IfaceTyVar $ (mkIfLclName (occNameFS $ getOccName n))

     go (HAppTy a b) = IfaceAppTy a (hieToIfaceArgs b)

     go (HForAllTy ((n,k),af) t) = let b = (mkIfLclName (occNameFS $ getOccName n), k)

                                   in IfaceForAllTy (Bndr (IfaceTvBndr b) af) t

     go (HFunTy w a b)   = IfaceFunTy visArgTypeLike   w       a    b

 rnIfaceType :: Rename IfaceType

 rnIfaceType (IfaceFreeTyVar n) = pure (IfaceFreeTyVar n)

 rnIfaceType (IfaceAppTy t1 t2)

     = IfaceAppTy <$> rnIfaceType t1 <*> rnIfaceAppArgs t2

 rnIfaceType (IfaceLitTy l)         = return (IfaceLitTy l)

 freeNamesIfAppArgs IA_Nil          = emptyNameSet

 freeNamesIfType :: IfaceType -> NameSet

 freeNamesIfType (IfaceAppTy s t)      = freeNamesIfType s &&& freeNamesIfAppArgs t

 freeNamesIfType (IfaceTyConApp tc ts) = freeNamesIfTc tc &&& freeNamesIfAppArgs ts

 freeNamesIfType (IfaceTupleTy _ _ ts) = freeNamesIfAppArgs ts

 data IfaceType

   = IfaceFreeTyVar TyVar                -- See Note [Free TyVars and CoVars in IfaceType]

   | IfaceTyVar     IfLclName            -- Type/coercion variable only, not tycon

   | IfaceLitTy     IfaceTyLit

   | IfaceAppTy     IfaceType IfaceAppArgs

                              -- See Note [Suppressing invisible arguments] for

 ifTypeIsVarFree ty = go ty

   where

     go (IfaceTyVar {})         = False

     go (IfaceFreeTyVar {})     = False

     go (IfaceAppTy fun args)   = go fun && go_args args

     go (IfaceFunTy _ w arg res) = go w && go arg && go res

     (<>) = Set.union

     go (IfaceTyVar var)         = Set.singleton var

     go (IfaceFreeTyVar {})      = mempty

     go (IfaceAppTy fun args)    = go fun <> go_args args

     go (IfaceFunTy _ w arg res) = go w <> go arg <> go res

 substIfaceType env ty

   = go ty

   where

     go (IfaceTyVar tv)        = substIfaceTyVar env tv

     go (IfaceAppTy  t ts)     = IfaceAppTy  (go t) (substIfaceAppArgs env ts)

     go (IfaceFunTy af w t1 t2)  = IfaceFunTy af (go w) (go t1) (go t2)

 ppr_ty ctxt_prec ty

   | not (isIfaceRhoType ty)             = ppr_sigma ShowForAllMust ctxt_prec ty

 ppr_ty _         (IfaceForAllTy {})     = panic "ppr_ty"  -- Covered by not.isIfaceRhoType

 ppr_ty ctxt_prec (IfaceTyConApp tc tys) = pprTyTcApp ctxt_prec tc tys

 ppr_ty ctxt_prec (IfaceTupleTy i p tys) = ppr_tuple ctxt_prec i p tys -- always fully saturated

 ppr_ty _         (IfaceLitTy n)         = pprIfaceTyLit n

       = IfaceForAllTy (go_ifacebndr subs bndr) (go subs rank1 ty)

     go subs _ ty@(IfaceTyVar tv) = case lookupFsEnv subs (ifLclNameFS tv) of

       Nothing -> ty

     go _ _ ty@(IfaceFreeTyVar tv)

       | otherwise

       = ty

     go subs _ (IfaceTyConApp tc tc_args)

       = IfaceTyConApp tc (go_args subs tc_args)

   = do { putByte bh 8; put_ bh s; put_ bh i; put_ bh tys }

 putIfaceType bh (IfaceLitTy n)

   = do { putByte bh 9; put_ bh n }

 -- | Deserialises an 'IfaceType' from the given 'ReadBinHandle'.

 --

               8 -> do { s <- get bh; i <- get bh; tys <- get bh

                       ; return (IfaceTupleTy s i tys) }

                        return (IfaceLitTy n)

 instance Binary IfLclName where

   put_ bh = put_ bh . ifLclNameFS

   rnf = \case

     IfaceFreeTyVar f1 -> f1 `seq` ()

     IfaceTyVar f1 -> rnf f1

     IfaceLitTy f1 -> rnf f1

     IfaceAppTy f1 f2 -> rnf f1 `seq` rnf f2

     IfaceFunTy f1 f2 f3 f4 -> rnf f1 `seq` rnf f2 `seq` rnf f3 `seq` rnf f4

 tcIfaceType = go

   where

     go (IfaceTyVar n)            = TyVarTy <$> tcIfaceTyVar n

     go (IfaceFreeTyVar n)        = pprPanic "tcIfaceType:IfaceFreeTyVar" (ppr n)

     go (IfaceLitTy l)            = LitTy <$> tcIfaceTyLit l

     go (IfaceFunTy flag w t1 t2) = FunTy flag <$> tcIfaceType w <*> go t1 <*> go t2

 -- the constructor (A and B) means that GHC will always typecheck

 -- this expression *after* typechecking T.

 tcIfaceTyCon :: IfaceTyCon -> IfL TyCon

 tcIfaceTyCon (IfaceTyCon name _info)

   = do { thing <- tcIfaceGlobal name