    -- | This module implements interface renaming, which is
    -- used to rewrite interface files on the fly when we
    -- are doing indefinite typechecking and need instantiations
    -- of modules which do not necessarily exist yet.

    module GHC.Iface.Rename (
        rnModIface,
        rnModExports,
        tcRnModIface,
        tcRnModExports,
        ) where

    import GHC.Prelude

    import GHC.Driver.Env

    import GHC.Tc.Utils.Monad

    import GHC.Iface.Syntax
    import GHC.Iface.Env
    import {-# SOURCE #-} GHC.Iface.Load -- a bit vexing

    import GHC.Unit
    import GHC.Unit.Module.ModIface
    import GHC.Unit.Module.Deps

    import GHC.Tc.Errors.Types
    import GHC.Types.SrcLoc
    import GHC.Types.Unique.FM
    import GHC.Types.Avail
    import GHC.Types.Error
    import GHC.Types.FieldLabel
    import GHC.Types.Var
    import GHC.Types.Basic
    import GHC.Types.Name
    import GHC.Types.Name.Shape

    import GHC.Utils.Outputable
    import GHC.Utils.Misc
    import GHC.Utils.Error
    import GHC.Utils.Fingerprint
    import GHC.Utils.Panic

    import qualified Data.Traversable as T

    import Data.IORef

    tcRnMsgMaybe :: IO (Either (Messages TcRnMessage) a) -> TcM a
    tcRnMsgMaybe :: forall a. IO (Either (Messages TcRnMessage) a) -> TcM a
    tcRnMsgMaybe IO (Either (Messages TcRnMessage) a)
    do_this = do
        r <- IO (Either (Messages TcRnMessage) a)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Either (Messages TcRnMessage) a)
    forall a. IO a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Either (Messages TcRnMessage) a)
     -> IOEnv (Env TcGblEnv TcLclEnv) (Either (Messages TcRnMessage) a))
    -> IO (Either (Messages TcRnMessage) a)
    -> IOEnv (Env TcGblEnv TcLclEnv) (Either (Messages TcRnMessage) a)
    forall a b. (a -> b) -> a -> b
    $ IO (Either (Messages TcRnMessage) a)
    do_this
        case r of
            Left Messages TcRnMessage
    msgs -> do
                Messages TcRnMessage -> TcRn ()
    addMessages Messages TcRnMessage
    msgs
                IOEnv (Env TcGblEnv TcLclEnv) a
    forall env a. IOEnv env a
    failM
            Right a
    x -> a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall a. a -> IOEnv (Env TcGblEnv TcLclEnv) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    tcRnModIface :: [(ModuleName, Module)] -> Maybe NameShape -> ModIface -> TcM ModIface
    tcRnModIface :: [(ModuleName, Module)]
    -> Maybe NameShape -> ModIface -> TcM ModIface
    tcRnModIface [(ModuleName, Module)]
    x Maybe NameShape
    y ModIface
    z = do
        hsc_env <- TcRnIf TcGblEnv TcLclEnv HscEnv
    forall gbl lcl. TcRnIf gbl lcl HscEnv
    getTopEnv
        tcRnMsgMaybe $ rnModIface hsc_env x y z

    tcRnModExports :: [(ModuleName, Module)] -> ModIface -> TcM [AvailInfo]
    tcRnModExports :: [(ModuleName, Module)] -> ModIface -> TcM [AvailInfo]
    tcRnModExports [(ModuleName, Module)]
    x ModIface
    y = do
        hsc_env <- TcRnIf TcGblEnv TcLclEnv HscEnv
    forall gbl lcl. TcRnIf gbl lcl HscEnv
    getTopEnv
        tcRnMsgMaybe $ rnModExports hsc_env x y

    failWithRn :: TcRnMessage -> ShIfM a
    failWithRn :: forall a. TcRnMessage -> ShIfM a
    failWithRn TcRnMessage
    tcRnMessage = do
        errs_var <- (ShIfEnv -> IORef (Messages TcRnMessage))
    -> IOEnv (Env ShIfEnv ()) ShIfEnv
    -> IOEnv (Env ShIfEnv ()) (IORef (Messages TcRnMessage))
    forall a b.
    (a -> b) -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ShIfEnv -> IORef (Messages TcRnMessage)
    sh_if_errs IOEnv (Env ShIfEnv ()) ShIfEnv
    forall gbl lcl. TcRnIf gbl lcl gbl
    getGblEnv
        errs <- readTcRef errs_var
        -- TODO: maybe associate this with a source location?
        let msg = SrcSpan -> TcRnMessage -> MsgEnvelope TcRnMessage
    forall e. Diagnostic e => SrcSpan -> e -> MsgEnvelope e
    mkPlainErrorMsgEnvelope SrcSpan
    noSrcSpan TcRnMessage
    tcRnMessage
        writeTcRef errs_var (msg `addMessage` errs)
        failM

    -- | What we have is a generalized ModIface, which corresponds to
    -- a module that looks like p[A=\<A>]:B.  We need a *specific* ModIface, e.g.
    -- p[A=q():A]:B (or maybe even p[A=\<B>]:B) which we load
    -- up (either to merge it, or to just use during typechecking).
    --
    -- Suppose we have:
    --
    --  p[A=\<A>]:M  ==>  p[A=q():A]:M
    --
    -- Substitute all occurrences of \<A> with q():A (renameHoleModule).
    -- Then, for any Name of form {A.T}, replace the Name with
    -- the Name according to the exports of the implementing module.
    -- This works even for p[A=\<B>]:M, since we just read in the
    -- exports of B.hi, which is assumed to be ready now.
    --
    -- This function takes an optional 'NameShape', which can be used
    -- to further refine the identities in this interface: suppose
    -- we read a declaration for {H.T} but we actually know that this
    -- should be Foo.T; then we'll also rename this (this is used
    -- when loading an interface to merge it into a requirement.)
    rnModIface :: HscEnv -> [(ModuleName, Module)] -> Maybe NameShape
               -> ModIface -> IO (Either (Messages TcRnMessage) ModIface)
    rnModIface :: HscEnv
    -> [(ModuleName, Module)]
    -> Maybe NameShape
    -> ModIface
    -> IO (Either (Messages TcRnMessage) ModIface)
    rnModIface HscEnv
    hsc_env [(ModuleName, Module)]
    insts Maybe NameShape
    nsubst ModIface
    iface =
        HscEnv
    -> ModIface
    -> [(ModuleName, Module)]
    -> Maybe NameShape
    -> ShIfM ModIface
    -> IO (Either (Messages TcRnMessage) ModIface)
    forall a.
    HscEnv
    -> ModIface
    -> [(ModuleName, Module)]
    -> Maybe NameShape
    -> ShIfM a
    -> IO (Either (Messages TcRnMessage) a)
    initRnIface HscEnv
    hsc_env ModIface
    iface [(ModuleName, Module)]
    insts Maybe NameShape
    nsubst (ShIfM ModIface -> IO (Either (Messages TcRnMessage) ModIface))
    -> ShIfM ModIface -> IO (Either (Messages TcRnMessage) ModIface)
    forall a b. (a -> b) -> a -> b
    $ do
            mod <- Rename Module
    rnModule (ModIface -> Module
    forall (phase :: ModIfacePhase). ModIface_ phase -> Module
    mi_module ModIface
    iface)
            sig_of <- case mi_sig_of iface of
                        Maybe Module
    Nothing -> Maybe Module -> IOEnv (Env ShIfEnv ()) (Maybe Module)
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Module
    forall a. Maybe a
    Nothing
                        Just Module
    x  -> (Module -> Maybe Module)
    -> IOEnv (Env ShIfEnv ()) Module
    -> IOEnv (Env ShIfEnv ()) (Maybe Module)
    forall a b.
    (a -> b) -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Module -> Maybe Module
    forall a. a -> Maybe a
    Just (Rename Module
    rnModule Module
    x)
            exports <- mapM rnAvailInfo (mi_exports iface)
            decls <- mapM rnIfaceDecl' (mi_decls iface)
            insts <- mapM rnIfaceClsInst (mi_insts iface)
            fams <- mapM rnIfaceFamInst (mi_fam_insts iface)
            deps <- rnDependencies (mi_deps iface)
            -- TODO:
            -- mi_rules
            return iface { mi_module = mod
                         , mi_sig_of = sig_of
                         , mi_insts = insts
                         , mi_fam_insts = fams
                         , mi_exports = exports
                         , mi_decls = decls
                         , mi_deps = deps }

    -- | Rename just the exports of a 'ModIface'.  Useful when we're doing
    -- shaping prior to signature merging.
    rnModExports :: HscEnv -> [(ModuleName, Module)] -> ModIface -> IO (Either (Messages TcRnMessage) [AvailInfo])
    rnModExports :: HscEnv
    -> [(ModuleName, Module)]
    -> ModIface
    -> IO (Either (Messages TcRnMessage) [AvailInfo])
    rnModExports HscEnv
    hsc_env [(ModuleName, Module)]
    insts ModIface
    iface
        = HscEnv
    -> ModIface
    -> [(ModuleName, Module)]
    -> Maybe NameShape
    -> IOEnv (Env ShIfEnv ()) [AvailInfo]
    -> IO (Either (Messages TcRnMessage) [AvailInfo])
    forall a.
    HscEnv
    -> ModIface
    -> [(ModuleName, Module)]
    -> Maybe NameShape
    -> ShIfM a
    -> IO (Either (Messages TcRnMessage) a)
    initRnIface HscEnv
    hsc_env ModIface
    iface [(ModuleName, Module)]
    insts Maybe NameShape
    forall a. Maybe a
    Nothing
        (IOEnv (Env ShIfEnv ()) [AvailInfo]
     -> IO (Either (Messages TcRnMessage) [AvailInfo]))
    -> IOEnv (Env ShIfEnv ()) [AvailInfo]
    -> IO (Either (Messages TcRnMessage) [AvailInfo])
    forall a b. (a -> b) -> a -> b
    $ (AvailInfo -> IOEnv (Env ShIfEnv ()) AvailInfo)
    -> [AvailInfo] -> IOEnv (Env ShIfEnv ()) [AvailInfo]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM AvailInfo -> IOEnv (Env ShIfEnv ()) AvailInfo
    rnAvailInfo (ModIface -> [AvailInfo]
    forall (phase :: ModIfacePhase). ModIface_ phase -> [AvailInfo]
    mi_exports ModIface
    iface)

    rnDependencies :: Rename Dependencies
    rnDependencies :: Rename Dependencies
    rnDependencies Dependencies
    deps0 = do
        deps1  <- Dependencies
    -> ([Module] -> IOEnv (Env ShIfEnv ()) [Module])
    -> IOEnv (Env ShIfEnv ()) Dependencies
    forall (m :: * -> *).
    Monad m =>
    Dependencies -> ([Module] -> m [Module]) -> m Dependencies
    dep_orphs_update Dependencies
    deps0 ((Dependencies -> [Module])
    -> [Module] -> IOEnv (Env ShIfEnv ()) [Module]
    rnDepModules Dependencies -> [Module]
    dep_orphs)
        dep_finsts_update deps1 (rnDepModules dep_finsts)

    rnDepModules :: (Dependencies -> [Module]) -> [Module] -> ShIfM [Module]
    rnDepModules :: (Dependencies -> [Module])
    -> [Module] -> IOEnv (Env ShIfEnv ()) [Module]
    rnDepModules Dependencies -> [Module]
    sel [Module]
    mods = do
        hsc_env <- TcRnIf ShIfEnv () HscEnv
    forall gbl lcl. TcRnIf gbl lcl HscEnv
    getTopEnv
        hmap <- getHoleSubst
        -- NB: It's not necessary to test if we're doing signature renaming,
        -- because ModIface will never contain module reference for itself
        -- in these dependencies.
        fmap (nubSort . concat) . T.forM mods $ \Module
    mod -> do
            -- For holes, its necessary to "see through" the instantiation
            -- of the hole to get accurate family instance dependencies.
            -- For example, if B imports <A>, and <A> is instantiated with
            -- F, we must grab and include all of the dep_finsts from
            -- F to have an accurate transitive dep_finsts list.
            --
            -- However, we MUST NOT do this for regular modules.
            -- First, for efficiency reasons, doing this
            -- bloats the dep_finsts list, because we *already* had
            -- those modules in the list (it wasn't a hole module, after
            -- all). But there's a second, more important correctness
            -- consideration: we perform module renaming when running
            -- --abi-hash.  In this case, GHC's contract to the user is that
            -- it will NOT go and read out interfaces of any dependencies
            -- (https://github.com/haskell/cabal/issues/3633); the point of
            -- --abi-hash is just to get a hash of the on-disk interfaces
            -- for this *specific* package.  If we go off and tug on the
            -- interface for /everything/ in dep_finsts, we're gonna have a
            -- bad time.  (It's safe to do this for hole modules, though,
            -- because the hmap for --abi-hash is always trivial, so the
            -- interface we request is local.  Though, maybe we ought
            -- not to do it in this case either...)
            --
            -- This mistake was bug #15594.
            let mod' :: Module
    mod' = UnitState -> ShHoleSubst -> Module -> Module
    renameHoleModule (HasDebugCallStack => HscEnv -> UnitState
    HscEnv -> UnitState
    hsc_units HscEnv
    hsc_env) ShHoleSubst
    hmap Module
    mod
            if Module -> Bool
    forall u. GenModule (GenUnit u) -> Bool
    isHoleModule Module
    mod
              then do iface <- IO ModIface -> ShIfM ModIface
    forall a. IO a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ModIface -> ShIfM ModIface)
    -> (IfG ModIface -> IO ModIface) -> IfG ModIface -> ShIfM ModIface
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SDoc -> HscEnv -> IfG ModIface -> IO ModIface
    forall a. SDoc -> HscEnv -> IfG a -> IO a
    initIfaceCheck (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "rnDepModule") HscEnv
    hsc_env
                                      (IfG ModIface -> ShIfM ModIface) -> IfG ModIface -> ShIfM ModIface
    forall a b. (a -> b) -> a -> b
    $ SDoc -> Module -> IfG ModIface
    forall lcl. SDoc -> Module -> IfM lcl ModIface
    loadSysInterface (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "rnDepModule") Module
    mod'
                      return (mod' : sel (mi_deps iface))
              else [Module] -> IOEnv (Env ShIfEnv ()) [Module]
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Module
    mod']

    {-
    ************************************************************************
    *                                                                      *
                            ModIface substitution
    *                                                                      *
    ************************************************************************
    -}

    -- | Run a computation in the 'ShIfM' monad.
    initRnIface :: HscEnv -> ModIface -> [(ModuleName, Module)] -> Maybe NameShape
                -> ShIfM a -> IO (Either (Messages TcRnMessage) a)
    initRnIface :: forall a.
    HscEnv
    -> ModIface
    -> [(ModuleName, Module)]
    -> Maybe NameShape
    -> ShIfM a
    -> IO (Either (Messages TcRnMessage) a)
    initRnIface HscEnv
    hsc_env ModIface
    iface [(ModuleName, Module)]
    insts Maybe NameShape
    nsubst ShIfM a
    do_this = do
        errs_var <- Messages TcRnMessage -> IO (IORef (Messages TcRnMessage))
    forall a. a -> IO (IORef a)
    newIORef Messages TcRnMessage
    forall e. Messages e
    emptyMessages
        let hsubst = [(ModuleName, Module)] -> ShHoleSubst
    forall key elt. Uniquable key => [(key, elt)] -> UniqFM key elt
    listToUFM [(ModuleName, Module)]
    insts
            rn_mod = UnitState -> ShHoleSubst -> Module -> Module
    renameHoleModule (HasDebugCallStack => HscEnv -> UnitState
    HscEnv -> UnitState
    hsc_units HscEnv
    hsc_env) ShHoleSubst
    hsubst
            env = ShIfEnv {
                sh_if_module :: Module
    sh_if_module = Module -> Module
    rn_mod (ModIface -> Module
    forall (phase :: ModIfacePhase). ModIface_ phase -> Module
    mi_module ModIface
    iface),
                sh_if_semantic_module :: Module
    sh_if_semantic_module = Module -> Module
    rn_mod (ModIface -> Module
    forall (phase :: ModIfacePhase). ModIface_ phase -> Module
    mi_semantic_module ModIface
    iface),
                sh_if_hole_subst :: ShHoleSubst
    sh_if_hole_subst = [(ModuleName, Module)] -> ShHoleSubst
    forall key elt. Uniquable key => [(key, elt)] -> UniqFM key elt
    listToUFM [(ModuleName, Module)]
    insts,
                sh_if_shape :: Maybe NameShape
    sh_if_shape = Maybe NameShape
    nsubst,
                sh_if_errs :: IORef (Messages TcRnMessage)
    sh_if_errs = IORef (Messages TcRnMessage)
    errs_var
            }
        -- Modeled off of 'initTc'
        res <- initTcRnIf 'c' hsc_env env () $ tryM do_this
        msgs <- readIORef errs_var
        case res of
            Left IOEnvFailure
    _                               -> Either (Messages TcRnMessage) a
    -> IO (Either (Messages TcRnMessage) a)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Messages TcRnMessage -> Either (Messages TcRnMessage) a
    forall a b. a -> Either a b
    Left Messages TcRnMessage
    msgs)
            Right a
    r | Bool -> Bool
    not (Messages TcRnMessage -> Bool
    forall e. Messages e -> Bool
    isEmptyMessages Messages TcRnMessage
    msgs) -> Either (Messages TcRnMessage) a
    -> IO (Either (Messages TcRnMessage) a)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Messages TcRnMessage -> Either (Messages TcRnMessage) a
    forall a b. a -> Either a b
    Left Messages TcRnMessage
    msgs)
                    | Bool
    otherwise                  -> Either (Messages TcRnMessage) a
    -> IO (Either (Messages TcRnMessage) a)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> Either (Messages TcRnMessage) a
    forall a b. b -> Either a b
    Right a
    r)

    -- | Environment for 'ShIfM' monads.
    data ShIfEnv = ShIfEnv {
            -- What we are renaming the ModIface to.  It assumed that
            -- the original mi_module of the ModIface is
            -- @generalizeModule (mi_module iface)@.
            ShIfEnv -> Module
    sh_if_module :: Module,
            -- The semantic module that we are renaming to
            ShIfEnv -> Module
    sh_if_semantic_module :: Module,
            -- Cached hole substitution, e.g.
            -- @sh_if_hole_subst == listToUFM . unitIdInsts . moduleUnit . sh_if_module@
            ShIfEnv -> ShHoleSubst
    sh_if_hole_subst :: ShHoleSubst,
            -- An optional name substitution to be applied when renaming
            -- the names in the interface.  If this is 'Nothing', then
            -- we just load the target interface and look at the export
            -- list to determine the renaming.
            ShIfEnv -> Maybe NameShape
    sh_if_shape :: Maybe NameShape,
            -- Mutable reference to keep track of diagnostics (similar to 'tcl_errs')
            ShIfEnv -> IORef (Messages TcRnMessage)
    sh_if_errs :: IORef (Messages TcRnMessage)
        }

    getHoleSubst :: ShIfM ShHoleSubst
    getHoleSubst :: ShIfM ShHoleSubst
    getHoleSubst = (ShIfEnv -> ShHoleSubst)
    -> IOEnv (Env ShIfEnv ()) ShIfEnv -> ShIfM ShHoleSubst
    forall a b.
    (a -> b) -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ShIfEnv -> ShHoleSubst
    sh_if_hole_subst IOEnv (Env ShIfEnv ()) ShIfEnv
    forall gbl lcl. TcRnIf gbl lcl gbl
    getGblEnv

    type ShIfM = TcRnIf ShIfEnv ()
    type Rename a = a -> ShIfM a

    rnModule :: Rename Module
    rnModule :: Rename Module
    rnModule Module
    mod = do
        hmap <- ShIfM ShHoleSubst
    getHoleSubst
        unit_state <- hsc_units <$> getTopEnv
        return (renameHoleModule unit_state hmap mod)

    rnAvailInfo :: Rename AvailInfo
    rnAvailInfo :: AvailInfo -> IOEnv (Env ShIfEnv ()) AvailInfo
    rnAvailInfo (Avail Name
    c) = Name -> AvailInfo
    Avail (Name -> AvailInfo)
    -> IOEnv (Env ShIfEnv ()) Name -> IOEnv (Env ShIfEnv ()) AvailInfo
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    c
    rnAvailInfo (AvailTC Name
    n [Name]
    ns) = do
        -- Why don't we rnIfaceGlobal the availName itself?  It may not
        -- actually be exported by the module it putatively is from, in
        -- which case we won't be able to tell what the name actually
        -- is.  But for the availNames they MUST be exported, so they
        -- will rename fine.
        ns' <- (Name -> IOEnv (Env ShIfEnv ()) Name)
    -> [Name] -> IOEnv (Env ShIfEnv ()) [Name]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal [Name]
    ns
        case ns' of
            [] -> String -> IOEnv (Env ShIfEnv ()) AvailInfo
    forall a. HasCallStack => String -> a
    panic String
    "rnAvailInfoEmpty AvailInfo"
            (Name
    rep:[Name]
    rest) -> Bool
    -> SDoc
    -> IOEnv (Env ShIfEnv ()) AvailInfo
    -> IOEnv (Env ShIfEnv ()) AvailInfo
    forall a. HasCallStack => Bool -> SDoc -> a -> a
    assertPpr ((Name -> Bool) -> [Name] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all ((Module -> Module -> Bool
    forall a. Eq a => a -> a -> Bool
    == Name -> Module
    childModule Name
    rep) (Module -> Bool) -> (Name -> Module) -> Name -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Name -> Module
    childModule) [Name]
    rest)
                                    (Name -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Name
    rep SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hcat ((Name -> SDoc) -> [Name] -> [SDoc]
    forall a b. (a -> b) -> [a] -> [b]
    map Name -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr [Name]
    rest)) (IOEnv (Env ShIfEnv ()) AvailInfo
     -> IOEnv (Env ShIfEnv ()) AvailInfo)
    -> IOEnv (Env ShIfEnv ()) AvailInfo
    -> IOEnv (Env ShIfEnv ()) AvailInfo
    forall a b. (a -> b) -> a -> b
    $ do
                             n' <- Maybe Module -> Name -> IOEnv (Env ShIfEnv ()) Name
    forall m n. Maybe Module -> Name -> TcRnIf m n Name
    setNameModule (Module -> Maybe Module
    forall a. a -> Maybe a
    Just (Name -> Module
    childModule Name
    rep)) Name
    n
                             return (AvailTC n' ns')
      where
        childModule :: Name -> Module
    childModule = HasDebugCallStack => Name -> Module
    Name -> Module
    nameModule

    rnFieldLabel :: Rename FieldLabel
    rnFieldLabel :: Rename FieldLabel
    rnFieldLabel FieldLabel
    fl = do
        sel' <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (FieldLabel -> Name
    flSelector FieldLabel
    fl)
        return (fl { flSelector = sel' })

    -- | The key function.  This gets called on every Name embedded
    -- inside a ModIface.  Our job is to take a Name from some
    -- generalized unit ID p[A=\<A>, B=\<B>], and change
    -- it to the correct name for a (partially) instantiated unit
    -- ID, e.g. p[A=q[]:A, B=\<B>].
    --
    -- There are two important things to do:
    --
    -- If a hole is substituted with a real module implementation,
    -- we need to look at that actual implementation to determine what
    -- the true identity of this name should be.  We'll do this by
    -- loading that module's interface and looking at the mi_exports.
    --
    -- However, there is one special exception: when we are loading
    -- the interface of a requirement.  In this case, we may not have
    -- the "implementing" interface, because we are reading this
    -- interface precisely to "merge it in".
    --
    --     External case:
    --         p[A=\<B>]:A (and thisUnitId is something else)
    --     We are loading this in order to determine B.hi!  So
    --     don't load B.hi to find the exports.
    --
    --     Local case:
    --         p[A=\<A>]:A (and thisUnitId is p[A=\<A>])
    --     This should not happen, because the rename is not necessary
    --     in this case, but if it does we shouldn't load A.hi!
    --
    -- Compare me with 'tcIfaceGlobal'!

    -- In effect, this function needs compute the name substitution on the
    -- fly.  What it has is the name that we would like to substitute.
    -- If the name is not a hole name {M.x} (e.g. isHoleModule) then
    -- no renaming can take place (although the inner hole structure must
    -- be updated to account for the hole module renaming.)
    rnIfaceGlobal :: Name -> ShIfM Name
    rnIfaceGlobal :: Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    n = do
        hsc_env <- TcRnIf ShIfEnv () HscEnv
    forall gbl lcl. TcRnIf gbl lcl HscEnv
    getTopEnv
        let unit_state = HasDebugCallStack => HscEnv -> UnitState
    HscEnv -> UnitState
    hsc_units HscEnv
    hsc_env
            home_unit  = HscEnv -> HomeUnit
    hsc_home_unit HscEnv
    hsc_env
        iface_semantic_mod <- fmap sh_if_semantic_module getGblEnv
        mb_nsubst <- fmap sh_if_shape getGblEnv
        hmap <- getHoleSubst
        let m = HasDebugCallStack => Name -> Module
    Name -> Module
    nameModule Name
    n
            m' = UnitState -> ShHoleSubst -> Module -> Module
    renameHoleModule UnitState
    unit_state ShHoleSubst
    hmap Module
    m
        case () of
           -- Did we encounter {A.T} while renaming p[A=<B>]:A? If so,
           -- do NOT assume B.hi is available.
           -- In this case, rename {A.T} to {B.T} but don't look up exports.
         ()
    _ | Module
    m' Module -> Module -> Bool
    forall a. Eq a => a -> a -> Bool
    == Module
    iface_semantic_mod
           , Module -> Bool
    forall u. GenModule (GenUnit u) -> Bool
    isHoleModule Module
    m'
          -- NB: this could be Nothing for computeExports, we have
          -- nothing to say.
          -> do n' <- Maybe Module -> Name -> IOEnv (Env ShIfEnv ()) Name
    forall m n. Maybe Module -> Name -> TcRnIf m n Name
    setNameModule (Module -> Maybe Module
    forall a. a -> Maybe a
    Just Module
    m') Name
    n
                case mb_nsubst of
                    Maybe NameShape
    Nothing -> Name -> IOEnv (Env ShIfEnv ()) Name
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    n'
                    Just NameShape
    nsubst ->
                        case NameShape -> Name -> Maybe Name
    maybeSubstNameShape NameShape
    nsubst Name
    n' of
                            -- TODO: would love to have context
                            -- TODO: This will give an unpleasant message if n'
                            -- is a constructor; then we'll suggest adding T
                            -- but it won't work.
                            Maybe Name
    Nothing ->
                              TcRnMessage -> IOEnv (Env ShIfEnv ()) Name
    forall a. TcRnMessage -> ShIfM a
    failWithRn (TcRnMessage -> IOEnv (Env ShIfEnv ()) Name)
    -> TcRnMessage -> IOEnv (Env ShIfEnv ()) Name
    forall a b. (a -> b) -> a -> b
    $ Name -> TcRnMessage
    TcRnIdNotExportedFromLocalSig Name
    n'
                            Just Name
    n'' -> Name -> IOEnv (Env ShIfEnv ()) Name
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    n''
           -- Fastpath: we are renaming p[H=<H>]:A.T, in which case the
           -- export list is irrelevant.
           | Bool -> Bool
    not (Module -> Bool
    forall u. GenModule (GenUnit u) -> Bool
    isHoleModule Module
    m)
          -> Maybe Module -> Name -> IOEnv (Env ShIfEnv ()) Name
    forall m n. Maybe Module -> Name -> TcRnIf m n Name
    setNameModule (Module -> Maybe Module
    forall a. a -> Maybe a
    Just Module
    m') Name
    n
           -- The substitution was from <A> to p[]:A.
           -- But this does not mean {A.T} goes to p[]:A.T:
           -- p[]:A may reexport T from somewhere else.  Do the name
           -- substitution.  Furthermore, we need
           -- to make sure we pick the accurate name NOW,
           -- or we might accidentally reject a merge.
           | Bool
    otherwise
          -> do -- Make sure we look up the local interface if substitution
                -- went from <A> to <B>.
                let m'' :: Module
    m'' = if Module -> Bool
    forall u. GenModule (GenUnit u) -> Bool
    isHoleModule Module
    m'
                            -- Pull out the local guy!!
                            then HomeUnit -> ModuleName -> Module
    mkHomeModule HomeUnit
    home_unit (Module -> ModuleName
    forall unit. GenModule unit -> ModuleName
    moduleName Module
    m')
                            else Module
    m'
                iface <- IO ModIface -> ShIfM ModIface
    forall a. IO a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO ModIface -> ShIfM ModIface)
    -> (IfG ModIface -> IO ModIface) -> IfG ModIface -> ShIfM ModIface
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SDoc -> HscEnv -> IfG ModIface -> IO ModIface
    forall a. SDoc -> HscEnv -> IfG a -> IO a
    initIfaceCheck (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "rnIfaceGlobal") HscEnv
    hsc_env
                                (IfG ModIface -> ShIfM ModIface) -> IfG ModIface -> ShIfM ModIface
    forall a b. (a -> b) -> a -> b
    $ SDoc -> Module -> IfG ModIface
    forall lcl. SDoc -> Module -> IfM lcl ModIface
    loadSysInterface (String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "rnIfaceGlobal") Module
    m''
                let nsubst = ModuleName -> [AvailInfo] -> NameShape
    mkNameShape (Module -> ModuleName
    forall unit. GenModule unit -> ModuleName
    moduleName Module
    m) (ModIface -> [AvailInfo]
    forall (phase :: ModIfacePhase). ModIface_ phase -> [AvailInfo]
    mi_exports ModIface
    iface)
                case maybeSubstNameShape nsubst n of
                    -- NB: report m' because it's more user-friendly
                    Maybe Name
    Nothing -> TcRnMessage -> IOEnv (Env ShIfEnv ()) Name
    forall a. TcRnMessage -> ShIfM a
    failWithRn (TcRnMessage -> IOEnv (Env ShIfEnv ()) Name)
    -> TcRnMessage -> IOEnv (Env ShIfEnv ()) Name
    forall a b. (a -> b) -> a -> b
    $ Name -> Module -> TcRnMessage
    TcRnIdNotExportedFromModuleSig Name
    n Module
    m'
                    Just Name
    n' -> Name -> IOEnv (Env ShIfEnv ()) Name
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Name
    n'

    -- | Rename an implicit name, e.g., a DFun or coercion axiom.
    -- Here is where we ensure that DFuns have the correct module as described in
    -- Note [rnIfaceNeverExported].
    rnIfaceNeverExported :: Name -> ShIfM Name
    rnIfaceNeverExported :: Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceNeverExported Name
    name = do
        hmap <- ShIfM ShHoleSubst
    getHoleSubst
        unit_state <- hsc_units <$> getTopEnv
        iface_semantic_mod <- fmap sh_if_semantic_module getGblEnv
        let m = UnitState -> ShHoleSubst -> Module -> Module
    renameHoleModule UnitState
    unit_state ShHoleSubst
    hmap (Module -> Module) -> Module -> Module
    forall a b. (a -> b) -> a -> b
    $ HasDebugCallStack => Name -> Module
    Name -> Module
    nameModule Name
    name
        -- Doublecheck that this DFun/coercion axiom was, indeed, locally defined.
        massertPpr (iface_semantic_mod == m) (ppr iface_semantic_mod <+> ppr m)
        setNameModule (Just m) name

    -- Note [rnIfaceNeverExported]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~
    -- For the high-level overview, see
    -- Note [Handling never-exported TyThings under Backpack]
    --
    -- When we see a reference to an entity that was defined in a signature,
    -- 'rnIfaceGlobal' relies on the identifier in question being part of the
    -- exports of the implementing 'ModIface', so that we can use the exports to
    -- decide how to rename the identifier.  Unfortunately, references to 'DFun's
    -- and 'CoAxiom's will run into trouble under this strategy, because they are
    -- never exported.
    --
    -- Let us consider first what should happen in the absence of promotion.  In
    -- this setting, a reference to a 'DFun' or a 'CoAxiom' can only occur inside
    -- the signature *that is defining it* (as there are no Core terms in
    -- typechecked-only interface files, there's no way for a reference to occur
    -- besides from the defining 'ClsInst' or closed type family).  Thus,
    -- it doesn't really matter what names we give the DFun/CoAxiom, as long
    -- as it's consistent between the declaration site and the use site.
    --
    -- We have to make sure that these bogus names don't get propagated,
    -- but it is fine: see Note [Signature merging DFuns] for the fixups
    -- to the names we do before writing out the merged interface.
    -- (It's even easier for instantiation, since the DFuns all get
    -- dropped entirely; the instances are reexported implicitly.)
    --
    -- Unfortunately, this strategy is not enough in the presence of promotion
    -- (see bug #13149), where modules which import the signature may make
    -- reference to their coercions.  It's not altogether clear how to
    -- fix this case, but it is definitely a bug!

    -- PILES AND PILES OF BOILERPLATE

    -- | Rename an 'IfaceClsInst', with special handling for an associated
    -- dictionary function.
    rnIfaceClsInst :: Rename IfaceClsInst
    rnIfaceClsInst :: IfaceClsInst -> IOEnv (Env ShIfEnv ()) IfaceClsInst
    rnIfaceClsInst IfaceClsInst
    cls_inst = do
        n <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceClsInst -> Name
    ifInstCls IfaceClsInst
    cls_inst)
        tys <- mapM rnRoughMatchTyCon (ifInstTys cls_inst)

        dfun <- rnIfaceNeverExported (ifDFun cls_inst)
        return cls_inst { ifInstCls = n
                        , ifInstTys = tys
                        , ifDFun = dfun
                        }

    rnRoughMatchTyCon :: Rename (Maybe IfaceTyCon)
    rnRoughMatchTyCon :: Maybe IfaceTyCon -> IOEnv (Env ShIfEnv ()) (Maybe IfaceTyCon)
    rnRoughMatchTyCon Maybe IfaceTyCon
    Nothing = Maybe IfaceTyCon -> IOEnv (Env ShIfEnv ()) (Maybe IfaceTyCon)
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe IfaceTyCon
    forall a. Maybe a
    Nothing
    rnRoughMatchTyCon (Just IfaceTyCon
    tc) = IfaceTyCon -> Maybe IfaceTyCon
    forall a. a -> Maybe a
    Just (IfaceTyCon -> Maybe IfaceTyCon)
    -> IOEnv (Env ShIfEnv ()) IfaceTyCon
    -> IOEnv (Env ShIfEnv ()) (Maybe IfaceTyCon)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceTyCon
    rnIfaceTyCon IfaceTyCon
    tc

    rnIfaceFamInst :: Rename IfaceFamInst
    rnIfaceFamInst :: IfaceFamInst -> IOEnv (Env ShIfEnv ()) IfaceFamInst
    rnIfaceFamInst IfaceFamInst
    d = do
        fam <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceFamInst -> Name
    ifFamInstFam IfaceFamInst
    d)
        tys <- mapM rnRoughMatchTyCon (ifFamInstTys d)
        axiom <- rnIfaceGlobal (ifFamInstAxiom d)
        return d { ifFamInstFam = fam, ifFamInstTys = tys, ifFamInstAxiom = axiom }

    rnIfaceDecl' :: Rename (Fingerprint, IfaceDecl)
    rnIfaceDecl' :: (Fingerprint, IfaceDecl)
    -> IOEnv (Env ShIfEnv ()) (Fingerprint, IfaceDecl)
    rnIfaceDecl' (Fingerprint
    fp, IfaceDecl
    decl) = (,) Fingerprint
    fp (IfaceDecl -> (Fingerprint, IfaceDecl))
    -> IOEnv (Env ShIfEnv ()) IfaceDecl
    -> IOEnv (Env ShIfEnv ()) (Fingerprint, IfaceDecl)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceDecl
    rnIfaceDecl IfaceDecl
    decl

    rnIfaceDecl :: Rename IfaceDecl
    rnIfaceDecl :: Rename IfaceDecl
    rnIfaceDecl d :: IfaceDecl
    d@IfaceId{} = do
                name <- case IfaceDecl -> IfaceIdDetails
    ifIdDetails IfaceDecl
    d of
                          IfaceIdDetails
    IfDFunId -> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceNeverExported (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                          IfaceIdDetails
    _ | OccName -> Bool
    isDefaultMethodOcc (Name -> OccName
    forall name. HasOccName name => name -> OccName
    occName (IfaceDecl -> Name
    ifName IfaceDecl
    d))
                            -> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceNeverExported (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                          -- Typeable bindings. See Note [Grand plan for Typeable].
                          IfaceIdDetails
    _ | OccName -> Bool
    isTypeableBindOcc (Name -> OccName
    forall name. HasOccName name => name -> OccName
    occName (IfaceDecl -> Name
    ifName IfaceDecl
    d))
                            -> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceNeverExported (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                            | Bool
    otherwise -> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                ty <- rnIfaceType (ifType d)
                details <- rnIfaceIdDetails (ifIdDetails d)
                info <- rnIfaceIdInfo (ifIdInfo d)
                return d { ifName = name
                         , ifType = ty
                         , ifIdDetails = details
                         , ifIdInfo = info
                         }
    rnIfaceDecl d :: IfaceDecl
    d@IfaceData{} = do
                name <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                binders <- mapM rnIfaceTyConBinder (ifBinders d)
                ctxt <- mapM rnIfaceType (ifCtxt d)
                cons <- rnIfaceConDecls (ifCons d)
                res_kind <- rnIfaceType (ifResKind d)
                parent <- rnIfaceTyConParent (ifParent d)
                return d { ifName = name
                         , ifBinders = binders
                         , ifCtxt = ctxt
                         , ifCons = cons
                         , ifResKind = res_kind
                         , ifParent = parent
                         }
    rnIfaceDecl d :: IfaceDecl
    d@IfaceSynonym{} = do
                name <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                binders <- mapM rnIfaceTyConBinder (ifBinders d)
                syn_kind <- rnIfaceType (ifResKind d)
                syn_rhs <- rnIfaceType (ifSynRhs d)
                return d { ifName = name
                         , ifBinders = binders
                         , ifResKind = syn_kind
                         , ifSynRhs = syn_rhs
                         }
    rnIfaceDecl d :: IfaceDecl
    d@IfaceFamily{} = do
                name <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                binders <- mapM rnIfaceTyConBinder (ifBinders d)
                fam_kind <- rnIfaceType (ifResKind d)
                fam_flav <- rnIfaceFamTyConFlav (ifFamFlav d)
                return d { ifName = name
                         , ifBinders = binders
                         , ifResKind = fam_kind
                         , ifFamFlav = fam_flav
                         }
    rnIfaceDecl d :: IfaceDecl
    d@IfaceClass{} = do
                name <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                binders <- mapM rnIfaceTyConBinder (ifBinders d)
                body <- rnIfaceClassBody (ifBody d)
                return d { ifName    = name
                         , ifBinders = binders
                         , ifBody    = body
                         }
    rnIfaceDecl d :: IfaceDecl
    d@IfaceAxiom{} = do
                name <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceNeverExported (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                tycon <- rnIfaceTyCon (ifTyCon d)
                ax_branches <- mapM rnIfaceAxBranch (ifAxBranches d)
                return d { ifName = name
                         , ifTyCon = tycon
                         , ifAxBranches = ax_branches
                         }
    rnIfaceDecl d :: IfaceDecl
    d@IfacePatSyn{} =  do
                name <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceDecl -> Name
    ifName IfaceDecl
    d)
                let rnPat (Name
    n, a
    b) = (,) (Name -> a -> (Name, a))
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv (Env ShIfEnv ()) (a -> (Name, a))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    n IOEnv (Env ShIfEnv ()) (a -> (Name, a))
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) (Name, a)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> a -> IOEnv (Env ShIfEnv ()) a
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    b
                pat_matcher <- rnPat (ifPatMatcher d)
                pat_builder <- T.traverse rnPat (ifPatBuilder d)
                pat_univ_bndrs <- mapM rnIfaceForAllBndr (ifPatUnivBndrs d)
                pat_ex_bndrs <- mapM rnIfaceForAllBndr (ifPatExBndrs d)
                pat_prov_ctxt <- mapM rnIfaceType (ifPatProvCtxt d)
                pat_req_ctxt <- mapM rnIfaceType (ifPatReqCtxt d)
                pat_args <- mapM rnIfaceType (ifPatArgs d)
                pat_ty <- rnIfaceType (ifPatTy d)
                return d { ifName = name
                         , ifPatMatcher = pat_matcher
                         , ifPatBuilder = pat_builder
                         , ifPatUnivBndrs = pat_univ_bndrs
                         , ifPatExBndrs = pat_ex_bndrs
                         , ifPatProvCtxt = pat_prov_ctxt
                         , ifPatReqCtxt = pat_req_ctxt
                         , ifPatArgs = pat_args
                         , ifPatTy = pat_ty
                         }

    rnIfaceClassBody :: Rename IfaceClassBody
    rnIfaceClassBody :: Rename IfaceClassBody
    rnIfaceClassBody IfaceClassBody
    IfAbstractClass = Rename IfaceClassBody
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return IfaceClassBody
    IfAbstractClass
    rnIfaceClassBody d :: IfaceClassBody
    d@IfConcreteClass{} = do
        ctxt <- Rename IfaceType
    -> [IfaceType] -> IOEnv (Env ShIfEnv ()) [IfaceType]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Rename IfaceType
    rnIfaceType (IfaceClassBody -> [IfaceType]
    ifClassCtxt IfaceClassBody
    d)
        ats <- mapM rnIfaceAT (ifATs d)
        sigs <- mapM rnIfaceClassOp (ifSigs d)
        return d { ifClassCtxt = ctxt, ifATs = ats, ifSigs = sigs }

    rnIfaceFamTyConFlav :: Rename IfaceFamTyConFlav
    rnIfaceFamTyConFlav :: Rename IfaceFamTyConFlav
    rnIfaceFamTyConFlav (IfaceClosedSynFamilyTyCon (Just (Name
    n, [IfaceAxBranch]
    axs)))
        = Maybe (Name, [IfaceAxBranch]) -> IfaceFamTyConFlav
    IfaceClosedSynFamilyTyCon (Maybe (Name, [IfaceAxBranch]) -> IfaceFamTyConFlav)
    -> ((Name, [IfaceAxBranch]) -> Maybe (Name, [IfaceAxBranch]))
    -> (Name, [IfaceAxBranch])
    -> IfaceFamTyConFlav
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Name, [IfaceAxBranch]) -> Maybe (Name, [IfaceAxBranch])
    forall a. a -> Maybe a
    Just ((Name, [IfaceAxBranch]) -> IfaceFamTyConFlav)
    -> IOEnv (Env ShIfEnv ()) (Name, [IfaceAxBranch])
    -> IOEnv (Env ShIfEnv ()) IfaceFamTyConFlav
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((,) (Name -> [IfaceAxBranch] -> (Name, [IfaceAxBranch]))
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv
         (Env ShIfEnv ()) ([IfaceAxBranch] -> (Name, [IfaceAxBranch]))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceNeverExported Name
    n
                                                    IOEnv (Env ShIfEnv ()) ([IfaceAxBranch] -> (Name, [IfaceAxBranch]))
    -> IOEnv (Env ShIfEnv ()) [IfaceAxBranch]
    -> IOEnv (Env ShIfEnv ()) (Name, [IfaceAxBranch])
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (IfaceAxBranch -> IOEnv (Env ShIfEnv ()) IfaceAxBranch)
    -> [IfaceAxBranch] -> IOEnv (Env ShIfEnv ()) [IfaceAxBranch]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM IfaceAxBranch -> IOEnv (Env ShIfEnv ()) IfaceAxBranch
    rnIfaceAxBranch [IfaceAxBranch]
    axs)
    rnIfaceFamTyConFlav IfaceFamTyConFlav
    flav = Rename IfaceFamTyConFlav
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceFamTyConFlav
    flav

    rnIfaceAT :: Rename IfaceAT
    rnIfaceAT :: IfaceAT -> IOEnv (Env ShIfEnv ()) IfaceAT
    rnIfaceAT (IfaceAT IfaceDecl
    decl Maybe IfaceType
    mb_ty)
        = IfaceDecl -> Maybe IfaceType -> IfaceAT
    IfaceAT (IfaceDecl -> Maybe IfaceType -> IfaceAT)
    -> IOEnv (Env ShIfEnv ()) IfaceDecl
    -> IOEnv (Env ShIfEnv ()) (Maybe IfaceType -> IfaceAT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceDecl
    rnIfaceDecl IfaceDecl
    decl IOEnv (Env ShIfEnv ()) (Maybe IfaceType -> IfaceAT)
    -> IOEnv (Env ShIfEnv ()) (Maybe IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceAT
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceType
    -> Maybe IfaceType -> IOEnv (Env ShIfEnv ()) (Maybe IfaceType)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Maybe a -> f (Maybe b)
    T.traverse Rename IfaceType
    rnIfaceType Maybe IfaceType
    mb_ty

    rnIfaceTyConParent :: Rename IfaceTyConParent
    rnIfaceTyConParent :: Rename IfaceTyConParent
    rnIfaceTyConParent (IfDataInstance Name
    n IfaceTyCon
    tc IfaceAppArgs
    args)
        = Name -> IfaceTyCon -> IfaceAppArgs -> IfaceTyConParent
    IfDataInstance (Name -> IfaceTyCon -> IfaceAppArgs -> IfaceTyConParent)
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv
         (Env ShIfEnv ()) (IfaceTyCon -> IfaceAppArgs -> IfaceTyConParent)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    n
                         IOEnv
      (Env ShIfEnv ()) (IfaceTyCon -> IfaceAppArgs -> IfaceTyConParent)
    -> IOEnv (Env ShIfEnv ()) IfaceTyCon
    -> IOEnv (Env ShIfEnv ()) (IfaceAppArgs -> IfaceTyConParent)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceTyCon
    rnIfaceTyCon IfaceTyCon
    tc
                         IOEnv (Env ShIfEnv ()) (IfaceAppArgs -> IfaceTyConParent)
    -> IOEnv (Env ShIfEnv ()) IfaceAppArgs
    -> IOEnv (Env ShIfEnv ()) IfaceTyConParent
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceAppArgs
    rnIfaceAppArgs IfaceAppArgs
    args
    rnIfaceTyConParent IfaceTyConParent
    IfNoParent = Rename IfaceTyConParent
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceTyConParent
    IfNoParent

    rnIfaceConDecls :: Rename IfaceConDecls
    rnIfaceConDecls :: Rename IfaceConDecls
    rnIfaceConDecls (IfDataTyCon Bool
    type_data [IfaceConDecl]
    ds)
        = Bool -> [IfaceConDecl] -> IfaceConDecls
    IfDataTyCon Bool
    type_data ([IfaceConDecl] -> IfaceConDecls)
    -> IOEnv (Env ShIfEnv ()) [IfaceConDecl]
    -> IOEnv (Env ShIfEnv ()) IfaceConDecls
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (IfaceConDecl -> IOEnv (Env ShIfEnv ()) IfaceConDecl)
    -> [IfaceConDecl] -> IOEnv (Env ShIfEnv ()) [IfaceConDecl]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM IfaceConDecl -> IOEnv (Env ShIfEnv ()) IfaceConDecl
    rnIfaceConDecl [IfaceConDecl]
    ds
    rnIfaceConDecls (IfNewTyCon IfaceConDecl
    d) = IfaceConDecl -> IfaceConDecls
    IfNewTyCon (IfaceConDecl -> IfaceConDecls)
    -> IOEnv (Env ShIfEnv ()) IfaceConDecl
    -> IOEnv (Env ShIfEnv ()) IfaceConDecls
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IfaceConDecl -> IOEnv (Env ShIfEnv ()) IfaceConDecl
    rnIfaceConDecl IfaceConDecl
    d
    rnIfaceConDecls IfaceConDecls
    IfAbstractTyCon = Rename IfaceConDecls
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceConDecls
    IfAbstractTyCon

    rnIfaceConDecl :: Rename IfaceConDecl
    rnIfaceConDecl :: IfaceConDecl -> IOEnv (Env ShIfEnv ()) IfaceConDecl
    rnIfaceConDecl IfaceConDecl
    d = do
        con_name <- Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal (IfaceConDecl -> Name
    ifConName IfaceConDecl
    d)
        con_ex_tvs <- mapM rnIfaceBndr (ifConExTCvs d)
        con_user_tvbs <- mapM rnIfaceForAllBndr (ifConUserTvBinders d)
        let rnIfConEqSpec (a
    n,IfaceType
    t) = (,) a
    n (IfaceType -> (a, IfaceType))
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (a, IfaceType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    t
        con_eq_spec <- mapM rnIfConEqSpec (ifConEqSpec d)
        con_ctxt <- mapM rnIfaceType (ifConCtxt d)
        con_arg_tys <- mapM rnIfaceScaledType (ifConArgTys d)
        con_fields <- mapM rnFieldLabel (ifConFields d)
        let rnIfaceBang (IfUnpackCo IfaceCoercion
    co) = IfaceCoercion -> IfaceBang
    IfUnpackCo (IfaceCoercion -> IfaceBang)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceBang
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co
            rnIfaceBang IfaceBang
    bang = IfaceBang -> IOEnv (Env ShIfEnv ()) IfaceBang
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceBang
    bang
        con_stricts <- mapM rnIfaceBang (ifConStricts d)
        return d { ifConName = con_name
                 , ifConExTCvs = con_ex_tvs
                 , ifConUserTvBinders = con_user_tvbs
                 , ifConEqSpec = con_eq_spec
                 , ifConCtxt = con_ctxt
                 , ifConArgTys = con_arg_tys
                 , ifConFields = con_fields
                 , ifConStricts = con_stricts
                 }

    rnIfaceClassOp :: Rename IfaceClassOp
    rnIfaceClassOp :: IfaceClassOp -> IOEnv (Env ShIfEnv ()) IfaceClassOp
    rnIfaceClassOp (IfaceClassOp Name
    n IfaceType
    ty Maybe (DefMethSpec IfaceType)
    dm) =
        Name -> IfaceType -> Maybe (DefMethSpec IfaceType) -> IfaceClassOp
    IfaceClassOp (Name
     -> IfaceType -> Maybe (DefMethSpec IfaceType) -> IfaceClassOp)
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv
         (Env ShIfEnv ())
         (IfaceType -> Maybe (DefMethSpec IfaceType) -> IfaceClassOp)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    n
                     IOEnv
      (Env ShIfEnv ())
      (IfaceType -> Maybe (DefMethSpec IfaceType) -> IfaceClassOp)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv
         (Env ShIfEnv ()) (Maybe (DefMethSpec IfaceType) -> IfaceClassOp)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceType
    rnIfaceType IfaceType
    ty
                     IOEnv
      (Env ShIfEnv ()) (Maybe (DefMethSpec IfaceType) -> IfaceClassOp)
    -> IOEnv (Env ShIfEnv ()) (Maybe (DefMethSpec IfaceType))
    -> IOEnv (Env ShIfEnv ()) IfaceClassOp
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename (Maybe (DefMethSpec IfaceType))
    rnMaybeDefMethSpec Maybe (DefMethSpec IfaceType)
    dm

    rnMaybeDefMethSpec :: Rename (Maybe (DefMethSpec IfaceType))
    rnMaybeDefMethSpec :: Rename (Maybe (DefMethSpec IfaceType))
    rnMaybeDefMethSpec (Just (GenericDM IfaceType
    ty)) = DefMethSpec IfaceType -> Maybe (DefMethSpec IfaceType)
    forall a. a -> Maybe a
    Just (DefMethSpec IfaceType -> Maybe (DefMethSpec IfaceType))
    -> (IfaceType -> DefMethSpec IfaceType)
    -> IfaceType
    -> Maybe (DefMethSpec IfaceType)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IfaceType -> DefMethSpec IfaceType
    forall ty. ty -> DefMethSpec ty
    GenericDM (IfaceType -> Maybe (DefMethSpec IfaceType))
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (Maybe (DefMethSpec IfaceType))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    ty
    rnMaybeDefMethSpec Maybe (DefMethSpec IfaceType)
    mb = Rename (Maybe (DefMethSpec IfaceType))
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (DefMethSpec IfaceType)
    mb

    rnIfaceAxBranch :: Rename IfaceAxBranch
    rnIfaceAxBranch :: IfaceAxBranch -> IOEnv (Env ShIfEnv ()) IfaceAxBranch
    rnIfaceAxBranch IfaceAxBranch
    d = do
        ty_vars <- ((IfLclName, IfaceType)
     -> IOEnv (Env ShIfEnv ()) (IfLclName, IfaceType))
    -> [(IfLclName, IfaceType)]
    -> IOEnv (Env ShIfEnv ()) [(IfLclName, IfaceType)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (IfLclName, IfaceType)
    -> IOEnv (Env ShIfEnv ()) (IfLclName, IfaceType)
    rnIfaceTvBndr (IfaceAxBranch -> [(IfLclName, IfaceType)]
    ifaxbTyVars IfaceAxBranch
    d)
        lhs <- rnIfaceAppArgs (ifaxbLHS d)
        rhs <- rnIfaceType (ifaxbRHS d)
        return d { ifaxbTyVars = ty_vars
                 , ifaxbLHS = lhs
                 , ifaxbRHS = rhs }

    rnIfaceIdInfo :: Rename IfaceIdInfo
    rnIfaceIdInfo :: Rename IfaceIdInfo
    rnIfaceIdInfo = (IfaceInfoItem -> IOEnv (Env ShIfEnv ()) IfaceInfoItem)
    -> Rename IfaceIdInfo
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM IfaceInfoItem -> IOEnv (Env ShIfEnv ()) IfaceInfoItem
    rnIfaceInfoItem

    rnIfaceInfoItem :: Rename IfaceInfoItem
    rnIfaceInfoItem :: IfaceInfoItem -> IOEnv (Env ShIfEnv ()) IfaceInfoItem
    rnIfaceInfoItem (HsUnfold Bool
    lb IfaceUnfolding
    if_unf)
        = Bool -> IfaceUnfolding -> IfaceInfoItem
    HsUnfold Bool
    lb (IfaceUnfolding -> IfaceInfoItem)
    -> IOEnv (Env ShIfEnv ()) IfaceUnfolding
    -> IOEnv (Env ShIfEnv ()) IfaceInfoItem
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceUnfolding
    rnIfaceUnfolding IfaceUnfolding
    if_unf
    rnIfaceInfoItem IfaceInfoItem
    i
        = IfaceInfoItem -> IOEnv (Env ShIfEnv ()) IfaceInfoItem
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceInfoItem
    i

    rnIfaceUnfolding :: Rename IfaceUnfolding
    rnIfaceUnfolding :: Rename IfaceUnfolding
    rnIfaceUnfolding (IfCoreUnfold UnfoldingSource
    src IfUnfoldingCache
    cache IfGuidance
    guide IfaceExpr
    if_expr)
        = UnfoldingSource
    -> IfUnfoldingCache -> IfGuidance -> IfaceExpr -> IfaceUnfolding
    IfCoreUnfold UnfoldingSource
    src IfUnfoldingCache
    cache IfGuidance
    guide (IfaceExpr -> IfaceUnfolding)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) IfaceUnfolding
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    if_expr
    rnIfaceUnfolding (IfDFunUnfold [IfaceBndr]
    bs [IfaceExpr]
    ops)
        = [IfaceBndr] -> [IfaceExpr] -> IfaceUnfolding
    IfDFunUnfold ([IfaceBndr] -> [IfaceExpr] -> IfaceUnfolding)
    -> IOEnv (Env ShIfEnv ()) [IfaceBndr]
    -> IOEnv (Env ShIfEnv ()) ([IfaceExpr] -> IfaceUnfolding)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [IfaceBndr] -> IOEnv (Env ShIfEnv ()) [IfaceBndr]
    rnIfaceBndrs [IfaceBndr]
    bs IOEnv (Env ShIfEnv ()) ([IfaceExpr] -> IfaceUnfolding)
    -> IOEnv (Env ShIfEnv ()) [IfaceExpr]
    -> IOEnv (Env ShIfEnv ()) IfaceUnfolding
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceExpr
    -> [IfaceExpr] -> IOEnv (Env ShIfEnv ()) [IfaceExpr]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Rename IfaceExpr
    rnIfaceExpr [IfaceExpr]
    ops

    rnIfaceExpr :: Rename IfaceExpr
    rnIfaceExpr :: Rename IfaceExpr
    rnIfaceExpr (IfaceLcl IfLclName
    name) = Rename IfaceExpr
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (IfLclName -> IfaceExpr
    IfaceLcl IfLclName
    name)
    rnIfaceExpr (IfaceExt Name
    gbl) = Name -> IfaceExpr
    IfaceExt (Name -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) Name -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    gbl
    rnIfaceExpr (IfaceType IfaceType
    ty) = IfaceType -> IfaceExpr
    IfaceType (IfaceType -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    ty
    rnIfaceExpr (IfaceCo IfaceCoercion
    co) = IfaceCoercion -> IfaceExpr
    IfaceCo (IfaceCoercion -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co
    rnIfaceExpr (IfaceTuple TupleSort
    sort [IfaceExpr]
    args) = TupleSort -> [IfaceExpr] -> IfaceExpr
    IfaceTuple TupleSort
    sort ([IfaceExpr] -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) [IfaceExpr]
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [IfaceExpr] -> IOEnv (Env ShIfEnv ()) [IfaceExpr]
    rnIfaceExprs [IfaceExpr]
    args
    rnIfaceExpr (IfaceLam IfaceLamBndr
    lam_bndr IfaceExpr
    expr)
        = IfaceLamBndr -> IfaceExpr -> IfaceExpr
    IfaceLam (IfaceLamBndr -> IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceLamBndr
    -> IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceExpr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceLamBndr
    rnIfaceLamBndr IfaceLamBndr
    lam_bndr IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    expr
    rnIfaceExpr (IfaceApp IfaceExpr
    fun IfaceExpr
    arg)
        = IfaceExpr -> IfaceExpr -> IfaceExpr
    IfaceApp (IfaceExpr -> IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceExpr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    fun IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    arg
    rnIfaceExpr (IfaceCase IfaceExpr
    scrut IfLclName
    case_bndr [IfaceAlt]
    alts)
        = IfaceExpr -> IfLclName -> [IfaceAlt] -> IfaceExpr
    IfaceCase (IfaceExpr -> IfLclName -> [IfaceAlt] -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) (IfLclName -> [IfaceAlt] -> IfaceExpr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    scrut
                    IOEnv (Env ShIfEnv ()) (IfLclName -> [IfaceAlt] -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfLclName
    -> IOEnv (Env ShIfEnv ()) ([IfaceAlt] -> IfaceExpr)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> IfLclName -> IOEnv (Env ShIfEnv ()) IfLclName
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfLclName
    case_bndr
                    IOEnv (Env ShIfEnv ()) ([IfaceAlt] -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) [IfaceAlt]
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (IfaceAlt -> IOEnv (Env ShIfEnv ()) IfaceAlt)
    -> [IfaceAlt] -> IOEnv (Env ShIfEnv ()) [IfaceAlt]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM IfaceAlt -> IOEnv (Env ShIfEnv ()) IfaceAlt
    rnIfaceAlt [IfaceAlt]
    alts
    rnIfaceExpr (IfaceECase IfaceExpr
    scrut IfaceType
    ty)
        = IfaceExpr -> IfaceType -> IfaceExpr
    IfaceECase (IfaceExpr -> IfaceType -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceExpr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    scrut IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceType
    rnIfaceType IfaceType
    ty
    rnIfaceExpr (IfaceLet (IfaceNonRec IfaceLetBndr
    bndr IfaceExpr
    rhs) IfaceExpr
    body)
        = IfaceBindingX IfaceExpr IfaceLetBndr -> IfaceExpr -> IfaceExpr
    IfaceLet (IfaceBindingX IfaceExpr IfaceLetBndr -> IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) (IfaceBindingX IfaceExpr IfaceLetBndr)
    -> IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceExpr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (IfaceLetBndr -> IfaceExpr -> IfaceBindingX IfaceExpr IfaceLetBndr
    forall r b. b -> r -> IfaceBindingX r b
    IfaceNonRec (IfaceLetBndr -> IfaceExpr -> IfaceBindingX IfaceExpr IfaceLetBndr)
    -> IOEnv (Env ShIfEnv ()) IfaceLetBndr
    -> IOEnv
         (Env ShIfEnv ())
         (IfaceExpr -> IfaceBindingX IfaceExpr IfaceLetBndr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceLetBndr
    rnIfaceLetBndr IfaceLetBndr
    bndr IOEnv
      (Env ShIfEnv ())
      (IfaceExpr -> IfaceBindingX IfaceExpr IfaceLetBndr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) (IfaceBindingX IfaceExpr IfaceLetBndr)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    rhs)
                   IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    body
    rnIfaceExpr (IfaceLet (IfaceRec [(IfaceLetBndr, IfaceExpr)]
    pairs) IfaceExpr
    body)
        = IfaceBindingX IfaceExpr IfaceLetBndr -> IfaceExpr -> IfaceExpr
    IfaceLet (IfaceBindingX IfaceExpr IfaceLetBndr -> IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) (IfaceBindingX IfaceExpr IfaceLetBndr)
    -> IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceExpr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ([(IfaceLetBndr, IfaceExpr)] -> IfaceBindingX IfaceExpr IfaceLetBndr
    forall r b. [(b, r)] -> IfaceBindingX r b
    IfaceRec ([(IfaceLetBndr, IfaceExpr)]
     -> IfaceBindingX IfaceExpr IfaceLetBndr)
    -> IOEnv (Env ShIfEnv ()) [(IfaceLetBndr, IfaceExpr)]
    -> IOEnv (Env ShIfEnv ()) (IfaceBindingX IfaceExpr IfaceLetBndr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((IfaceLetBndr, IfaceExpr)
     -> IOEnv (Env ShIfEnv ()) (IfaceLetBndr, IfaceExpr))
    -> [(IfaceLetBndr, IfaceExpr)]
    -> IOEnv (Env ShIfEnv ()) [(IfaceLetBndr, IfaceExpr)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM (\(IfaceLetBndr
    bndr, IfaceExpr
    rhs) ->
                                            (,) (IfaceLetBndr -> IfaceExpr -> (IfaceLetBndr, IfaceExpr))
    -> IOEnv (Env ShIfEnv ()) IfaceLetBndr
    -> IOEnv (Env ShIfEnv ()) (IfaceExpr -> (IfaceLetBndr, IfaceExpr))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceLetBndr
    rnIfaceLetBndr IfaceLetBndr
    bndr
                                                IOEnv (Env ShIfEnv ()) (IfaceExpr -> (IfaceLetBndr, IfaceExpr))
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) (IfaceLetBndr, IfaceExpr)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    rhs) [(IfaceLetBndr, IfaceExpr)]
    pairs)
                   IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    body
    rnIfaceExpr (IfaceCast IfaceExpr
    expr IfaceCoercion
    co)
        = IfaceExpr -> IfaceCoercion -> IfaceExpr
    IfaceCast (IfaceExpr -> IfaceCoercion -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceExpr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    expr IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co
    rnIfaceExpr (IfaceLit Literal
    lit)           = Rename IfaceExpr
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Literal -> IfaceExpr
    IfaceLit Literal
    lit)
    rnIfaceExpr (IfaceLitRubbish TypeOrConstraint
    tc IfaceType
    rep) = TypeOrConstraint -> IfaceType -> IfaceExpr
    IfaceLitRubbish TypeOrConstraint
    tc (IfaceType -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    rep
    rnIfaceExpr (IfaceFCall ForeignCall
    cc IfaceType
    ty)       = ForeignCall -> IfaceType -> IfaceExpr
    IfaceFCall ForeignCall
    cc (IfaceType -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    ty
    rnIfaceExpr (IfaceTick IfaceTickish
    tickish IfaceExpr
    expr) = IfaceTickish -> IfaceExpr -> IfaceExpr
    IfaceTick IfaceTickish
    tickish (IfaceExpr -> IfaceExpr)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    expr

    rnIfaceBndrs :: Rename [IfaceBndr]
    rnIfaceBndrs :: [IfaceBndr] -> IOEnv (Env ShIfEnv ()) [IfaceBndr]
    rnIfaceBndrs = (IfaceBndr -> IOEnv (Env ShIfEnv ()) IfaceBndr)
    -> [IfaceBndr] -> IOEnv (Env ShIfEnv ()) [IfaceBndr]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM IfaceBndr -> IOEnv (Env ShIfEnv ()) IfaceBndr
    rnIfaceBndr

    rnIfaceBndr :: Rename IfaceBndr
    rnIfaceBndr :: IfaceBndr -> IOEnv (Env ShIfEnv ()) IfaceBndr
    rnIfaceBndr (IfaceIdBndr (IfaceType
    w, IfLclName
    fs, IfaceType
    ty)) = (IfaceType, IfLclName, IfaceType) -> IfaceBndr
    IfaceIdBndr ((IfaceType, IfLclName, IfaceType) -> IfaceBndr)
    -> IOEnv (Env ShIfEnv ()) (IfaceType, IfLclName, IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceBndr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ((,,) IfaceType
    w IfLclName
    fs (IfaceType -> (IfaceType, IfLclName, IfaceType))
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceType, IfLclName, IfaceType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    ty)
    rnIfaceBndr (IfaceTvBndr (IfLclName, IfaceType)
    tv_bndr) = (IfLclName, IfaceType) -> IfaceBndr
    IfaceTvBndr ((IfLclName, IfaceType) -> IfaceBndr)
    -> IOEnv (Env ShIfEnv ()) (IfLclName, IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceBndr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (IfLclName, IfaceType)
    -> IOEnv (Env ShIfEnv ()) (IfLclName, IfaceType)
    rnIfaceTvBndr (IfLclName, IfaceType)
    tv_bndr

    rnIfaceTvBndr :: Rename IfaceTvBndr
    rnIfaceTvBndr :: (IfLclName, IfaceType)
    -> IOEnv (Env ShIfEnv ()) (IfLclName, IfaceType)
    rnIfaceTvBndr (IfLclName
    fs, IfaceType
    kind) = (,) IfLclName
    fs (IfaceType -> (IfLclName, IfaceType))
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfLclName, IfaceType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    kind

    rnIfaceTyConBinder :: Rename IfaceTyConBinder
    rnIfaceTyConBinder :: IfaceTyConBinder -> IOEnv (Env ShIfEnv ()) IfaceTyConBinder
    rnIfaceTyConBinder (Bndr IfaceBndr
    tv TyConBndrVis
    vis) = IfaceBndr -> TyConBndrVis -> IfaceTyConBinder
    forall var argf. var -> argf -> VarBndr var argf
    Bndr (IfaceBndr -> TyConBndrVis -> IfaceTyConBinder)
    -> IOEnv (Env ShIfEnv ()) IfaceBndr
    -> IOEnv (Env ShIfEnv ()) (TyConBndrVis -> IfaceTyConBinder)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IfaceBndr -> IOEnv (Env ShIfEnv ()) IfaceBndr
    rnIfaceBndr IfaceBndr
    tv IOEnv (Env ShIfEnv ()) (TyConBndrVis -> IfaceTyConBinder)
    -> IOEnv (Env ShIfEnv ()) TyConBndrVis
    -> IOEnv (Env ShIfEnv ()) IfaceTyConBinder
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> TyConBndrVis -> IOEnv (Env ShIfEnv ()) TyConBndrVis
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TyConBndrVis
    vis

    rnIfaceAlt :: Rename IfaceAlt
    rnIfaceAlt :: IfaceAlt -> IOEnv (Env ShIfEnv ()) IfaceAlt
    rnIfaceAlt (IfaceAlt IfaceConAlt
    conalt [IfLclName]
    names IfaceExpr
    rhs)
         = IfaceConAlt -> [IfLclName] -> IfaceExpr -> IfaceAlt
    IfaceAlt (IfaceConAlt -> [IfLclName] -> IfaceExpr -> IfaceAlt)
    -> IOEnv (Env ShIfEnv ()) IfaceConAlt
    -> IOEnv (Env ShIfEnv ()) ([IfLclName] -> IfaceExpr -> IfaceAlt)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceConAlt
    rnIfaceConAlt IfaceConAlt
    conalt IOEnv (Env ShIfEnv ()) ([IfLclName] -> IfaceExpr -> IfaceAlt)
    -> IOEnv (Env ShIfEnv ()) [IfLclName]
    -> IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceAlt)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> [IfLclName] -> IOEnv (Env ShIfEnv ()) [IfLclName]
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure [IfLclName]
    names IOEnv (Env ShIfEnv ()) (IfaceExpr -> IfaceAlt)
    -> IOEnv (Env ShIfEnv ()) IfaceExpr
    -> IOEnv (Env ShIfEnv ()) IfaceAlt
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceExpr
    rnIfaceExpr IfaceExpr
    rhs

    rnIfaceConAlt :: Rename IfaceConAlt
    rnIfaceConAlt :: Rename IfaceConAlt
    rnIfaceConAlt (IfaceDataAlt Name
    data_occ) = Name -> IfaceConAlt
    IfaceDataAlt (Name -> IfaceConAlt)
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv (Env ShIfEnv ()) IfaceConAlt
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    data_occ
    rnIfaceConAlt IfaceConAlt
    alt = Rename IfaceConAlt
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceConAlt
    alt

    rnIfaceLetBndr :: Rename IfaceLetBndr
    rnIfaceLetBndr :: Rename IfaceLetBndr
    rnIfaceLetBndr (IfLetBndr IfLclName
    fs IfaceType
    ty IfaceIdInfo
    info JoinPointHood
    jpi)
        = IfLclName
    -> IfaceType -> IfaceIdInfo -> JoinPointHood -> IfaceLetBndr
    IfLetBndr IfLclName
    fs (IfaceType -> IfaceIdInfo -> JoinPointHood -> IfaceLetBndr)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv
         (Env ShIfEnv ()) (IfaceIdInfo -> JoinPointHood -> IfaceLetBndr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    ty IOEnv
      (Env ShIfEnv ()) (IfaceIdInfo -> JoinPointHood -> IfaceLetBndr)
    -> IOEnv (Env ShIfEnv ()) IfaceIdInfo
    -> IOEnv (Env ShIfEnv ()) (JoinPointHood -> IfaceLetBndr)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceIdInfo
    rnIfaceIdInfo IfaceIdInfo
    info IOEnv (Env ShIfEnv ()) (JoinPointHood -> IfaceLetBndr)
    -> IOEnv (Env ShIfEnv ()) JoinPointHood
    -> IOEnv (Env ShIfEnv ()) IfaceLetBndr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> JoinPointHood -> IOEnv (Env ShIfEnv ()) JoinPointHood
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure JoinPointHood
    jpi

    rnIfaceLamBndr :: Rename IfaceLamBndr
    rnIfaceLamBndr :: Rename IfaceLamBndr
    rnIfaceLamBndr (IfaceBndr
    bndr, IfaceOneShot
    oneshot) = (,) (IfaceBndr -> IfaceOneShot -> IfaceLamBndr)
    -> IOEnv (Env ShIfEnv ()) IfaceBndr
    -> IOEnv (Env ShIfEnv ()) (IfaceOneShot -> IfaceLamBndr)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IfaceBndr -> IOEnv (Env ShIfEnv ()) IfaceBndr
    rnIfaceBndr IfaceBndr
    bndr IOEnv (Env ShIfEnv ()) (IfaceOneShot -> IfaceLamBndr)
    -> IOEnv (Env ShIfEnv ()) IfaceOneShot
    -> IOEnv (Env ShIfEnv ()) IfaceLamBndr
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> IfaceOneShot -> IOEnv (Env ShIfEnv ()) IfaceOneShot
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceOneShot
    oneshot

    rnIfaceMCo :: Rename IfaceMCoercion
    rnIfaceMCo :: Rename IfaceMCoercion
    rnIfaceMCo IfaceMCoercion
    IfaceMRefl    = Rename IfaceMCoercion
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceMCoercion
    IfaceMRefl
    rnIfaceMCo (IfaceMCo IfaceCoercion
    co) = IfaceCoercion -> IfaceMCoercion
    IfaceMCo (IfaceCoercion -> IfaceMCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceMCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co

    rnIfaceCo :: Rename IfaceCoercion
    rnIfaceCo :: Rename IfaceCoercion
    rnIfaceCo (IfaceReflCo IfaceType
    ty) = IfaceType -> IfaceCoercion
    IfaceReflCo (IfaceType -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    ty
    rnIfaceCo (IfaceGReflCo Role
    role IfaceType
    ty IfaceMCoercion
    mco)
      = Role -> IfaceType -> IfaceMCoercion -> IfaceCoercion
    IfaceGReflCo Role
    role (IfaceType -> IfaceMCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceMCoercion -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    ty IOEnv (Env ShIfEnv ()) (IfaceMCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceMCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceMCoercion
    rnIfaceMCo IfaceMCoercion
    mco
    rnIfaceCo (IfaceFunCo Role
    role IfaceCoercion
    w IfaceCoercion
    co1 IfaceCoercion
    co2)
        = Role
    -> IfaceCoercion -> IfaceCoercion -> IfaceCoercion -> IfaceCoercion
    IfaceFunCo Role
    role (IfaceCoercion -> IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv
         (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    w IOEnv
      (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co1 IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co2
    rnIfaceCo (IfaceTyConAppCo Role
    role IfaceTyCon
    tc [IfaceCoercion]
    cos)
        = Role -> IfaceTyCon -> [IfaceCoercion] -> IfaceCoercion
    IfaceTyConAppCo Role
    role (IfaceTyCon -> [IfaceCoercion] -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceTyCon
    -> IOEnv (Env ShIfEnv ()) ([IfaceCoercion] -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceTyCon
    rnIfaceTyCon IfaceTyCon
    tc IOEnv (Env ShIfEnv ()) ([IfaceCoercion] -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) [IfaceCoercion]
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    -> [IfaceCoercion] -> IOEnv (Env ShIfEnv ()) [IfaceCoercion]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Rename IfaceCoercion
    rnIfaceCo [IfaceCoercion]
    cos
    rnIfaceCo (IfaceAppCo IfaceCoercion
    co1 IfaceCoercion
    co2)
        = IfaceCoercion -> IfaceCoercion -> IfaceCoercion
    IfaceAppCo (IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co1 IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co2
    rnIfaceCo (IfaceForAllCo IfaceBndr
    bndr ForAllTyFlag
    visL ForAllTyFlag
    visR IfaceCoercion
    co1 IfaceCoercion
    co2)
        = (\IfaceBndr
    bndr' IfaceCoercion
    co1' IfaceCoercion
    co2' -> IfaceBndr
    -> ForAllTyFlag
    -> ForAllTyFlag
    -> IfaceCoercion
    -> IfaceCoercion
    -> IfaceCoercion
    IfaceForAllCo IfaceBndr
    bndr' ForAllTyFlag
    visL ForAllTyFlag
    visR IfaceCoercion
    co1' IfaceCoercion
    co2')
          (IfaceBndr -> IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceBndr
    -> IOEnv
         (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IfaceBndr -> IOEnv (Env ShIfEnv ()) IfaceBndr
    rnIfaceBndr IfaceBndr
    bndr IOEnv
      (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co1 IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co2
    rnIfaceCo (IfaceFreeCoVar CoVar
    c) = Rename IfaceCoercion
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (CoVar -> IfaceCoercion
    IfaceFreeCoVar CoVar
    c)
    rnIfaceCo (IfaceCoVarCo IfLclName
    lcl) = IfLclName -> IfaceCoercion
    IfaceCoVarCo (IfLclName -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfLclName
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IfLclName -> IOEnv (Env ShIfEnv ()) IfLclName
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfLclName
    lcl
    rnIfaceCo (IfaceHoleCo CoVar
    lcl)  = CoVar -> IfaceCoercion
    IfaceHoleCo  (CoVar -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) CoVar
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> CoVar -> IOEnv (Env ShIfEnv ()) CoVar
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure CoVar
    lcl
    rnIfaceCo (IfaceAxiomInstCo Name
    n BranchIndex
    i [IfaceCoercion]
    cs)
        = Name -> BranchIndex -> [IfaceCoercion] -> IfaceCoercion
    IfaceAxiomInstCo (Name -> BranchIndex -> [IfaceCoercion] -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv
         (Env ShIfEnv ()) (BranchIndex -> [IfaceCoercion] -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    n IOEnv
      (Env ShIfEnv ()) (BranchIndex -> [IfaceCoercion] -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) BranchIndex
    -> IOEnv (Env ShIfEnv ()) ([IfaceCoercion] -> IfaceCoercion)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> BranchIndex -> IOEnv (Env ShIfEnv ()) BranchIndex
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure BranchIndex
    i IOEnv (Env ShIfEnv ()) ([IfaceCoercion] -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) [IfaceCoercion]
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    -> [IfaceCoercion] -> IOEnv (Env ShIfEnv ()) [IfaceCoercion]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Rename IfaceCoercion
    rnIfaceCo [IfaceCoercion]
    cs
    rnIfaceCo (IfaceUnivCo IfaceUnivCoProv
    s Role
    r IfaceType
    t1 IfaceType
    t2)
        = IfaceUnivCoProv -> Role -> IfaceType -> IfaceType -> IfaceCoercion
    IfaceUnivCo IfaceUnivCoProv
    s Role
    r (IfaceType -> IfaceType -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    t1 IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceType
    rnIfaceType IfaceType
    t2
    rnIfaceCo (IfaceSymCo IfaceCoercion
    c)
        = IfaceCoercion -> IfaceCoercion
    IfaceSymCo (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c
    rnIfaceCo (IfaceTransCo IfaceCoercion
    c1 IfaceCoercion
    c2)
        = IfaceCoercion -> IfaceCoercion -> IfaceCoercion
    IfaceTransCo (IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c1 IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c2
    rnIfaceCo (IfaceInstCo IfaceCoercion
    c1 IfaceCoercion
    c2)
        = IfaceCoercion -> IfaceCoercion -> IfaceCoercion
    IfaceInstCo (IfaceCoercion -> IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c1 IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c2
    rnIfaceCo (IfaceSelCo CoSel
    d IfaceCoercion
    c) = CoSel -> IfaceCoercion -> IfaceCoercion
    IfaceSelCo CoSel
    d (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c
    rnIfaceCo (IfaceLRCo LeftOrRight
    lr IfaceCoercion
    c) = LeftOrRight -> IfaceCoercion -> IfaceCoercion
    IfaceLRCo LeftOrRight
    lr (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c
    rnIfaceCo (IfaceSubCo IfaceCoercion
    c) = IfaceCoercion -> IfaceCoercion
    IfaceSubCo (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c
    rnIfaceCo (IfaceAxiomRuleCo IfLclName
    ax [IfaceCoercion]
    cos)
        = IfLclName -> [IfaceCoercion] -> IfaceCoercion
    IfaceAxiomRuleCo IfLclName
    ax ([IfaceCoercion] -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) [IfaceCoercion]
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    -> [IfaceCoercion] -> IOEnv (Env ShIfEnv ()) [IfaceCoercion]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Rename IfaceCoercion
    rnIfaceCo [IfaceCoercion]
    cos
    rnIfaceCo (IfaceKindCo IfaceCoercion
    c) = IfaceCoercion -> IfaceCoercion
    IfaceKindCo (IfaceCoercion -> IfaceCoercion)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    c

    rnIfaceTyCon :: Rename IfaceTyCon
    rnIfaceTyCon :: Rename IfaceTyCon
    rnIfaceTyCon (IfaceTyCon Name
    n IfaceTyConInfo
    info)
        = Name -> IfaceTyConInfo -> IfaceTyCon
    IfaceTyCon (Name -> IfaceTyConInfo -> IfaceTyCon)
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv (Env ShIfEnv ()) (IfaceTyConInfo -> IfaceTyCon)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    n IOEnv (Env ShIfEnv ()) (IfaceTyConInfo -> IfaceTyCon)
    -> IOEnv (Env ShIfEnv ()) IfaceTyConInfo
    -> IOEnv (Env ShIfEnv ()) IfaceTyCon
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> IfaceTyConInfo -> IOEnv (Env ShIfEnv ()) IfaceTyConInfo
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceTyConInfo
    info

    rnIfaceExprs :: Rename [IfaceExpr]
    rnIfaceExprs :: [IfaceExpr] -> IOEnv (Env ShIfEnv ()) [IfaceExpr]
    rnIfaceExprs = Rename IfaceExpr
    -> [IfaceExpr] -> IOEnv (Env ShIfEnv ()) [IfaceExpr]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Rename IfaceExpr
    rnIfaceExpr

    rnIfaceIdDetails :: Rename IfaceIdDetails
    rnIfaceIdDetails :: Rename IfaceIdDetails
    rnIfaceIdDetails (IfRecSelId (Left IfaceTyCon
    tc) Name
    con Bool
    naughty FieldLabel
    fl)
      = Either IfaceTyCon IfaceDecl
    -> Name -> Bool -> FieldLabel -> IfaceIdDetails
    IfRecSelId (Either IfaceTyCon IfaceDecl
     -> Name -> Bool -> FieldLabel -> IfaceIdDetails)
    -> IOEnv (Env ShIfEnv ()) (Either IfaceTyCon IfaceDecl)
    -> IOEnv
         (Env ShIfEnv ()) (Name -> Bool -> FieldLabel -> IfaceIdDetails)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (IfaceTyCon -> Either IfaceTyCon IfaceDecl)
    -> IOEnv (Env ShIfEnv ()) IfaceTyCon
    -> IOEnv (Env ShIfEnv ()) (Either IfaceTyCon IfaceDecl)
    forall a b.
    (a -> b) -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap IfaceTyCon -> Either IfaceTyCon IfaceDecl
    forall a b. a -> Either a b
    Left (Rename IfaceTyCon
    rnIfaceTyCon IfaceTyCon
    tc) IOEnv
      (Env ShIfEnv ()) (Name -> Bool -> FieldLabel -> IfaceIdDetails)
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv (Env ShIfEnv ()) (Bool -> FieldLabel -> IfaceIdDetails)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    con IOEnv (Env ShIfEnv ()) (Bool -> FieldLabel -> IfaceIdDetails)
    -> IOEnv (Env ShIfEnv ()) Bool
    -> IOEnv (Env ShIfEnv ()) (FieldLabel -> IfaceIdDetails)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Bool -> IOEnv (Env ShIfEnv ()) Bool
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Bool
    naughty IOEnv (Env ShIfEnv ()) (FieldLabel -> IfaceIdDetails)
    -> IOEnv (Env ShIfEnv ()) FieldLabel
    -> IOEnv (Env ShIfEnv ()) IfaceIdDetails
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename FieldLabel
    rnFieldLabel FieldLabel
    fl
    rnIfaceIdDetails (IfRecSelId (Right IfaceDecl
    decl) Name
    con Bool
    naughty FieldLabel
    fl)
      = Either IfaceTyCon IfaceDecl
    -> Name -> Bool -> FieldLabel -> IfaceIdDetails
    IfRecSelId (Either IfaceTyCon IfaceDecl
     -> Name -> Bool -> FieldLabel -> IfaceIdDetails)
    -> IOEnv (Env ShIfEnv ()) (Either IfaceTyCon IfaceDecl)
    -> IOEnv
         (Env ShIfEnv ()) (Name -> Bool -> FieldLabel -> IfaceIdDetails)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (IfaceDecl -> Either IfaceTyCon IfaceDecl)
    -> IOEnv (Env ShIfEnv ()) IfaceDecl
    -> IOEnv (Env ShIfEnv ()) (Either IfaceTyCon IfaceDecl)
    forall a b.
    (a -> b) -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap IfaceDecl -> Either IfaceTyCon IfaceDecl
    forall a b. b -> Either a b
    Right (Rename IfaceDecl
    rnIfaceDecl IfaceDecl
    decl) IOEnv
      (Env ShIfEnv ()) (Name -> Bool -> FieldLabel -> IfaceIdDetails)
    -> IOEnv (Env ShIfEnv ()) Name
    -> IOEnv (Env ShIfEnv ()) (Bool -> FieldLabel -> IfaceIdDetails)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Name -> IOEnv (Env ShIfEnv ()) Name
    rnIfaceGlobal Name
    con IOEnv (Env ShIfEnv ()) (Bool -> FieldLabel -> IfaceIdDetails)
    -> IOEnv (Env ShIfEnv ()) Bool
    -> IOEnv (Env ShIfEnv ()) (FieldLabel -> IfaceIdDetails)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Bool -> IOEnv (Env ShIfEnv ()) Bool
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Bool
    naughty IOEnv (Env ShIfEnv ()) (FieldLabel -> IfaceIdDetails)
    -> IOEnv (Env ShIfEnv ()) FieldLabel
    -> IOEnv (Env ShIfEnv ()) IfaceIdDetails
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename FieldLabel
    rnFieldLabel FieldLabel
    fl
    rnIfaceIdDetails IfaceIdDetails
    details
      = Rename IfaceIdDetails
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceIdDetails
    details

    rnIfaceType :: Rename IfaceType
    rnIfaceType :: Rename IfaceType
    rnIfaceType (IfaceFreeTyVar CoVar
    n) = Rename IfaceType
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (CoVar -> IfaceType
    IfaceFreeTyVar CoVar
    n)
    rnIfaceType (IfaceTyVar   IfLclName
    n)   = Rename IfaceType
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (IfLclName -> IfaceType
    IfaceTyVar IfLclName
    n)
    rnIfaceType (IfaceAppTy IfaceType
    t1 IfaceAppArgs
    t2)
        = IfaceType -> IfaceAppArgs -> IfaceType
    IfaceAppTy (IfaceType -> IfaceAppArgs -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceAppArgs -> IfaceType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    t1 IOEnv (Env ShIfEnv ()) (IfaceAppArgs -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceAppArgs
    -> IOEnv (Env ShIfEnv ()) IfaceType
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceAppArgs
    rnIfaceAppArgs IfaceAppArgs
    t2
    rnIfaceType (IfaceLitTy IfaceTyLit
    l)         = Rename IfaceType
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (IfaceTyLit -> IfaceType
    IfaceLitTy IfaceTyLit
    l)
    rnIfaceType (IfaceFunTy FunTyFlag
    af IfaceType
    w IfaceType
    t1 IfaceType
    t2)
        = FunTyFlag -> IfaceType -> IfaceType -> IfaceType -> IfaceType
    IfaceFunTy FunTyFlag
    af (IfaceType -> IfaceType -> IfaceType -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceType -> IfaceType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    w IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceType -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceType)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceType
    rnIfaceType IfaceType
    t1 IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) IfaceType
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceType
    rnIfaceType IfaceType
    t2
    rnIfaceType (IfaceTupleTy TupleSort
    s PromotionFlag
    i IfaceAppArgs
    tks)
        = TupleSort -> PromotionFlag -> IfaceAppArgs -> IfaceType
    IfaceTupleTy TupleSort
    s PromotionFlag
    i (IfaceAppArgs -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceAppArgs
    -> IOEnv (Env ShIfEnv ()) IfaceType
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceAppArgs
    rnIfaceAppArgs IfaceAppArgs
    tks
    rnIfaceType (IfaceTyConApp IfaceTyCon
    tc IfaceAppArgs
    tks)
        = IfaceTyCon -> IfaceAppArgs -> IfaceType
    IfaceTyConApp (IfaceTyCon -> IfaceAppArgs -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceTyCon
    -> IOEnv (Env ShIfEnv ()) (IfaceAppArgs -> IfaceType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceTyCon
    rnIfaceTyCon IfaceTyCon
    tc IOEnv (Env ShIfEnv ()) (IfaceAppArgs -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceAppArgs
    -> IOEnv (Env ShIfEnv ()) IfaceType
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceAppArgs
    rnIfaceAppArgs IfaceAppArgs
    tks
    rnIfaceType (IfaceForAllTy IfaceForAllBndr
    tv IfaceType
    t)
        = IfaceForAllBndr -> IfaceType -> IfaceType
    IfaceForAllTy (IfaceForAllBndr -> IfaceType -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceForAllBndr
    -> IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceForAllBndr
    forall flag. Rename (VarBndr IfaceBndr flag)
    rnIfaceForAllBndr IfaceForAllBndr
    tv IOEnv (Env ShIfEnv ()) (IfaceType -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) IfaceType
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceType
    rnIfaceType IfaceType
    t
    rnIfaceType (IfaceCoercionTy IfaceCoercion
    co)
        = IfaceCoercion -> IfaceType
    IfaceCoercionTy (IfaceCoercion -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceType
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co
    rnIfaceType (IfaceCastTy IfaceType
    ty IfaceCoercion
    co)
        = IfaceType -> IfaceCoercion -> IfaceType
    IfaceCastTy (IfaceType -> IfaceCoercion -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceType)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    ty IOEnv (Env ShIfEnv ()) (IfaceCoercion -> IfaceType)
    -> IOEnv (Env ShIfEnv ()) IfaceCoercion
    -> IOEnv (Env ShIfEnv ()) IfaceType
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceCoercion
    rnIfaceCo IfaceCoercion
    co

    rnIfaceScaledType :: Rename (IfaceMult, IfaceType)
    rnIfaceScaledType :: (IfaceType, IfaceType)
    -> IOEnv (Env ShIfEnv ()) (IfaceType, IfaceType)
    rnIfaceScaledType (IfaceType
    m, IfaceType
    t) = (,) (IfaceType -> IfaceType -> (IfaceType, IfaceType))
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceType -> (IfaceType, IfaceType))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    m IOEnv (Env ShIfEnv ()) (IfaceType -> (IfaceType, IfaceType))
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv (Env ShIfEnv ()) (IfaceType, IfaceType)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceType
    rnIfaceType IfaceType
    t

    rnIfaceForAllBndr :: Rename (VarBndr IfaceBndr flag)
    rnIfaceForAllBndr :: forall flag. Rename (VarBndr IfaceBndr flag)
    rnIfaceForAllBndr (Bndr IfaceBndr
    tv flag
    vis) = IfaceBndr -> flag -> VarBndr IfaceBndr flag
    forall var argf. var -> argf -> VarBndr var argf
    Bndr (IfaceBndr -> flag -> VarBndr IfaceBndr flag)
    -> IOEnv (Env ShIfEnv ()) IfaceBndr
    -> IOEnv (Env ShIfEnv ()) (flag -> VarBndr IfaceBndr flag)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IfaceBndr -> IOEnv (Env ShIfEnv ()) IfaceBndr
    rnIfaceBndr IfaceBndr
    tv IOEnv (Env ShIfEnv ()) (flag -> VarBndr IfaceBndr flag)
    -> IOEnv (Env ShIfEnv ()) flag
    -> IOEnv (Env ShIfEnv ()) (VarBndr IfaceBndr flag)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> flag -> IOEnv (Env ShIfEnv ()) flag
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure flag
    vis

    rnIfaceAppArgs :: Rename IfaceAppArgs
    rnIfaceAppArgs :: Rename IfaceAppArgs
    rnIfaceAppArgs (IA_Arg IfaceType
    t ForAllTyFlag
    a IfaceAppArgs
    ts) = IfaceType -> ForAllTyFlag -> IfaceAppArgs -> IfaceAppArgs
    IA_Arg (IfaceType -> ForAllTyFlag -> IfaceAppArgs -> IfaceAppArgs)
    -> IOEnv (Env ShIfEnv ()) IfaceType
    -> IOEnv
         (Env ShIfEnv ()) (ForAllTyFlag -> IfaceAppArgs -> IfaceAppArgs)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Rename IfaceType
    rnIfaceType IfaceType
    t IOEnv
      (Env ShIfEnv ()) (ForAllTyFlag -> IfaceAppArgs -> IfaceAppArgs)
    -> IOEnv (Env ShIfEnv ()) ForAllTyFlag
    -> IOEnv (Env ShIfEnv ()) (IfaceAppArgs -> IfaceAppArgs)
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ForAllTyFlag -> IOEnv (Env ShIfEnv ()) ForAllTyFlag
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ForAllTyFlag
    a
                                            IOEnv (Env ShIfEnv ()) (IfaceAppArgs -> IfaceAppArgs)
    -> IOEnv (Env ShIfEnv ()) IfaceAppArgs
    -> IOEnv (Env ShIfEnv ()) IfaceAppArgs
    forall a b.
    IOEnv (Env ShIfEnv ()) (a -> b)
    -> IOEnv (Env ShIfEnv ()) a -> IOEnv (Env ShIfEnv ()) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Rename IfaceAppArgs
    rnIfaceAppArgs IfaceAppArgs
    ts
    rnIfaceAppArgs IfaceAppArgs
    IA_Nil = Rename IfaceAppArgs
    forall a. a -> IOEnv (Env ShIfEnv ()) a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure IfaceAppArgs
    IA_Nil