{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# OPTIONS_GHC -Wno-incomplete-record-updates #-}

module Haddock.Interface.RenameType
  ( rename
  ) where

import Control.Monad.Trans.State
import qualified Data.List as List
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
import Data.Maybe
import Data.Set (Set)
import qualified Data.Set as Set
import GHC
import GHC.Data.FastString
import GHC.Types.Name

import Haddock.Types

-- | Haskell AST type representation.
--
-- This type is used for renaming (more below), essentially the ambiguous (!)
-- version of 'Name'. So, why is this 'FastString' instead of 'OccName'? Well,
-- it was 'OccName' before, but turned out that 'OccName' sometimes also
-- contains namespace information, differentiating visually same types.
--
-- And 'FastString' is used because it is /visual/ part of 'OccName' - it is
-- not converted to 'String' or alike to avoid new allocations. Additionally,
-- since it is stored mostly in 'Set', fast comparison of 'FastString' is also
-- quite nice.
newtype NameRep
  = NameRep FastString
  deriving (NameRep -> NameRep -> Bool
(NameRep -> NameRep -> Bool)
-> (NameRep -> NameRep -> Bool) -> Eq NameRep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NameRep -> NameRep -> Bool
== :: NameRep -> NameRep -> Bool
$c/= :: NameRep -> NameRep -> Bool
/= :: NameRep -> NameRep -> Bool
Eq)

instance Ord NameRep where
  compare :: NameRep -> NameRep -> Ordering
compare (NameRep FastString
fs1) (NameRep FastString
fs2) = FastString -> FastString -> Ordering
uniqCompareFS FastString
fs1 FastString
fs2

getNameRep :: NamedThing name => name -> NameRep
getNameRep :: forall name. NamedThing name => name -> NameRep
getNameRep = FastString -> NameRep
FastString -> NameRep
NameRep (FastString -> NameRep) -> (name -> FastString) -> name -> NameRep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. name -> FastString
forall a. NamedThing a => a -> FastString
getOccFS

nameRepString :: NameRep -> String
nameRepString :: NameRep -> String
nameRepString (NameRep FastString
fs) = FastString -> String
unpackFS FastString
fs

stringNameRep :: String -> NameRep
stringNameRep :: String -> NameRep
stringNameRep = FastString -> NameRep
FastString -> NameRep
NameRep (FastString -> NameRep)
-> (String -> FastString) -> String -> NameRep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> FastString
mkFastString

setInternalNameRep :: SetName name => NameRep -> name -> name
setInternalNameRep :: forall name. SetName name => NameRep -> name -> name
setInternalNameRep (NameRep FastString
fs) = OccName -> name -> name
forall name. SetName name => OccName -> name -> name
setInternalOccName (FastString -> OccName
mkVarOccFS FastString
fs)

setInternalOccName :: SetName name => OccName -> name -> name
setInternalOccName :: forall name. SetName name => OccName -> name -> name
setInternalOccName OccName
occ name
name =
  Name -> name -> name
forall name. SetName name => Name -> name -> name
setName Name
nname' name
name
  where
    nname :: Name
nname = name -> Name
forall a. NamedThing a => a -> Name
getName name
name
    nname' :: Name
nname' = Unique -> OccName -> SrcSpan -> Name
mkInternalName (Name -> Unique
nameUnique Name
nname) OccName
occ (Name -> SrcSpan
nameSrcSpan Name
nname)

-- | Make given type visually unambiguous.
--
-- After applying 'specialize' method, some free type variables may become
-- visually ambiguous - for example, having @a -> b@ and specializing @a@ to
-- @(a -> b)@ we get @(a -> b) -> b@ where first occurrence of @b@ refers to
-- different type variable than latter one. Applying 'rename' function
-- will fix that type to be visually unambiguous again (making it something
-- like @(a -> b0) -> b@).
rename :: [Name] -> LHsType GhcRn -> LHsType GhcRn
rename :: [Name] -> LHsType (GhcPass 'Renamed) -> LHsType (GhcPass 'Renamed)
rename [] LHsType (GhcPass 'Renamed)
typ = LHsType (GhcPass 'Renamed)
typ
rename [Name]
fv LHsType (GhcPass 'Renamed)
typ = State
  (RenameEnv Name)
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> RenameEnv Name
-> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
forall s a. State s a -> s -> a
evalState ((HsType (GhcPass 'Renamed)
 -> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed)))
-> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
forall (t :: Type -> Type) (f :: Type -> Type) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: Type -> Type) a b.
Applicative f =>
(a -> f b)
-> GenLocated SrcSpanAnnA a -> f (GenLocated SrcSpanAnnA b)
traverse HsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (HsType (GhcPass 'Renamed))
HsType (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
renameType LHsType (GhcPass 'Renamed)
GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
typ) RenameEnv Name
env
  where
    env :: RenameEnv Name
env =
      RenameEnv
        { rneHeadFVs :: Map NameRep Name
rneHeadFVs = [(NameRep, Name)] -> Map NameRep Name
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(NameRep, Name)] -> Map NameRep Name)
-> [(NameRep, Name)] -> Map NameRep Name
forall a b. (a -> b) -> a -> b
$ (Name -> (NameRep, Name)) -> [Name] -> [(NameRep, Name)]
forall a b. (a -> b) -> [a] -> [b]
map Name -> (NameRep, Name)
forall {b}. NamedThing b => b -> (NameRep, b)
mkPair [Name]
fv
        , rneCtx :: Map Name Name
rneCtx = Map Name Name
forall k a. Map k a
Map.empty
        }
    mkPair :: b -> (NameRep, b)
mkPair b
name = (b -> NameRep
forall name. NamedThing name => name -> NameRep
getNameRep b
name, b
name)

-- | Renaming monad.
type Rename name = State (RenameEnv name)

data RenameEnv name = RenameEnv
  { forall name. RenameEnv name -> Map NameRep Name
rneHeadFVs :: Map NameRep Name
  , forall name. RenameEnv name -> Map Name name
rneCtx :: Map Name name
  }

renameType :: HsType GhcRn -> Rename (IdP GhcRn) (HsType GhcRn)
renameType :: HsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (HsType (GhcPass 'Renamed))
renameType (HsForAllTy XForAllTy (GhcPass 'Renamed)
x HsForAllTelescope (GhcPass 'Renamed)
tele LHsType (GhcPass 'Renamed)
lt) =
  XForAllTy (GhcPass 'Renamed)
-> HsForAllTelescope (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XForAllTy pass
-> HsForAllTelescope pass -> LHsType pass -> HsType pass
HsForAllTy XForAllTy (GhcPass 'Renamed)
x
    (HsForAllTelescope (GhcPass 'Renamed)
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name) Identity (HsForAllTelescope (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HsForAllTelescope (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (HsForAllTelescope (GhcPass 'Renamed))
renameForAllTelescope HsForAllTelescope (GhcPass 'Renamed)
tele
    StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lt
renameType (HsQualTy XQualTy (GhcPass 'Renamed)
x LHsContext (GhcPass 'Renamed)
lctxt LHsType (GhcPass 'Renamed)
lt) =
  XQualTy (GhcPass 'Renamed)
-> LHsContext (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XQualTy pass -> LHsContext pass -> LHsType pass -> HsType pass
HsQualTy XQualTy (GhcPass 'Renamed)
x
    (GenLocated
   SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated
        SrcSpanAnnC [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))])
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsContext (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsContext (GhcPass 'Renamed))
renameLContext LHsContext (GhcPass 'Renamed)
lctxt
    StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lt
renameType (HsTyVar XTyVar (GhcPass 'Renamed)
x PromotionFlag
ip LIdOccP (GhcPass 'Renamed)
name) = XTyVar (GhcPass 'Renamed)
-> PromotionFlag
-> LIdOccP (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XTyVar pass -> PromotionFlag -> LIdOccP pass -> HsType pass
HsTyVar XTyVar (GhcPass 'Renamed)
x PromotionFlag
ip (GenLocated SrcSpanAnnN (WithUserRdr Name)
 -> HsType (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnN (WithUserRdr Name))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LIdOccP (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LIdOccP (GhcPass 'Renamed))
renameLNameOcc LIdOccP (GhcPass 'Renamed)
name
renameType t :: HsType (GhcPass 'Renamed)
t@(HsStarTy XStarTy (GhcPass 'Renamed)
_) = HsType (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure HsType (GhcPass 'Renamed)
t
renameType (HsAppTy XAppTy (GhcPass 'Renamed)
x LHsType (GhcPass 'Renamed)
lf LHsType (GhcPass 'Renamed)
la) = XAppTy (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XAppTy pass -> LHsType pass -> LHsType pass -> HsType pass
HsAppTy XAppTy (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lf StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
la
renameType (HsAppKindTy XAppKindTy (GhcPass 'Renamed)
x LHsType (GhcPass 'Renamed)
lt LHsType (GhcPass 'Renamed)
lk) = XAppKindTy (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XAppKindTy pass -> LHsType pass -> LHsType pass -> HsType pass
HsAppKindTy XAppKindTy (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lt StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLKind LHsType (GhcPass 'Renamed)
lk
renameType (HsFunTy XFunTy (GhcPass 'Renamed)
x HsModifiedFunArr (GhcPass 'Renamed)
w LHsType (GhcPass 'Renamed)
la LHsType (GhcPass 'Renamed)
lr) = XFunTy (GhcPass 'Renamed)
-> HsModifiedFunArr (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XFunTy pass
-> HsModifiedFunArr pass
-> LHsType pass
-> LHsType pass
-> HsType pass
HsFunTy XFunTy (GhcPass 'Renamed)
x (HsModifiedFunArrOf
   (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
   (GhcPass 'Renamed)
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (HsModifiedFunArrOf
        (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
        (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HsModifiedFunArr (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (HsModifiedFunArr (GhcPass 'Renamed))
renameHsModifiedFunArr HsModifiedFunArr (GhcPass 'Renamed)
w StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
la StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lr
renameType (HsListTy XListTy (GhcPass 'Renamed)
x LHsType (GhcPass 'Renamed)
lt) = XListTy (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed) -> HsType (GhcPass 'Renamed)
forall pass. XListTy pass -> LHsType pass -> HsType pass
HsListTy XListTy (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lt
renameType (HsTupleTy XTupleTy (GhcPass 'Renamed)
x HsTupleSort
srt [LHsType (GhcPass 'Renamed)]
lt) = XTupleTy (GhcPass 'Renamed)
-> HsTupleSort
-> [LHsType (GhcPass 'Renamed)]
-> HsType (GhcPass 'Renamed)
forall pass.
XTupleTy pass -> HsTupleSort -> [LHsType pass] -> HsType pass
HsTupleTy XTupleTy (GhcPass 'Renamed)
x HsTupleSort
srt ([GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
 -> HsType (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> State
      (RenameEnv Name)
      (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))))
-> [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
forall (t :: Type -> Type) (m :: Type -> Type) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: Type -> Type) a b.
Monad m =>
(a -> m b) -> [a] -> m [b]
mapM LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
renameLType [LHsType (GhcPass 'Renamed)]
[GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
lt
renameType (HsSumTy XSumTy (GhcPass 'Renamed)
x [LHsType (GhcPass 'Renamed)]
lt) = XSumTy (GhcPass 'Renamed)
-> [LHsType (GhcPass 'Renamed)] -> HsType (GhcPass 'Renamed)
forall pass. XSumTy pass -> [LHsType pass] -> HsType pass
HsSumTy XSumTy (GhcPass 'Renamed)
x ([GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
 -> HsType (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> State
      (RenameEnv Name)
      (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))))
-> [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
forall (t :: Type -> Type) (m :: Type -> Type) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: Type -> Type) a b.
Monad m =>
(a -> m b) -> [a] -> m [b]
mapM LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
renameLType [LHsType (GhcPass 'Renamed)]
[GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
lt
renameType (HsOpTy XOpTy (GhcPass 'Renamed)
x LHsType (GhcPass 'Renamed)
la LHsType (GhcPass 'Renamed)
lop LHsType (GhcPass 'Renamed)
lb) =
  XOpTy (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XOpTy pass
-> LHsType pass -> LHsType pass -> LHsType pass -> HsType pass
HsOpTy XOpTy (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
la StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lop StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lb
renameType (HsParTy XParTy (GhcPass 'Renamed)
x LHsType (GhcPass 'Renamed)
lt) = XParTy (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed) -> HsType (GhcPass 'Renamed)
forall pass. XParTy pass -> LHsType pass -> HsType pass
HsParTy XParTy (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lt
renameType (HsIParamTy XIParamTy (GhcPass 'Renamed)
x XRec (GhcPass 'Renamed) HsIPName
ip LHsType (GhcPass 'Renamed)
lt) = XIParamTy (GhcPass 'Renamed)
-> XRec (GhcPass 'Renamed) HsIPName
-> LHsType (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XIParamTy pass -> XRec pass HsIPName -> LHsType pass -> HsType pass
HsIParamTy XIParamTy (GhcPass 'Renamed)
x XRec (GhcPass 'Renamed) HsIPName
ip (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lt
renameType (HsKindSig XKindSig (GhcPass 'Renamed)
x LHsType (GhcPass 'Renamed)
lt LHsType (GhcPass 'Renamed)
lk) = XKindSig (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XKindSig pass -> LHsType pass -> LHsType pass -> HsType pass
HsKindSig XKindSig (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
      -> HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lt StateT
  (RenameEnv Name)
  Identity
  (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
   -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure LHsType (GhcPass 'Renamed)
GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
lk
renameType t :: HsType (GhcPass 'Renamed)
t@(HsSpliceTy XSpliceTy (GhcPass 'Renamed)
_ HsUntypedSplice (GhcPass 'Renamed)
_) = HsType (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure HsType (GhcPass 'Renamed)
t
renameType (HsDocTy XDocTy (GhcPass 'Renamed)
x LHsType (GhcPass 'Renamed)
lt LHsDoc (GhcPass 'Renamed)
doc) = XDocTy (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed)
-> LHsDoc (GhcPass 'Renamed)
-> HsType (GhcPass 'Renamed)
forall pass.
XDocTy pass -> LHsType pass -> LHsDoc pass -> HsType pass
HsDocTy XDocTy (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> LHsDoc (GhcPass 'Renamed) -> HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT
     (RenameEnv Name)
     Identity
     (LHsDoc (GhcPass 'Renamed) -> HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
lt StateT
  (RenameEnv Name)
  Identity
  (LHsDoc (GhcPass 'Renamed) -> HsType (GhcPass 'Renamed))
-> StateT (RenameEnv Name) Identity (LHsDoc (GhcPass 'Renamed))
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> LHsDoc (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (LHsDoc (GhcPass 'Renamed))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure LHsDoc (GhcPass 'Renamed)
doc
renameType t :: HsType (GhcPass 'Renamed)
t@(XHsType XXType (GhcPass 'Renamed)
_) = HsType (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure HsType (GhcPass 'Renamed)
t
renameType (HsExplicitListTy XExplicitListTy (GhcPass 'Renamed)
x PromotionFlag
ip [LHsType (GhcPass 'Renamed)]
ltys) =
  XExplicitListTy (GhcPass 'Renamed)
-> PromotionFlag
-> [LHsType (GhcPass 'Renamed)]
-> HsType (GhcPass 'Renamed)
forall pass.
XExplicitListTy pass
-> PromotionFlag -> [LHsType pass] -> HsType pass
HsExplicitListTy XExplicitListTy (GhcPass 'Renamed)
x PromotionFlag
ip ([GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
 -> HsType (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> [LHsType (GhcPass 'Renamed)]
-> Rename (IdP (GhcPass 'Renamed)) [LHsType (GhcPass 'Renamed)]
renameLTypes [LHsType (GhcPass 'Renamed)]
ltys
renameType (HsExplicitTupleTy XExplicitTupleTy (GhcPass 'Renamed)
x PromotionFlag
ip [LHsType (GhcPass 'Renamed)]
ltys) =
  XExplicitTupleTy (GhcPass 'Renamed)
-> PromotionFlag
-> [LHsType (GhcPass 'Renamed)]
-> HsType (GhcPass 'Renamed)
forall pass.
XExplicitTupleTy pass
-> PromotionFlag -> [LHsType pass] -> HsType pass
HsExplicitTupleTy XExplicitTupleTy (GhcPass 'Renamed)
x PromotionFlag
ip ([GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
 -> HsType (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> [LHsType (GhcPass 'Renamed)]
-> Rename (IdP (GhcPass 'Renamed)) [LHsType (GhcPass 'Renamed)]
renameLTypes [LHsType (GhcPass 'Renamed)]
ltys
renameType t :: HsType (GhcPass 'Renamed)
t@(HsTyLit XTyLit (GhcPass 'Renamed)
_ HsLit (GhcPass 'Renamed)
_) = HsType (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure HsType (GhcPass 'Renamed)
t
renameType (HsWildCardTy XWildCardTy (GhcPass 'Renamed)
wc) = HsType (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (XWildCardTy (GhcPass 'Renamed) -> HsType (GhcPass 'Renamed)
forall pass. XWildCardTy pass -> HsType pass
HsWildCardTy XWildCardTy (GhcPass 'Renamed)
wc)

renameModifier :: LHsModifier GhcRn -> Rename (IdP GhcRn) (LHsModifier GhcRn)
renameModifier :: LHsModifier (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsModifier (GhcPass 'Renamed))
renameModifier (L SrcSpanAnnA
l (HsModifier XModifier (GhcPass 'Renamed)
x GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
ty)) = SrcSpanAnnA
-> HsModifierOf
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
     (GhcPass 'Renamed)
-> GenLocated
     SrcSpanAnnA
     (HsModifierOf
        (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
        (GhcPass 'Renamed))
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnA
l (HsModifierOf
   (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
   (GhcPass 'Renamed)
 -> GenLocated
      SrcSpanAnnA
      (HsModifierOf
         (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
         (GhcPass 'Renamed)))
-> (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
    -> HsModifierOf
         (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
         (GhcPass 'Renamed))
-> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> GenLocated
     SrcSpanAnnA
     (HsModifierOf
        (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
        (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> XModifier (GhcPass 'Renamed)
-> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> HsModifierOf
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
     (GhcPass 'Renamed)
forall ty pass. XModifier pass -> ty -> HsModifierOf ty pass
HsModifier XModifier (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> GenLocated
      SrcSpanAnnA
      (HsModifierOf
         (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
         (GhcPass 'Renamed)))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated
        SrcSpanAnnA
        (HsModifierOf
           (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
           (GhcPass 'Renamed)))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType LHsType (GhcPass 'Renamed)
GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
ty

renameModifiers :: [LHsModifier GhcRn] -> Rename (IdP GhcRn) [LHsModifier GhcRn]
renameModifiers :: [LHsModifier (GhcPass 'Renamed)]
-> Rename (IdP (GhcPass 'Renamed)) [LHsModifier (GhcPass 'Renamed)]
renameModifiers = (GenLocated
   SrcSpanAnnA
   (HsModifierOf
      (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
      (GhcPass 'Renamed))
 -> StateT
      (RenameEnv Name)
      Identity
      (GenLocated
         SrcSpanAnnA
         (HsModifierOf
            (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
            (GhcPass 'Renamed))))
-> [GenLocated
      SrcSpanAnnA
      (HsModifierOf
         (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
         (GhcPass 'Renamed))]
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated
        SrcSpanAnnA
        (HsModifierOf
           (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
           (GhcPass 'Renamed))]
forall (t :: Type -> Type) (m :: Type -> Type) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: Type -> Type) a b.
Monad m =>
(a -> m b) -> [a] -> m [b]
mapM LHsModifier (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsModifier (GhcPass 'Renamed))
GenLocated
  SrcSpanAnnA
  (HsModifierOf
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
     (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated
        SrcSpanAnnA
        (HsModifierOf
           (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
           (GhcPass 'Renamed)))
renameModifier

renameHsModifiedFunArr :: HsModifiedFunArr GhcRn
                       -> Rename (IdP GhcRn) (HsModifiedFunArr GhcRn)
renameHsModifiedFunArr :: HsModifiedFunArr (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (HsModifiedFunArr (GhcPass 'Renamed))
renameHsModifiedFunArr (HsModifiedFunArr XHsModifiedFunArr
  (LHsType (NoGhcTc (GhcPass 'Renamed))) (GhcPass 'Renamed)
_ [LHsModifier (GhcPass 'Renamed)]
mods HsFunArr (GhcPass 'Renamed)
arr) = do
  mods' <- [LHsModifier (GhcPass 'Renamed)]
-> Rename (IdP (GhcPass 'Renamed)) [LHsModifier (GhcPass 'Renamed)]
renameModifiers [LHsModifier (GhcPass 'Renamed)]
mods
  pure $ HsModifiedFunArr noExtField mods' arr

renameLType :: LHsType GhcRn -> Rename (IdP GhcRn) (LHsType GhcRn)
renameLType :: LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType = (HsType (GhcPass 'Renamed)
 -> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed)))
-> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
forall (f :: Type -> Type) a b l.
Functor f =>
(a -> f b) -> GenLocated l a -> f (GenLocated l b)
located HsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (HsType (GhcPass 'Renamed))
HsType (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
renameType

renameLKind :: LHsKind GhcRn -> Rename (IdP GhcRn) (LHsKind GhcRn)
renameLKind :: LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLKind = LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
renameLType

renameLTypes :: [LHsType GhcRn] -> Rename (IdP GhcRn) [LHsType GhcRn]
renameLTypes :: [LHsType (GhcPass 'Renamed)]
-> Rename (IdP (GhcPass 'Renamed)) [LHsType (GhcPass 'Renamed)]
renameLTypes = (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> State
      (RenameEnv Name)
      (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))))
-> [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
forall (t :: Type -> Type) (m :: Type -> Type) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: Type -> Type) a b.
Monad m =>
(a -> m b) -> [a] -> m [b]
mapM LHsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsType (GhcPass 'Renamed))
GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
renameLType

renameLContext :: LHsContext GhcRn -> Rename (IdP GhcRn) (LHsContext GhcRn)
renameLContext :: LHsContext (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LHsContext (GhcPass 'Renamed))
renameLContext (L SrcSpanAnnC
l [GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
ctxt) = do
  ctxt' <- [LHsType (GhcPass 'Renamed)]
-> Rename (IdP (GhcPass 'Renamed)) [LHsType (GhcPass 'Renamed)]
renameContext [LHsType (GhcPass 'Renamed)]
[GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))]
ctxt
  return (L l ctxt')

renameContext :: HsContext GhcRn -> Rename (IdP GhcRn) (HsContext GhcRn)
renameContext :: [LHsType (GhcPass 'Renamed)]
-> Rename (IdP (GhcPass 'Renamed)) [LHsType (GhcPass 'Renamed)]
renameContext = [LHsType (GhcPass 'Renamed)]
-> Rename (IdP (GhcPass 'Renamed)) [LHsType (GhcPass 'Renamed)]
renameLTypes

renameForAllTelescope
  :: HsForAllTelescope GhcRn
  -> Rename (IdP GhcRn) (HsForAllTelescope GhcRn)
renameForAllTelescope :: HsForAllTelescope (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (HsForAllTelescope (GhcPass 'Renamed))
renameForAllTelescope (HsForAllVis XHsForAllVis (GhcPass 'Renamed)
x [LHsTyVarBndr () (GhcPass 'Renamed)]
bndrs) =
  XHsForAllVis (GhcPass 'Renamed)
-> [LHsTyVarBndr () (GhcPass 'Renamed)]
-> HsForAllTelescope (GhcPass 'Renamed)
forall pass.
XHsForAllVis pass
-> [LHsTyVarBndr () pass] -> HsForAllTelescope pass
HsForAllVis XHsForAllVis (GhcPass 'Renamed)
x ([GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed))]
 -> HsForAllTelescope (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed))]
-> StateT
     (RenameEnv Name) Identity (HsForAllTelescope (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed))
 -> StateT
      (RenameEnv Name)
      Identity
      (GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed))))
-> [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed))]
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed))]
forall (t :: Type -> Type) (m :: Type -> Type) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: Type -> Type) a b.
Monad m =>
(a -> m b) -> [a] -> m [b]
mapM LHsTyVarBndr () (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (LHsTyVarBndr () (GhcPass 'Renamed))
GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed)))
forall flag.
LHsTyVarBndr flag (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (LHsTyVarBndr flag (GhcPass 'Renamed))
renameLBinder [LHsTyVarBndr () (GhcPass 'Renamed)]
[GenLocated SrcSpanAnnA (HsTyVarBndr () (GhcPass 'Renamed))]
bndrs
renameForAllTelescope (HsForAllInvis XHsForAllInvis (GhcPass 'Renamed)
x [LHsTyVarBndr Specificity (GhcPass 'Renamed)]
bndrs) =
  XHsForAllInvis (GhcPass 'Renamed)
-> [LHsTyVarBndr Specificity (GhcPass 'Renamed)]
-> HsForAllTelescope (GhcPass 'Renamed)
forall pass.
XHsForAllInvis pass
-> [LHsTyVarBndr Specificity pass] -> HsForAllTelescope pass
HsForAllInvis XHsForAllInvis (GhcPass 'Renamed)
x ([GenLocated
    SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed))]
 -> HsForAllTelescope (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated
        SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed))]
-> StateT
     (RenameEnv Name) Identity (HsForAllTelescope (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> (GenLocated
   SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed))
 -> StateT
      (RenameEnv Name)
      Identity
      (GenLocated
         SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed))))
-> [GenLocated
      SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed))]
-> StateT
     (RenameEnv Name)
     Identity
     [GenLocated
        SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed))]
forall (t :: Type -> Type) (m :: Type -> Type) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: Type -> Type) a b.
Monad m =>
(a -> m b) -> [a] -> m [b]
mapM LHsTyVarBndr Specificity (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed))
     (LHsTyVarBndr Specificity (GhcPass 'Renamed))
GenLocated SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated
        SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed)))
forall flag.
LHsTyVarBndr flag (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (LHsTyVarBndr flag (GhcPass 'Renamed))
renameLBinder [LHsTyVarBndr Specificity (GhcPass 'Renamed)]
[GenLocated
   SrcSpanAnnA (HsTyVarBndr Specificity (GhcPass 'Renamed))]
bndrs

renameBinder :: HsTyVarBndr flag GhcRn -> Rename (IdP GhcRn) (HsTyVarBndr flag GhcRn)
renameBinder :: forall flag.
HsTyVarBndr flag (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (HsTyVarBndr flag (GhcPass 'Renamed))
renameBinder (HsTvb XTyVarBndr (GhcPass 'Renamed)
x flag
fl HsBndrVar (GhcPass 'Renamed)
bvar HsBndrKind (GhcPass 'Renamed)
lkind) =
  XTyVarBndr (GhcPass 'Renamed)
-> flag
-> HsBndrVar (GhcPass 'Renamed)
-> HsBndrKind (GhcPass 'Renamed)
-> HsTyVarBndr flag (GhcPass 'Renamed)
forall flag pass.
XTyVarBndr pass
-> flag
-> HsBndrVar pass
-> HsBndrKind pass
-> HsTyVarBndr flag pass
HsTvb XTyVarBndr (GhcPass 'Renamed)
x flag
fl (HsBndrVar (GhcPass 'Renamed)
 -> HsBndrKind (GhcPass 'Renamed)
 -> HsTyVarBndr flag (GhcPass 'Renamed))
-> StateT (RenameEnv Name) Identity (HsBndrVar (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (HsBndrKind (GhcPass 'Renamed)
      -> HsTyVarBndr flag (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HsBndrVar (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (HsBndrVar (GhcPass 'Renamed))
renameBinderVar HsBndrVar (GhcPass 'Renamed)
bvar StateT
  (RenameEnv Name)
  Identity
  (HsBndrKind (GhcPass 'Renamed)
   -> HsTyVarBndr flag (GhcPass 'Renamed))
-> StateT (RenameEnv Name) Identity (HsBndrKind (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name) Identity (HsTyVarBndr flag (GhcPass 'Renamed))
forall a b.
StateT (RenameEnv Name) Identity (a -> b)
-> StateT (RenameEnv Name) Identity a
-> StateT (RenameEnv Name) Identity b
forall (f :: Type -> Type) a b.
Applicative f =>
f (a -> b) -> f a -> f b
<*> HsBndrKind (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (HsBndrKind (GhcPass 'Renamed))
renameBinderKind HsBndrKind (GhcPass 'Renamed)
lkind

renameBinderVar :: HsBndrVar GhcRn -> Rename (IdP GhcRn) (HsBndrVar GhcRn)
renameBinderVar :: HsBndrVar (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (HsBndrVar (GhcPass 'Renamed))
renameBinderVar (HsBndrVar XBndrVar (GhcPass 'Renamed)
x LIdP (GhcPass 'Renamed)
lname) = XBndrVar (GhcPass 'Renamed)
-> LIdP (GhcPass 'Renamed) -> HsBndrVar (GhcPass 'Renamed)
forall pass. XBndrVar pass -> LIdP pass -> HsBndrVar pass
HsBndrVar XBndrVar (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnN Name -> HsBndrVar (GhcPass 'Renamed))
-> StateT (RenameEnv Name) Identity (GenLocated SrcSpanAnnN Name)
-> StateT (RenameEnv Name) Identity (HsBndrVar (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> (Name -> StateT (RenameEnv Name) Identity Name)
-> GenLocated SrcSpanAnnN Name
-> StateT (RenameEnv Name) Identity (GenLocated SrcSpanAnnN Name)
forall (f :: Type -> Type) a b.
Functor f =>
(a -> f b) -> LocatedN a -> f (LocatedN b)
locatedN Name -> StateT (RenameEnv Name) Identity Name
forall name. SetName name => name -> Rename name name
renameName LIdP (GhcPass 'Renamed)
GenLocated SrcSpanAnnN Name
lname
renameBinderVar (HsBndrWildCard XBndrWildCard (GhcPass 'Renamed)
x) = HsBndrVar (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsBndrVar (GhcPass 'Renamed))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (m :: Type -> Type) a. Monad m => a -> m a
return (XBndrWildCard (GhcPass 'Renamed) -> HsBndrVar (GhcPass 'Renamed)
forall pass. XBndrWildCard pass -> HsBndrVar pass
HsBndrWildCard XBndrWildCard (GhcPass 'Renamed)
x)

renameBinderKind :: HsBndrKind GhcRn -> Rename (IdP GhcRn) (HsBndrKind GhcRn)
renameBinderKind :: HsBndrKind (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (HsBndrKind (GhcPass 'Renamed))
renameBinderKind (HsBndrNoKind XBndrNoKind (GhcPass 'Renamed)
x) = HsBndrKind (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsBndrKind (GhcPass 'Renamed))
forall a. a -> StateT (RenameEnv Name) Identity a
forall (m :: Type -> Type) a. Monad m => a -> m a
return (XBndrNoKind (GhcPass 'Renamed) -> HsBndrKind (GhcPass 'Renamed)
forall pass. XBndrNoKind pass -> HsBndrKind pass
HsBndrNoKind XBndrNoKind (GhcPass 'Renamed)
x)
renameBinderKind (HsBndrKind XBndrKind (GhcPass 'Renamed)
x LHsType (GhcPass 'Renamed)
k) = XBndrKind (GhcPass 'Renamed)
-> LHsType (GhcPass 'Renamed) -> HsBndrKind (GhcPass 'Renamed)
forall pass. XBndrKind pass -> LHsKind pass -> HsBndrKind pass
HsBndrKind XBndrKind (GhcPass 'Renamed)
x (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
 -> HsBndrKind (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
-> StateT (RenameEnv Name) Identity (HsBndrKind (GhcPass 'Renamed))
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> (HsType (GhcPass 'Renamed)
 -> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed)))
-> GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
-> State
     (RenameEnv Name)
     (GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed)))
forall (f :: Type -> Type) a b l.
Functor f =>
(a -> f b) -> GenLocated l a -> f (GenLocated l b)
located HsType (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (HsType (GhcPass 'Renamed))
HsType (GhcPass 'Renamed)
-> StateT (RenameEnv Name) Identity (HsType (GhcPass 'Renamed))
renameType LHsType (GhcPass 'Renamed)
GenLocated SrcSpanAnnA (HsType (GhcPass 'Renamed))
k

renameLBinder :: LHsTyVarBndr flag GhcRn -> Rename (IdP GhcRn) (LHsTyVarBndr flag GhcRn)
renameLBinder :: forall flag.
LHsTyVarBndr flag (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (LHsTyVarBndr flag (GhcPass 'Renamed))
renameLBinder = (HsTyVarBndr flag (GhcPass 'Renamed)
 -> StateT
      (RenameEnv Name) Identity (HsTyVarBndr flag (GhcPass 'Renamed)))
-> GenLocated SrcSpanAnnA (HsTyVarBndr flag (GhcPass 'Renamed))
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnA (HsTyVarBndr flag (GhcPass 'Renamed)))
forall (f :: Type -> Type) a b l.
Functor f =>
(a -> f b) -> GenLocated l a -> f (GenLocated l b)
located HsTyVarBndr flag (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (HsTyVarBndr flag (GhcPass 'Renamed))
HsTyVarBndr flag (GhcPass 'Renamed)
-> StateT
     (RenameEnv Name) Identity (HsTyVarBndr flag (GhcPass 'Renamed))
forall flag.
HsTyVarBndr flag (GhcPass 'Renamed)
-> Rename
     (IdP (GhcPass 'Renamed)) (HsTyVarBndr flag (GhcPass 'Renamed))
renameBinder

-- | Core renaming logic.
renameName :: SetName name => name -> Rename name name
renameName :: forall name. SetName name => name -> Rename name name
renameName name
name = do
  RenameEnv{..} <- StateT (RenameEnv name) Identity (RenameEnv name)
forall (m :: Type -> Type) s. Monad m => StateT s m s
get
  case Map.lookup (getName name) rneCtx of
    Maybe name
Nothing
      | Just Name
headTv <- NameRep -> Map NameRep Name -> Maybe Name
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup (name -> NameRep
forall name. NamedThing name => name -> NameRep
getNameRep name
name) Map NameRep Name
rneHeadFVs
      , Name
headTv Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
/= name -> Name
forall a. NamedThing a => a -> Name
getName name
name ->
          name -> StateT (RenameEnv name) Identity name
forall name. SetName name => name -> Rename name name
freshName name
name
    Just name
name' -> name -> StateT (RenameEnv name) Identity name
forall a. a -> StateT (RenameEnv name) Identity a
forall (m :: Type -> Type) a. Monad m => a -> m a
return name
name'
    Maybe name
_ -> name -> StateT (RenameEnv name) Identity name
forall a. a -> StateT (RenameEnv name) Identity a
forall (m :: Type -> Type) a. Monad m => a -> m a
return name
name

renameLNameOcc :: LIdOccP GhcRn -> Rename (IdP GhcRn) (LIdOccP GhcRn)
renameLNameOcc :: LIdOccP (GhcPass 'Renamed)
-> Rename (IdP (GhcPass 'Renamed)) (LIdOccP (GhcPass 'Renamed))
renameLNameOcc = (WithUserRdr Name
 -> StateT (RenameEnv Name) Identity (WithUserRdr Name))
-> GenLocated SrcSpanAnnN (WithUserRdr Name)
-> StateT
     (RenameEnv Name)
     Identity
     (GenLocated SrcSpanAnnN (WithUserRdr Name))
forall (f :: Type -> Type) a b.
Functor f =>
(a -> f b) -> LocatedN a -> f (LocatedN b)
locatedN ((Name -> StateT (RenameEnv Name) Identity Name)
-> WithUserRdr Name
-> StateT (RenameEnv Name) Identity (WithUserRdr Name)
forall (t :: Type -> Type) (f :: Type -> Type) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: Type -> Type) a b.
Applicative f =>
(a -> f b) -> WithUserRdr a -> f (WithUserRdr b)
traverse Name -> StateT (RenameEnv Name) Identity Name
forall name. SetName name => name -> Rename name name
renameName)

-- | Generate fresh occurrence name, put it into context and return.
freshName :: SetName name => name -> Rename name name
freshName :: forall name. SetName name => name -> Rename name name
freshName name
name = do
  taken <- Rename name (Set NameRep)
forall name. NamedThing name => Rename name (Set NameRep)
takenNames
  let name' = NameRep -> name -> name
forall name. SetName name => NameRep -> name -> name
setInternalNameRep (Set NameRep -> NameRep -> NameRep
findFreshName Set NameRep
taken NameRep
rep) name
name
  modify $ \RenameEnv name
rne ->
    RenameEnv name
rne
      { rneCtx = Map.insert (getName name) name' (rneCtx rne)
      }
  return name'
  where
    nname :: Name
nname = name -> Name
forall a. NamedThing a => a -> Name
getName name
name
    rep :: NameRep
rep = Name -> NameRep
forall name. NamedThing name => name -> NameRep
getNameRep Name
nname

takenNames :: NamedThing name => Rename name (Set NameRep)
takenNames :: forall name. NamedThing name => Rename name (Set NameRep)
takenNames = do
  RenameEnv{..} <- StateT (RenameEnv name) Identity (RenameEnv name)
forall (m :: Type -> Type) s. Monad m => StateT s m s
get
  return $ Set.unions [headReps rneHeadFVs, ctxElems rneCtx]
  where
    headReps :: Map NameRep a -> Set NameRep
headReps = [NameRep] -> Set NameRep
forall a. Ord a => [a] -> Set a
Set.fromList ([NameRep] -> Set NameRep)
-> (Map NameRep a -> [NameRep]) -> Map NameRep a -> Set NameRep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map NameRep a -> [NameRep]
forall k a. Map k a -> [k]
Map.keys
    ctxElems :: Map k name -> Set NameRep
ctxElems = [NameRep] -> Set NameRep
forall a. Ord a => [a] -> Set a
Set.fromList ([NameRep] -> Set NameRep)
-> (Map k name -> [NameRep]) -> Map k name -> Set NameRep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (name -> NameRep) -> [name] -> [NameRep]
forall a b. (a -> b) -> [a] -> [b]
map name -> NameRep
forall name. NamedThing name => name -> NameRep
getNameRep ([name] -> [NameRep])
-> (Map k name -> [name]) -> Map k name -> [NameRep]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map k name -> [name]
forall k a. Map k a -> [a]
Map.elems

findFreshName :: Set NameRep -> NameRep -> NameRep
findFreshName :: Set NameRep -> NameRep -> NameRep
findFreshName Set NameRep
taken =
  Maybe NameRep -> NameRep
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe NameRep -> NameRep)
-> (NameRep -> Maybe NameRep) -> NameRep -> NameRep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NameRep -> Bool) -> [NameRep] -> Maybe NameRep
forall (t :: Type -> Type) a.
Foldable t =>
(a -> Bool) -> t a -> Maybe a
List.find NameRep -> Bool
isFresh ([NameRep] -> Maybe NameRep)
-> (NameRep -> [NameRep]) -> NameRep -> Maybe NameRep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NameRep -> [NameRep]
alternativeNames
  where
    isFresh :: NameRep -> Bool
isFresh = Bool -> Bool
not (Bool -> Bool) -> (NameRep -> Bool) -> NameRep -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NameRep -> Set NameRep -> Bool) -> Set NameRep -> NameRep -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip NameRep -> Set NameRep -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member Set NameRep
taken

alternativeNames :: NameRep -> [NameRep]
alternativeNames :: NameRep -> [NameRep]
alternativeNames NameRep
name =
  [String -> NameRep
stringNameRep (String -> NameRep) -> String -> NameRep
forall a b. (a -> b) -> a -> b
$ String
str String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
i | Int
i :: Int <- [Int
0 ..]]
  where
    str :: String
str = NameRep -> String
nameRepString NameRep
name

located :: Functor f => (a -> f b) -> GenLocated l a -> f (GenLocated l b)
located :: forall (f :: Type -> Type) a b l.
Functor f =>
(a -> f b) -> GenLocated l a -> f (GenLocated l b)
located a -> f b
f (L l
loc a
e) = l -> b -> GenLocated l b
forall l e. l -> e -> GenLocated l e
L l
loc (b -> GenLocated l b) -> f b -> f (GenLocated l b)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
e

locatedN :: Functor f => (a -> f b) -> LocatedN a -> f (LocatedN b)
locatedN :: forall (f :: Type -> Type) a b.
Functor f =>
(a -> f b) -> LocatedN a -> f (LocatedN b)
locatedN a -> f b
f (L SrcSpanAnnN
loc a
e) = SrcSpanAnnN -> b -> GenLocated SrcSpanAnnN b
forall l e. l -> e -> GenLocated l e
L SrcSpanAnnN
loc (b -> GenLocated SrcSpanAnnN b)
-> f b -> f (GenLocated SrcSpanAnnN b)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
e