{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE RankNTypes         #-}

module Distribution.Types.ModuleRenaming (
    ModuleRenaming(..),
    interpModuleRenaming,
    defaultRenaming,
    isDefaultRenaming,
) where

import Distribution.CabalSpecVersion
import Distribution.Compat.Prelude hiding (empty)
import Prelude ()

import Distribution.ModuleName
import Distribution.Parsec
import Distribution.Pretty

import qualified Data.Map                   as Map
import qualified Data.Set                   as Set
import qualified Distribution.Compat.CharParsing as P
import           Text.PrettyPrint           (hsep, parens, punctuate, text, comma)

-- | Renaming applied to the modules provided by a package.
-- The boolean indicates whether or not to also include all of the
-- original names of modules.  Thus, @ModuleRenaming False []@ is
-- "don't expose any modules, and @ModuleRenaming True [("Data.Bool", "Bool")]@
-- is, "expose all modules, but also expose @Data.Bool@ as @Bool@".
-- If a renaming is omitted you get the 'DefaultRenaming'.
--
-- (NB: This is a list not a map so that we can preserve order.)
--
data ModuleRenaming
        -- | A module renaming/thinning; e.g., @(A as B, C as C)@
        -- brings @B@ and @C@ into scope.
        = ModuleRenaming [(ModuleName, ModuleName)]
        -- | The default renaming, bringing all exported modules
        -- into scope.
        | DefaultRenaming
        -- | Hiding renaming, e.g., @hiding (A, B)@, bringing all
        -- exported modules into scope except the hidden ones.
        | HidingRenaming [ModuleName]
    deriving (Int -> ModuleRenaming -> ShowS
[ModuleRenaming] -> ShowS
ModuleRenaming -> String
(Int -> ModuleRenaming -> ShowS)
-> (ModuleRenaming -> String)
-> ([ModuleRenaming] -> ShowS)
-> Show ModuleRenaming
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModuleRenaming] -> ShowS
$cshowList :: [ModuleRenaming] -> ShowS
show :: ModuleRenaming -> String
$cshow :: ModuleRenaming -> String
showsPrec :: Int -> ModuleRenaming -> ShowS
$cshowsPrec :: Int -> ModuleRenaming -> ShowS
Show, ReadPrec [ModuleRenaming]
ReadPrec ModuleRenaming
Int -> ReadS ModuleRenaming
ReadS [ModuleRenaming]
(Int -> ReadS ModuleRenaming)
-> ReadS [ModuleRenaming]
-> ReadPrec ModuleRenaming
-> ReadPrec [ModuleRenaming]
-> Read ModuleRenaming
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ModuleRenaming]
$creadListPrec :: ReadPrec [ModuleRenaming]
readPrec :: ReadPrec ModuleRenaming
$creadPrec :: ReadPrec ModuleRenaming
readList :: ReadS [ModuleRenaming]
$creadList :: ReadS [ModuleRenaming]
readsPrec :: Int -> ReadS ModuleRenaming
$creadsPrec :: Int -> ReadS ModuleRenaming
Read, ModuleRenaming -> ModuleRenaming -> Bool
(ModuleRenaming -> ModuleRenaming -> Bool)
-> (ModuleRenaming -> ModuleRenaming -> Bool) -> Eq ModuleRenaming
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModuleRenaming -> ModuleRenaming -> Bool
$c/= :: ModuleRenaming -> ModuleRenaming -> Bool
== :: ModuleRenaming -> ModuleRenaming -> Bool
$c== :: ModuleRenaming -> ModuleRenaming -> Bool
Eq, Eq ModuleRenaming
Eq ModuleRenaming
-> (ModuleRenaming -> ModuleRenaming -> Ordering)
-> (ModuleRenaming -> ModuleRenaming -> Bool)
-> (ModuleRenaming -> ModuleRenaming -> Bool)
-> (ModuleRenaming -> ModuleRenaming -> Bool)
-> (ModuleRenaming -> ModuleRenaming -> Bool)
-> (ModuleRenaming -> ModuleRenaming -> ModuleRenaming)
-> (ModuleRenaming -> ModuleRenaming -> ModuleRenaming)
-> Ord ModuleRenaming
ModuleRenaming -> ModuleRenaming -> Bool
ModuleRenaming -> ModuleRenaming -> Ordering
ModuleRenaming -> ModuleRenaming -> ModuleRenaming
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModuleRenaming -> ModuleRenaming -> ModuleRenaming
$cmin :: ModuleRenaming -> ModuleRenaming -> ModuleRenaming
max :: ModuleRenaming -> ModuleRenaming -> ModuleRenaming
$cmax :: ModuleRenaming -> ModuleRenaming -> ModuleRenaming
>= :: ModuleRenaming -> ModuleRenaming -> Bool
$c>= :: ModuleRenaming -> ModuleRenaming -> Bool
> :: ModuleRenaming -> ModuleRenaming -> Bool
$c> :: ModuleRenaming -> ModuleRenaming -> Bool
<= :: ModuleRenaming -> ModuleRenaming -> Bool
$c<= :: ModuleRenaming -> ModuleRenaming -> Bool
< :: ModuleRenaming -> ModuleRenaming -> Bool
$c< :: ModuleRenaming -> ModuleRenaming -> Bool
compare :: ModuleRenaming -> ModuleRenaming -> Ordering
$ccompare :: ModuleRenaming -> ModuleRenaming -> Ordering
Ord, Typeable, Typeable ModuleRenaming
Typeable ModuleRenaming
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleRenaming -> c ModuleRenaming)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleRenaming)
-> (ModuleRenaming -> Constr)
-> (ModuleRenaming -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleRenaming))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModuleRenaming))
-> ((forall b. Data b => b -> b)
    -> ModuleRenaming -> ModuleRenaming)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleRenaming -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleRenaming -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ModuleRenaming -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleRenaming -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ModuleRenaming -> m ModuleRenaming)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModuleRenaming -> m ModuleRenaming)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModuleRenaming -> m ModuleRenaming)
-> Data ModuleRenaming
ModuleRenaming -> DataType
ModuleRenaming -> Constr
(forall b. Data b => b -> b) -> ModuleRenaming -> ModuleRenaming
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ModuleRenaming -> u
forall u. (forall d. Data d => d -> u) -> ModuleRenaming -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleRenaming -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleRenaming -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModuleRenaming -> m ModuleRenaming
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModuleRenaming -> m ModuleRenaming
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleRenaming
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleRenaming -> c ModuleRenaming
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleRenaming)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleRenaming)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModuleRenaming -> m ModuleRenaming
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModuleRenaming -> m ModuleRenaming
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModuleRenaming -> m ModuleRenaming
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModuleRenaming -> m ModuleRenaming
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModuleRenaming -> m ModuleRenaming
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModuleRenaming -> m ModuleRenaming
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ModuleRenaming -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ModuleRenaming -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleRenaming -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleRenaming -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleRenaming -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleRenaming -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleRenaming -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleRenaming -> r
gmapT :: (forall b. Data b => b -> b) -> ModuleRenaming -> ModuleRenaming
$cgmapT :: (forall b. Data b => b -> b) -> ModuleRenaming -> ModuleRenaming
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleRenaming)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModuleRenaming)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleRenaming)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleRenaming)
dataTypeOf :: ModuleRenaming -> DataType
$cdataTypeOf :: ModuleRenaming -> DataType
toConstr :: ModuleRenaming -> Constr
$ctoConstr :: ModuleRenaming -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleRenaming
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleRenaming
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleRenaming -> c ModuleRenaming
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleRenaming -> c ModuleRenaming
Data, (forall x. ModuleRenaming -> Rep ModuleRenaming x)
-> (forall x. Rep ModuleRenaming x -> ModuleRenaming)
-> Generic ModuleRenaming
forall x. Rep ModuleRenaming x -> ModuleRenaming
forall x. ModuleRenaming -> Rep ModuleRenaming x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModuleRenaming x -> ModuleRenaming
$cfrom :: forall x. ModuleRenaming -> Rep ModuleRenaming x
Generic)

-- | Interpret a 'ModuleRenaming' as a partial map from 'ModuleName'
-- to 'ModuleName'.  For efficiency, you should partially apply it
-- with 'ModuleRenaming' and then reuse it.
interpModuleRenaming :: ModuleRenaming -> ModuleName -> Maybe ModuleName
interpModuleRenaming :: ModuleRenaming -> ModuleName -> Maybe ModuleName
interpModuleRenaming ModuleRenaming
DefaultRenaming = ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just
interpModuleRenaming (ModuleRenaming [(ModuleName, ModuleName)]
rns) =
    let m :: Map ModuleName ModuleName
m = [(ModuleName, ModuleName)] -> Map ModuleName ModuleName
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(ModuleName, ModuleName)]
rns
    in \ModuleName
k -> ModuleName -> Map ModuleName ModuleName -> Maybe ModuleName
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup ModuleName
k Map ModuleName ModuleName
m
interpModuleRenaming (HidingRenaming [ModuleName]
hs) =
    let s :: Set ModuleName
s = [ModuleName] -> Set ModuleName
forall a. Ord a => [a] -> Set a
Set.fromList [ModuleName]
hs
    in \ModuleName
k -> if ModuleName
k ModuleName -> Set ModuleName -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set ModuleName
s then Maybe ModuleName
forall a. Maybe a
Nothing else ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just ModuleName
k

-- | The default renaming, if something is specified in @build-depends@
-- only.
defaultRenaming :: ModuleRenaming
defaultRenaming :: ModuleRenaming
defaultRenaming = ModuleRenaming
DefaultRenaming

-- | Tests if its the default renaming; we can use a more compact syntax
-- in 'Distribution.Types.IncludeRenaming.IncludeRenaming' in this case.
isDefaultRenaming :: ModuleRenaming -> Bool
isDefaultRenaming :: ModuleRenaming -> Bool
isDefaultRenaming ModuleRenaming
DefaultRenaming = Bool
True
isDefaultRenaming ModuleRenaming
_ = Bool
False



instance Binary ModuleRenaming where
instance Structured ModuleRenaming where

instance NFData ModuleRenaming where rnf :: ModuleRenaming -> ()
rnf = ModuleRenaming -> ()
forall a. (Generic a, GNFData (Rep a)) => a -> ()
genericRnf

-- NB: parentheses are mandatory, because later we may extend this syntax
-- to allow "hiding (A, B)" or other modifier words.
instance Pretty ModuleRenaming where
  pretty :: ModuleRenaming -> Doc
pretty ModuleRenaming
DefaultRenaming = Doc
forall a. Monoid a => a
mempty
  pretty (HidingRenaming [ModuleName]
hides)
        = String -> Doc
text String
"hiding" Doc -> Doc -> Doc
<+> Doc -> Doc
parens ([Doc] -> Doc
hsep (Doc -> [Doc] -> [Doc]
punctuate Doc
comma ((ModuleName -> Doc) -> [ModuleName] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map ModuleName -> Doc
forall a. Pretty a => a -> Doc
pretty [ModuleName]
hides)))
  pretty (ModuleRenaming [(ModuleName, ModuleName)]
rns)
        = Doc -> Doc
parens (Doc -> Doc) -> ([Doc] -> Doc) -> [Doc] -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc] -> Doc
hsep ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ Doc -> [Doc] -> [Doc]
punctuate Doc
comma (((ModuleName, ModuleName) -> Doc)
-> [(ModuleName, ModuleName)] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (ModuleName, ModuleName) -> Doc
forall {a}. (Eq a, Pretty a) => (a, a) -> Doc
dispEntry [(ModuleName, ModuleName)]
rns)
    where dispEntry :: (a, a) -> Doc
dispEntry (a
orig, a
new)
            | a
orig a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
new = a -> Doc
forall a. Pretty a => a -> Doc
pretty a
orig
            | Bool
otherwise = a -> Doc
forall a. Pretty a => a -> Doc
pretty a
orig Doc -> Doc -> Doc
<+> String -> Doc
text String
"as" Doc -> Doc -> Doc
<+> a -> Doc
forall a. Pretty a => a -> Doc
pretty a
new

instance Parsec ModuleRenaming where
    parsec :: forall (m :: * -> *). CabalParsing m => m ModuleRenaming
parsec = do
        CabalSpecVersion
csv <- m CabalSpecVersion
forall (m :: * -> *). CabalParsing m => m CabalSpecVersion
askCabalSpecVersion
        if CabalSpecVersion
csv CabalSpecVersion -> CabalSpecVersion -> Bool
forall a. Ord a => a -> a -> Bool
>= CabalSpecVersion
CabalSpecV3_0
        then (forall a. m a -> m a) -> m ModuleName -> m ModuleRenaming
forall (m :: * -> *).
CabalParsing m =>
(forall a. m a -> m a) -> m ModuleName -> m ModuleRenaming
moduleRenamingParsec forall a. m a -> m a
forall {m :: * -> *} {a}. (Monad m, CharParsing m) => m a -> m a
parensLax    m ModuleName
forall (m :: * -> *) a. (CabalParsing m, Parsec a) => m a
lexemeParsec
        else (forall a. m a -> m a) -> m ModuleName -> m ModuleRenaming
forall (m :: * -> *).
CabalParsing m =>
(forall a. m a -> m a) -> m ModuleName -> m ModuleRenaming
moduleRenamingParsec forall a. m a -> m a
parensStrict m ModuleName
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec
      where
        -- For cabal spec versions < 3.0 white spaces were not skipped
        -- after the '(' and ')' tokens in the mixin field. This
        -- parser checks the cabal file version and does the correct
        -- skipping of spaces.
        parensLax :: m a -> m a
parensLax    m a
p = m () -> m () -> m a -> m a
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
P.between (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
'(' m Char -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
forall (m :: * -> *). CharParsing m => m ()
P.spaces)   (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
')' m Char -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
forall (m :: * -> *). CharParsing m => m ()
P.spaces)   m a
p
        parensStrict :: m a -> m a
parensStrict m a
p = m (Maybe Any) -> m Char -> m a -> m a
forall (m :: * -> *) bra ket a.
Applicative m =>
m bra -> m ket -> m a -> m a
P.between (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
'(' m Char -> m (Maybe Any) -> m (Maybe Any)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m (Maybe Any)
forall {a}. m (Maybe a)
warnSpaces) (Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
')') m a
p

        warnSpaces :: m (Maybe a)
warnSpaces = m a -> m (Maybe a)
forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
P.optional (m a -> m (Maybe a)) -> m a -> m (Maybe a)
forall a b. (a -> b) -> a -> b
$
            m Char
forall (m :: * -> *). CharParsing m => m Char
P.space m Char -> m a -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"space after parenthesis, use cabal-version: 3.0 or higher"

moduleRenamingParsec
    :: CabalParsing m
    => (forall a. m a -> m a)  -- ^ between parens
    -> m ModuleName            -- ^ module name parser
    -> m ModuleRenaming
moduleRenamingParsec :: forall (m :: * -> *).
CabalParsing m =>
(forall a. m a -> m a) -> m ModuleName -> m ModuleRenaming
moduleRenamingParsec forall a. m a -> m a
bp m ModuleName
mn =
    -- NB: try not necessary as the first token is obvious
    [m ModuleRenaming] -> m ModuleRenaming
forall (m :: * -> *) a. Alternative m => [m a] -> m a
P.choice [ m ModuleRenaming
parseRename, m ModuleRenaming
parseHiding, ModuleRenaming -> m ModuleRenaming
forall (m :: * -> *) a. Monad m => a -> m a
return ModuleRenaming
DefaultRenaming ]
  where
    cma :: m ()
cma = Char -> m Char
forall (m :: * -> *). CharParsing m => Char -> m Char
P.char Char
',' m Char -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m ()
forall (m :: * -> *). CharParsing m => m ()
P.spaces
    parseRename :: m ModuleRenaming
parseRename = do
        [(ModuleName, ModuleName)]
rns <- m [(ModuleName, ModuleName)] -> m [(ModuleName, ModuleName)]
forall a. m a -> m a
bp m [(ModuleName, ModuleName)]
parseList
        m ()
forall (m :: * -> *). CharParsing m => m ()
P.spaces
        ModuleRenaming -> m ModuleRenaming
forall (m :: * -> *) a. Monad m => a -> m a
return ([(ModuleName, ModuleName)] -> ModuleRenaming
ModuleRenaming [(ModuleName, ModuleName)]
rns)
    parseHiding :: m ModuleRenaming
parseHiding = do
        String
_ <- String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string String
"hiding"
        m ()
forall (m :: * -> *). CharParsing m => m ()
P.spaces -- space isn't strictly required as next is an open paren
        [ModuleName]
hides <- m [ModuleName] -> m [ModuleName]
forall a. m a -> m a
bp (m ModuleName -> m () -> m [ModuleName]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
P.sepBy m ModuleName
mn m ()
cma)
        ModuleRenaming -> m ModuleRenaming
forall (m :: * -> *) a. Monad m => a -> m a
return ([ModuleName] -> ModuleRenaming
HidingRenaming [ModuleName]
hides)
    parseList :: m [(ModuleName, ModuleName)]
parseList =
        m (ModuleName, ModuleName) -> m () -> m [(ModuleName, ModuleName)]
forall (m :: * -> *) a sep. Alternative m => m a -> m sep -> m [a]
P.sepBy m (ModuleName, ModuleName)
parseEntry m ()
cma
    parseEntry :: m (ModuleName, ModuleName)
parseEntry = do
        ModuleName
orig <- m ModuleName
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec
        m ()
forall (m :: * -> *). CharParsing m => m ()
P.spaces
        (ModuleName, ModuleName)
-> m (ModuleName, ModuleName) -> m (ModuleName, ModuleName)
forall (m :: * -> *) a. Alternative m => a -> m a -> m a
P.option (ModuleName
orig, ModuleName
orig) (m (ModuleName, ModuleName) -> m (ModuleName, ModuleName))
-> m (ModuleName, ModuleName) -> m (ModuleName, ModuleName)
forall a b. (a -> b) -> a -> b
$ do
            String
_ <- String -> m String
forall (m :: * -> *). CharParsing m => String -> m String
P.string String
"as"
            m ()
forall (m :: * -> *). CharParsing m => m ()
P.skipSpaces1 -- require space after "as"
            ModuleName
new <- m ModuleName
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
parsec
            m ()
forall (m :: * -> *). CharParsing m => m ()
P.spaces
            (ModuleName, ModuleName) -> m (ModuleName, ModuleName)
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
orig, ModuleName
new)