{-# LANGUAGE DuplicateRecordFields #-}
-- | A type to represent operands to LLVM 'LLVM.AST.Instruction.Instruction's
module LLVM.AST.Operand
( module LLVM.AST.Operand
)
where

import LLVM.Prelude

import LLVM.AST.Name
import LLVM.AST.Constant
import LLVM.AST.InlineAssembly
import LLVM.AST.Type


-- | An 'Operand' is roughly that which is an argument to an 'LLVM.AST.Instruction.Instruction'
data Operand
  -- | %foo
  = LocalReference Type Name
  -- | 'Constant's include 'LLVM.AST.Constant.GlobalReference', for \@foo
  | ConstantOperand Constant
  | MetadataOperand Metadata
  deriving (Operand -> Operand -> Bool
(Operand -> Operand -> Bool)
-> (Operand -> Operand -> Bool) -> Eq Operand
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Operand -> Operand -> Bool
== :: Operand -> Operand -> Bool
$c/= :: Operand -> Operand -> Bool
/= :: Operand -> Operand -> Bool
Eq, Eq Operand
Eq Operand
-> (Operand -> Operand -> Ordering)
-> (Operand -> Operand -> Bool)
-> (Operand -> Operand -> Bool)
-> (Operand -> Operand -> Bool)
-> (Operand -> Operand -> Bool)
-> (Operand -> Operand -> Operand)
-> (Operand -> Operand -> Operand)
-> Ord Operand
Operand -> Operand -> Bool
Operand -> Operand -> Ordering
Operand -> Operand -> Operand
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
$ccompare :: Operand -> Operand -> Ordering
compare :: Operand -> Operand -> Ordering
$c< :: Operand -> Operand -> Bool
< :: Operand -> Operand -> Bool
$c<= :: Operand -> Operand -> Bool
<= :: Operand -> Operand -> Bool
$c> :: Operand -> Operand -> Bool
> :: Operand -> Operand -> Bool
$c>= :: Operand -> Operand -> Bool
>= :: Operand -> Operand -> Bool
$cmax :: Operand -> Operand -> Operand
max :: Operand -> Operand -> Operand
$cmin :: Operand -> Operand -> Operand
min :: Operand -> Operand -> Operand
Ord, ReadPrec [Operand]
ReadPrec Operand
Int -> ReadS Operand
ReadS [Operand]
(Int -> ReadS Operand)
-> ReadS [Operand]
-> ReadPrec Operand
-> ReadPrec [Operand]
-> Read Operand
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Operand
readsPrec :: Int -> ReadS Operand
$creadList :: ReadS [Operand]
readList :: ReadS [Operand]
$creadPrec :: ReadPrec Operand
readPrec :: ReadPrec Operand
$creadListPrec :: ReadPrec [Operand]
readListPrec :: ReadPrec [Operand]
Read, Int -> Operand -> ShowS
[Operand] -> ShowS
Operand -> String
(Int -> Operand -> ShowS)
-> (Operand -> String) -> ([Operand] -> ShowS) -> Show Operand
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Operand -> ShowS
showsPrec :: Int -> Operand -> ShowS
$cshow :: Operand -> String
show :: Operand -> String
$cshowList :: [Operand] -> ShowS
showList :: [Operand] -> ShowS
Show, Typeable, Typeable Operand
Typeable Operand
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Operand -> c Operand)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Operand)
-> (Operand -> Constr)
-> (Operand -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Operand))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand))
-> ((forall b. Data b => b -> b) -> Operand -> Operand)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Operand -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Operand -> r)
-> (forall u. (forall d. Data d => d -> u) -> Operand -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Operand -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Operand -> m Operand)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Operand -> m Operand)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Operand -> m Operand)
-> Data Operand
Operand -> Constr
Operand -> DataType
(forall b. Data b => b -> b) -> Operand -> Operand
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) -> Operand -> u
forall u. (forall d. Data d => d -> u) -> Operand -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operand
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operand -> c Operand
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operand)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operand -> c Operand
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Operand -> c Operand
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operand
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Operand
$ctoConstr :: Operand -> Constr
toConstr :: Operand -> Constr
$cdataTypeOf :: Operand -> DataType
dataTypeOf :: Operand -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operand)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Operand)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Operand)
$cgmapT :: (forall b. Data b => b -> b) -> Operand -> Operand
gmapT :: (forall b. Data b => b -> b) -> Operand -> Operand
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Operand -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Operand -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Operand -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Operand -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Operand -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Operand -> m Operand
Data, (forall x. Operand -> Rep Operand x)
-> (forall x. Rep Operand x -> Operand) -> Generic Operand
forall x. Rep Operand x -> Operand
forall x. Operand -> Rep Operand x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Operand -> Rep Operand x
from :: forall x. Operand -> Rep Operand x
$cto :: forall x. Rep Operand x -> Operand
to :: forall x. Rep Operand x -> Operand
Generic)

-- | The 'LLVM.AST.Instruction.Call' instruction is special: the callee can be inline assembly
type CallableOperand  = Either InlineAssembly Operand

-- | <http://llvm.org/docs/LangRef.html#metadata>
data Metadata
  = MDString ShortByteString -- ^ <http://llvm.org/docs/doxygen/html/classllvm_1_1MDNode.html>
  | MDNode (MDRef MDNode) -- ^ <http://llvm.org/docs/doxygen/html/classllvm_1_1MDNode.html>
  | MDValue Operand -- ^ <http://llvm.org/docs/doxygen/html/classllvm_1_1ValueAsMetadata.html>
  deriving (Metadata -> Metadata -> Bool
(Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool) -> Eq Metadata
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Metadata -> Metadata -> Bool
== :: Metadata -> Metadata -> Bool
$c/= :: Metadata -> Metadata -> Bool
/= :: Metadata -> Metadata -> Bool
Eq, Eq Metadata
Eq Metadata
-> (Metadata -> Metadata -> Ordering)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Bool)
-> (Metadata -> Metadata -> Metadata)
-> (Metadata -> Metadata -> Metadata)
-> Ord Metadata
Metadata -> Metadata -> Bool
Metadata -> Metadata -> Ordering
Metadata -> Metadata -> Metadata
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
$ccompare :: Metadata -> Metadata -> Ordering
compare :: Metadata -> Metadata -> Ordering
$c< :: Metadata -> Metadata -> Bool
< :: Metadata -> Metadata -> Bool
$c<= :: Metadata -> Metadata -> Bool
<= :: Metadata -> Metadata -> Bool
$c> :: Metadata -> Metadata -> Bool
> :: Metadata -> Metadata -> Bool
$c>= :: Metadata -> Metadata -> Bool
>= :: Metadata -> Metadata -> Bool
$cmax :: Metadata -> Metadata -> Metadata
max :: Metadata -> Metadata -> Metadata
$cmin :: Metadata -> Metadata -> Metadata
min :: Metadata -> Metadata -> Metadata
Ord, ReadPrec [Metadata]
ReadPrec Metadata
Int -> ReadS Metadata
ReadS [Metadata]
(Int -> ReadS Metadata)
-> ReadS [Metadata]
-> ReadPrec Metadata
-> ReadPrec [Metadata]
-> Read Metadata
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Metadata
readsPrec :: Int -> ReadS Metadata
$creadList :: ReadS [Metadata]
readList :: ReadS [Metadata]
$creadPrec :: ReadPrec Metadata
readPrec :: ReadPrec Metadata
$creadListPrec :: ReadPrec [Metadata]
readListPrec :: ReadPrec [Metadata]
Read, Int -> Metadata -> ShowS
[Metadata] -> ShowS
Metadata -> String
(Int -> Metadata -> ShowS)
-> (Metadata -> String) -> ([Metadata] -> ShowS) -> Show Metadata
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Metadata -> ShowS
showsPrec :: Int -> Metadata -> ShowS
$cshow :: Metadata -> String
show :: Metadata -> String
$cshowList :: [Metadata] -> ShowS
showList :: [Metadata] -> ShowS
Show, Typeable, Typeable Metadata
Typeable Metadata
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Metadata -> c Metadata)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Metadata)
-> (Metadata -> Constr)
-> (Metadata -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Metadata))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata))
-> ((forall b. Data b => b -> b) -> Metadata -> Metadata)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Metadata -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Metadata -> r)
-> (forall u. (forall d. Data d => d -> u) -> Metadata -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Metadata -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Metadata -> m Metadata)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Metadata -> m Metadata)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Metadata -> m Metadata)
-> Data Metadata
Metadata -> Constr
Metadata -> DataType
(forall b. Data b => b -> b) -> Metadata -> Metadata
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) -> Metadata -> u
forall u. (forall d. Data d => d -> u) -> Metadata -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Metadata
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Metadata -> c Metadata
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Metadata)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Metadata -> c Metadata
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Metadata -> c Metadata
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Metadata
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Metadata
$ctoConstr :: Metadata -> Constr
toConstr :: Metadata -> Constr
$cdataTypeOf :: Metadata -> DataType
dataTypeOf :: Metadata -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Metadata)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Metadata)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Metadata)
$cgmapT :: (forall b. Data b => b -> b) -> Metadata -> Metadata
gmapT :: (forall b. Data b => b -> b) -> Metadata -> Metadata
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Metadata -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Metadata -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Metadata -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Metadata -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Metadata -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Metadata -> m Metadata
Data, (forall x. Metadata -> Rep Metadata x)
-> (forall x. Rep Metadata x -> Metadata) -> Generic Metadata
forall x. Rep Metadata x -> Metadata
forall x. Metadata -> Rep Metadata x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Metadata -> Rep Metadata x
from :: forall x. Metadata -> Rep Metadata x
$cto :: forall x. Rep Metadata x -> Metadata
to :: forall x. Rep Metadata x -> Metadata
Generic)

-- | A 'MetadataNodeID' is a number for identifying a metadata node.
-- Note this is different from "named metadata", which are represented with
-- 'LLVM.AST.NamedMetadataDefinition'.
newtype MetadataNodeID = MetadataNodeID Word
  deriving (MetadataNodeID -> MetadataNodeID -> Bool
(MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> Bool) -> Eq MetadataNodeID
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MetadataNodeID -> MetadataNodeID -> Bool
== :: MetadataNodeID -> MetadataNodeID -> Bool
$c/= :: MetadataNodeID -> MetadataNodeID -> Bool
/= :: MetadataNodeID -> MetadataNodeID -> Bool
Eq, Eq MetadataNodeID
Eq MetadataNodeID
-> (MetadataNodeID -> MetadataNodeID -> Ordering)
-> (MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> Bool)
-> (MetadataNodeID -> MetadataNodeID -> MetadataNodeID)
-> (MetadataNodeID -> MetadataNodeID -> MetadataNodeID)
-> Ord MetadataNodeID
MetadataNodeID -> MetadataNodeID -> Bool
MetadataNodeID -> MetadataNodeID -> Ordering
MetadataNodeID -> MetadataNodeID -> MetadataNodeID
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
$ccompare :: MetadataNodeID -> MetadataNodeID -> Ordering
compare :: MetadataNodeID -> MetadataNodeID -> Ordering
$c< :: MetadataNodeID -> MetadataNodeID -> Bool
< :: MetadataNodeID -> MetadataNodeID -> Bool
$c<= :: MetadataNodeID -> MetadataNodeID -> Bool
<= :: MetadataNodeID -> MetadataNodeID -> Bool
$c> :: MetadataNodeID -> MetadataNodeID -> Bool
> :: MetadataNodeID -> MetadataNodeID -> Bool
$c>= :: MetadataNodeID -> MetadataNodeID -> Bool
>= :: MetadataNodeID -> MetadataNodeID -> Bool
$cmax :: MetadataNodeID -> MetadataNodeID -> MetadataNodeID
max :: MetadataNodeID -> MetadataNodeID -> MetadataNodeID
$cmin :: MetadataNodeID -> MetadataNodeID -> MetadataNodeID
min :: MetadataNodeID -> MetadataNodeID -> MetadataNodeID
Ord, ReadPrec [MetadataNodeID]
ReadPrec MetadataNodeID
Int -> ReadS MetadataNodeID
ReadS [MetadataNodeID]
(Int -> ReadS MetadataNodeID)
-> ReadS [MetadataNodeID]
-> ReadPrec MetadataNodeID
-> ReadPrec [MetadataNodeID]
-> Read MetadataNodeID
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MetadataNodeID
readsPrec :: Int -> ReadS MetadataNodeID
$creadList :: ReadS [MetadataNodeID]
readList :: ReadS [MetadataNodeID]
$creadPrec :: ReadPrec MetadataNodeID
readPrec :: ReadPrec MetadataNodeID
$creadListPrec :: ReadPrec [MetadataNodeID]
readListPrec :: ReadPrec [MetadataNodeID]
Read, Int -> MetadataNodeID -> ShowS
[MetadataNodeID] -> ShowS
MetadataNodeID -> String
(Int -> MetadataNodeID -> ShowS)
-> (MetadataNodeID -> String)
-> ([MetadataNodeID] -> ShowS)
-> Show MetadataNodeID
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MetadataNodeID -> ShowS
showsPrec :: Int -> MetadataNodeID -> ShowS
$cshow :: MetadataNodeID -> String
show :: MetadataNodeID -> String
$cshowList :: [MetadataNodeID] -> ShowS
showList :: [MetadataNodeID] -> ShowS
Show, Typeable, Typeable MetadataNodeID
Typeable MetadataNodeID
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MetadataNodeID)
-> (MetadataNodeID -> Constr)
-> (MetadataNodeID -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MetadataNodeID))
-> ((forall b. Data b => b -> b)
    -> MetadataNodeID -> MetadataNodeID)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MetadataNodeID -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MetadataNodeID -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MetadataNodeID -> m MetadataNodeID)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MetadataNodeID -> m MetadataNodeID)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MetadataNodeID -> m MetadataNodeID)
-> Data MetadataNodeID
MetadataNodeID -> Constr
MetadataNodeID -> DataType
(forall b. Data b => b -> b) -> MetadataNodeID -> MetadataNodeID
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) -> MetadataNodeID -> u
forall u. (forall d. Data d => d -> u) -> MetadataNodeID -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetadataNodeID
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetadataNodeID)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MetadataNodeID -> c MetadataNodeID
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetadataNodeID
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MetadataNodeID
$ctoConstr :: MetadataNodeID -> Constr
toConstr :: MetadataNodeID -> Constr
$cdataTypeOf :: MetadataNodeID -> DataType
dataTypeOf :: MetadataNodeID -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MetadataNodeID)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetadataNodeID)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MetadataNodeID)
$cgmapT :: (forall b. Data b => b -> b) -> MetadataNodeID -> MetadataNodeID
gmapT :: (forall b. Data b => b -> b) -> MetadataNodeID -> MetadataNodeID
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MetadataNodeID -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MetadataNodeID -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MetadataNodeID -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MetadataNodeID -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MetadataNodeID -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MetadataNodeID -> m MetadataNodeID
Data, (forall x. MetadataNodeID -> Rep MetadataNodeID x)
-> (forall x. Rep MetadataNodeID x -> MetadataNodeID)
-> Generic MetadataNodeID
forall x. Rep MetadataNodeID x -> MetadataNodeID
forall x. MetadataNodeID -> Rep MetadataNodeID x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MetadataNodeID -> Rep MetadataNodeID x
from :: forall x. MetadataNodeID -> Rep MetadataNodeID x
$cto :: forall x. Rep MetadataNodeID x -> MetadataNodeID
to :: forall x. Rep MetadataNodeID x -> MetadataNodeID
Generic)

-- | `MDRef` can either represent a reference to some piece of
-- metadata or the metadata itself.
--
-- This is mainly useful for encoding cyclic metadata. Note that LLVM
-- represents inline and non-inline nodes identically, so
-- roundtripping the Haskell AST does not preserve whether a node was
-- inline or not.
data MDRef a
  = MDRef MetadataNodeID
  | MDInline a
  deriving (MDRef a -> MDRef a -> Bool
(MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> Bool) -> Eq (MDRef a)
forall a. Eq a => MDRef a -> MDRef a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => MDRef a -> MDRef a -> Bool
== :: MDRef a -> MDRef a -> Bool
$c/= :: forall a. Eq a => MDRef a -> MDRef a -> Bool
/= :: MDRef a -> MDRef a -> Bool
Eq, Eq (MDRef a)
Eq (MDRef a)
-> (MDRef a -> MDRef a -> Ordering)
-> (MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> Bool)
-> (MDRef a -> MDRef a -> MDRef a)
-> (MDRef a -> MDRef a -> MDRef a)
-> Ord (MDRef a)
MDRef a -> MDRef a -> Bool
MDRef a -> MDRef a -> Ordering
MDRef a -> MDRef a -> MDRef a
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
forall {a}. Ord a => Eq (MDRef a)
forall a. Ord a => MDRef a -> MDRef a -> Bool
forall a. Ord a => MDRef a -> MDRef a -> Ordering
forall a. Ord a => MDRef a -> MDRef a -> MDRef a
$ccompare :: forall a. Ord a => MDRef a -> MDRef a -> Ordering
compare :: MDRef a -> MDRef a -> Ordering
$c< :: forall a. Ord a => MDRef a -> MDRef a -> Bool
< :: MDRef a -> MDRef a -> Bool
$c<= :: forall a. Ord a => MDRef a -> MDRef a -> Bool
<= :: MDRef a -> MDRef a -> Bool
$c> :: forall a. Ord a => MDRef a -> MDRef a -> Bool
> :: MDRef a -> MDRef a -> Bool
$c>= :: forall a. Ord a => MDRef a -> MDRef a -> Bool
>= :: MDRef a -> MDRef a -> Bool
$cmax :: forall a. Ord a => MDRef a -> MDRef a -> MDRef a
max :: MDRef a -> MDRef a -> MDRef a
$cmin :: forall a. Ord a => MDRef a -> MDRef a -> MDRef a
min :: MDRef a -> MDRef a -> MDRef a
Ord, ReadPrec [MDRef a]
ReadPrec (MDRef a)
Int -> ReadS (MDRef a)
ReadS [MDRef a]
(Int -> ReadS (MDRef a))
-> ReadS [MDRef a]
-> ReadPrec (MDRef a)
-> ReadPrec [MDRef a]
-> Read (MDRef a)
forall a. Read a => ReadPrec [MDRef a]
forall a. Read a => ReadPrec (MDRef a)
forall a. Read a => Int -> ReadS (MDRef a)
forall a. Read a => ReadS [MDRef a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (MDRef a)
readsPrec :: Int -> ReadS (MDRef a)
$creadList :: forall a. Read a => ReadS [MDRef a]
readList :: ReadS [MDRef a]
$creadPrec :: forall a. Read a => ReadPrec (MDRef a)
readPrec :: ReadPrec (MDRef a)
$creadListPrec :: forall a. Read a => ReadPrec [MDRef a]
readListPrec :: ReadPrec [MDRef a]
Read, Int -> MDRef a -> ShowS
[MDRef a] -> ShowS
MDRef a -> String
(Int -> MDRef a -> ShowS)
-> (MDRef a -> String) -> ([MDRef a] -> ShowS) -> Show (MDRef a)
forall a. Show a => Int -> MDRef a -> ShowS
forall a. Show a => [MDRef a] -> ShowS
forall a. Show a => MDRef a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MDRef a -> ShowS
showsPrec :: Int -> MDRef a -> ShowS
$cshow :: forall a. Show a => MDRef a -> String
show :: MDRef a -> String
$cshowList :: forall a. Show a => [MDRef a] -> ShowS
showList :: [MDRef a] -> ShowS
Show, Typeable, Typeable (MDRef a)
Typeable (MDRef a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MDRef a -> c (MDRef a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MDRef a))
-> (MDRef a -> Constr)
-> (MDRef a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (MDRef a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a)))
-> ((forall b. Data b => b -> b) -> MDRef a -> MDRef a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MDRef a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MDRef a -> r)
-> (forall u. (forall d. Data d => d -> u) -> MDRef a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MDRef a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a))
-> Data (MDRef a)
MDRef a -> Constr
MDRef a -> DataType
(forall b. Data b => b -> b) -> MDRef a -> MDRef a
forall {a}. Data a => Typeable (MDRef a)
forall a. Data a => MDRef a -> Constr
forall a. Data a => MDRef a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> MDRef a -> MDRef a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> MDRef a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> MDRef a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a))
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) -> MDRef a -> u
forall u. (forall d. Data d => d -> u) -> MDRef a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDRef a -> c (MDRef a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MDRef a)
$ctoConstr :: forall a. Data a => MDRef a -> Constr
toConstr :: MDRef a -> Constr
$cdataTypeOf :: forall a. Data a => MDRef a -> DataType
dataTypeOf :: MDRef a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (MDRef a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MDRef a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> MDRef a -> MDRef a
gmapT :: (forall b. Data b => b -> b) -> MDRef a -> MDRef a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MDRef a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> MDRef a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MDRef a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> MDRef a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MDRef a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDRef a -> m (MDRef a)
Data, (forall x. MDRef a -> Rep (MDRef a) x)
-> (forall x. Rep (MDRef a) x -> MDRef a) -> Generic (MDRef a)
forall x. Rep (MDRef a) x -> MDRef a
forall x. MDRef a -> Rep (MDRef a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (MDRef a) x -> MDRef a
forall a x. MDRef a -> Rep (MDRef a) x
$cfrom :: forall a x. MDRef a -> Rep (MDRef a) x
from :: forall x. MDRef a -> Rep (MDRef a) x
$cto :: forall a x. Rep (MDRef a) x -> MDRef a
to :: forall x. Rep (MDRef a) x -> MDRef a
Generic)

instance Functor MDRef where
  fmap :: forall a b. (a -> b) -> MDRef a -> MDRef b
fmap a -> b
_ (MDRef MetadataNodeID
i) = MetadataNodeID -> MDRef b
forall a. MetadataNodeID -> MDRef a
MDRef MetadataNodeID
i
  fmap a -> b
f (MDInline a
a) = b -> MDRef b
forall a. a -> MDRef a
MDInline (a -> b
f a
a)

data DWOpFragment = DW_OP_LLVM_Fragment
  { DWOpFragment -> Word64
offset :: Word64
  , DWOpFragment -> Word64
size :: Word64
  } deriving (DWOpFragment -> DWOpFragment -> Bool
(DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> Bool) -> Eq DWOpFragment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DWOpFragment -> DWOpFragment -> Bool
== :: DWOpFragment -> DWOpFragment -> Bool
$c/= :: DWOpFragment -> DWOpFragment -> Bool
/= :: DWOpFragment -> DWOpFragment -> Bool
Eq, Eq DWOpFragment
Eq DWOpFragment
-> (DWOpFragment -> DWOpFragment -> Ordering)
-> (DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> Bool)
-> (DWOpFragment -> DWOpFragment -> DWOpFragment)
-> (DWOpFragment -> DWOpFragment -> DWOpFragment)
-> Ord DWOpFragment
DWOpFragment -> DWOpFragment -> Bool
DWOpFragment -> DWOpFragment -> Ordering
DWOpFragment -> DWOpFragment -> DWOpFragment
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
$ccompare :: DWOpFragment -> DWOpFragment -> Ordering
compare :: DWOpFragment -> DWOpFragment -> Ordering
$c< :: DWOpFragment -> DWOpFragment -> Bool
< :: DWOpFragment -> DWOpFragment -> Bool
$c<= :: DWOpFragment -> DWOpFragment -> Bool
<= :: DWOpFragment -> DWOpFragment -> Bool
$c> :: DWOpFragment -> DWOpFragment -> Bool
> :: DWOpFragment -> DWOpFragment -> Bool
$c>= :: DWOpFragment -> DWOpFragment -> Bool
>= :: DWOpFragment -> DWOpFragment -> Bool
$cmax :: DWOpFragment -> DWOpFragment -> DWOpFragment
max :: DWOpFragment -> DWOpFragment -> DWOpFragment
$cmin :: DWOpFragment -> DWOpFragment -> DWOpFragment
min :: DWOpFragment -> DWOpFragment -> DWOpFragment
Ord, ReadPrec [DWOpFragment]
ReadPrec DWOpFragment
Int -> ReadS DWOpFragment
ReadS [DWOpFragment]
(Int -> ReadS DWOpFragment)
-> ReadS [DWOpFragment]
-> ReadPrec DWOpFragment
-> ReadPrec [DWOpFragment]
-> Read DWOpFragment
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DWOpFragment
readsPrec :: Int -> ReadS DWOpFragment
$creadList :: ReadS [DWOpFragment]
readList :: ReadS [DWOpFragment]
$creadPrec :: ReadPrec DWOpFragment
readPrec :: ReadPrec DWOpFragment
$creadListPrec :: ReadPrec [DWOpFragment]
readListPrec :: ReadPrec [DWOpFragment]
Read, Int -> DWOpFragment -> ShowS
[DWOpFragment] -> ShowS
DWOpFragment -> String
(Int -> DWOpFragment -> ShowS)
-> (DWOpFragment -> String)
-> ([DWOpFragment] -> ShowS)
-> Show DWOpFragment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DWOpFragment -> ShowS
showsPrec :: Int -> DWOpFragment -> ShowS
$cshow :: DWOpFragment -> String
show :: DWOpFragment -> String
$cshowList :: [DWOpFragment] -> ShowS
showList :: [DWOpFragment] -> ShowS
Show, Typeable, Typeable DWOpFragment
Typeable DWOpFragment
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DWOpFragment)
-> (DWOpFragment -> Constr)
-> (DWOpFragment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DWOpFragment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DWOpFragment))
-> ((forall b. Data b => b -> b) -> DWOpFragment -> DWOpFragment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r)
-> (forall u. (forall d. Data d => d -> u) -> DWOpFragment -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DWOpFragment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment)
-> Data DWOpFragment
DWOpFragment -> Constr
DWOpFragment -> DataType
(forall b. Data b => b -> b) -> DWOpFragment -> DWOpFragment
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) -> DWOpFragment -> u
forall u. (forall d. Data d => d -> u) -> DWOpFragment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOpFragment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOpFragment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DWOpFragment)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOpFragment -> c DWOpFragment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOpFragment
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOpFragment
$ctoConstr :: DWOpFragment -> Constr
toConstr :: DWOpFragment -> Constr
$cdataTypeOf :: DWOpFragment -> DataType
dataTypeOf :: DWOpFragment -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOpFragment)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOpFragment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DWOpFragment)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DWOpFragment)
$cgmapT :: (forall b. Data b => b -> b) -> DWOpFragment -> DWOpFragment
gmapT :: (forall b. Data b => b -> b) -> DWOpFragment -> DWOpFragment
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DWOpFragment -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DWOpFragment -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DWOpFragment -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DWOpFragment -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DWOpFragment -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOpFragment -> m DWOpFragment
Data, (forall x. DWOpFragment -> Rep DWOpFragment x)
-> (forall x. Rep DWOpFragment x -> DWOpFragment)
-> Generic DWOpFragment
forall x. Rep DWOpFragment x -> DWOpFragment
forall x. DWOpFragment -> Rep DWOpFragment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DWOpFragment -> Rep DWOpFragment x
from :: forall x. DWOpFragment -> Rep DWOpFragment x
$cto :: forall x. Rep DWOpFragment x -> DWOpFragment
to :: forall x. Rep DWOpFragment x -> DWOpFragment
Generic)

-- | <https://llvm.org/docs/LangRef.html#diexpression>
data DWOp
  = DW_OP_And
  | DW_OP_Bregx
  | DW_OP_ConstU Word64
  | DW_OP_Deref
  | DW_OP_Div
  | DW_OP_Dup
  | DwOpFragment DWOpFragment -- ^ Must appear at the end
  | DW_OP_Lit0
  | DW_OP_Minus
  | DW_OP_Mod
  | DW_OP_Mul
  | DW_OP_Not
  | DW_OP_Or
  | DW_OP_Plus
  | DW_OP_PlusUConst Word64
  | DW_OP_PushObjectAddress
  | DW_OP_Shl
  | DW_OP_Shr
  | DW_OP_Shra
  | DW_OP_StackValue -- ^ Must be the last one or followed by a DW_OP_LLVM_Fragment
  | DW_OP_Swap
  | DW_OP_XDeref
  | DW_OP_Xor
  deriving (DWOp -> DWOp -> Bool
(DWOp -> DWOp -> Bool) -> (DWOp -> DWOp -> Bool) -> Eq DWOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DWOp -> DWOp -> Bool
== :: DWOp -> DWOp -> Bool
$c/= :: DWOp -> DWOp -> Bool
/= :: DWOp -> DWOp -> Bool
Eq, Eq DWOp
Eq DWOp
-> (DWOp -> DWOp -> Ordering)
-> (DWOp -> DWOp -> Bool)
-> (DWOp -> DWOp -> Bool)
-> (DWOp -> DWOp -> Bool)
-> (DWOp -> DWOp -> Bool)
-> (DWOp -> DWOp -> DWOp)
-> (DWOp -> DWOp -> DWOp)
-> Ord DWOp
DWOp -> DWOp -> Bool
DWOp -> DWOp -> Ordering
DWOp -> DWOp -> DWOp
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
$ccompare :: DWOp -> DWOp -> Ordering
compare :: DWOp -> DWOp -> Ordering
$c< :: DWOp -> DWOp -> Bool
< :: DWOp -> DWOp -> Bool
$c<= :: DWOp -> DWOp -> Bool
<= :: DWOp -> DWOp -> Bool
$c> :: DWOp -> DWOp -> Bool
> :: DWOp -> DWOp -> Bool
$c>= :: DWOp -> DWOp -> Bool
>= :: DWOp -> DWOp -> Bool
$cmax :: DWOp -> DWOp -> DWOp
max :: DWOp -> DWOp -> DWOp
$cmin :: DWOp -> DWOp -> DWOp
min :: DWOp -> DWOp -> DWOp
Ord, ReadPrec [DWOp]
ReadPrec DWOp
Int -> ReadS DWOp
ReadS [DWOp]
(Int -> ReadS DWOp)
-> ReadS [DWOp] -> ReadPrec DWOp -> ReadPrec [DWOp] -> Read DWOp
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DWOp
readsPrec :: Int -> ReadS DWOp
$creadList :: ReadS [DWOp]
readList :: ReadS [DWOp]
$creadPrec :: ReadPrec DWOp
readPrec :: ReadPrec DWOp
$creadListPrec :: ReadPrec [DWOp]
readListPrec :: ReadPrec [DWOp]
Read, Int -> DWOp -> ShowS
[DWOp] -> ShowS
DWOp -> String
(Int -> DWOp -> ShowS)
-> (DWOp -> String) -> ([DWOp] -> ShowS) -> Show DWOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DWOp -> ShowS
showsPrec :: Int -> DWOp -> ShowS
$cshow :: DWOp -> String
show :: DWOp -> String
$cshowList :: [DWOp] -> ShowS
showList :: [DWOp] -> ShowS
Show, Typeable, Typeable DWOp
Typeable DWOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DWOp -> c DWOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DWOp)
-> (DWOp -> Constr)
-> (DWOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DWOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DWOp))
-> ((forall b. Data b => b -> b) -> DWOp -> DWOp)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> DWOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DWOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DWOp -> m DWOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DWOp -> m DWOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DWOp -> m DWOp)
-> Data DWOp
DWOp -> Constr
DWOp -> DataType
(forall b. Data b => b -> b) -> DWOp -> DWOp
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) -> DWOp -> u
forall u. (forall d. Data d => d -> u) -> DWOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOp -> c DWOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DWOp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOp -> c DWOp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DWOp -> c DWOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DWOp
$ctoConstr :: DWOp -> Constr
toConstr :: DWOp -> Constr
$cdataTypeOf :: DWOp -> DataType
dataTypeOf :: DWOp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DWOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DWOp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DWOp)
$cgmapT :: (forall b. Data b => b -> b) -> DWOp -> DWOp
gmapT :: (forall b. Data b => b -> b) -> DWOp -> DWOp
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DWOp -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DWOp -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DWOp -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DWOp -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DWOp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DWOp -> m DWOp
Data, (forall x. DWOp -> Rep DWOp x)
-> (forall x. Rep DWOp x -> DWOp) -> Generic DWOp
forall x. Rep DWOp x -> DWOp
forall x. DWOp -> Rep DWOp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DWOp -> Rep DWOp x
from :: forall x. DWOp -> Rep DWOp x
$cto :: forall x. Rep DWOp x -> DWOp
to :: forall x. Rep DWOp x -> DWOp
Generic)

-- | <http://llvm.org/docs/LangRef.html#metadata>
data MDNode
  = MDTuple [Maybe Metadata] -- ^ Nothing represents 'null'
  | DIExpression DIExpression
  | DIGlobalVariableExpression DIGlobalVariableExpression
  | DILocation DILocation
  | DIMacroNode DIMacroNode
  | DINode DINode
  deriving (MDNode -> MDNode -> Bool
(MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> Bool) -> Eq MDNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MDNode -> MDNode -> Bool
== :: MDNode -> MDNode -> Bool
$c/= :: MDNode -> MDNode -> Bool
/= :: MDNode -> MDNode -> Bool
Eq, Eq MDNode
Eq MDNode
-> (MDNode -> MDNode -> Ordering)
-> (MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> Bool)
-> (MDNode -> MDNode -> MDNode)
-> (MDNode -> MDNode -> MDNode)
-> Ord MDNode
MDNode -> MDNode -> Bool
MDNode -> MDNode -> Ordering
MDNode -> MDNode -> MDNode
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
$ccompare :: MDNode -> MDNode -> Ordering
compare :: MDNode -> MDNode -> Ordering
$c< :: MDNode -> MDNode -> Bool
< :: MDNode -> MDNode -> Bool
$c<= :: MDNode -> MDNode -> Bool
<= :: MDNode -> MDNode -> Bool
$c> :: MDNode -> MDNode -> Bool
> :: MDNode -> MDNode -> Bool
$c>= :: MDNode -> MDNode -> Bool
>= :: MDNode -> MDNode -> Bool
$cmax :: MDNode -> MDNode -> MDNode
max :: MDNode -> MDNode -> MDNode
$cmin :: MDNode -> MDNode -> MDNode
min :: MDNode -> MDNode -> MDNode
Ord, ReadPrec [MDNode]
ReadPrec MDNode
Int -> ReadS MDNode
ReadS [MDNode]
(Int -> ReadS MDNode)
-> ReadS [MDNode]
-> ReadPrec MDNode
-> ReadPrec [MDNode]
-> Read MDNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MDNode
readsPrec :: Int -> ReadS MDNode
$creadList :: ReadS [MDNode]
readList :: ReadS [MDNode]
$creadPrec :: ReadPrec MDNode
readPrec :: ReadPrec MDNode
$creadListPrec :: ReadPrec [MDNode]
readListPrec :: ReadPrec [MDNode]
Read, Int -> MDNode -> ShowS
[MDNode] -> ShowS
MDNode -> String
(Int -> MDNode -> ShowS)
-> (MDNode -> String) -> ([MDNode] -> ShowS) -> Show MDNode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MDNode -> ShowS
showsPrec :: Int -> MDNode -> ShowS
$cshow :: MDNode -> String
show :: MDNode -> String
$cshowList :: [MDNode] -> ShowS
showList :: [MDNode] -> ShowS
Show, Typeable, Typeable MDNode
Typeable MDNode
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MDNode -> c MDNode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MDNode)
-> (MDNode -> Constr)
-> (MDNode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MDNode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MDNode))
-> ((forall b. Data b => b -> b) -> MDNode -> MDNode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MDNode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MDNode -> r)
-> (forall u. (forall d. Data d => d -> u) -> MDNode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MDNode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MDNode -> m MDNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MDNode -> m MDNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MDNode -> m MDNode)
-> Data MDNode
MDNode -> Constr
MDNode -> DataType
(forall b. Data b => b -> b) -> MDNode -> MDNode
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) -> MDNode -> u
forall u. (forall d. Data d => d -> u) -> MDNode -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MDNode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDNode -> c MDNode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MDNode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MDNode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDNode -> c MDNode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MDNode -> c MDNode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MDNode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MDNode
$ctoConstr :: MDNode -> Constr
toConstr :: MDNode -> Constr
$cdataTypeOf :: MDNode -> DataType
dataTypeOf :: MDNode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MDNode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MDNode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MDNode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MDNode)
$cgmapT :: (forall b. Data b => b -> b) -> MDNode -> MDNode
gmapT :: (forall b. Data b => b -> b) -> MDNode -> MDNode
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MDNode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MDNode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MDNode -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MDNode -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MDNode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MDNode -> m MDNode
Data, (forall x. MDNode -> Rep MDNode x)
-> (forall x. Rep MDNode x -> MDNode) -> Generic MDNode
forall x. Rep MDNode x -> MDNode
forall x. MDNode -> Rep MDNode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MDNode -> Rep MDNode x
from :: forall x. MDNode -> Rep MDNode x
$cto :: forall x. Rep MDNode x -> MDNode
to :: forall x. Rep MDNode x -> MDNode
Generic)

data DILocation = Location
  { DILocation -> Word32
line :: Word32
  , DILocation -> Word16
column :: Word16
  , DILocation -> MDRef DILocalScope
scope :: MDRef DILocalScope
  } deriving (DILocation -> DILocation -> Bool
(DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> Bool) -> Eq DILocation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DILocation -> DILocation -> Bool
== :: DILocation -> DILocation -> Bool
$c/= :: DILocation -> DILocation -> Bool
/= :: DILocation -> DILocation -> Bool
Eq, Eq DILocation
Eq DILocation
-> (DILocation -> DILocation -> Ordering)
-> (DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> Bool)
-> (DILocation -> DILocation -> DILocation)
-> (DILocation -> DILocation -> DILocation)
-> Ord DILocation
DILocation -> DILocation -> Bool
DILocation -> DILocation -> Ordering
DILocation -> DILocation -> DILocation
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
$ccompare :: DILocation -> DILocation -> Ordering
compare :: DILocation -> DILocation -> Ordering
$c< :: DILocation -> DILocation -> Bool
< :: DILocation -> DILocation -> Bool
$c<= :: DILocation -> DILocation -> Bool
<= :: DILocation -> DILocation -> Bool
$c> :: DILocation -> DILocation -> Bool
> :: DILocation -> DILocation -> Bool
$c>= :: DILocation -> DILocation -> Bool
>= :: DILocation -> DILocation -> Bool
$cmax :: DILocation -> DILocation -> DILocation
max :: DILocation -> DILocation -> DILocation
$cmin :: DILocation -> DILocation -> DILocation
min :: DILocation -> DILocation -> DILocation
Ord, ReadPrec [DILocation]
ReadPrec DILocation
Int -> ReadS DILocation
ReadS [DILocation]
(Int -> ReadS DILocation)
-> ReadS [DILocation]
-> ReadPrec DILocation
-> ReadPrec [DILocation]
-> Read DILocation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DILocation
readsPrec :: Int -> ReadS DILocation
$creadList :: ReadS [DILocation]
readList :: ReadS [DILocation]
$creadPrec :: ReadPrec DILocation
readPrec :: ReadPrec DILocation
$creadListPrec :: ReadPrec [DILocation]
readListPrec :: ReadPrec [DILocation]
Read, Int -> DILocation -> ShowS
[DILocation] -> ShowS
DILocation -> String
(Int -> DILocation -> ShowS)
-> (DILocation -> String)
-> ([DILocation] -> ShowS)
-> Show DILocation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DILocation -> ShowS
showsPrec :: Int -> DILocation -> ShowS
$cshow :: DILocation -> String
show :: DILocation -> String
$cshowList :: [DILocation] -> ShowS
showList :: [DILocation] -> ShowS
Show, Typeable, Typeable DILocation
Typeable DILocation
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DILocation -> c DILocation)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DILocation)
-> (DILocation -> Constr)
-> (DILocation -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DILocation))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DILocation))
-> ((forall b. Data b => b -> b) -> DILocation -> DILocation)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocation -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocation -> r)
-> (forall u. (forall d. Data d => d -> u) -> DILocation -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILocation -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DILocation -> m DILocation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILocation -> m DILocation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILocation -> m DILocation)
-> Data DILocation
DILocation -> Constr
DILocation -> DataType
(forall b. Data b => b -> b) -> DILocation -> DILocation
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) -> DILocation -> u
forall u. (forall d. Data d => d -> u) -> DILocation -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocation
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocation -> c DILocation
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocation)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DILocation)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocation -> c DILocation
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocation -> c DILocation
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocation
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocation
$ctoConstr :: DILocation -> Constr
toConstr :: DILocation -> Constr
$cdataTypeOf :: DILocation -> DataType
dataTypeOf :: DILocation -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocation)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocation)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DILocation)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DILocation)
$cgmapT :: (forall b. Data b => b -> b) -> DILocation -> DILocation
gmapT :: (forall b. Data b => b -> b) -> DILocation -> DILocation
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocation -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DILocation -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DILocation -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DILocation -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DILocation -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocation -> m DILocation
Data, (forall x. DILocation -> Rep DILocation x)
-> (forall x. Rep DILocation x -> DILocation) -> Generic DILocation
forall x. Rep DILocation x -> DILocation
forall x. DILocation -> Rep DILocation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DILocation -> Rep DILocation x
from :: forall x. DILocation -> Rep DILocation x
$cto :: forall x. Rep DILocation x -> DILocation
to :: forall x. Rep DILocation x -> DILocation
Generic)

-- | <https://llvm.org/docs/LangRef.html#diexpression>
data DIExpression = Expression
  { DIExpression -> [DWOp]
operands :: [DWOp]
  } deriving (DIExpression -> DIExpression -> Bool
(DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool) -> Eq DIExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIExpression -> DIExpression -> Bool
== :: DIExpression -> DIExpression -> Bool
$c/= :: DIExpression -> DIExpression -> Bool
/= :: DIExpression -> DIExpression -> Bool
Eq, Eq DIExpression
Eq DIExpression
-> (DIExpression -> DIExpression -> Ordering)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> Bool)
-> (DIExpression -> DIExpression -> DIExpression)
-> (DIExpression -> DIExpression -> DIExpression)
-> Ord DIExpression
DIExpression -> DIExpression -> Bool
DIExpression -> DIExpression -> Ordering
DIExpression -> DIExpression -> DIExpression
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
$ccompare :: DIExpression -> DIExpression -> Ordering
compare :: DIExpression -> DIExpression -> Ordering
$c< :: DIExpression -> DIExpression -> Bool
< :: DIExpression -> DIExpression -> Bool
$c<= :: DIExpression -> DIExpression -> Bool
<= :: DIExpression -> DIExpression -> Bool
$c> :: DIExpression -> DIExpression -> Bool
> :: DIExpression -> DIExpression -> Bool
$c>= :: DIExpression -> DIExpression -> Bool
>= :: DIExpression -> DIExpression -> Bool
$cmax :: DIExpression -> DIExpression -> DIExpression
max :: DIExpression -> DIExpression -> DIExpression
$cmin :: DIExpression -> DIExpression -> DIExpression
min :: DIExpression -> DIExpression -> DIExpression
Ord, ReadPrec [DIExpression]
ReadPrec DIExpression
Int -> ReadS DIExpression
ReadS [DIExpression]
(Int -> ReadS DIExpression)
-> ReadS [DIExpression]
-> ReadPrec DIExpression
-> ReadPrec [DIExpression]
-> Read DIExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIExpression
readsPrec :: Int -> ReadS DIExpression
$creadList :: ReadS [DIExpression]
readList :: ReadS [DIExpression]
$creadPrec :: ReadPrec DIExpression
readPrec :: ReadPrec DIExpression
$creadListPrec :: ReadPrec [DIExpression]
readListPrec :: ReadPrec [DIExpression]
Read, Int -> DIExpression -> ShowS
[DIExpression] -> ShowS
DIExpression -> String
(Int -> DIExpression -> ShowS)
-> (DIExpression -> String)
-> ([DIExpression] -> ShowS)
-> Show DIExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIExpression -> ShowS
showsPrec :: Int -> DIExpression -> ShowS
$cshow :: DIExpression -> String
show :: DIExpression -> String
$cshowList :: [DIExpression] -> ShowS
showList :: [DIExpression] -> ShowS
Show, Typeable, Typeable DIExpression
Typeable DIExpression
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIExpression -> c DIExpression)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIExpression)
-> (DIExpression -> Constr)
-> (DIExpression -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIExpression))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIExpression))
-> ((forall b. Data b => b -> b) -> DIExpression -> DIExpression)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIExpression -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIExpression -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIExpression -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIExpression -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIExpression -> m DIExpression)
-> Data DIExpression
DIExpression -> Constr
DIExpression -> DataType
(forall b. Data b => b -> b) -> DIExpression -> DIExpression
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) -> DIExpression -> u
forall u. (forall d. Data d => d -> u) -> DIExpression -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIExpression)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIExpression -> c DIExpression
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIExpression
$ctoConstr :: DIExpression -> Constr
toConstr :: DIExpression -> Constr
$cdataTypeOf :: DIExpression -> DataType
dataTypeOf :: DIExpression -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIExpression)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIExpression)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIExpression)
$cgmapT :: (forall b. Data b => b -> b) -> DIExpression -> DIExpression
gmapT :: (forall b. Data b => b -> b) -> DIExpression -> DIExpression
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIExpression -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIExpression -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIExpression -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIExpression -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIExpression -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIExpression -> m DIExpression
Data, (forall x. DIExpression -> Rep DIExpression x)
-> (forall x. Rep DIExpression x -> DIExpression)
-> Generic DIExpression
forall x. Rep DIExpression x -> DIExpression
forall x. DIExpression -> Rep DIExpression x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIExpression -> Rep DIExpression x
from :: forall x. DIExpression -> Rep DIExpression x
$cto :: forall x. Rep DIExpression x -> DIExpression
to :: forall x. Rep DIExpression x -> DIExpression
Generic)

-- | A pair of a `DIGlobalVariable` and a `DIExpression`.
--
-- This is used in the `cuGlobals` fields of `DICompileUnit`.
data DIGlobalVariableExpression = GlobalVariableExpression
  { DIGlobalVariableExpression -> MDRef DIGlobalVariable
var :: MDRef DIGlobalVariable
  , DIGlobalVariableExpression -> MDRef DIExpression
expr :: MDRef DIExpression
  } deriving (DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
(DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> Eq DIGlobalVariableExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
== :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c/= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
/= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
Eq, Eq DIGlobalVariableExpression
Eq DIGlobalVariableExpression
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Ordering)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> Bool)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> DIGlobalVariableExpression)
-> (DIGlobalVariableExpression
    -> DIGlobalVariableExpression -> DIGlobalVariableExpression)
-> Ord DIGlobalVariableExpression
DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
DIGlobalVariableExpression
-> DIGlobalVariableExpression -> Ordering
DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
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
$ccompare :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> Ordering
compare :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> Ordering
$c< :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
< :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c<= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
<= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c> :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
> :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$c>= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
>= :: DIGlobalVariableExpression -> DIGlobalVariableExpression -> Bool
$cmax :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
max :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
$cmin :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
min :: DIGlobalVariableExpression
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
Ord, ReadPrec [DIGlobalVariableExpression]
ReadPrec DIGlobalVariableExpression
Int -> ReadS DIGlobalVariableExpression
ReadS [DIGlobalVariableExpression]
(Int -> ReadS DIGlobalVariableExpression)
-> ReadS [DIGlobalVariableExpression]
-> ReadPrec DIGlobalVariableExpression
-> ReadPrec [DIGlobalVariableExpression]
-> Read DIGlobalVariableExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIGlobalVariableExpression
readsPrec :: Int -> ReadS DIGlobalVariableExpression
$creadList :: ReadS [DIGlobalVariableExpression]
readList :: ReadS [DIGlobalVariableExpression]
$creadPrec :: ReadPrec DIGlobalVariableExpression
readPrec :: ReadPrec DIGlobalVariableExpression
$creadListPrec :: ReadPrec [DIGlobalVariableExpression]
readListPrec :: ReadPrec [DIGlobalVariableExpression]
Read, Int -> DIGlobalVariableExpression -> ShowS
[DIGlobalVariableExpression] -> ShowS
DIGlobalVariableExpression -> String
(Int -> DIGlobalVariableExpression -> ShowS)
-> (DIGlobalVariableExpression -> String)
-> ([DIGlobalVariableExpression] -> ShowS)
-> Show DIGlobalVariableExpression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIGlobalVariableExpression -> ShowS
showsPrec :: Int -> DIGlobalVariableExpression -> ShowS
$cshow :: DIGlobalVariableExpression -> String
show :: DIGlobalVariableExpression -> String
$cshowList :: [DIGlobalVariableExpression] -> ShowS
showList :: [DIGlobalVariableExpression] -> ShowS
Show, Typeable, Typeable DIGlobalVariableExpression
Typeable DIGlobalVariableExpression
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> DIGlobalVariableExpression
    -> c DIGlobalVariableExpression)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression)
-> (DIGlobalVariableExpression -> Constr)
-> (DIGlobalVariableExpression -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c DIGlobalVariableExpression))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIGlobalVariableExpression))
-> ((forall b. Data b => b -> b)
    -> DIGlobalVariableExpression -> DIGlobalVariableExpression)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIGlobalVariableExpression
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> DIGlobalVariableExpression
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression -> m DIGlobalVariableExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression -> m DIGlobalVariableExpression)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariableExpression -> m DIGlobalVariableExpression)
-> Data DIGlobalVariableExpression
DIGlobalVariableExpression -> Constr
DIGlobalVariableExpression -> DataType
(forall b. Data b => b -> b)
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
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) -> DIGlobalVariableExpression -> u
forall u.
(forall d. Data d => d -> u) -> DIGlobalVariableExpression -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression
-> c DIGlobalVariableExpression
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c DIGlobalVariableExpression)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariableExpression)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression
-> c DIGlobalVariableExpression
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DIGlobalVariableExpression
-> c DIGlobalVariableExpression
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariableExpression
$ctoConstr :: DIGlobalVariableExpression -> Constr
toConstr :: DIGlobalVariableExpression -> Constr
$cdataTypeOf :: DIGlobalVariableExpression -> DataType
dataTypeOf :: DIGlobalVariableExpression -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c DIGlobalVariableExpression)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c DIGlobalVariableExpression)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariableExpression)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariableExpression)
$cgmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
gmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariableExpression -> DIGlobalVariableExpression
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> DIGlobalVariableExpression
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> DIGlobalVariableExpression -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DIGlobalVariableExpression -> [u]
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> DIGlobalVariableExpression -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariableExpression -> m DIGlobalVariableExpression
Data, (forall x.
 DIGlobalVariableExpression -> Rep DIGlobalVariableExpression x)
-> (forall x.
    Rep DIGlobalVariableExpression x -> DIGlobalVariableExpression)
-> Generic DIGlobalVariableExpression
forall x.
Rep DIGlobalVariableExpression x -> DIGlobalVariableExpression
forall x.
DIGlobalVariableExpression -> Rep DIGlobalVariableExpression x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
DIGlobalVariableExpression -> Rep DIGlobalVariableExpression x
from :: forall x.
DIGlobalVariableExpression -> Rep DIGlobalVariableExpression x
$cto :: forall x.
Rep DIGlobalVariableExpression x -> DIGlobalVariableExpression
to :: forall x.
Rep DIGlobalVariableExpression x -> DIGlobalVariableExpression
Generic)

-- | Accessiblity flag
data DIAccessibility
  = Private
  | Protected
  | Public
  deriving (DIAccessibility -> DIAccessibility -> Bool
(DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> Eq DIAccessibility
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIAccessibility -> DIAccessibility -> Bool
== :: DIAccessibility -> DIAccessibility -> Bool
$c/= :: DIAccessibility -> DIAccessibility -> Bool
/= :: DIAccessibility -> DIAccessibility -> Bool
Eq, Eq DIAccessibility
Eq DIAccessibility
-> (DIAccessibility -> DIAccessibility -> Ordering)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> Bool)
-> (DIAccessibility -> DIAccessibility -> DIAccessibility)
-> (DIAccessibility -> DIAccessibility -> DIAccessibility)
-> Ord DIAccessibility
DIAccessibility -> DIAccessibility -> Bool
DIAccessibility -> DIAccessibility -> Ordering
DIAccessibility -> DIAccessibility -> DIAccessibility
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
$ccompare :: DIAccessibility -> DIAccessibility -> Ordering
compare :: DIAccessibility -> DIAccessibility -> Ordering
$c< :: DIAccessibility -> DIAccessibility -> Bool
< :: DIAccessibility -> DIAccessibility -> Bool
$c<= :: DIAccessibility -> DIAccessibility -> Bool
<= :: DIAccessibility -> DIAccessibility -> Bool
$c> :: DIAccessibility -> DIAccessibility -> Bool
> :: DIAccessibility -> DIAccessibility -> Bool
$c>= :: DIAccessibility -> DIAccessibility -> Bool
>= :: DIAccessibility -> DIAccessibility -> Bool
$cmax :: DIAccessibility -> DIAccessibility -> DIAccessibility
max :: DIAccessibility -> DIAccessibility -> DIAccessibility
$cmin :: DIAccessibility -> DIAccessibility -> DIAccessibility
min :: DIAccessibility -> DIAccessibility -> DIAccessibility
Ord, ReadPrec [DIAccessibility]
ReadPrec DIAccessibility
Int -> ReadS DIAccessibility
ReadS [DIAccessibility]
(Int -> ReadS DIAccessibility)
-> ReadS [DIAccessibility]
-> ReadPrec DIAccessibility
-> ReadPrec [DIAccessibility]
-> Read DIAccessibility
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIAccessibility
readsPrec :: Int -> ReadS DIAccessibility
$creadList :: ReadS [DIAccessibility]
readList :: ReadS [DIAccessibility]
$creadPrec :: ReadPrec DIAccessibility
readPrec :: ReadPrec DIAccessibility
$creadListPrec :: ReadPrec [DIAccessibility]
readListPrec :: ReadPrec [DIAccessibility]
Read, Int -> DIAccessibility -> ShowS
[DIAccessibility] -> ShowS
DIAccessibility -> String
(Int -> DIAccessibility -> ShowS)
-> (DIAccessibility -> String)
-> ([DIAccessibility] -> ShowS)
-> Show DIAccessibility
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIAccessibility -> ShowS
showsPrec :: Int -> DIAccessibility -> ShowS
$cshow :: DIAccessibility -> String
show :: DIAccessibility -> String
$cshowList :: [DIAccessibility] -> ShowS
showList :: [DIAccessibility] -> ShowS
Show, Typeable, Typeable DIAccessibility
Typeable DIAccessibility
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIAccessibility)
-> (DIAccessibility -> Constr)
-> (DIAccessibility -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIAccessibility))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIAccessibility))
-> ((forall b. Data b => b -> b)
    -> DIAccessibility -> DIAccessibility)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIAccessibility -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIAccessibility -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIAccessibility -> m DIAccessibility)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIAccessibility -> m DIAccessibility)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIAccessibility -> m DIAccessibility)
-> Data DIAccessibility
DIAccessibility -> Constr
DIAccessibility -> DataType
(forall b. Data b => b -> b) -> DIAccessibility -> DIAccessibility
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) -> DIAccessibility -> u
forall u. (forall d. Data d => d -> u) -> DIAccessibility -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIAccessibility
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIAccessibility)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIAccessibility)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIAccessibility -> c DIAccessibility
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIAccessibility
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIAccessibility
$ctoConstr :: DIAccessibility -> Constr
toConstr :: DIAccessibility -> Constr
$cdataTypeOf :: DIAccessibility -> DataType
dataTypeOf :: DIAccessibility -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIAccessibility)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIAccessibility)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIAccessibility)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIAccessibility)
$cgmapT :: (forall b. Data b => b -> b) -> DIAccessibility -> DIAccessibility
gmapT :: (forall b. Data b => b -> b) -> DIAccessibility -> DIAccessibility
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIAccessibility -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIAccessibility -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIAccessibility -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIAccessibility -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIAccessibility -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIAccessibility -> m DIAccessibility
Data, (forall x. DIAccessibility -> Rep DIAccessibility x)
-> (forall x. Rep DIAccessibility x -> DIAccessibility)
-> Generic DIAccessibility
forall x. Rep DIAccessibility x -> DIAccessibility
forall x. DIAccessibility -> Rep DIAccessibility x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIAccessibility -> Rep DIAccessibility x
from :: forall x. DIAccessibility -> Rep DIAccessibility x
$cto :: forall x. Rep DIAccessibility x -> DIAccessibility
to :: forall x. Rep DIAccessibility x -> DIAccessibility
Generic)

-- | Inheritance flag
data DIInheritance
  = SingleInheritance
  | MultipleInheritance
  | VirtualInheritance
  deriving (DIInheritance -> DIInheritance -> Bool
(DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> Bool) -> Eq DIInheritance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIInheritance -> DIInheritance -> Bool
== :: DIInheritance -> DIInheritance -> Bool
$c/= :: DIInheritance -> DIInheritance -> Bool
/= :: DIInheritance -> DIInheritance -> Bool
Eq, Eq DIInheritance
Eq DIInheritance
-> (DIInheritance -> DIInheritance -> Ordering)
-> (DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> Bool)
-> (DIInheritance -> DIInheritance -> DIInheritance)
-> (DIInheritance -> DIInheritance -> DIInheritance)
-> Ord DIInheritance
DIInheritance -> DIInheritance -> Bool
DIInheritance -> DIInheritance -> Ordering
DIInheritance -> DIInheritance -> DIInheritance
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
$ccompare :: DIInheritance -> DIInheritance -> Ordering
compare :: DIInheritance -> DIInheritance -> Ordering
$c< :: DIInheritance -> DIInheritance -> Bool
< :: DIInheritance -> DIInheritance -> Bool
$c<= :: DIInheritance -> DIInheritance -> Bool
<= :: DIInheritance -> DIInheritance -> Bool
$c> :: DIInheritance -> DIInheritance -> Bool
> :: DIInheritance -> DIInheritance -> Bool
$c>= :: DIInheritance -> DIInheritance -> Bool
>= :: DIInheritance -> DIInheritance -> Bool
$cmax :: DIInheritance -> DIInheritance -> DIInheritance
max :: DIInheritance -> DIInheritance -> DIInheritance
$cmin :: DIInheritance -> DIInheritance -> DIInheritance
min :: DIInheritance -> DIInheritance -> DIInheritance
Ord, ReadPrec [DIInheritance]
ReadPrec DIInheritance
Int -> ReadS DIInheritance
ReadS [DIInheritance]
(Int -> ReadS DIInheritance)
-> ReadS [DIInheritance]
-> ReadPrec DIInheritance
-> ReadPrec [DIInheritance]
-> Read DIInheritance
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIInheritance
readsPrec :: Int -> ReadS DIInheritance
$creadList :: ReadS [DIInheritance]
readList :: ReadS [DIInheritance]
$creadPrec :: ReadPrec DIInheritance
readPrec :: ReadPrec DIInheritance
$creadListPrec :: ReadPrec [DIInheritance]
readListPrec :: ReadPrec [DIInheritance]
Read, Int -> DIInheritance -> ShowS
[DIInheritance] -> ShowS
DIInheritance -> String
(Int -> DIInheritance -> ShowS)
-> (DIInheritance -> String)
-> ([DIInheritance] -> ShowS)
-> Show DIInheritance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIInheritance -> ShowS
showsPrec :: Int -> DIInheritance -> ShowS
$cshow :: DIInheritance -> String
show :: DIInheritance -> String
$cshowList :: [DIInheritance] -> ShowS
showList :: [DIInheritance] -> ShowS
Show, Typeable, Typeable DIInheritance
Typeable DIInheritance
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIInheritance -> c DIInheritance)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIInheritance)
-> (DIInheritance -> Constr)
-> (DIInheritance -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIInheritance))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIInheritance))
-> ((forall b. Data b => b -> b) -> DIInheritance -> DIInheritance)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIInheritance -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIInheritance -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIInheritance -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIInheritance -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance)
-> Data DIInheritance
DIInheritance -> Constr
DIInheritance -> DataType
(forall b. Data b => b -> b) -> DIInheritance -> DIInheritance
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) -> DIInheritance -> u
forall u. (forall d. Data d => d -> u) -> DIInheritance -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIInheritance
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIInheritance -> c DIInheritance
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIInheritance)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIInheritance)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIInheritance -> c DIInheritance
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIInheritance -> c DIInheritance
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIInheritance
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIInheritance
$ctoConstr :: DIInheritance -> Constr
toConstr :: DIInheritance -> Constr
$cdataTypeOf :: DIInheritance -> DataType
dataTypeOf :: DIInheritance -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIInheritance)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIInheritance)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIInheritance)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIInheritance)
$cgmapT :: (forall b. Data b => b -> b) -> DIInheritance -> DIInheritance
gmapT :: (forall b. Data b => b -> b) -> DIInheritance -> DIInheritance
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIInheritance -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIInheritance -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIInheritance -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIInheritance -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIInheritance -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIInheritance -> m DIInheritance
Data, (forall x. DIInheritance -> Rep DIInheritance x)
-> (forall x. Rep DIInheritance x -> DIInheritance)
-> Generic DIInheritance
forall x. Rep DIInheritance x -> DIInheritance
forall x. DIInheritance -> Rep DIInheritance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIInheritance -> Rep DIInheritance x
from :: forall x. DIInheritance -> Rep DIInheritance x
$cto :: forall x. Rep DIInheritance x -> DIInheritance
to :: forall x. Rep DIInheritance x -> DIInheritance
Generic)

data DIFlag
  = Accessibility DIAccessibility
  | FwdDecl
  | AppleBlock
  | ReservedBit4 -- Used to be BlockByRef, can be reused for anything except DICompositeType.
  | VirtualFlag
  | Artificial
  | Explicit
  | Prototyped
  | ObjcClassComplete
  | ObjectPointer
  | Vector
  | StaticMember
  | LValueReference
  | RValueReference
  | InheritanceFlag DIInheritance
  | IntroducedVirtual
  | BitField
  | NoReturn
  | TypePassByValue
  | TypePassByReference
  | EnumClass
  | Thunk
  | NonTrivial
  | BigEndian
  | LittleEndian
  | AllCallsDescribed
  deriving (DIFlag -> DIFlag -> Bool
(DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> Bool) -> Eq DIFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIFlag -> DIFlag -> Bool
== :: DIFlag -> DIFlag -> Bool
$c/= :: DIFlag -> DIFlag -> Bool
/= :: DIFlag -> DIFlag -> Bool
Eq, Eq DIFlag
Eq DIFlag
-> (DIFlag -> DIFlag -> Ordering)
-> (DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> Bool)
-> (DIFlag -> DIFlag -> DIFlag)
-> (DIFlag -> DIFlag -> DIFlag)
-> Ord DIFlag
DIFlag -> DIFlag -> Bool
DIFlag -> DIFlag -> Ordering
DIFlag -> DIFlag -> DIFlag
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
$ccompare :: DIFlag -> DIFlag -> Ordering
compare :: DIFlag -> DIFlag -> Ordering
$c< :: DIFlag -> DIFlag -> Bool
< :: DIFlag -> DIFlag -> Bool
$c<= :: DIFlag -> DIFlag -> Bool
<= :: DIFlag -> DIFlag -> Bool
$c> :: DIFlag -> DIFlag -> Bool
> :: DIFlag -> DIFlag -> Bool
$c>= :: DIFlag -> DIFlag -> Bool
>= :: DIFlag -> DIFlag -> Bool
$cmax :: DIFlag -> DIFlag -> DIFlag
max :: DIFlag -> DIFlag -> DIFlag
$cmin :: DIFlag -> DIFlag -> DIFlag
min :: DIFlag -> DIFlag -> DIFlag
Ord, ReadPrec [DIFlag]
ReadPrec DIFlag
Int -> ReadS DIFlag
ReadS [DIFlag]
(Int -> ReadS DIFlag)
-> ReadS [DIFlag]
-> ReadPrec DIFlag
-> ReadPrec [DIFlag]
-> Read DIFlag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIFlag
readsPrec :: Int -> ReadS DIFlag
$creadList :: ReadS [DIFlag]
readList :: ReadS [DIFlag]
$creadPrec :: ReadPrec DIFlag
readPrec :: ReadPrec DIFlag
$creadListPrec :: ReadPrec [DIFlag]
readListPrec :: ReadPrec [DIFlag]
Read, Int -> DIFlag -> ShowS
[DIFlag] -> ShowS
DIFlag -> String
(Int -> DIFlag -> ShowS)
-> (DIFlag -> String) -> ([DIFlag] -> ShowS) -> Show DIFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIFlag -> ShowS
showsPrec :: Int -> DIFlag -> ShowS
$cshow :: DIFlag -> String
show :: DIFlag -> String
$cshowList :: [DIFlag] -> ShowS
showList :: [DIFlag] -> ShowS
Show, Typeable, Typeable DIFlag
Typeable DIFlag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIFlag -> c DIFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIFlag)
-> (DIFlag -> Constr)
-> (DIFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFlag))
-> ((forall b. Data b => b -> b) -> DIFlag -> DIFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIFlag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFlag -> m DIFlag)
-> Data DIFlag
DIFlag -> Constr
DIFlag -> DataType
(forall b. Data b => b -> b) -> DIFlag -> DIFlag
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) -> DIFlag -> u
forall u. (forall d. Data d => d -> u) -> DIFlag -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFlag -> c DIFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFlag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFlag -> c DIFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFlag -> c DIFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFlag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFlag
$ctoConstr :: DIFlag -> Constr
toConstr :: DIFlag -> Constr
$cdataTypeOf :: DIFlag -> DataType
dataTypeOf :: DIFlag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFlag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFlag)
$cgmapT :: (forall b. Data b => b -> b) -> DIFlag -> DIFlag
gmapT :: (forall b. Data b => b -> b) -> DIFlag -> DIFlag
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFlag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIFlag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIFlag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIFlag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIFlag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFlag -> m DIFlag
Data, (forall x. DIFlag -> Rep DIFlag x)
-> (forall x. Rep DIFlag x -> DIFlag) -> Generic DIFlag
forall x. Rep DIFlag x -> DIFlag
forall x. DIFlag -> Rep DIFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIFlag -> Rep DIFlag x
from :: forall x. DIFlag -> Rep DIFlag x
$cto :: forall x. Rep DIFlag x -> DIFlag
to :: forall x. Rep DIFlag x -> DIFlag
Generic)

data DIMacroInfo = Define | Undef
  deriving (DIMacroInfo -> DIMacroInfo -> Bool
(DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> Bool) -> Eq DIMacroInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIMacroInfo -> DIMacroInfo -> Bool
== :: DIMacroInfo -> DIMacroInfo -> Bool
$c/= :: DIMacroInfo -> DIMacroInfo -> Bool
/= :: DIMacroInfo -> DIMacroInfo -> Bool
Eq, Eq DIMacroInfo
Eq DIMacroInfo
-> (DIMacroInfo -> DIMacroInfo -> Ordering)
-> (DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> Bool)
-> (DIMacroInfo -> DIMacroInfo -> DIMacroInfo)
-> (DIMacroInfo -> DIMacroInfo -> DIMacroInfo)
-> Ord DIMacroInfo
DIMacroInfo -> DIMacroInfo -> Bool
DIMacroInfo -> DIMacroInfo -> Ordering
DIMacroInfo -> DIMacroInfo -> DIMacroInfo
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
$ccompare :: DIMacroInfo -> DIMacroInfo -> Ordering
compare :: DIMacroInfo -> DIMacroInfo -> Ordering
$c< :: DIMacroInfo -> DIMacroInfo -> Bool
< :: DIMacroInfo -> DIMacroInfo -> Bool
$c<= :: DIMacroInfo -> DIMacroInfo -> Bool
<= :: DIMacroInfo -> DIMacroInfo -> Bool
$c> :: DIMacroInfo -> DIMacroInfo -> Bool
> :: DIMacroInfo -> DIMacroInfo -> Bool
$c>= :: DIMacroInfo -> DIMacroInfo -> Bool
>= :: DIMacroInfo -> DIMacroInfo -> Bool
$cmax :: DIMacroInfo -> DIMacroInfo -> DIMacroInfo
max :: DIMacroInfo -> DIMacroInfo -> DIMacroInfo
$cmin :: DIMacroInfo -> DIMacroInfo -> DIMacroInfo
min :: DIMacroInfo -> DIMacroInfo -> DIMacroInfo
Ord, ReadPrec [DIMacroInfo]
ReadPrec DIMacroInfo
Int -> ReadS DIMacroInfo
ReadS [DIMacroInfo]
(Int -> ReadS DIMacroInfo)
-> ReadS [DIMacroInfo]
-> ReadPrec DIMacroInfo
-> ReadPrec [DIMacroInfo]
-> Read DIMacroInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIMacroInfo
readsPrec :: Int -> ReadS DIMacroInfo
$creadList :: ReadS [DIMacroInfo]
readList :: ReadS [DIMacroInfo]
$creadPrec :: ReadPrec DIMacroInfo
readPrec :: ReadPrec DIMacroInfo
$creadListPrec :: ReadPrec [DIMacroInfo]
readListPrec :: ReadPrec [DIMacroInfo]
Read, Int -> DIMacroInfo -> ShowS
[DIMacroInfo] -> ShowS
DIMacroInfo -> String
(Int -> DIMacroInfo -> ShowS)
-> (DIMacroInfo -> String)
-> ([DIMacroInfo] -> ShowS)
-> Show DIMacroInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIMacroInfo -> ShowS
showsPrec :: Int -> DIMacroInfo -> ShowS
$cshow :: DIMacroInfo -> String
show :: DIMacroInfo -> String
$cshowList :: [DIMacroInfo] -> ShowS
showList :: [DIMacroInfo] -> ShowS
Show, Typeable, Typeable DIMacroInfo
Typeable DIMacroInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIMacroInfo)
-> (DIMacroInfo -> Constr)
-> (DIMacroInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIMacroInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIMacroInfo))
-> ((forall b. Data b => b -> b) -> DIMacroInfo -> DIMacroInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIMacroInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIMacroInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo)
-> Data DIMacroInfo
DIMacroInfo -> Constr
DIMacroInfo -> DataType
(forall b. Data b => b -> b) -> DIMacroInfo -> DIMacroInfo
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) -> DIMacroInfo -> u
forall u. (forall d. Data d => d -> u) -> DIMacroInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroInfo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroInfo -> c DIMacroInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroInfo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroInfo
$ctoConstr :: DIMacroInfo -> Constr
toConstr :: DIMacroInfo -> Constr
$cdataTypeOf :: DIMacroInfo -> DataType
dataTypeOf :: DIMacroInfo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroInfo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroInfo)
$cgmapT :: (forall b. Data b => b -> b) -> DIMacroInfo -> DIMacroInfo
gmapT :: (forall b. Data b => b -> b) -> DIMacroInfo -> DIMacroInfo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroInfo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIMacroInfo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIMacroInfo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIMacroInfo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIMacroInfo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroInfo -> m DIMacroInfo
Data, (forall x. DIMacroInfo -> Rep DIMacroInfo x)
-> (forall x. Rep DIMacroInfo x -> DIMacroInfo)
-> Generic DIMacroInfo
forall x. Rep DIMacroInfo x -> DIMacroInfo
forall x. DIMacroInfo -> Rep DIMacroInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIMacroInfo -> Rep DIMacroInfo x
from :: forall x. DIMacroInfo -> Rep DIMacroInfo x
$cto :: forall x. Rep DIMacroInfo x -> DIMacroInfo
to :: forall x. Rep DIMacroInfo x -> DIMacroInfo
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIMacroNode.html>
data DIMacroNode
  -- | <https://llvm.org/docs/LangRef.html#dimacro>
  = DIMacro
    { DIMacroNode -> DIMacroInfo
info :: DIMacroInfo
    , DIMacroNode -> Word32
line :: Word32
    , DIMacroNode -> ShortByteString
name :: ShortByteString
    , DIMacroNode -> ShortByteString
value :: ShortByteString
    }
  -- | <https://llvm.org/docs/LangRef.html#dimacrofile>
  | DIMacroFile
    { line :: Word32
    , DIMacroNode -> MDRef DIFile
file :: MDRef DIFile
    , DIMacroNode -> [MDRef DIMacroNode]
elements :: [MDRef DIMacroNode]
    }
  deriving (DIMacroNode -> DIMacroNode -> Bool
(DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> Bool) -> Eq DIMacroNode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIMacroNode -> DIMacroNode -> Bool
== :: DIMacroNode -> DIMacroNode -> Bool
$c/= :: DIMacroNode -> DIMacroNode -> Bool
/= :: DIMacroNode -> DIMacroNode -> Bool
Eq, Eq DIMacroNode
Eq DIMacroNode
-> (DIMacroNode -> DIMacroNode -> Ordering)
-> (DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> Bool)
-> (DIMacroNode -> DIMacroNode -> DIMacroNode)
-> (DIMacroNode -> DIMacroNode -> DIMacroNode)
-> Ord DIMacroNode
DIMacroNode -> DIMacroNode -> Bool
DIMacroNode -> DIMacroNode -> Ordering
DIMacroNode -> DIMacroNode -> DIMacroNode
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
$ccompare :: DIMacroNode -> DIMacroNode -> Ordering
compare :: DIMacroNode -> DIMacroNode -> Ordering
$c< :: DIMacroNode -> DIMacroNode -> Bool
< :: DIMacroNode -> DIMacroNode -> Bool
$c<= :: DIMacroNode -> DIMacroNode -> Bool
<= :: DIMacroNode -> DIMacroNode -> Bool
$c> :: DIMacroNode -> DIMacroNode -> Bool
> :: DIMacroNode -> DIMacroNode -> Bool
$c>= :: DIMacroNode -> DIMacroNode -> Bool
>= :: DIMacroNode -> DIMacroNode -> Bool
$cmax :: DIMacroNode -> DIMacroNode -> DIMacroNode
max :: DIMacroNode -> DIMacroNode -> DIMacroNode
$cmin :: DIMacroNode -> DIMacroNode -> DIMacroNode
min :: DIMacroNode -> DIMacroNode -> DIMacroNode
Ord, ReadPrec [DIMacroNode]
ReadPrec DIMacroNode
Int -> ReadS DIMacroNode
ReadS [DIMacroNode]
(Int -> ReadS DIMacroNode)
-> ReadS [DIMacroNode]
-> ReadPrec DIMacroNode
-> ReadPrec [DIMacroNode]
-> Read DIMacroNode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIMacroNode
readsPrec :: Int -> ReadS DIMacroNode
$creadList :: ReadS [DIMacroNode]
readList :: ReadS [DIMacroNode]
$creadPrec :: ReadPrec DIMacroNode
readPrec :: ReadPrec DIMacroNode
$creadListPrec :: ReadPrec [DIMacroNode]
readListPrec :: ReadPrec [DIMacroNode]
Read, Int -> DIMacroNode -> ShowS
[DIMacroNode] -> ShowS
DIMacroNode -> String
(Int -> DIMacroNode -> ShowS)
-> (DIMacroNode -> String)
-> ([DIMacroNode] -> ShowS)
-> Show DIMacroNode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIMacroNode -> ShowS
showsPrec :: Int -> DIMacroNode -> ShowS
$cshow :: DIMacroNode -> String
show :: DIMacroNode -> String
$cshowList :: [DIMacroNode] -> ShowS
showList :: [DIMacroNode] -> ShowS
Show, Typeable, Typeable DIMacroNode
Typeable DIMacroNode
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIMacroNode)
-> (DIMacroNode -> Constr)
-> (DIMacroNode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIMacroNode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIMacroNode))
-> ((forall b. Data b => b -> b) -> DIMacroNode -> DIMacroNode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIMacroNode -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIMacroNode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode)
-> Data DIMacroNode
DIMacroNode -> Constr
DIMacroNode -> DataType
(forall b. Data b => b -> b) -> DIMacroNode -> DIMacroNode
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) -> DIMacroNode -> u
forall u. (forall d. Data d => d -> u) -> DIMacroNode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroNode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroNode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroNode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIMacroNode -> c DIMacroNode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroNode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIMacroNode
$ctoConstr :: DIMacroNode -> Constr
toConstr :: DIMacroNode -> Constr
$cdataTypeOf :: DIMacroNode -> DataType
dataTypeOf :: DIMacroNode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroNode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIMacroNode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroNode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIMacroNode)
$cgmapT :: (forall b. Data b => b -> b) -> DIMacroNode -> DIMacroNode
gmapT :: (forall b. Data b => b -> b) -> DIMacroNode -> DIMacroNode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIMacroNode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIMacroNode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIMacroNode -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIMacroNode -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIMacroNode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIMacroNode -> m DIMacroNode
Data, (forall x. DIMacroNode -> Rep DIMacroNode x)
-> (forall x. Rep DIMacroNode x -> DIMacroNode)
-> Generic DIMacroNode
forall x. Rep DIMacroNode x -> DIMacroNode
forall x. DIMacroNode -> Rep DIMacroNode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIMacroNode -> Rep DIMacroNode x
from :: forall x. DIMacroNode -> Rep DIMacroNode x
$cto :: forall x. Rep DIMacroNode x -> DIMacroNode
to :: forall x. Rep DIMacroNode x -> DIMacroNode
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DINode.html>
data DINode
  = DIEnumerator DIEnumerator
  | DIImportedEntity DIImportedEntity
  | DIObjCProperty DIObjCProperty
  | DIScope DIScope
  | DISubrange DISubrange
  | DITemplateParameter DITemplateParameter
  | DIVariable DIVariable
  deriving (DINode -> DINode -> Bool
(DINode -> DINode -> Bool)
-> (DINode -> DINode -> Bool) -> Eq DINode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DINode -> DINode -> Bool
== :: DINode -> DINode -> Bool
$c/= :: DINode -> DINode -> Bool
/= :: DINode -> DINode -> Bool
Eq, Eq DINode
Eq DINode
-> (DINode -> DINode -> Ordering)
-> (DINode -> DINode -> Bool)
-> (DINode -> DINode -> Bool)
-> (DINode -> DINode -> Bool)
-> (DINode -> DINode -> Bool)
-> (DINode -> DINode -> DINode)
-> (DINode -> DINode -> DINode)
-> Ord DINode
DINode -> DINode -> Bool
DINode -> DINode -> Ordering
DINode -> DINode -> DINode
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
$ccompare :: DINode -> DINode -> Ordering
compare :: DINode -> DINode -> Ordering
$c< :: DINode -> DINode -> Bool
< :: DINode -> DINode -> Bool
$c<= :: DINode -> DINode -> Bool
<= :: DINode -> DINode -> Bool
$c> :: DINode -> DINode -> Bool
> :: DINode -> DINode -> Bool
$c>= :: DINode -> DINode -> Bool
>= :: DINode -> DINode -> Bool
$cmax :: DINode -> DINode -> DINode
max :: DINode -> DINode -> DINode
$cmin :: DINode -> DINode -> DINode
min :: DINode -> DINode -> DINode
Ord, ReadPrec [DINode]
ReadPrec DINode
Int -> ReadS DINode
ReadS [DINode]
(Int -> ReadS DINode)
-> ReadS [DINode]
-> ReadPrec DINode
-> ReadPrec [DINode]
-> Read DINode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DINode
readsPrec :: Int -> ReadS DINode
$creadList :: ReadS [DINode]
readList :: ReadS [DINode]
$creadPrec :: ReadPrec DINode
readPrec :: ReadPrec DINode
$creadListPrec :: ReadPrec [DINode]
readListPrec :: ReadPrec [DINode]
Read, Int -> DINode -> ShowS
[DINode] -> ShowS
DINode -> String
(Int -> DINode -> ShowS)
-> (DINode -> String) -> ([DINode] -> ShowS) -> Show DINode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DINode -> ShowS
showsPrec :: Int -> DINode -> ShowS
$cshow :: DINode -> String
show :: DINode -> String
$cshowList :: [DINode] -> ShowS
showList :: [DINode] -> ShowS
Show, Typeable, Typeable DINode
Typeable DINode
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DINode -> c DINode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DINode)
-> (DINode -> Constr)
-> (DINode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DINode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DINode))
-> ((forall b. Data b => b -> b) -> DINode -> DINode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DINode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DINode -> r)
-> (forall u. (forall d. Data d => d -> u) -> DINode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DINode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DINode -> m DINode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DINode -> m DINode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DINode -> m DINode)
-> Data DINode
DINode -> Constr
DINode -> DataType
(forall b. Data b => b -> b) -> DINode -> DINode
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) -> DINode -> u
forall u. (forall d. Data d => d -> u) -> DINode -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINode -> c DINode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DINode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINode -> c DINode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINode -> c DINode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINode
$ctoConstr :: DINode -> Constr
toConstr :: DINode -> Constr
$cdataTypeOf :: DINode -> DataType
dataTypeOf :: DINode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DINode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DINode)
$cgmapT :: (forall b. Data b => b -> b) -> DINode -> DINode
gmapT :: (forall b. Data b => b -> b) -> DINode -> DINode
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DINode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DINode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DINode -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DINode -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DINode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINode -> m DINode
Data, (forall x. DINode -> Rep DINode x)
-> (forall x. Rep DINode x -> DINode) -> Generic DINode
forall x. Rep DINode x -> DINode
forall x. DINode -> Rep DINode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DINode -> Rep DINode x
from :: forall x. DINode -> Rep DINode x
$cto :: forall x. Rep DINode x -> DINode
to :: forall x. Rep DINode x -> DINode
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIObjCProperty.html>
data DIObjCProperty = ObjCProperty
  { DIObjCProperty -> ShortByteString
name :: ShortByteString
  , DIObjCProperty -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DIObjCProperty -> Word32
line :: Word32
  , DIObjCProperty -> ShortByteString
getterName :: ShortByteString
  , DIObjCProperty -> ShortByteString
setterName :: ShortByteString
  , DIObjCProperty -> Word32
attributes :: Word32
  , DIObjCProperty -> Maybe (MDRef DIType)
type' :: Maybe (MDRef DIType)
  } deriving (DIObjCProperty -> DIObjCProperty -> Bool
(DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> Bool) -> Eq DIObjCProperty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIObjCProperty -> DIObjCProperty -> Bool
== :: DIObjCProperty -> DIObjCProperty -> Bool
$c/= :: DIObjCProperty -> DIObjCProperty -> Bool
/= :: DIObjCProperty -> DIObjCProperty -> Bool
Eq, Eq DIObjCProperty
Eq DIObjCProperty
-> (DIObjCProperty -> DIObjCProperty -> Ordering)
-> (DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> Bool)
-> (DIObjCProperty -> DIObjCProperty -> DIObjCProperty)
-> (DIObjCProperty -> DIObjCProperty -> DIObjCProperty)
-> Ord DIObjCProperty
DIObjCProperty -> DIObjCProperty -> Bool
DIObjCProperty -> DIObjCProperty -> Ordering
DIObjCProperty -> DIObjCProperty -> DIObjCProperty
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
$ccompare :: DIObjCProperty -> DIObjCProperty -> Ordering
compare :: DIObjCProperty -> DIObjCProperty -> Ordering
$c< :: DIObjCProperty -> DIObjCProperty -> Bool
< :: DIObjCProperty -> DIObjCProperty -> Bool
$c<= :: DIObjCProperty -> DIObjCProperty -> Bool
<= :: DIObjCProperty -> DIObjCProperty -> Bool
$c> :: DIObjCProperty -> DIObjCProperty -> Bool
> :: DIObjCProperty -> DIObjCProperty -> Bool
$c>= :: DIObjCProperty -> DIObjCProperty -> Bool
>= :: DIObjCProperty -> DIObjCProperty -> Bool
$cmax :: DIObjCProperty -> DIObjCProperty -> DIObjCProperty
max :: DIObjCProperty -> DIObjCProperty -> DIObjCProperty
$cmin :: DIObjCProperty -> DIObjCProperty -> DIObjCProperty
min :: DIObjCProperty -> DIObjCProperty -> DIObjCProperty
Ord, ReadPrec [DIObjCProperty]
ReadPrec DIObjCProperty
Int -> ReadS DIObjCProperty
ReadS [DIObjCProperty]
(Int -> ReadS DIObjCProperty)
-> ReadS [DIObjCProperty]
-> ReadPrec DIObjCProperty
-> ReadPrec [DIObjCProperty]
-> Read DIObjCProperty
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIObjCProperty
readsPrec :: Int -> ReadS DIObjCProperty
$creadList :: ReadS [DIObjCProperty]
readList :: ReadS [DIObjCProperty]
$creadPrec :: ReadPrec DIObjCProperty
readPrec :: ReadPrec DIObjCProperty
$creadListPrec :: ReadPrec [DIObjCProperty]
readListPrec :: ReadPrec [DIObjCProperty]
Read, Int -> DIObjCProperty -> ShowS
[DIObjCProperty] -> ShowS
DIObjCProperty -> String
(Int -> DIObjCProperty -> ShowS)
-> (DIObjCProperty -> String)
-> ([DIObjCProperty] -> ShowS)
-> Show DIObjCProperty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIObjCProperty -> ShowS
showsPrec :: Int -> DIObjCProperty -> ShowS
$cshow :: DIObjCProperty -> String
show :: DIObjCProperty -> String
$cshowList :: [DIObjCProperty] -> ShowS
showList :: [DIObjCProperty] -> ShowS
Show, Typeable, Typeable DIObjCProperty
Typeable DIObjCProperty
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIObjCProperty)
-> (DIObjCProperty -> Constr)
-> (DIObjCProperty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIObjCProperty))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIObjCProperty))
-> ((forall b. Data b => b -> b)
    -> DIObjCProperty -> DIObjCProperty)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIObjCProperty -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIObjCProperty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIObjCProperty -> m DIObjCProperty)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIObjCProperty -> m DIObjCProperty)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIObjCProperty -> m DIObjCProperty)
-> Data DIObjCProperty
DIObjCProperty -> Constr
DIObjCProperty -> DataType
(forall b. Data b => b -> b) -> DIObjCProperty -> DIObjCProperty
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) -> DIObjCProperty -> u
forall u. (forall d. Data d => d -> u) -> DIObjCProperty -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIObjCProperty
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIObjCProperty)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIObjCProperty)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIObjCProperty -> c DIObjCProperty
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIObjCProperty
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIObjCProperty
$ctoConstr :: DIObjCProperty -> Constr
toConstr :: DIObjCProperty -> Constr
$cdataTypeOf :: DIObjCProperty -> DataType
dataTypeOf :: DIObjCProperty -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIObjCProperty)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIObjCProperty)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIObjCProperty)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIObjCProperty)
$cgmapT :: (forall b. Data b => b -> b) -> DIObjCProperty -> DIObjCProperty
gmapT :: (forall b. Data b => b -> b) -> DIObjCProperty -> DIObjCProperty
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIObjCProperty -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIObjCProperty -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIObjCProperty -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIObjCProperty -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIObjCProperty -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIObjCProperty -> m DIObjCProperty
Data, (forall x. DIObjCProperty -> Rep DIObjCProperty x)
-> (forall x. Rep DIObjCProperty x -> DIObjCProperty)
-> Generic DIObjCProperty
forall x. Rep DIObjCProperty x -> DIObjCProperty
forall x. DIObjCProperty -> Rep DIObjCProperty x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIObjCProperty -> Rep DIObjCProperty x
from :: forall x. DIObjCProperty -> Rep DIObjCProperty x
$cto :: forall x. Rep DIObjCProperty x -> DIObjCProperty
to :: forall x. Rep DIObjCProperty x -> DIObjCProperty
Generic)

data ImportedEntityTag = ImportedModule | ImportedDeclaration
  deriving (ImportedEntityTag -> ImportedEntityTag -> Bool
(ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> Eq ImportedEntityTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImportedEntityTag -> ImportedEntityTag -> Bool
== :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c/= :: ImportedEntityTag -> ImportedEntityTag -> Bool
/= :: ImportedEntityTag -> ImportedEntityTag -> Bool
Eq, Eq ImportedEntityTag
Eq ImportedEntityTag
-> (ImportedEntityTag -> ImportedEntityTag -> Ordering)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> Bool)
-> (ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag)
-> (ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag)
-> Ord ImportedEntityTag
ImportedEntityTag -> ImportedEntityTag -> Bool
ImportedEntityTag -> ImportedEntityTag -> Ordering
ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
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
$ccompare :: ImportedEntityTag -> ImportedEntityTag -> Ordering
compare :: ImportedEntityTag -> ImportedEntityTag -> Ordering
$c< :: ImportedEntityTag -> ImportedEntityTag -> Bool
< :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c<= :: ImportedEntityTag -> ImportedEntityTag -> Bool
<= :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c> :: ImportedEntityTag -> ImportedEntityTag -> Bool
> :: ImportedEntityTag -> ImportedEntityTag -> Bool
$c>= :: ImportedEntityTag -> ImportedEntityTag -> Bool
>= :: ImportedEntityTag -> ImportedEntityTag -> Bool
$cmax :: ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
max :: ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
$cmin :: ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
min :: ImportedEntityTag -> ImportedEntityTag -> ImportedEntityTag
Ord, ReadPrec [ImportedEntityTag]
ReadPrec ImportedEntityTag
Int -> ReadS ImportedEntityTag
ReadS [ImportedEntityTag]
(Int -> ReadS ImportedEntityTag)
-> ReadS [ImportedEntityTag]
-> ReadPrec ImportedEntityTag
-> ReadPrec [ImportedEntityTag]
-> Read ImportedEntityTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ImportedEntityTag
readsPrec :: Int -> ReadS ImportedEntityTag
$creadList :: ReadS [ImportedEntityTag]
readList :: ReadS [ImportedEntityTag]
$creadPrec :: ReadPrec ImportedEntityTag
readPrec :: ReadPrec ImportedEntityTag
$creadListPrec :: ReadPrec [ImportedEntityTag]
readListPrec :: ReadPrec [ImportedEntityTag]
Read, Int -> ImportedEntityTag -> ShowS
[ImportedEntityTag] -> ShowS
ImportedEntityTag -> String
(Int -> ImportedEntityTag -> ShowS)
-> (ImportedEntityTag -> String)
-> ([ImportedEntityTag] -> ShowS)
-> Show ImportedEntityTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImportedEntityTag -> ShowS
showsPrec :: Int -> ImportedEntityTag -> ShowS
$cshow :: ImportedEntityTag -> String
show :: ImportedEntityTag -> String
$cshowList :: [ImportedEntityTag] -> ShowS
showList :: [ImportedEntityTag] -> ShowS
Show, Typeable, Typeable ImportedEntityTag
Typeable ImportedEntityTag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> ImportedEntityTag
    -> c ImportedEntityTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImportedEntityTag)
-> (ImportedEntityTag -> Constr)
-> (ImportedEntityTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImportedEntityTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ImportedEntityTag))
-> ((forall b. Data b => b -> b)
    -> ImportedEntityTag -> ImportedEntityTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ImportedEntityTag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImportedEntityTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ImportedEntityTag -> m ImportedEntityTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportedEntityTag -> m ImportedEntityTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ImportedEntityTag -> m ImportedEntityTag)
-> Data ImportedEntityTag
ImportedEntityTag -> Constr
ImportedEntityTag -> DataType
(forall b. Data b => b -> b)
-> ImportedEntityTag -> ImportedEntityTag
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) -> ImportedEntityTag -> u
forall u. (forall d. Data d => d -> u) -> ImportedEntityTag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportedEntityTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportedEntityTag -> c ImportedEntityTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportedEntityTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportedEntityTag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportedEntityTag -> c ImportedEntityTag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportedEntityTag -> c ImportedEntityTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportedEntityTag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportedEntityTag
$ctoConstr :: ImportedEntityTag -> Constr
toConstr :: ImportedEntityTag -> Constr
$cdataTypeOf :: ImportedEntityTag -> DataType
dataTypeOf :: ImportedEntityTag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportedEntityTag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportedEntityTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportedEntityTag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImportedEntityTag)
$cgmapT :: (forall b. Data b => b -> b)
-> ImportedEntityTag -> ImportedEntityTag
gmapT :: (forall b. Data b => b -> b)
-> ImportedEntityTag -> ImportedEntityTag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportedEntityTag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImportedEntityTag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportedEntityTag -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ImportedEntityTag -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ImportedEntityTag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ImportedEntityTag -> m ImportedEntityTag
Data, (forall x. ImportedEntityTag -> Rep ImportedEntityTag x)
-> (forall x. Rep ImportedEntityTag x -> ImportedEntityTag)
-> Generic ImportedEntityTag
forall x. Rep ImportedEntityTag x -> ImportedEntityTag
forall x. ImportedEntityTag -> Rep ImportedEntityTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ImportedEntityTag -> Rep ImportedEntityTag x
from :: forall x. ImportedEntityTag -> Rep ImportedEntityTag x
$cto :: forall x. Rep ImportedEntityTag x -> ImportedEntityTag
to :: forall x. Rep ImportedEntityTag x -> ImportedEntityTag
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIImportedEntity.html>
data DIImportedEntity = ImportedEntity
  { DIImportedEntity -> ImportedEntityTag
tag :: ImportedEntityTag
  , DIImportedEntity -> ShortByteString
name :: ShortByteString
  , DIImportedEntity -> MDRef DIScope
scope :: MDRef DIScope
  , DIImportedEntity -> Maybe (MDRef DINode)
entity :: Maybe (MDRef DINode)
  , DIImportedEntity -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DIImportedEntity -> Word32
line :: Word32
  } deriving (DIImportedEntity -> DIImportedEntity -> Bool
(DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> Eq DIImportedEntity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIImportedEntity -> DIImportedEntity -> Bool
== :: DIImportedEntity -> DIImportedEntity -> Bool
$c/= :: DIImportedEntity -> DIImportedEntity -> Bool
/= :: DIImportedEntity -> DIImportedEntity -> Bool
Eq, Eq DIImportedEntity
Eq DIImportedEntity
-> (DIImportedEntity -> DIImportedEntity -> Ordering)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> Bool)
-> (DIImportedEntity -> DIImportedEntity -> DIImportedEntity)
-> (DIImportedEntity -> DIImportedEntity -> DIImportedEntity)
-> Ord DIImportedEntity
DIImportedEntity -> DIImportedEntity -> Bool
DIImportedEntity -> DIImportedEntity -> Ordering
DIImportedEntity -> DIImportedEntity -> DIImportedEntity
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
$ccompare :: DIImportedEntity -> DIImportedEntity -> Ordering
compare :: DIImportedEntity -> DIImportedEntity -> Ordering
$c< :: DIImportedEntity -> DIImportedEntity -> Bool
< :: DIImportedEntity -> DIImportedEntity -> Bool
$c<= :: DIImportedEntity -> DIImportedEntity -> Bool
<= :: DIImportedEntity -> DIImportedEntity -> Bool
$c> :: DIImportedEntity -> DIImportedEntity -> Bool
> :: DIImportedEntity -> DIImportedEntity -> Bool
$c>= :: DIImportedEntity -> DIImportedEntity -> Bool
>= :: DIImportedEntity -> DIImportedEntity -> Bool
$cmax :: DIImportedEntity -> DIImportedEntity -> DIImportedEntity
max :: DIImportedEntity -> DIImportedEntity -> DIImportedEntity
$cmin :: DIImportedEntity -> DIImportedEntity -> DIImportedEntity
min :: DIImportedEntity -> DIImportedEntity -> DIImportedEntity
Ord, ReadPrec [DIImportedEntity]
ReadPrec DIImportedEntity
Int -> ReadS DIImportedEntity
ReadS [DIImportedEntity]
(Int -> ReadS DIImportedEntity)
-> ReadS [DIImportedEntity]
-> ReadPrec DIImportedEntity
-> ReadPrec [DIImportedEntity]
-> Read DIImportedEntity
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIImportedEntity
readsPrec :: Int -> ReadS DIImportedEntity
$creadList :: ReadS [DIImportedEntity]
readList :: ReadS [DIImportedEntity]
$creadPrec :: ReadPrec DIImportedEntity
readPrec :: ReadPrec DIImportedEntity
$creadListPrec :: ReadPrec [DIImportedEntity]
readListPrec :: ReadPrec [DIImportedEntity]
Read, Int -> DIImportedEntity -> ShowS
[DIImportedEntity] -> ShowS
DIImportedEntity -> String
(Int -> DIImportedEntity -> ShowS)
-> (DIImportedEntity -> String)
-> ([DIImportedEntity] -> ShowS)
-> Show DIImportedEntity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIImportedEntity -> ShowS
showsPrec :: Int -> DIImportedEntity -> ShowS
$cshow :: DIImportedEntity -> String
show :: DIImportedEntity -> String
$cshowList :: [DIImportedEntity] -> ShowS
showList :: [DIImportedEntity] -> ShowS
Show, Typeable, Typeable DIImportedEntity
Typeable DIImportedEntity
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIImportedEntity)
-> (DIImportedEntity -> Constr)
-> (DIImportedEntity -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIImportedEntity))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIImportedEntity))
-> ((forall b. Data b => b -> b)
    -> DIImportedEntity -> DIImportedEntity)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIImportedEntity -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIImportedEntity -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity -> m DIImportedEntity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity -> m DIImportedEntity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIImportedEntity -> m DIImportedEntity)
-> Data DIImportedEntity
DIImportedEntity -> Constr
DIImportedEntity -> DataType
(forall b. Data b => b -> b)
-> DIImportedEntity -> DIImportedEntity
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) -> DIImportedEntity -> u
forall u. (forall d. Data d => d -> u) -> DIImportedEntity -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIImportedEntity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIImportedEntity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIImportedEntity)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIImportedEntity -> c DIImportedEntity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIImportedEntity
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIImportedEntity
$ctoConstr :: DIImportedEntity -> Constr
toConstr :: DIImportedEntity -> Constr
$cdataTypeOf :: DIImportedEntity -> DataType
dataTypeOf :: DIImportedEntity -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIImportedEntity)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIImportedEntity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIImportedEntity)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIImportedEntity)
$cgmapT :: (forall b. Data b => b -> b)
-> DIImportedEntity -> DIImportedEntity
gmapT :: (forall b. Data b => b -> b)
-> DIImportedEntity -> DIImportedEntity
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIImportedEntity -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIImportedEntity -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIImportedEntity -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIImportedEntity -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIImportedEntity -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIImportedEntity -> m DIImportedEntity
Data, (forall x. DIImportedEntity -> Rep DIImportedEntity x)
-> (forall x. Rep DIImportedEntity x -> DIImportedEntity)
-> Generic DIImportedEntity
forall x. Rep DIImportedEntity x -> DIImportedEntity
forall x. DIImportedEntity -> Rep DIImportedEntity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIImportedEntity -> Rep DIImportedEntity x
from :: forall x. DIImportedEntity -> Rep DIImportedEntity x
$cto :: forall x. Rep DIImportedEntity x -> DIImportedEntity
to :: forall x. Rep DIImportedEntity x -> DIImportedEntity
Generic)

-- | <https://llvm.org/docs/LangRef.html#dienumerator>
data DIEnumerator =
  Enumerator { DIEnumerator -> Int64
value :: Int64, DIEnumerator -> Bool
isUnsigned :: Bool, DIEnumerator -> ShortByteString
name :: ShortByteString }
  deriving (DIEnumerator -> DIEnumerator -> Bool
(DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> Bool) -> Eq DIEnumerator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIEnumerator -> DIEnumerator -> Bool
== :: DIEnumerator -> DIEnumerator -> Bool
$c/= :: DIEnumerator -> DIEnumerator -> Bool
/= :: DIEnumerator -> DIEnumerator -> Bool
Eq, Eq DIEnumerator
Eq DIEnumerator
-> (DIEnumerator -> DIEnumerator -> Ordering)
-> (DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> Bool)
-> (DIEnumerator -> DIEnumerator -> DIEnumerator)
-> (DIEnumerator -> DIEnumerator -> DIEnumerator)
-> Ord DIEnumerator
DIEnumerator -> DIEnumerator -> Bool
DIEnumerator -> DIEnumerator -> Ordering
DIEnumerator -> DIEnumerator -> DIEnumerator
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
$ccompare :: DIEnumerator -> DIEnumerator -> Ordering
compare :: DIEnumerator -> DIEnumerator -> Ordering
$c< :: DIEnumerator -> DIEnumerator -> Bool
< :: DIEnumerator -> DIEnumerator -> Bool
$c<= :: DIEnumerator -> DIEnumerator -> Bool
<= :: DIEnumerator -> DIEnumerator -> Bool
$c> :: DIEnumerator -> DIEnumerator -> Bool
> :: DIEnumerator -> DIEnumerator -> Bool
$c>= :: DIEnumerator -> DIEnumerator -> Bool
>= :: DIEnumerator -> DIEnumerator -> Bool
$cmax :: DIEnumerator -> DIEnumerator -> DIEnumerator
max :: DIEnumerator -> DIEnumerator -> DIEnumerator
$cmin :: DIEnumerator -> DIEnumerator -> DIEnumerator
min :: DIEnumerator -> DIEnumerator -> DIEnumerator
Ord, ReadPrec [DIEnumerator]
ReadPrec DIEnumerator
Int -> ReadS DIEnumerator
ReadS [DIEnumerator]
(Int -> ReadS DIEnumerator)
-> ReadS [DIEnumerator]
-> ReadPrec DIEnumerator
-> ReadPrec [DIEnumerator]
-> Read DIEnumerator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIEnumerator
readsPrec :: Int -> ReadS DIEnumerator
$creadList :: ReadS [DIEnumerator]
readList :: ReadS [DIEnumerator]
$creadPrec :: ReadPrec DIEnumerator
readPrec :: ReadPrec DIEnumerator
$creadListPrec :: ReadPrec [DIEnumerator]
readListPrec :: ReadPrec [DIEnumerator]
Read, Int -> DIEnumerator -> ShowS
[DIEnumerator] -> ShowS
DIEnumerator -> String
(Int -> DIEnumerator -> ShowS)
-> (DIEnumerator -> String)
-> ([DIEnumerator] -> ShowS)
-> Show DIEnumerator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIEnumerator -> ShowS
showsPrec :: Int -> DIEnumerator -> ShowS
$cshow :: DIEnumerator -> String
show :: DIEnumerator -> String
$cshowList :: [DIEnumerator] -> ShowS
showList :: [DIEnumerator] -> ShowS
Show, Typeable, Typeable DIEnumerator
Typeable DIEnumerator
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIEnumerator)
-> (DIEnumerator -> Constr)
-> (DIEnumerator -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIEnumerator))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIEnumerator))
-> ((forall b. Data b => b -> b) -> DIEnumerator -> DIEnumerator)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIEnumerator -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIEnumerator -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator)
-> Data DIEnumerator
DIEnumerator -> Constr
DIEnumerator -> DataType
(forall b. Data b => b -> b) -> DIEnumerator -> DIEnumerator
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) -> DIEnumerator -> u
forall u. (forall d. Data d => d -> u) -> DIEnumerator -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIEnumerator
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIEnumerator)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIEnumerator)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIEnumerator -> c DIEnumerator
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIEnumerator
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIEnumerator
$ctoConstr :: DIEnumerator -> Constr
toConstr :: DIEnumerator -> Constr
$cdataTypeOf :: DIEnumerator -> DataType
dataTypeOf :: DIEnumerator -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIEnumerator)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIEnumerator)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIEnumerator)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIEnumerator)
$cgmapT :: (forall b. Data b => b -> b) -> DIEnumerator -> DIEnumerator
gmapT :: (forall b. Data b => b -> b) -> DIEnumerator -> DIEnumerator
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIEnumerator -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIEnumerator -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIEnumerator -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIEnumerator -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIEnumerator -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIEnumerator -> m DIEnumerator
Data, (forall x. DIEnumerator -> Rep DIEnumerator x)
-> (forall x. Rep DIEnumerator x -> DIEnumerator)
-> Generic DIEnumerator
forall x. Rep DIEnumerator x -> DIEnumerator
forall x. DIEnumerator -> Rep DIEnumerator x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIEnumerator -> Rep DIEnumerator x
from :: forall x. DIEnumerator -> Rep DIEnumerator x
$cto :: forall x. Rep DIEnumerator x -> DIEnumerator
to :: forall x. Rep DIEnumerator x -> DIEnumerator
Generic)

-- | <https://llvm.org/docs/LangRef.html#disubrange>
data DISubrange = Subrange
  { DISubrange -> DICount
count :: DICount
  , DISubrange -> Maybe DIBound
lowerBound :: Maybe DIBound
  , DISubrange -> Maybe DIBound
upperBound :: Maybe DIBound
  , DISubrange -> Maybe DIBound
stride :: Maybe DIBound
  } deriving (DISubrange -> DISubrange -> Bool
(DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> Bool) -> Eq DISubrange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DISubrange -> DISubrange -> Bool
== :: DISubrange -> DISubrange -> Bool
$c/= :: DISubrange -> DISubrange -> Bool
/= :: DISubrange -> DISubrange -> Bool
Eq, Eq DISubrange
Eq DISubrange
-> (DISubrange -> DISubrange -> Ordering)
-> (DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> Bool)
-> (DISubrange -> DISubrange -> DISubrange)
-> (DISubrange -> DISubrange -> DISubrange)
-> Ord DISubrange
DISubrange -> DISubrange -> Bool
DISubrange -> DISubrange -> Ordering
DISubrange -> DISubrange -> DISubrange
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
$ccompare :: DISubrange -> DISubrange -> Ordering
compare :: DISubrange -> DISubrange -> Ordering
$c< :: DISubrange -> DISubrange -> Bool
< :: DISubrange -> DISubrange -> Bool
$c<= :: DISubrange -> DISubrange -> Bool
<= :: DISubrange -> DISubrange -> Bool
$c> :: DISubrange -> DISubrange -> Bool
> :: DISubrange -> DISubrange -> Bool
$c>= :: DISubrange -> DISubrange -> Bool
>= :: DISubrange -> DISubrange -> Bool
$cmax :: DISubrange -> DISubrange -> DISubrange
max :: DISubrange -> DISubrange -> DISubrange
$cmin :: DISubrange -> DISubrange -> DISubrange
min :: DISubrange -> DISubrange -> DISubrange
Ord, ReadPrec [DISubrange]
ReadPrec DISubrange
Int -> ReadS DISubrange
ReadS [DISubrange]
(Int -> ReadS DISubrange)
-> ReadS [DISubrange]
-> ReadPrec DISubrange
-> ReadPrec [DISubrange]
-> Read DISubrange
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DISubrange
readsPrec :: Int -> ReadS DISubrange
$creadList :: ReadS [DISubrange]
readList :: ReadS [DISubrange]
$creadPrec :: ReadPrec DISubrange
readPrec :: ReadPrec DISubrange
$creadListPrec :: ReadPrec [DISubrange]
readListPrec :: ReadPrec [DISubrange]
Read, Int -> DISubrange -> ShowS
[DISubrange] -> ShowS
DISubrange -> String
(Int -> DISubrange -> ShowS)
-> (DISubrange -> String)
-> ([DISubrange] -> ShowS)
-> Show DISubrange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DISubrange -> ShowS
showsPrec :: Int -> DISubrange -> ShowS
$cshow :: DISubrange -> String
show :: DISubrange -> String
$cshowList :: [DISubrange] -> ShowS
showList :: [DISubrange] -> ShowS
Show, Typeable, Typeable DISubrange
Typeable DISubrange
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DISubrange -> c DISubrange)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DISubrange)
-> (DISubrange -> Constr)
-> (DISubrange -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DISubrange))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DISubrange))
-> ((forall b. Data b => b -> b) -> DISubrange -> DISubrange)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubrange -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubrange -> r)
-> (forall u. (forall d. Data d => d -> u) -> DISubrange -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubrange -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DISubrange -> m DISubrange)
-> Data DISubrange
DISubrange -> Constr
DISubrange -> DataType
(forall b. Data b => b -> b) -> DISubrange -> DISubrange
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) -> DISubrange -> u
forall u. (forall d. Data d => d -> u) -> DISubrange -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubrange
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange -> c DISubrange
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubrange)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DISubrange)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange -> c DISubrange
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubrange -> c DISubrange
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubrange
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubrange
$ctoConstr :: DISubrange -> Constr
toConstr :: DISubrange -> Constr
$cdataTypeOf :: DISubrange -> DataType
dataTypeOf :: DISubrange -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubrange)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubrange)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DISubrange)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DISubrange)
$cgmapT :: (forall b. Data b => b -> b) -> DISubrange -> DISubrange
gmapT :: (forall b. Data b => b -> b) -> DISubrange -> DISubrange
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubrange -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DISubrange -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DISubrange -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DISubrange -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DISubrange -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubrange -> m DISubrange
Data, (forall x. DISubrange -> Rep DISubrange x)
-> (forall x. Rep DISubrange x -> DISubrange) -> Generic DISubrange
forall x. Rep DISubrange x -> DISubrange
forall x. DISubrange -> Rep DISubrange x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DISubrange -> Rep DISubrange x
from :: forall x. DISubrange -> Rep DISubrange x
$cto :: forall x. Rep DISubrange x -> DISubrange
to :: forall x. Rep DISubrange x -> DISubrange
Generic)

data DICount
  = DICountConstant Int64
  | DICountVariable (MDRef DIVariable)
  deriving (DICount -> DICount -> Bool
(DICount -> DICount -> Bool)
-> (DICount -> DICount -> Bool) -> Eq DICount
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DICount -> DICount -> Bool
== :: DICount -> DICount -> Bool
$c/= :: DICount -> DICount -> Bool
/= :: DICount -> DICount -> Bool
Eq, Eq DICount
Eq DICount
-> (DICount -> DICount -> Ordering)
-> (DICount -> DICount -> Bool)
-> (DICount -> DICount -> Bool)
-> (DICount -> DICount -> Bool)
-> (DICount -> DICount -> Bool)
-> (DICount -> DICount -> DICount)
-> (DICount -> DICount -> DICount)
-> Ord DICount
DICount -> DICount -> Bool
DICount -> DICount -> Ordering
DICount -> DICount -> DICount
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
$ccompare :: DICount -> DICount -> Ordering
compare :: DICount -> DICount -> Ordering
$c< :: DICount -> DICount -> Bool
< :: DICount -> DICount -> Bool
$c<= :: DICount -> DICount -> Bool
<= :: DICount -> DICount -> Bool
$c> :: DICount -> DICount -> Bool
> :: DICount -> DICount -> Bool
$c>= :: DICount -> DICount -> Bool
>= :: DICount -> DICount -> Bool
$cmax :: DICount -> DICount -> DICount
max :: DICount -> DICount -> DICount
$cmin :: DICount -> DICount -> DICount
min :: DICount -> DICount -> DICount
Ord, ReadPrec [DICount]
ReadPrec DICount
Int -> ReadS DICount
ReadS [DICount]
(Int -> ReadS DICount)
-> ReadS [DICount]
-> ReadPrec DICount
-> ReadPrec [DICount]
-> Read DICount
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DICount
readsPrec :: Int -> ReadS DICount
$creadList :: ReadS [DICount]
readList :: ReadS [DICount]
$creadPrec :: ReadPrec DICount
readPrec :: ReadPrec DICount
$creadListPrec :: ReadPrec [DICount]
readListPrec :: ReadPrec [DICount]
Read, Int -> DICount -> ShowS
[DICount] -> ShowS
DICount -> String
(Int -> DICount -> ShowS)
-> (DICount -> String) -> ([DICount] -> ShowS) -> Show DICount
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DICount -> ShowS
showsPrec :: Int -> DICount -> ShowS
$cshow :: DICount -> String
show :: DICount -> String
$cshowList :: [DICount] -> ShowS
showList :: [DICount] -> ShowS
Show, Typeable, Typeable DICount
Typeable DICount
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DICount -> c DICount)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DICount)
-> (DICount -> Constr)
-> (DICount -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DICount))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DICount))
-> ((forall b. Data b => b -> b) -> DICount -> DICount)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DICount -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DICount -> r)
-> (forall u. (forall d. Data d => d -> u) -> DICount -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DICount -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DICount -> m DICount)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DICount -> m DICount)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DICount -> m DICount)
-> Data DICount
DICount -> Constr
DICount -> DataType
(forall b. Data b => b -> b) -> DICount -> DICount
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) -> DICount -> u
forall u. (forall d. Data d => d -> u) -> DICount -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICount
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICount -> c DICount
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICount)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DICount)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICount -> c DICount
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICount -> c DICount
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICount
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICount
$ctoConstr :: DICount -> Constr
toConstr :: DICount -> Constr
$cdataTypeOf :: DICount -> DataType
dataTypeOf :: DICount -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICount)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICount)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DICount)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DICount)
$cgmapT :: (forall b. Data b => b -> b) -> DICount -> DICount
gmapT :: (forall b. Data b => b -> b) -> DICount -> DICount
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICount -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DICount -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DICount -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DICount -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DICount -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICount -> m DICount
Data, (forall x. DICount -> Rep DICount x)
-> (forall x. Rep DICount x -> DICount) -> Generic DICount
forall x. Rep DICount x -> DICount
forall x. DICount -> Rep DICount x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DICount -> Rep DICount x
from :: forall x. DICount -> Rep DICount x
$cto :: forall x. Rep DICount x -> DICount
to :: forall x. Rep DICount x -> DICount
Generic)

data DIBound
  = DIBoundConstant Int64
  | DIBoundVariable (MDRef DIVariable)
  | DIBoundExpression (MDRef DIExpression)
  deriving (DIBound -> DIBound -> Bool
(DIBound -> DIBound -> Bool)
-> (DIBound -> DIBound -> Bool) -> Eq DIBound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIBound -> DIBound -> Bool
== :: DIBound -> DIBound -> Bool
$c/= :: DIBound -> DIBound -> Bool
/= :: DIBound -> DIBound -> Bool
Eq, Eq DIBound
Eq DIBound
-> (DIBound -> DIBound -> Ordering)
-> (DIBound -> DIBound -> Bool)
-> (DIBound -> DIBound -> Bool)
-> (DIBound -> DIBound -> Bool)
-> (DIBound -> DIBound -> Bool)
-> (DIBound -> DIBound -> DIBound)
-> (DIBound -> DIBound -> DIBound)
-> Ord DIBound
DIBound -> DIBound -> Bool
DIBound -> DIBound -> Ordering
DIBound -> DIBound -> DIBound
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
$ccompare :: DIBound -> DIBound -> Ordering
compare :: DIBound -> DIBound -> Ordering
$c< :: DIBound -> DIBound -> Bool
< :: DIBound -> DIBound -> Bool
$c<= :: DIBound -> DIBound -> Bool
<= :: DIBound -> DIBound -> Bool
$c> :: DIBound -> DIBound -> Bool
> :: DIBound -> DIBound -> Bool
$c>= :: DIBound -> DIBound -> Bool
>= :: DIBound -> DIBound -> Bool
$cmax :: DIBound -> DIBound -> DIBound
max :: DIBound -> DIBound -> DIBound
$cmin :: DIBound -> DIBound -> DIBound
min :: DIBound -> DIBound -> DIBound
Ord, ReadPrec [DIBound]
ReadPrec DIBound
Int -> ReadS DIBound
ReadS [DIBound]
(Int -> ReadS DIBound)
-> ReadS [DIBound]
-> ReadPrec DIBound
-> ReadPrec [DIBound]
-> Read DIBound
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIBound
readsPrec :: Int -> ReadS DIBound
$creadList :: ReadS [DIBound]
readList :: ReadS [DIBound]
$creadPrec :: ReadPrec DIBound
readPrec :: ReadPrec DIBound
$creadListPrec :: ReadPrec [DIBound]
readListPrec :: ReadPrec [DIBound]
Read, Int -> DIBound -> ShowS
[DIBound] -> ShowS
DIBound -> String
(Int -> DIBound -> ShowS)
-> (DIBound -> String) -> ([DIBound] -> ShowS) -> Show DIBound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIBound -> ShowS
showsPrec :: Int -> DIBound -> ShowS
$cshow :: DIBound -> String
show :: DIBound -> String
$cshowList :: [DIBound] -> ShowS
showList :: [DIBound] -> ShowS
Show, Typeable, Typeable DIBound
Typeable DIBound
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIBound -> c DIBound)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIBound)
-> (DIBound -> Constr)
-> (DIBound -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIBound))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIBound))
-> ((forall b. Data b => b -> b) -> DIBound -> DIBound)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIBound -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIBound -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIBound -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIBound -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIBound -> m DIBound)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIBound -> m DIBound)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIBound -> m DIBound)
-> Data DIBound
DIBound -> Constr
DIBound -> DataType
(forall b. Data b => b -> b) -> DIBound -> DIBound
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) -> DIBound -> u
forall u. (forall d. Data d => d -> u) -> DIBound -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBound -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBound -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBound -> m DIBound
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBound -> m DIBound
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBound
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBound -> c DIBound
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBound)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIBound)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBound -> c DIBound
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBound -> c DIBound
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBound
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBound
$ctoConstr :: DIBound -> Constr
toConstr :: DIBound -> Constr
$cdataTypeOf :: DIBound -> DataType
dataTypeOf :: DIBound -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBound)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBound)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIBound)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIBound)
$cgmapT :: (forall b. Data b => b -> b) -> DIBound -> DIBound
gmapT :: (forall b. Data b => b -> b) -> DIBound -> DIBound
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBound -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBound -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBound -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBound -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIBound -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIBound -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIBound -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIBound -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBound -> m DIBound
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBound -> m DIBound
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBound -> m DIBound
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBound -> m DIBound
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBound -> m DIBound
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBound -> m DIBound
Data, (forall x. DIBound -> Rep DIBound x)
-> (forall x. Rep DIBound x -> DIBound) -> Generic DIBound
forall x. Rep DIBound x -> DIBound
forall x. DIBound -> Rep DIBound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIBound -> Rep DIBound x
from :: forall x. DIBound -> Rep DIBound x
$cto :: forall x. Rep DIBound x -> DIBound
to :: forall x. Rep DIBound x -> DIBound
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIScope.html>
data DIScope
  = DICompileUnit DICompileUnit
  | DIFile DIFile
  | DILocalScope DILocalScope
  | DIModule DIModule
  | DINamespace DINamespace
  | DIType DIType
  deriving (DIScope -> DIScope -> Bool
(DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> Bool) -> Eq DIScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIScope -> DIScope -> Bool
== :: DIScope -> DIScope -> Bool
$c/= :: DIScope -> DIScope -> Bool
/= :: DIScope -> DIScope -> Bool
Eq, Eq DIScope
Eq DIScope
-> (DIScope -> DIScope -> Ordering)
-> (DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> Bool)
-> (DIScope -> DIScope -> DIScope)
-> (DIScope -> DIScope -> DIScope)
-> Ord DIScope
DIScope -> DIScope -> Bool
DIScope -> DIScope -> Ordering
DIScope -> DIScope -> DIScope
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
$ccompare :: DIScope -> DIScope -> Ordering
compare :: DIScope -> DIScope -> Ordering
$c< :: DIScope -> DIScope -> Bool
< :: DIScope -> DIScope -> Bool
$c<= :: DIScope -> DIScope -> Bool
<= :: DIScope -> DIScope -> Bool
$c> :: DIScope -> DIScope -> Bool
> :: DIScope -> DIScope -> Bool
$c>= :: DIScope -> DIScope -> Bool
>= :: DIScope -> DIScope -> Bool
$cmax :: DIScope -> DIScope -> DIScope
max :: DIScope -> DIScope -> DIScope
$cmin :: DIScope -> DIScope -> DIScope
min :: DIScope -> DIScope -> DIScope
Ord, ReadPrec [DIScope]
ReadPrec DIScope
Int -> ReadS DIScope
ReadS [DIScope]
(Int -> ReadS DIScope)
-> ReadS [DIScope]
-> ReadPrec DIScope
-> ReadPrec [DIScope]
-> Read DIScope
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIScope
readsPrec :: Int -> ReadS DIScope
$creadList :: ReadS [DIScope]
readList :: ReadS [DIScope]
$creadPrec :: ReadPrec DIScope
readPrec :: ReadPrec DIScope
$creadListPrec :: ReadPrec [DIScope]
readListPrec :: ReadPrec [DIScope]
Read, Int -> DIScope -> ShowS
[DIScope] -> ShowS
DIScope -> String
(Int -> DIScope -> ShowS)
-> (DIScope -> String) -> ([DIScope] -> ShowS) -> Show DIScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIScope -> ShowS
showsPrec :: Int -> DIScope -> ShowS
$cshow :: DIScope -> String
show :: DIScope -> String
$cshowList :: [DIScope] -> ShowS
showList :: [DIScope] -> ShowS
Show, Typeable, Typeable DIScope
Typeable DIScope
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIScope -> c DIScope)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIScope)
-> (DIScope -> Constr)
-> (DIScope -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIScope))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIScope))
-> ((forall b. Data b => b -> b) -> DIScope -> DIScope)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIScope -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIScope -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIScope -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIScope -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIScope -> m DIScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIScope -> m DIScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIScope -> m DIScope)
-> Data DIScope
DIScope -> Constr
DIScope -> DataType
(forall b. Data b => b -> b) -> DIScope -> DIScope
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) -> DIScope -> u
forall u. (forall d. Data d => d -> u) -> DIScope -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIScope
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIScope -> c DIScope
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIScope)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIScope)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIScope -> c DIScope
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIScope -> c DIScope
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIScope
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIScope
$ctoConstr :: DIScope -> Constr
toConstr :: DIScope -> Constr
$cdataTypeOf :: DIScope -> DataType
dataTypeOf :: DIScope -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIScope)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIScope)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIScope)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIScope)
$cgmapT :: (forall b. Data b => b -> b) -> DIScope -> DIScope
gmapT :: (forall b. Data b => b -> b) -> DIScope -> DIScope
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIScope -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIScope -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIScope -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIScope -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIScope -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIScope -> m DIScope
Data, (forall x. DIScope -> Rep DIScope x)
-> (forall x. Rep DIScope x -> DIScope) -> Generic DIScope
forall x. Rep DIScope x -> DIScope
forall x. DIScope -> Rep DIScope x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIScope -> Rep DIScope x
from :: forall x. DIScope -> Rep DIScope x
$cto :: forall x. Rep DIScope x -> DIScope
to :: forall x. Rep DIScope x -> DIScope
Generic)

data DIModule = Module
  { DIModule -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
  , DIModule -> ShortByteString
name :: ShortByteString
  , DIModule -> ShortByteString
configurationMacros :: ShortByteString
  , DIModule -> ShortByteString
includePath :: ShortByteString
  , DIModule -> ShortByteString
apiNotesFile :: ShortByteString
  , DIModule -> Word32
lineNo :: Word32
  } deriving (DIModule -> DIModule -> Bool
(DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> Bool) -> Eq DIModule
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIModule -> DIModule -> Bool
== :: DIModule -> DIModule -> Bool
$c/= :: DIModule -> DIModule -> Bool
/= :: DIModule -> DIModule -> Bool
Eq, Eq DIModule
Eq DIModule
-> (DIModule -> DIModule -> Ordering)
-> (DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> Bool)
-> (DIModule -> DIModule -> DIModule)
-> (DIModule -> DIModule -> DIModule)
-> Ord DIModule
DIModule -> DIModule -> Bool
DIModule -> DIModule -> Ordering
DIModule -> DIModule -> DIModule
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
$ccompare :: DIModule -> DIModule -> Ordering
compare :: DIModule -> DIModule -> Ordering
$c< :: DIModule -> DIModule -> Bool
< :: DIModule -> DIModule -> Bool
$c<= :: DIModule -> DIModule -> Bool
<= :: DIModule -> DIModule -> Bool
$c> :: DIModule -> DIModule -> Bool
> :: DIModule -> DIModule -> Bool
$c>= :: DIModule -> DIModule -> Bool
>= :: DIModule -> DIModule -> Bool
$cmax :: DIModule -> DIModule -> DIModule
max :: DIModule -> DIModule -> DIModule
$cmin :: DIModule -> DIModule -> DIModule
min :: DIModule -> DIModule -> DIModule
Ord, ReadPrec [DIModule]
ReadPrec DIModule
Int -> ReadS DIModule
ReadS [DIModule]
(Int -> ReadS DIModule)
-> ReadS [DIModule]
-> ReadPrec DIModule
-> ReadPrec [DIModule]
-> Read DIModule
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIModule
readsPrec :: Int -> ReadS DIModule
$creadList :: ReadS [DIModule]
readList :: ReadS [DIModule]
$creadPrec :: ReadPrec DIModule
readPrec :: ReadPrec DIModule
$creadListPrec :: ReadPrec [DIModule]
readListPrec :: ReadPrec [DIModule]
Read, Int -> DIModule -> ShowS
[DIModule] -> ShowS
DIModule -> String
(Int -> DIModule -> ShowS)
-> (DIModule -> String) -> ([DIModule] -> ShowS) -> Show DIModule
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIModule -> ShowS
showsPrec :: Int -> DIModule -> ShowS
$cshow :: DIModule -> String
show :: DIModule -> String
$cshowList :: [DIModule] -> ShowS
showList :: [DIModule] -> ShowS
Show, Typeable, Typeable DIModule
Typeable DIModule
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIModule -> c DIModule)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIModule)
-> (DIModule -> Constr)
-> (DIModule -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIModule))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIModule))
-> ((forall b. Data b => b -> b) -> DIModule -> DIModule)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIModule -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIModule -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIModule -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIModule -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIModule -> m DIModule)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIModule -> m DIModule)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIModule -> m DIModule)
-> Data DIModule
DIModule -> Constr
DIModule -> DataType
(forall b. Data b => b -> b) -> DIModule -> DIModule
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) -> DIModule -> u
forall u. (forall d. Data d => d -> u) -> DIModule -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIModule
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIModule -> c DIModule
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIModule)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIModule)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIModule -> c DIModule
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIModule -> c DIModule
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIModule
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIModule
$ctoConstr :: DIModule -> Constr
toConstr :: DIModule -> Constr
$cdataTypeOf :: DIModule -> DataType
dataTypeOf :: DIModule -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIModule)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIModule)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIModule)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIModule)
$cgmapT :: (forall b. Data b => b -> b) -> DIModule -> DIModule
gmapT :: (forall b. Data b => b -> b) -> DIModule -> DIModule
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIModule -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIModule -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIModule -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIModule -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIModule -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIModule -> m DIModule
Data, (forall x. DIModule -> Rep DIModule x)
-> (forall x. Rep DIModule x -> DIModule) -> Generic DIModule
forall x. Rep DIModule x -> DIModule
forall x. DIModule -> Rep DIModule x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIModule -> Rep DIModule x
from :: forall x. DIModule -> Rep DIModule x
$cto :: forall x. Rep DIModule x -> DIModule
to :: forall x. Rep DIModule x -> DIModule
Generic)

data DINamespace = Namespace
  { DINamespace -> ShortByteString
name :: ShortByteString
  , DINamespace -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
  , DINamespace -> Bool
exportSymbols :: Bool
  } deriving (DINamespace -> DINamespace -> Bool
(DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> Bool) -> Eq DINamespace
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DINamespace -> DINamespace -> Bool
== :: DINamespace -> DINamespace -> Bool
$c/= :: DINamespace -> DINamespace -> Bool
/= :: DINamespace -> DINamespace -> Bool
Eq, Eq DINamespace
Eq DINamespace
-> (DINamespace -> DINamespace -> Ordering)
-> (DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> Bool)
-> (DINamespace -> DINamespace -> DINamespace)
-> (DINamespace -> DINamespace -> DINamespace)
-> Ord DINamespace
DINamespace -> DINamespace -> Bool
DINamespace -> DINamespace -> Ordering
DINamespace -> DINamespace -> DINamespace
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
$ccompare :: DINamespace -> DINamespace -> Ordering
compare :: DINamespace -> DINamespace -> Ordering
$c< :: DINamespace -> DINamespace -> Bool
< :: DINamespace -> DINamespace -> Bool
$c<= :: DINamespace -> DINamespace -> Bool
<= :: DINamespace -> DINamespace -> Bool
$c> :: DINamespace -> DINamespace -> Bool
> :: DINamespace -> DINamespace -> Bool
$c>= :: DINamespace -> DINamespace -> Bool
>= :: DINamespace -> DINamespace -> Bool
$cmax :: DINamespace -> DINamespace -> DINamespace
max :: DINamespace -> DINamespace -> DINamespace
$cmin :: DINamespace -> DINamespace -> DINamespace
min :: DINamespace -> DINamespace -> DINamespace
Ord, ReadPrec [DINamespace]
ReadPrec DINamespace
Int -> ReadS DINamespace
ReadS [DINamespace]
(Int -> ReadS DINamespace)
-> ReadS [DINamespace]
-> ReadPrec DINamespace
-> ReadPrec [DINamespace]
-> Read DINamespace
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DINamespace
readsPrec :: Int -> ReadS DINamespace
$creadList :: ReadS [DINamespace]
readList :: ReadS [DINamespace]
$creadPrec :: ReadPrec DINamespace
readPrec :: ReadPrec DINamespace
$creadListPrec :: ReadPrec [DINamespace]
readListPrec :: ReadPrec [DINamespace]
Read, Int -> DINamespace -> ShowS
[DINamespace] -> ShowS
DINamespace -> String
(Int -> DINamespace -> ShowS)
-> (DINamespace -> String)
-> ([DINamespace] -> ShowS)
-> Show DINamespace
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DINamespace -> ShowS
showsPrec :: Int -> DINamespace -> ShowS
$cshow :: DINamespace -> String
show :: DINamespace -> String
$cshowList :: [DINamespace] -> ShowS
showList :: [DINamespace] -> ShowS
Show, Typeable, Typeable DINamespace
Typeable DINamespace
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DINamespace -> c DINamespace)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DINamespace)
-> (DINamespace -> Constr)
-> (DINamespace -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DINamespace))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DINamespace))
-> ((forall b. Data b => b -> b) -> DINamespace -> DINamespace)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DINamespace -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DINamespace -> r)
-> (forall u. (forall d. Data d => d -> u) -> DINamespace -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DINamespace -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DINamespace -> m DINamespace)
-> Data DINamespace
DINamespace -> Constr
DINamespace -> DataType
(forall b. Data b => b -> b) -> DINamespace -> DINamespace
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) -> DINamespace -> u
forall u. (forall d. Data d => d -> u) -> DINamespace -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINamespace
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINamespace -> c DINamespace
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINamespace)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DINamespace)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINamespace -> c DINamespace
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DINamespace -> c DINamespace
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINamespace
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DINamespace
$ctoConstr :: DINamespace -> Constr
toConstr :: DINamespace -> Constr
$cdataTypeOf :: DINamespace -> DataType
dataTypeOf :: DINamespace -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINamespace)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DINamespace)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DINamespace)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DINamespace)
$cgmapT :: (forall b. Data b => b -> b) -> DINamespace -> DINamespace
gmapT :: (forall b. Data b => b -> b) -> DINamespace -> DINamespace
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DINamespace -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DINamespace -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DINamespace -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DINamespace -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DINamespace -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DINamespace -> m DINamespace
Data, (forall x. DINamespace -> Rep DINamespace x)
-> (forall x. Rep DINamespace x -> DINamespace)
-> Generic DINamespace
forall x. Rep DINamespace x -> DINamespace
forall x. DINamespace -> Rep DINamespace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DINamespace -> Rep DINamespace x
from :: forall x. DINamespace -> Rep DINamespace x
$cto :: forall x. Rep DINamespace x -> DINamespace
to :: forall x. Rep DINamespace x -> DINamespace
Generic)

data DebugEmissionKind = NoDebug | FullDebug | LineTablesOnly
  deriving (DebugEmissionKind -> DebugEmissionKind -> Bool
(DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> Eq DebugEmissionKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DebugEmissionKind -> DebugEmissionKind -> Bool
== :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c/= :: DebugEmissionKind -> DebugEmissionKind -> Bool
/= :: DebugEmissionKind -> DebugEmissionKind -> Bool
Eq, Eq DebugEmissionKind
Eq DebugEmissionKind
-> (DebugEmissionKind -> DebugEmissionKind -> Ordering)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> Bool)
-> (DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind)
-> (DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind)
-> Ord DebugEmissionKind
DebugEmissionKind -> DebugEmissionKind -> Bool
DebugEmissionKind -> DebugEmissionKind -> Ordering
DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
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
$ccompare :: DebugEmissionKind -> DebugEmissionKind -> Ordering
compare :: DebugEmissionKind -> DebugEmissionKind -> Ordering
$c< :: DebugEmissionKind -> DebugEmissionKind -> Bool
< :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c<= :: DebugEmissionKind -> DebugEmissionKind -> Bool
<= :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c> :: DebugEmissionKind -> DebugEmissionKind -> Bool
> :: DebugEmissionKind -> DebugEmissionKind -> Bool
$c>= :: DebugEmissionKind -> DebugEmissionKind -> Bool
>= :: DebugEmissionKind -> DebugEmissionKind -> Bool
$cmax :: DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
max :: DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
$cmin :: DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
min :: DebugEmissionKind -> DebugEmissionKind -> DebugEmissionKind
Ord, ReadPrec [DebugEmissionKind]
ReadPrec DebugEmissionKind
Int -> ReadS DebugEmissionKind
ReadS [DebugEmissionKind]
(Int -> ReadS DebugEmissionKind)
-> ReadS [DebugEmissionKind]
-> ReadPrec DebugEmissionKind
-> ReadPrec [DebugEmissionKind]
-> Read DebugEmissionKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DebugEmissionKind
readsPrec :: Int -> ReadS DebugEmissionKind
$creadList :: ReadS [DebugEmissionKind]
readList :: ReadS [DebugEmissionKind]
$creadPrec :: ReadPrec DebugEmissionKind
readPrec :: ReadPrec DebugEmissionKind
$creadListPrec :: ReadPrec [DebugEmissionKind]
readListPrec :: ReadPrec [DebugEmissionKind]
Read, Int -> DebugEmissionKind -> ShowS
[DebugEmissionKind] -> ShowS
DebugEmissionKind -> String
(Int -> DebugEmissionKind -> ShowS)
-> (DebugEmissionKind -> String)
-> ([DebugEmissionKind] -> ShowS)
-> Show DebugEmissionKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DebugEmissionKind -> ShowS
showsPrec :: Int -> DebugEmissionKind -> ShowS
$cshow :: DebugEmissionKind -> String
show :: DebugEmissionKind -> String
$cshowList :: [DebugEmissionKind] -> ShowS
showList :: [DebugEmissionKind] -> ShowS
Show, Typeable, Typeable DebugEmissionKind
Typeable DebugEmissionKind
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> DebugEmissionKind
    -> c DebugEmissionKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DebugEmissionKind)
-> (DebugEmissionKind -> Constr)
-> (DebugEmissionKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DebugEmissionKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DebugEmissionKind))
-> ((forall b. Data b => b -> b)
    -> DebugEmissionKind -> DebugEmissionKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DebugEmissionKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DebugEmissionKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DebugEmissionKind -> m DebugEmissionKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugEmissionKind -> m DebugEmissionKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugEmissionKind -> m DebugEmissionKind)
-> Data DebugEmissionKind
DebugEmissionKind -> Constr
DebugEmissionKind -> DataType
(forall b. Data b => b -> b)
-> DebugEmissionKind -> DebugEmissionKind
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) -> DebugEmissionKind -> u
forall u. (forall d. Data d => d -> u) -> DebugEmissionKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugEmissionKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugEmissionKind -> c DebugEmissionKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugEmissionKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugEmissionKind)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugEmissionKind -> c DebugEmissionKind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DebugEmissionKind -> c DebugEmissionKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugEmissionKind
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugEmissionKind
$ctoConstr :: DebugEmissionKind -> Constr
toConstr :: DebugEmissionKind -> Constr
$cdataTypeOf :: DebugEmissionKind -> DataType
dataTypeOf :: DebugEmissionKind -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugEmissionKind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugEmissionKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugEmissionKind)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugEmissionKind)
$cgmapT :: (forall b. Data b => b -> b)
-> DebugEmissionKind -> DebugEmissionKind
gmapT :: (forall b. Data b => b -> b)
-> DebugEmissionKind -> DebugEmissionKind
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugEmissionKind -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DebugEmissionKind -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DebugEmissionKind -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DebugEmissionKind -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DebugEmissionKind -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugEmissionKind -> m DebugEmissionKind
Data, (forall x. DebugEmissionKind -> Rep DebugEmissionKind x)
-> (forall x. Rep DebugEmissionKind x -> DebugEmissionKind)
-> Generic DebugEmissionKind
forall x. Rep DebugEmissionKind x -> DebugEmissionKind
forall x. DebugEmissionKind -> Rep DebugEmissionKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DebugEmissionKind -> Rep DebugEmissionKind x
from :: forall x. DebugEmissionKind -> Rep DebugEmissionKind x
$cto :: forall x. Rep DebugEmissionKind x -> DebugEmissionKind
to :: forall x. Rep DebugEmissionKind x -> DebugEmissionKind
Generic)

data DebugNameTableKind = NameTableKindDefault | NameTableKindGNU | NameTableKindNone
  deriving (DebugNameTableKind -> DebugNameTableKind -> Bool
(DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> Eq DebugNameTableKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DebugNameTableKind -> DebugNameTableKind -> Bool
== :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c/= :: DebugNameTableKind -> DebugNameTableKind -> Bool
/= :: DebugNameTableKind -> DebugNameTableKind -> Bool
Eq, Eq DebugNameTableKind
Eq DebugNameTableKind
-> (DebugNameTableKind -> DebugNameTableKind -> Ordering)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> Bool)
-> (DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind)
-> (DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind)
-> Ord DebugNameTableKind
DebugNameTableKind -> DebugNameTableKind -> Bool
DebugNameTableKind -> DebugNameTableKind -> Ordering
DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
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
$ccompare :: DebugNameTableKind -> DebugNameTableKind -> Ordering
compare :: DebugNameTableKind -> DebugNameTableKind -> Ordering
$c< :: DebugNameTableKind -> DebugNameTableKind -> Bool
< :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c<= :: DebugNameTableKind -> DebugNameTableKind -> Bool
<= :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c> :: DebugNameTableKind -> DebugNameTableKind -> Bool
> :: DebugNameTableKind -> DebugNameTableKind -> Bool
$c>= :: DebugNameTableKind -> DebugNameTableKind -> Bool
>= :: DebugNameTableKind -> DebugNameTableKind -> Bool
$cmax :: DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
max :: DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
$cmin :: DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
min :: DebugNameTableKind -> DebugNameTableKind -> DebugNameTableKind
Ord, ReadPrec [DebugNameTableKind]
ReadPrec DebugNameTableKind
Int -> ReadS DebugNameTableKind
ReadS [DebugNameTableKind]
(Int -> ReadS DebugNameTableKind)
-> ReadS [DebugNameTableKind]
-> ReadPrec DebugNameTableKind
-> ReadPrec [DebugNameTableKind]
-> Read DebugNameTableKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DebugNameTableKind
readsPrec :: Int -> ReadS DebugNameTableKind
$creadList :: ReadS [DebugNameTableKind]
readList :: ReadS [DebugNameTableKind]
$creadPrec :: ReadPrec DebugNameTableKind
readPrec :: ReadPrec DebugNameTableKind
$creadListPrec :: ReadPrec [DebugNameTableKind]
readListPrec :: ReadPrec [DebugNameTableKind]
Read, Int -> DebugNameTableKind -> ShowS
[DebugNameTableKind] -> ShowS
DebugNameTableKind -> String
(Int -> DebugNameTableKind -> ShowS)
-> (DebugNameTableKind -> String)
-> ([DebugNameTableKind] -> ShowS)
-> Show DebugNameTableKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DebugNameTableKind -> ShowS
showsPrec :: Int -> DebugNameTableKind -> ShowS
$cshow :: DebugNameTableKind -> String
show :: DebugNameTableKind -> String
$cshowList :: [DebugNameTableKind] -> ShowS
showList :: [DebugNameTableKind] -> ShowS
Show, Typeable, Typeable DebugNameTableKind
Typeable DebugNameTableKind
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> DebugNameTableKind
    -> c DebugNameTableKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DebugNameTableKind)
-> (DebugNameTableKind -> Constr)
-> (DebugNameTableKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DebugNameTableKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DebugNameTableKind))
-> ((forall b. Data b => b -> b)
    -> DebugNameTableKind -> DebugNameTableKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DebugNameTableKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DebugNameTableKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DebugNameTableKind -> m DebugNameTableKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugNameTableKind -> m DebugNameTableKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DebugNameTableKind -> m DebugNameTableKind)
-> Data DebugNameTableKind
DebugNameTableKind -> Constr
DebugNameTableKind -> DataType
(forall b. Data b => b -> b)
-> DebugNameTableKind -> DebugNameTableKind
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) -> DebugNameTableKind -> u
forall u. (forall d. Data d => d -> u) -> DebugNameTableKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugNameTableKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DebugNameTableKind
-> c DebugNameTableKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugNameTableKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugNameTableKind)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DebugNameTableKind
-> c DebugNameTableKind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DebugNameTableKind
-> c DebugNameTableKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugNameTableKind
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DebugNameTableKind
$ctoConstr :: DebugNameTableKind -> Constr
toConstr :: DebugNameTableKind -> Constr
$cdataTypeOf :: DebugNameTableKind -> DataType
dataTypeOf :: DebugNameTableKind -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugNameTableKind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DebugNameTableKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugNameTableKind)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DebugNameTableKind)
$cgmapT :: (forall b. Data b => b -> b)
-> DebugNameTableKind -> DebugNameTableKind
gmapT :: (forall b. Data b => b -> b)
-> DebugNameTableKind -> DebugNameTableKind
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DebugNameTableKind -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DebugNameTableKind -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DebugNameTableKind -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DebugNameTableKind -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DebugNameTableKind -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DebugNameTableKind -> m DebugNameTableKind
Data, (forall x. DebugNameTableKind -> Rep DebugNameTableKind x)
-> (forall x. Rep DebugNameTableKind x -> DebugNameTableKind)
-> Generic DebugNameTableKind
forall x. Rep DebugNameTableKind x -> DebugNameTableKind
forall x. DebugNameTableKind -> Rep DebugNameTableKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DebugNameTableKind -> Rep DebugNameTableKind x
from :: forall x. DebugNameTableKind -> Rep DebugNameTableKind x
$cto :: forall x. Rep DebugNameTableKind x -> DebugNameTableKind
to :: forall x. Rep DebugNameTableKind x -> DebugNameTableKind
Generic)

-- | <https://llvm.org/docs/LangRef.html#dicompileunit>
data DICompileUnit = CompileUnit
  { DICompileUnit -> Word32
language :: Word32
  , DICompileUnit -> MDRef DIFile
file :: MDRef DIFile
  , DICompileUnit -> ShortByteString
producer :: ShortByteString
  , DICompileUnit -> Bool
optimized :: Bool
  , DICompileUnit -> ShortByteString
flags :: ShortByteString
  , DICompileUnit -> Word32
runtimeVersion :: Word32
  , DICompileUnit -> ShortByteString
splitDebugFileName :: ShortByteString
  , DICompileUnit -> DebugEmissionKind
emissionKind :: DebugEmissionKind
  , DICompileUnit -> [MDRef DICompositeType]
enums :: [MDRef DICompositeType] -- ^ Only enum types are allowed here
  , DICompileUnit -> [MDRef (Either DIType DISubprogram)]
retainedTypes :: [MDRef (Either DIType DISubprogram)]
  , DICompileUnit -> [MDRef DIGlobalVariableExpression]
globals :: [MDRef DIGlobalVariableExpression]
  , DICompileUnit -> [MDRef DIImportedEntity]
imports :: [MDRef DIImportedEntity]
  , DICompileUnit -> [MDRef DIMacroNode]
macros :: [MDRef DIMacroNode]
  , DICompileUnit -> Word64
dWOId :: Word64
  , DICompileUnit -> Bool
splitDebugInlining :: Bool
  , DICompileUnit -> Bool
debugInfoForProfiling :: Bool
  , DICompileUnit -> DebugNameTableKind
nameTableKind :: DebugNameTableKind
  , DICompileUnit -> Bool
rangesBaseAddress :: Bool
  } deriving (DICompileUnit -> DICompileUnit -> Bool
(DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> Bool) -> Eq DICompileUnit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DICompileUnit -> DICompileUnit -> Bool
== :: DICompileUnit -> DICompileUnit -> Bool
$c/= :: DICompileUnit -> DICompileUnit -> Bool
/= :: DICompileUnit -> DICompileUnit -> Bool
Eq, Eq DICompileUnit
Eq DICompileUnit
-> (DICompileUnit -> DICompileUnit -> Ordering)
-> (DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> Bool)
-> (DICompileUnit -> DICompileUnit -> DICompileUnit)
-> (DICompileUnit -> DICompileUnit -> DICompileUnit)
-> Ord DICompileUnit
DICompileUnit -> DICompileUnit -> Bool
DICompileUnit -> DICompileUnit -> Ordering
DICompileUnit -> DICompileUnit -> DICompileUnit
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
$ccompare :: DICompileUnit -> DICompileUnit -> Ordering
compare :: DICompileUnit -> DICompileUnit -> Ordering
$c< :: DICompileUnit -> DICompileUnit -> Bool
< :: DICompileUnit -> DICompileUnit -> Bool
$c<= :: DICompileUnit -> DICompileUnit -> Bool
<= :: DICompileUnit -> DICompileUnit -> Bool
$c> :: DICompileUnit -> DICompileUnit -> Bool
> :: DICompileUnit -> DICompileUnit -> Bool
$c>= :: DICompileUnit -> DICompileUnit -> Bool
>= :: DICompileUnit -> DICompileUnit -> Bool
$cmax :: DICompileUnit -> DICompileUnit -> DICompileUnit
max :: DICompileUnit -> DICompileUnit -> DICompileUnit
$cmin :: DICompileUnit -> DICompileUnit -> DICompileUnit
min :: DICompileUnit -> DICompileUnit -> DICompileUnit
Ord, ReadPrec [DICompileUnit]
ReadPrec DICompileUnit
Int -> ReadS DICompileUnit
ReadS [DICompileUnit]
(Int -> ReadS DICompileUnit)
-> ReadS [DICompileUnit]
-> ReadPrec DICompileUnit
-> ReadPrec [DICompileUnit]
-> Read DICompileUnit
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DICompileUnit
readsPrec :: Int -> ReadS DICompileUnit
$creadList :: ReadS [DICompileUnit]
readList :: ReadS [DICompileUnit]
$creadPrec :: ReadPrec DICompileUnit
readPrec :: ReadPrec DICompileUnit
$creadListPrec :: ReadPrec [DICompileUnit]
readListPrec :: ReadPrec [DICompileUnit]
Read, Int -> DICompileUnit -> ShowS
[DICompileUnit] -> ShowS
DICompileUnit -> String
(Int -> DICompileUnit -> ShowS)
-> (DICompileUnit -> String)
-> ([DICompileUnit] -> ShowS)
-> Show DICompileUnit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DICompileUnit -> ShowS
showsPrec :: Int -> DICompileUnit -> ShowS
$cshow :: DICompileUnit -> String
show :: DICompileUnit -> String
$cshowList :: [DICompileUnit] -> ShowS
showList :: [DICompileUnit] -> ShowS
Show, Typeable, Typeable DICompileUnit
Typeable DICompileUnit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DICompileUnit)
-> (DICompileUnit -> Constr)
-> (DICompileUnit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DICompileUnit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DICompileUnit))
-> ((forall b. Data b => b -> b) -> DICompileUnit -> DICompileUnit)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r)
-> (forall u. (forall d. Data d => d -> u) -> DICompileUnit -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DICompileUnit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit)
-> Data DICompileUnit
DICompileUnit -> Constr
DICompileUnit -> DataType
(forall b. Data b => b -> b) -> DICompileUnit -> DICompileUnit
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) -> DICompileUnit -> u
forall u. (forall d. Data d => d -> u) -> DICompileUnit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompileUnit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompileUnit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompileUnit)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompileUnit -> c DICompileUnit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompileUnit
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompileUnit
$ctoConstr :: DICompileUnit -> Constr
toConstr :: DICompileUnit -> Constr
$cdataTypeOf :: DICompileUnit -> DataType
dataTypeOf :: DICompileUnit -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompileUnit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompileUnit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompileUnit)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompileUnit)
$cgmapT :: (forall b. Data b => b -> b) -> DICompileUnit -> DICompileUnit
gmapT :: (forall b. Data b => b -> b) -> DICompileUnit -> DICompileUnit
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompileUnit -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DICompileUnit -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DICompileUnit -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DICompileUnit -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DICompileUnit -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DICompileUnit -> m DICompileUnit
Data, (forall x. DICompileUnit -> Rep DICompileUnit x)
-> (forall x. Rep DICompileUnit x -> DICompileUnit)
-> Generic DICompileUnit
forall x. Rep DICompileUnit x -> DICompileUnit
forall x. DICompileUnit -> Rep DICompileUnit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DICompileUnit -> Rep DICompileUnit x
from :: forall x. DICompileUnit -> Rep DICompileUnit x
$cto :: forall x. Rep DICompileUnit x -> DICompileUnit
to :: forall x. Rep DICompileUnit x -> DICompileUnit
Generic)

-- | <https://llvm.org/docs/LangRef.html#difile>
data DIFile = File
  { DIFile -> ShortByteString
filename :: ShortByteString
  , DIFile -> ShortByteString
directory :: ShortByteString
  , DIFile -> Maybe ChecksumInfo
checksum :: Maybe ChecksumInfo
  } deriving (DIFile -> DIFile -> Bool
(DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool) -> Eq DIFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIFile -> DIFile -> Bool
== :: DIFile -> DIFile -> Bool
$c/= :: DIFile -> DIFile -> Bool
/= :: DIFile -> DIFile -> Bool
Eq, Eq DIFile
Eq DIFile
-> (DIFile -> DIFile -> Ordering)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> Bool)
-> (DIFile -> DIFile -> DIFile)
-> (DIFile -> DIFile -> DIFile)
-> Ord DIFile
DIFile -> DIFile -> Bool
DIFile -> DIFile -> Ordering
DIFile -> DIFile -> DIFile
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
$ccompare :: DIFile -> DIFile -> Ordering
compare :: DIFile -> DIFile -> Ordering
$c< :: DIFile -> DIFile -> Bool
< :: DIFile -> DIFile -> Bool
$c<= :: DIFile -> DIFile -> Bool
<= :: DIFile -> DIFile -> Bool
$c> :: DIFile -> DIFile -> Bool
> :: DIFile -> DIFile -> Bool
$c>= :: DIFile -> DIFile -> Bool
>= :: DIFile -> DIFile -> Bool
$cmax :: DIFile -> DIFile -> DIFile
max :: DIFile -> DIFile -> DIFile
$cmin :: DIFile -> DIFile -> DIFile
min :: DIFile -> DIFile -> DIFile
Ord, ReadPrec [DIFile]
ReadPrec DIFile
Int -> ReadS DIFile
ReadS [DIFile]
(Int -> ReadS DIFile)
-> ReadS [DIFile]
-> ReadPrec DIFile
-> ReadPrec [DIFile]
-> Read DIFile
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIFile
readsPrec :: Int -> ReadS DIFile
$creadList :: ReadS [DIFile]
readList :: ReadS [DIFile]
$creadPrec :: ReadPrec DIFile
readPrec :: ReadPrec DIFile
$creadListPrec :: ReadPrec [DIFile]
readListPrec :: ReadPrec [DIFile]
Read, Int -> DIFile -> ShowS
[DIFile] -> ShowS
DIFile -> String
(Int -> DIFile -> ShowS)
-> (DIFile -> String) -> ([DIFile] -> ShowS) -> Show DIFile
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIFile -> ShowS
showsPrec :: Int -> DIFile -> ShowS
$cshow :: DIFile -> String
show :: DIFile -> String
$cshowList :: [DIFile] -> ShowS
showList :: [DIFile] -> ShowS
Show, Typeable, Typeable DIFile
Typeable DIFile
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIFile -> c DIFile)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIFile)
-> (DIFile -> Constr)
-> (DIFile -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIFile))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile))
-> ((forall b. Data b => b -> b) -> DIFile -> DIFile)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFile -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIFile -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIFile -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIFile -> m DIFile)
-> Data DIFile
DIFile -> Constr
DIFile -> DataType
(forall b. Data b => b -> b) -> DIFile -> DIFile
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) -> DIFile -> u
forall u. (forall d. Data d => d -> u) -> DIFile -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFile)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIFile -> c DIFile
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIFile
$ctoConstr :: DIFile -> Constr
toConstr :: DIFile -> Constr
$cdataTypeOf :: DIFile -> DataType
dataTypeOf :: DIFile -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFile)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIFile)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIFile)
$cgmapT :: (forall b. Data b => b -> b) -> DIFile -> DIFile
gmapT :: (forall b. Data b => b -> b) -> DIFile -> DIFile
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIFile -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIFile -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIFile -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIFile -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIFile -> m DIFile
Data, (forall x. DIFile -> Rep DIFile x)
-> (forall x. Rep DIFile x -> DIFile) -> Generic DIFile
forall x. Rep DIFile x -> DIFile
forall x. DIFile -> Rep DIFile x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIFile -> Rep DIFile x
from :: forall x. DIFile -> Rep DIFile x
$cto :: forall x. Rep DIFile x -> DIFile
to :: forall x. Rep DIFile x -> DIFile
Generic)

data ChecksumInfo = ChecksumInfo
  { ChecksumInfo -> ChecksumKind
checksumKind :: ChecksumKind
  , ChecksumInfo -> ShortByteString
checksumValue :: ShortByteString
  } deriving (ChecksumInfo -> ChecksumInfo -> Bool
(ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> Bool) -> Eq ChecksumInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChecksumInfo -> ChecksumInfo -> Bool
== :: ChecksumInfo -> ChecksumInfo -> Bool
$c/= :: ChecksumInfo -> ChecksumInfo -> Bool
/= :: ChecksumInfo -> ChecksumInfo -> Bool
Eq, Eq ChecksumInfo
Eq ChecksumInfo
-> (ChecksumInfo -> ChecksumInfo -> Ordering)
-> (ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> Bool)
-> (ChecksumInfo -> ChecksumInfo -> ChecksumInfo)
-> (ChecksumInfo -> ChecksumInfo -> ChecksumInfo)
-> Ord ChecksumInfo
ChecksumInfo -> ChecksumInfo -> Bool
ChecksumInfo -> ChecksumInfo -> Ordering
ChecksumInfo -> ChecksumInfo -> ChecksumInfo
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
$ccompare :: ChecksumInfo -> ChecksumInfo -> Ordering
compare :: ChecksumInfo -> ChecksumInfo -> Ordering
$c< :: ChecksumInfo -> ChecksumInfo -> Bool
< :: ChecksumInfo -> ChecksumInfo -> Bool
$c<= :: ChecksumInfo -> ChecksumInfo -> Bool
<= :: ChecksumInfo -> ChecksumInfo -> Bool
$c> :: ChecksumInfo -> ChecksumInfo -> Bool
> :: ChecksumInfo -> ChecksumInfo -> Bool
$c>= :: ChecksumInfo -> ChecksumInfo -> Bool
>= :: ChecksumInfo -> ChecksumInfo -> Bool
$cmax :: ChecksumInfo -> ChecksumInfo -> ChecksumInfo
max :: ChecksumInfo -> ChecksumInfo -> ChecksumInfo
$cmin :: ChecksumInfo -> ChecksumInfo -> ChecksumInfo
min :: ChecksumInfo -> ChecksumInfo -> ChecksumInfo
Ord, ReadPrec [ChecksumInfo]
ReadPrec ChecksumInfo
Int -> ReadS ChecksumInfo
ReadS [ChecksumInfo]
(Int -> ReadS ChecksumInfo)
-> ReadS [ChecksumInfo]
-> ReadPrec ChecksumInfo
-> ReadPrec [ChecksumInfo]
-> Read ChecksumInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ChecksumInfo
readsPrec :: Int -> ReadS ChecksumInfo
$creadList :: ReadS [ChecksumInfo]
readList :: ReadS [ChecksumInfo]
$creadPrec :: ReadPrec ChecksumInfo
readPrec :: ReadPrec ChecksumInfo
$creadListPrec :: ReadPrec [ChecksumInfo]
readListPrec :: ReadPrec [ChecksumInfo]
Read, Int -> ChecksumInfo -> ShowS
[ChecksumInfo] -> ShowS
ChecksumInfo -> String
(Int -> ChecksumInfo -> ShowS)
-> (ChecksumInfo -> String)
-> ([ChecksumInfo] -> ShowS)
-> Show ChecksumInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChecksumInfo -> ShowS
showsPrec :: Int -> ChecksumInfo -> ShowS
$cshow :: ChecksumInfo -> String
show :: ChecksumInfo -> String
$cshowList :: [ChecksumInfo] -> ShowS
showList :: [ChecksumInfo] -> ShowS
Show, Typeable, Typeable ChecksumInfo
Typeable ChecksumInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ChecksumInfo)
-> (ChecksumInfo -> Constr)
-> (ChecksumInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ChecksumInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ChecksumInfo))
-> ((forall b. Data b => b -> b) -> ChecksumInfo -> ChecksumInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> ChecksumInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ChecksumInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo)
-> Data ChecksumInfo
ChecksumInfo -> Constr
ChecksumInfo -> DataType
(forall b. Data b => b -> b) -> ChecksumInfo -> ChecksumInfo
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) -> ChecksumInfo -> u
forall u. (forall d. Data d => d -> u) -> ChecksumInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumInfo)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumInfo -> c ChecksumInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumInfo
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumInfo
$ctoConstr :: ChecksumInfo -> Constr
toConstr :: ChecksumInfo -> Constr
$cdataTypeOf :: ChecksumInfo -> DataType
dataTypeOf :: ChecksumInfo -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumInfo)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumInfo)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumInfo)
$cgmapT :: (forall b. Data b => b -> b) -> ChecksumInfo -> ChecksumInfo
gmapT :: (forall b. Data b => b -> b) -> ChecksumInfo -> ChecksumInfo
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumInfo -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChecksumInfo -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ChecksumInfo -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChecksumInfo -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChecksumInfo -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumInfo -> m ChecksumInfo
Data, (forall x. ChecksumInfo -> Rep ChecksumInfo x)
-> (forall x. Rep ChecksumInfo x -> ChecksumInfo)
-> Generic ChecksumInfo
forall x. Rep ChecksumInfo x -> ChecksumInfo
forall x. ChecksumInfo -> Rep ChecksumInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ChecksumInfo -> Rep ChecksumInfo x
from :: forall x. ChecksumInfo -> Rep ChecksumInfo x
$cto :: forall x. Rep ChecksumInfo x -> ChecksumInfo
to :: forall x. Rep ChecksumInfo x -> ChecksumInfo
Generic)

data ChecksumKind = MD5 | SHA1
  deriving (ChecksumKind -> ChecksumKind -> Bool
(ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> Bool) -> Eq ChecksumKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ChecksumKind -> ChecksumKind -> Bool
== :: ChecksumKind -> ChecksumKind -> Bool
$c/= :: ChecksumKind -> ChecksumKind -> Bool
/= :: ChecksumKind -> ChecksumKind -> Bool
Eq, Eq ChecksumKind
Eq ChecksumKind
-> (ChecksumKind -> ChecksumKind -> Ordering)
-> (ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> Bool)
-> (ChecksumKind -> ChecksumKind -> ChecksumKind)
-> (ChecksumKind -> ChecksumKind -> ChecksumKind)
-> Ord ChecksumKind
ChecksumKind -> ChecksumKind -> Bool
ChecksumKind -> ChecksumKind -> Ordering
ChecksumKind -> ChecksumKind -> ChecksumKind
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
$ccompare :: ChecksumKind -> ChecksumKind -> Ordering
compare :: ChecksumKind -> ChecksumKind -> Ordering
$c< :: ChecksumKind -> ChecksumKind -> Bool
< :: ChecksumKind -> ChecksumKind -> Bool
$c<= :: ChecksumKind -> ChecksumKind -> Bool
<= :: ChecksumKind -> ChecksumKind -> Bool
$c> :: ChecksumKind -> ChecksumKind -> Bool
> :: ChecksumKind -> ChecksumKind -> Bool
$c>= :: ChecksumKind -> ChecksumKind -> Bool
>= :: ChecksumKind -> ChecksumKind -> Bool
$cmax :: ChecksumKind -> ChecksumKind -> ChecksumKind
max :: ChecksumKind -> ChecksumKind -> ChecksumKind
$cmin :: ChecksumKind -> ChecksumKind -> ChecksumKind
min :: ChecksumKind -> ChecksumKind -> ChecksumKind
Ord, ReadPrec [ChecksumKind]
ReadPrec ChecksumKind
Int -> ReadS ChecksumKind
ReadS [ChecksumKind]
(Int -> ReadS ChecksumKind)
-> ReadS [ChecksumKind]
-> ReadPrec ChecksumKind
-> ReadPrec [ChecksumKind]
-> Read ChecksumKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ChecksumKind
readsPrec :: Int -> ReadS ChecksumKind
$creadList :: ReadS [ChecksumKind]
readList :: ReadS [ChecksumKind]
$creadPrec :: ReadPrec ChecksumKind
readPrec :: ReadPrec ChecksumKind
$creadListPrec :: ReadPrec [ChecksumKind]
readListPrec :: ReadPrec [ChecksumKind]
Read, Int -> ChecksumKind -> ShowS
[ChecksumKind] -> ShowS
ChecksumKind -> String
(Int -> ChecksumKind -> ShowS)
-> (ChecksumKind -> String)
-> ([ChecksumKind] -> ShowS)
-> Show ChecksumKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ChecksumKind -> ShowS
showsPrec :: Int -> ChecksumKind -> ShowS
$cshow :: ChecksumKind -> String
show :: ChecksumKind -> String
$cshowList :: [ChecksumKind] -> ShowS
showList :: [ChecksumKind] -> ShowS
Show, Typeable, Typeable ChecksumKind
Typeable ChecksumKind
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ChecksumKind)
-> (ChecksumKind -> Constr)
-> (ChecksumKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ChecksumKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ChecksumKind))
-> ((forall b. Data b => b -> b) -> ChecksumKind -> ChecksumKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r)
-> (forall u. (forall d. Data d => d -> u) -> ChecksumKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ChecksumKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind)
-> Data ChecksumKind
ChecksumKind -> Constr
ChecksumKind -> DataType
(forall b. Data b => b -> b) -> ChecksumKind -> ChecksumKind
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) -> ChecksumKind -> u
forall u. (forall d. Data d => d -> u) -> ChecksumKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumKind)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ChecksumKind -> c ChecksumKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumKind
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ChecksumKind
$ctoConstr :: ChecksumKind -> Constr
toConstr :: ChecksumKind -> Constr
$cdataTypeOf :: ChecksumKind -> DataType
dataTypeOf :: ChecksumKind -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumKind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ChecksumKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumKind)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ChecksumKind)
$cgmapT :: (forall b. Data b => b -> b) -> ChecksumKind -> ChecksumKind
gmapT :: (forall b. Data b => b -> b) -> ChecksumKind -> ChecksumKind
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ChecksumKind -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ChecksumKind -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ChecksumKind -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChecksumKind -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ChecksumKind -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ChecksumKind -> m ChecksumKind
Data, (forall x. ChecksumKind -> Rep ChecksumKind x)
-> (forall x. Rep ChecksumKind x -> ChecksumKind)
-> Generic ChecksumKind
forall x. Rep ChecksumKind x -> ChecksumKind
forall x. ChecksumKind -> Rep ChecksumKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ChecksumKind -> Rep ChecksumKind x
from :: forall x. ChecksumKind -> Rep ChecksumKind x
$cto :: forall x. Rep ChecksumKind x -> ChecksumKind
to :: forall x. Rep ChecksumKind x -> ChecksumKind
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DILocalScope.html>
data DILocalScope
  = DILexicalBlockBase DILexicalBlockBase
  | DISubprogram DISubprogram
  deriving (DILocalScope -> DILocalScope -> Bool
(DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> Bool) -> Eq DILocalScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DILocalScope -> DILocalScope -> Bool
== :: DILocalScope -> DILocalScope -> Bool
$c/= :: DILocalScope -> DILocalScope -> Bool
/= :: DILocalScope -> DILocalScope -> Bool
Eq, Eq DILocalScope
Eq DILocalScope
-> (DILocalScope -> DILocalScope -> Ordering)
-> (DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> Bool)
-> (DILocalScope -> DILocalScope -> DILocalScope)
-> (DILocalScope -> DILocalScope -> DILocalScope)
-> Ord DILocalScope
DILocalScope -> DILocalScope -> Bool
DILocalScope -> DILocalScope -> Ordering
DILocalScope -> DILocalScope -> DILocalScope
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
$ccompare :: DILocalScope -> DILocalScope -> Ordering
compare :: DILocalScope -> DILocalScope -> Ordering
$c< :: DILocalScope -> DILocalScope -> Bool
< :: DILocalScope -> DILocalScope -> Bool
$c<= :: DILocalScope -> DILocalScope -> Bool
<= :: DILocalScope -> DILocalScope -> Bool
$c> :: DILocalScope -> DILocalScope -> Bool
> :: DILocalScope -> DILocalScope -> Bool
$c>= :: DILocalScope -> DILocalScope -> Bool
>= :: DILocalScope -> DILocalScope -> Bool
$cmax :: DILocalScope -> DILocalScope -> DILocalScope
max :: DILocalScope -> DILocalScope -> DILocalScope
$cmin :: DILocalScope -> DILocalScope -> DILocalScope
min :: DILocalScope -> DILocalScope -> DILocalScope
Ord, ReadPrec [DILocalScope]
ReadPrec DILocalScope
Int -> ReadS DILocalScope
ReadS [DILocalScope]
(Int -> ReadS DILocalScope)
-> ReadS [DILocalScope]
-> ReadPrec DILocalScope
-> ReadPrec [DILocalScope]
-> Read DILocalScope
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DILocalScope
readsPrec :: Int -> ReadS DILocalScope
$creadList :: ReadS [DILocalScope]
readList :: ReadS [DILocalScope]
$creadPrec :: ReadPrec DILocalScope
readPrec :: ReadPrec DILocalScope
$creadListPrec :: ReadPrec [DILocalScope]
readListPrec :: ReadPrec [DILocalScope]
Read, Int -> DILocalScope -> ShowS
[DILocalScope] -> ShowS
DILocalScope -> String
(Int -> DILocalScope -> ShowS)
-> (DILocalScope -> String)
-> ([DILocalScope] -> ShowS)
-> Show DILocalScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DILocalScope -> ShowS
showsPrec :: Int -> DILocalScope -> ShowS
$cshow :: DILocalScope -> String
show :: DILocalScope -> String
$cshowList :: [DILocalScope] -> ShowS
showList :: [DILocalScope] -> ShowS
Show, Typeable, Typeable DILocalScope
Typeable DILocalScope
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DILocalScope -> c DILocalScope)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DILocalScope)
-> (DILocalScope -> Constr)
-> (DILocalScope -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DILocalScope))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DILocalScope))
-> ((forall b. Data b => b -> b) -> DILocalScope -> DILocalScope)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalScope -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalScope -> r)
-> (forall u. (forall d. Data d => d -> u) -> DILocalScope -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILocalScope -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope)
-> Data DILocalScope
DILocalScope -> Constr
DILocalScope -> DataType
(forall b. Data b => b -> b) -> DILocalScope -> DILocalScope
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) -> DILocalScope -> u
forall u. (forall d. Data d => d -> u) -> DILocalScope -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalScope
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalScope -> c DILocalScope
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalScope)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalScope)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalScope -> c DILocalScope
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalScope -> c DILocalScope
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalScope
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalScope
$ctoConstr :: DILocalScope -> Constr
toConstr :: DILocalScope -> Constr
$cdataTypeOf :: DILocalScope -> DataType
dataTypeOf :: DILocalScope -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalScope)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalScope)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalScope)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalScope)
$cgmapT :: (forall b. Data b => b -> b) -> DILocalScope -> DILocalScope
gmapT :: (forall b. Data b => b -> b) -> DILocalScope -> DILocalScope
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalScope -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DILocalScope -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DILocalScope -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DILocalScope -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DILocalScope -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DILocalScope -> m DILocalScope
Data, (forall x. DILocalScope -> Rep DILocalScope x)
-> (forall x. Rep DILocalScope x -> DILocalScope)
-> Generic DILocalScope
forall x. Rep DILocalScope x -> DILocalScope
forall x. DILocalScope -> Rep DILocalScope x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DILocalScope -> Rep DILocalScope x
from :: forall x. DILocalScope -> Rep DILocalScope x
$cto :: forall x. Rep DILocalScope x -> DILocalScope
to :: forall x. Rep DILocalScope x -> DILocalScope
Generic)

-- | <https://llvm.org/docs/LangRef.html#disubprogram>
data DISubprogram = Subprogram
  { DISubprogram -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
  , DISubprogram -> ShortByteString
name :: ShortByteString
  , DISubprogram -> ShortByteString
linkageName :: ShortByteString
  , DISubprogram -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DISubprogram -> Word32
line :: Word32
  , DISubprogram -> Maybe (MDRef DISubroutineType)
type' :: Maybe (MDRef DISubroutineType)
  , DISubprogram -> Bool
localToUnit :: Bool
  , DISubprogram -> Bool
definition :: Bool
  , DISubprogram -> Word32
scopeLine :: Word32
  , DISubprogram -> Maybe (MDRef DIType)
containingType :: Maybe (MDRef DIType)
  , DISubprogram -> Virtuality
virtuality :: Virtuality
  , DISubprogram -> Word32
virtualityIndex :: Word32
  , DISubprogram -> Int32
thisAdjustment :: Int32
  , DISubprogram -> [DIFlag]
flags :: [DIFlag]
  , DISubprogram -> Bool
optimized :: Bool
  , DISubprogram -> Maybe (MDRef DICompileUnit)
unit :: Maybe (MDRef DICompileUnit)
  , DISubprogram -> [MDRef DITemplateParameter]
templateParams :: [MDRef DITemplateParameter]
  , DISubprogram -> Maybe (MDRef DISubprogram)
declaration :: Maybe (MDRef DISubprogram)
  , DISubprogram -> [MDRef DILocalVariable]
retainedNodes :: [MDRef DILocalVariable]
  , DISubprogram -> [MDRef DIType]
thrownTypes :: [MDRef DIType]
  } deriving (DISubprogram -> DISubprogram -> Bool
(DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> Bool) -> Eq DISubprogram
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DISubprogram -> DISubprogram -> Bool
== :: DISubprogram -> DISubprogram -> Bool
$c/= :: DISubprogram -> DISubprogram -> Bool
/= :: DISubprogram -> DISubprogram -> Bool
Eq, Eq DISubprogram
Eq DISubprogram
-> (DISubprogram -> DISubprogram -> Ordering)
-> (DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> Bool)
-> (DISubprogram -> DISubprogram -> DISubprogram)
-> (DISubprogram -> DISubprogram -> DISubprogram)
-> Ord DISubprogram
DISubprogram -> DISubprogram -> Bool
DISubprogram -> DISubprogram -> Ordering
DISubprogram -> DISubprogram -> DISubprogram
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
$ccompare :: DISubprogram -> DISubprogram -> Ordering
compare :: DISubprogram -> DISubprogram -> Ordering
$c< :: DISubprogram -> DISubprogram -> Bool
< :: DISubprogram -> DISubprogram -> Bool
$c<= :: DISubprogram -> DISubprogram -> Bool
<= :: DISubprogram -> DISubprogram -> Bool
$c> :: DISubprogram -> DISubprogram -> Bool
> :: DISubprogram -> DISubprogram -> Bool
$c>= :: DISubprogram -> DISubprogram -> Bool
>= :: DISubprogram -> DISubprogram -> Bool
$cmax :: DISubprogram -> DISubprogram -> DISubprogram
max :: DISubprogram -> DISubprogram -> DISubprogram
$cmin :: DISubprogram -> DISubprogram -> DISubprogram
min :: DISubprogram -> DISubprogram -> DISubprogram
Ord, ReadPrec [DISubprogram]
ReadPrec DISubprogram
Int -> ReadS DISubprogram
ReadS [DISubprogram]
(Int -> ReadS DISubprogram)
-> ReadS [DISubprogram]
-> ReadPrec DISubprogram
-> ReadPrec [DISubprogram]
-> Read DISubprogram
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DISubprogram
readsPrec :: Int -> ReadS DISubprogram
$creadList :: ReadS [DISubprogram]
readList :: ReadS [DISubprogram]
$creadPrec :: ReadPrec DISubprogram
readPrec :: ReadPrec DISubprogram
$creadListPrec :: ReadPrec [DISubprogram]
readListPrec :: ReadPrec [DISubprogram]
Read, Int -> DISubprogram -> ShowS
[DISubprogram] -> ShowS
DISubprogram -> String
(Int -> DISubprogram -> ShowS)
-> (DISubprogram -> String)
-> ([DISubprogram] -> ShowS)
-> Show DISubprogram
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DISubprogram -> ShowS
showsPrec :: Int -> DISubprogram -> ShowS
$cshow :: DISubprogram -> String
show :: DISubprogram -> String
$cshowList :: [DISubprogram] -> ShowS
showList :: [DISubprogram] -> ShowS
Show, Typeable, Typeable DISubprogram
Typeable DISubprogram
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DISubprogram -> c DISubprogram)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DISubprogram)
-> (DISubprogram -> Constr)
-> (DISubprogram -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DISubprogram))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DISubprogram))
-> ((forall b. Data b => b -> b) -> DISubprogram -> DISubprogram)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubprogram -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubprogram -> r)
-> (forall u. (forall d. Data d => d -> u) -> DISubprogram -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubprogram -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram)
-> Data DISubprogram
DISubprogram -> Constr
DISubprogram -> DataType
(forall b. Data b => b -> b) -> DISubprogram -> DISubprogram
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) -> DISubprogram -> u
forall u. (forall d. Data d => d -> u) -> DISubprogram -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubprogram
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubprogram -> c DISubprogram
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubprogram)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubprogram)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubprogram -> c DISubprogram
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubprogram -> c DISubprogram
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubprogram
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubprogram
$ctoConstr :: DISubprogram -> Constr
toConstr :: DISubprogram -> Constr
$cdataTypeOf :: DISubprogram -> DataType
dataTypeOf :: DISubprogram -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubprogram)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubprogram)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubprogram)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubprogram)
$cgmapT :: (forall b. Data b => b -> b) -> DISubprogram -> DISubprogram
gmapT :: (forall b. Data b => b -> b) -> DISubprogram -> DISubprogram
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubprogram -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DISubprogram -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DISubprogram -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DISubprogram -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DISubprogram -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DISubprogram -> m DISubprogram
Data, (forall x. DISubprogram -> Rep DISubprogram x)
-> (forall x. Rep DISubprogram x -> DISubprogram)
-> Generic DISubprogram
forall x. Rep DISubprogram x -> DISubprogram
forall x. DISubprogram -> Rep DISubprogram x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DISubprogram -> Rep DISubprogram x
from :: forall x. DISubprogram -> Rep DISubprogram x
$cto :: forall x. Rep DISubprogram x -> DISubprogram
to :: forall x. Rep DISubprogram x -> DISubprogram
Generic)

data Virtuality = NoVirtuality | Virtual | PureVirtual
  deriving (Virtuality -> Virtuality -> Bool
(Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Bool) -> Eq Virtuality
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Virtuality -> Virtuality -> Bool
== :: Virtuality -> Virtuality -> Bool
$c/= :: Virtuality -> Virtuality -> Bool
/= :: Virtuality -> Virtuality -> Bool
Eq, Eq Virtuality
Eq Virtuality
-> (Virtuality -> Virtuality -> Ordering)
-> (Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Bool)
-> (Virtuality -> Virtuality -> Virtuality)
-> (Virtuality -> Virtuality -> Virtuality)
-> Ord Virtuality
Virtuality -> Virtuality -> Bool
Virtuality -> Virtuality -> Ordering
Virtuality -> Virtuality -> Virtuality
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
$ccompare :: Virtuality -> Virtuality -> Ordering
compare :: Virtuality -> Virtuality -> Ordering
$c< :: Virtuality -> Virtuality -> Bool
< :: Virtuality -> Virtuality -> Bool
$c<= :: Virtuality -> Virtuality -> Bool
<= :: Virtuality -> Virtuality -> Bool
$c> :: Virtuality -> Virtuality -> Bool
> :: Virtuality -> Virtuality -> Bool
$c>= :: Virtuality -> Virtuality -> Bool
>= :: Virtuality -> Virtuality -> Bool
$cmax :: Virtuality -> Virtuality -> Virtuality
max :: Virtuality -> Virtuality -> Virtuality
$cmin :: Virtuality -> Virtuality -> Virtuality
min :: Virtuality -> Virtuality -> Virtuality
Ord, ReadPrec [Virtuality]
ReadPrec Virtuality
Int -> ReadS Virtuality
ReadS [Virtuality]
(Int -> ReadS Virtuality)
-> ReadS [Virtuality]
-> ReadPrec Virtuality
-> ReadPrec [Virtuality]
-> Read Virtuality
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Virtuality
readsPrec :: Int -> ReadS Virtuality
$creadList :: ReadS [Virtuality]
readList :: ReadS [Virtuality]
$creadPrec :: ReadPrec Virtuality
readPrec :: ReadPrec Virtuality
$creadListPrec :: ReadPrec [Virtuality]
readListPrec :: ReadPrec [Virtuality]
Read, Int -> Virtuality -> ShowS
[Virtuality] -> ShowS
Virtuality -> String
(Int -> Virtuality -> ShowS)
-> (Virtuality -> String)
-> ([Virtuality] -> ShowS)
-> Show Virtuality
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Virtuality -> ShowS
showsPrec :: Int -> Virtuality -> ShowS
$cshow :: Virtuality -> String
show :: Virtuality -> String
$cshowList :: [Virtuality] -> ShowS
showList :: [Virtuality] -> ShowS
Show, Typeable, Typeable Virtuality
Typeable Virtuality
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Virtuality -> c Virtuality)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Virtuality)
-> (Virtuality -> Constr)
-> (Virtuality -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Virtuality))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Virtuality))
-> ((forall b. Data b => b -> b) -> Virtuality -> Virtuality)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Virtuality -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Virtuality -> r)
-> (forall u. (forall d. Data d => d -> u) -> Virtuality -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Virtuality -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Virtuality -> m Virtuality)
-> Data Virtuality
Virtuality -> Constr
Virtuality -> DataType
(forall b. Data b => b -> b) -> Virtuality -> Virtuality
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) -> Virtuality -> u
forall u. (forall d. Data d => d -> u) -> Virtuality -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Virtuality
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Virtuality -> c Virtuality
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Virtuality)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Virtuality)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Virtuality -> c Virtuality
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Virtuality -> c Virtuality
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Virtuality
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Virtuality
$ctoConstr :: Virtuality -> Constr
toConstr :: Virtuality -> Constr
$cdataTypeOf :: Virtuality -> DataType
dataTypeOf :: Virtuality -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Virtuality)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Virtuality)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Virtuality)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Virtuality)
$cgmapT :: (forall b. Data b => b -> b) -> Virtuality -> Virtuality
gmapT :: (forall b. Data b => b -> b) -> Virtuality -> Virtuality
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Virtuality -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Virtuality -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Virtuality -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Virtuality -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Virtuality -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Virtuality -> m Virtuality
Data, (forall x. Virtuality -> Rep Virtuality x)
-> (forall x. Rep Virtuality x -> Virtuality) -> Generic Virtuality
forall x. Rep Virtuality x -> Virtuality
forall x. Virtuality -> Rep Virtuality x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Virtuality -> Rep Virtuality x
from :: forall x. Virtuality -> Rep Virtuality x
$cto :: forall x. Rep Virtuality x -> Virtuality
to :: forall x. Rep Virtuality x -> Virtuality
Generic)

data BasicTypeTag = BaseType | UnspecifiedType
  deriving (BasicTypeTag -> BasicTypeTag -> Bool
(BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> Bool) -> Eq BasicTypeTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BasicTypeTag -> BasicTypeTag -> Bool
== :: BasicTypeTag -> BasicTypeTag -> Bool
$c/= :: BasicTypeTag -> BasicTypeTag -> Bool
/= :: BasicTypeTag -> BasicTypeTag -> Bool
Eq, Eq BasicTypeTag
Eq BasicTypeTag
-> (BasicTypeTag -> BasicTypeTag -> Ordering)
-> (BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> Bool)
-> (BasicTypeTag -> BasicTypeTag -> BasicTypeTag)
-> (BasicTypeTag -> BasicTypeTag -> BasicTypeTag)
-> Ord BasicTypeTag
BasicTypeTag -> BasicTypeTag -> Bool
BasicTypeTag -> BasicTypeTag -> Ordering
BasicTypeTag -> BasicTypeTag -> BasicTypeTag
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
$ccompare :: BasicTypeTag -> BasicTypeTag -> Ordering
compare :: BasicTypeTag -> BasicTypeTag -> Ordering
$c< :: BasicTypeTag -> BasicTypeTag -> Bool
< :: BasicTypeTag -> BasicTypeTag -> Bool
$c<= :: BasicTypeTag -> BasicTypeTag -> Bool
<= :: BasicTypeTag -> BasicTypeTag -> Bool
$c> :: BasicTypeTag -> BasicTypeTag -> Bool
> :: BasicTypeTag -> BasicTypeTag -> Bool
$c>= :: BasicTypeTag -> BasicTypeTag -> Bool
>= :: BasicTypeTag -> BasicTypeTag -> Bool
$cmax :: BasicTypeTag -> BasicTypeTag -> BasicTypeTag
max :: BasicTypeTag -> BasicTypeTag -> BasicTypeTag
$cmin :: BasicTypeTag -> BasicTypeTag -> BasicTypeTag
min :: BasicTypeTag -> BasicTypeTag -> BasicTypeTag
Ord, ReadPrec [BasicTypeTag]
ReadPrec BasicTypeTag
Int -> ReadS BasicTypeTag
ReadS [BasicTypeTag]
(Int -> ReadS BasicTypeTag)
-> ReadS [BasicTypeTag]
-> ReadPrec BasicTypeTag
-> ReadPrec [BasicTypeTag]
-> Read BasicTypeTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BasicTypeTag
readsPrec :: Int -> ReadS BasicTypeTag
$creadList :: ReadS [BasicTypeTag]
readList :: ReadS [BasicTypeTag]
$creadPrec :: ReadPrec BasicTypeTag
readPrec :: ReadPrec BasicTypeTag
$creadListPrec :: ReadPrec [BasicTypeTag]
readListPrec :: ReadPrec [BasicTypeTag]
Read, Int -> BasicTypeTag -> ShowS
[BasicTypeTag] -> ShowS
BasicTypeTag -> String
(Int -> BasicTypeTag -> ShowS)
-> (BasicTypeTag -> String)
-> ([BasicTypeTag] -> ShowS)
-> Show BasicTypeTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BasicTypeTag -> ShowS
showsPrec :: Int -> BasicTypeTag -> ShowS
$cshow :: BasicTypeTag -> String
show :: BasicTypeTag -> String
$cshowList :: [BasicTypeTag] -> ShowS
showList :: [BasicTypeTag] -> ShowS
Show, Typeable, Typeable BasicTypeTag
Typeable BasicTypeTag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BasicTypeTag)
-> (BasicTypeTag -> Constr)
-> (BasicTypeTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BasicTypeTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BasicTypeTag))
-> ((forall b. Data b => b -> b) -> BasicTypeTag -> BasicTypeTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r)
-> (forall u. (forall d. Data d => d -> u) -> BasicTypeTag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BasicTypeTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag)
-> Data BasicTypeTag
BasicTypeTag -> Constr
BasicTypeTag -> DataType
(forall b. Data b => b -> b) -> BasicTypeTag -> BasicTypeTag
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) -> BasicTypeTag -> u
forall u. (forall d. Data d => d -> u) -> BasicTypeTag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicTypeTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BasicTypeTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BasicTypeTag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BasicTypeTag -> c BasicTypeTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicTypeTag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BasicTypeTag
$ctoConstr :: BasicTypeTag -> Constr
toConstr :: BasicTypeTag -> Constr
$cdataTypeOf :: BasicTypeTag -> DataType
dataTypeOf :: BasicTypeTag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BasicTypeTag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BasicTypeTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BasicTypeTag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BasicTypeTag)
$cgmapT :: (forall b. Data b => b -> b) -> BasicTypeTag -> BasicTypeTag
gmapT :: (forall b. Data b => b -> b) -> BasicTypeTag -> BasicTypeTag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BasicTypeTag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BasicTypeTag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BasicTypeTag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BasicTypeTag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BasicTypeTag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BasicTypeTag -> m BasicTypeTag
Data, (forall x. BasicTypeTag -> Rep BasicTypeTag x)
-> (forall x. Rep BasicTypeTag x -> BasicTypeTag)
-> Generic BasicTypeTag
forall x. Rep BasicTypeTag x -> BasicTypeTag
forall x. BasicTypeTag -> Rep BasicTypeTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BasicTypeTag -> Rep BasicTypeTag x
from :: forall x. BasicTypeTag -> Rep BasicTypeTag x
$cto :: forall x. Rep BasicTypeTag x -> BasicTypeTag
to :: forall x. Rep BasicTypeTag x -> BasicTypeTag
Generic)

-- <https://llvm.org/doxygen/classllvm_1_1DIType.html>
data DIType
  = DIBasicType DIBasicType
  | DICompositeType DICompositeType
  | DIDerivedType DIDerivedType
  | DISubroutineType DISubroutineType
  deriving (DIType -> DIType -> Bool
(DIType -> DIType -> Bool)
-> (DIType -> DIType -> Bool) -> Eq DIType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIType -> DIType -> Bool
== :: DIType -> DIType -> Bool
$c/= :: DIType -> DIType -> Bool
/= :: DIType -> DIType -> Bool
Eq, Eq DIType
Eq DIType
-> (DIType -> DIType -> Ordering)
-> (DIType -> DIType -> Bool)
-> (DIType -> DIType -> Bool)
-> (DIType -> DIType -> Bool)
-> (DIType -> DIType -> Bool)
-> (DIType -> DIType -> DIType)
-> (DIType -> DIType -> DIType)
-> Ord DIType
DIType -> DIType -> Bool
DIType -> DIType -> Ordering
DIType -> DIType -> DIType
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
$ccompare :: DIType -> DIType -> Ordering
compare :: DIType -> DIType -> Ordering
$c< :: DIType -> DIType -> Bool
< :: DIType -> DIType -> Bool
$c<= :: DIType -> DIType -> Bool
<= :: DIType -> DIType -> Bool
$c> :: DIType -> DIType -> Bool
> :: DIType -> DIType -> Bool
$c>= :: DIType -> DIType -> Bool
>= :: DIType -> DIType -> Bool
$cmax :: DIType -> DIType -> DIType
max :: DIType -> DIType -> DIType
$cmin :: DIType -> DIType -> DIType
min :: DIType -> DIType -> DIType
Ord, ReadPrec [DIType]
ReadPrec DIType
Int -> ReadS DIType
ReadS [DIType]
(Int -> ReadS DIType)
-> ReadS [DIType]
-> ReadPrec DIType
-> ReadPrec [DIType]
-> Read DIType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIType
readsPrec :: Int -> ReadS DIType
$creadList :: ReadS [DIType]
readList :: ReadS [DIType]
$creadPrec :: ReadPrec DIType
readPrec :: ReadPrec DIType
$creadListPrec :: ReadPrec [DIType]
readListPrec :: ReadPrec [DIType]
Read, Int -> DIType -> ShowS
[DIType] -> ShowS
DIType -> String
(Int -> DIType -> ShowS)
-> (DIType -> String) -> ([DIType] -> ShowS) -> Show DIType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIType -> ShowS
showsPrec :: Int -> DIType -> ShowS
$cshow :: DIType -> String
show :: DIType -> String
$cshowList :: [DIType] -> ShowS
showList :: [DIType] -> ShowS
Show, Typeable, Typeable DIType
Typeable DIType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIType -> c DIType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIType)
-> (DIType -> Constr)
-> (DIType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIType))
-> ((forall b. Data b => b -> b) -> DIType -> DIType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DIType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIType -> m DIType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIType -> m DIType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIType -> m DIType)
-> Data DIType
DIType -> Constr
DIType -> DataType
(forall b. Data b => b -> b) -> DIType -> DIType
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) -> DIType -> u
forall u. (forall d. Data d => d -> u) -> DIType -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIType -> c DIType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIType -> c DIType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIType -> c DIType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIType
$ctoConstr :: DIType -> Constr
toConstr :: DIType -> Constr
$cdataTypeOf :: DIType -> DataType
dataTypeOf :: DIType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIType)
$cgmapT :: (forall b. Data b => b -> b) -> DIType -> DIType
gmapT :: (forall b. Data b => b -> b) -> DIType -> DIType
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DIType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIType -> m DIType
Data, (forall x. DIType -> Rep DIType x)
-> (forall x. Rep DIType x -> DIType) -> Generic DIType
forall x. Rep DIType x -> DIType
forall x. DIType -> Rep DIType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIType -> Rep DIType x
from :: forall x. DIType -> Rep DIType x
$cto :: forall x. Rep DIType x -> DIType
to :: forall x. Rep DIType x -> DIType
Generic)

-- | <https://llvm.org/docs/LangRef.html#dibasictype>
data DIBasicType = BasicType
  { DIBasicType -> ShortByteString
name :: ShortByteString
  , DIBasicType -> Word64
sizeInBits :: Word64
  , DIBasicType -> Word32
alignInBits :: Word32
  , DIBasicType -> Maybe Encoding
encoding :: Maybe Encoding
  , DIBasicType -> BasicTypeTag
tag :: BasicTypeTag
  , DIBasicType -> [DIFlag]
flags :: [DIFlag]
  } deriving (DIBasicType -> DIBasicType -> Bool
(DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool) -> Eq DIBasicType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIBasicType -> DIBasicType -> Bool
== :: DIBasicType -> DIBasicType -> Bool
$c/= :: DIBasicType -> DIBasicType -> Bool
/= :: DIBasicType -> DIBasicType -> Bool
Eq, Eq DIBasicType
Eq DIBasicType
-> (DIBasicType -> DIBasicType -> Ordering)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> Bool)
-> (DIBasicType -> DIBasicType -> DIBasicType)
-> (DIBasicType -> DIBasicType -> DIBasicType)
-> Ord DIBasicType
DIBasicType -> DIBasicType -> Bool
DIBasicType -> DIBasicType -> Ordering
DIBasicType -> DIBasicType -> DIBasicType
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
$ccompare :: DIBasicType -> DIBasicType -> Ordering
compare :: DIBasicType -> DIBasicType -> Ordering
$c< :: DIBasicType -> DIBasicType -> Bool
< :: DIBasicType -> DIBasicType -> Bool
$c<= :: DIBasicType -> DIBasicType -> Bool
<= :: DIBasicType -> DIBasicType -> Bool
$c> :: DIBasicType -> DIBasicType -> Bool
> :: DIBasicType -> DIBasicType -> Bool
$c>= :: DIBasicType -> DIBasicType -> Bool
>= :: DIBasicType -> DIBasicType -> Bool
$cmax :: DIBasicType -> DIBasicType -> DIBasicType
max :: DIBasicType -> DIBasicType -> DIBasicType
$cmin :: DIBasicType -> DIBasicType -> DIBasicType
min :: DIBasicType -> DIBasicType -> DIBasicType
Ord, ReadPrec [DIBasicType]
ReadPrec DIBasicType
Int -> ReadS DIBasicType
ReadS [DIBasicType]
(Int -> ReadS DIBasicType)
-> ReadS [DIBasicType]
-> ReadPrec DIBasicType
-> ReadPrec [DIBasicType]
-> Read DIBasicType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIBasicType
readsPrec :: Int -> ReadS DIBasicType
$creadList :: ReadS [DIBasicType]
readList :: ReadS [DIBasicType]
$creadPrec :: ReadPrec DIBasicType
readPrec :: ReadPrec DIBasicType
$creadListPrec :: ReadPrec [DIBasicType]
readListPrec :: ReadPrec [DIBasicType]
Read, Int -> DIBasicType -> ShowS
[DIBasicType] -> ShowS
DIBasicType -> String
(Int -> DIBasicType -> ShowS)
-> (DIBasicType -> String)
-> ([DIBasicType] -> ShowS)
-> Show DIBasicType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIBasicType -> ShowS
showsPrec :: Int -> DIBasicType -> ShowS
$cshow :: DIBasicType -> String
show :: DIBasicType -> String
$cshowList :: [DIBasicType] -> ShowS
showList :: [DIBasicType] -> ShowS
Show, Typeable, Typeable DIBasicType
Typeable DIBasicType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIBasicType -> c DIBasicType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIBasicType)
-> (DIBasicType -> Constr)
-> (DIBasicType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIBasicType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIBasicType))
-> ((forall b. Data b => b -> b) -> DIBasicType -> DIBasicType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIBasicType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIBasicType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIBasicType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType)
-> Data DIBasicType
DIBasicType -> Constr
DIBasicType -> DataType
(forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
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) -> DIBasicType -> u
forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIBasicType -> c DIBasicType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIBasicType
$ctoConstr :: DIBasicType -> Constr
toConstr :: DIBasicType -> Constr
$cdataTypeOf :: DIBasicType -> DataType
dataTypeOf :: DIBasicType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIBasicType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIBasicType)
$cgmapT :: (forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
gmapT :: (forall b. Data b => b -> b) -> DIBasicType -> DIBasicType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIBasicType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIBasicType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIBasicType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIBasicType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIBasicType -> m DIBasicType
Data, (forall x. DIBasicType -> Rep DIBasicType x)
-> (forall x. Rep DIBasicType x -> DIBasicType)
-> Generic DIBasicType
forall x. Rep DIBasicType x -> DIBasicType
forall x. DIBasicType -> Rep DIBasicType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIBasicType -> Rep DIBasicType x
from :: forall x. DIBasicType -> Rep DIBasicType x
$cto :: forall x. Rep DIBasicType x -> DIBasicType
to :: forall x. Rep DIBasicType x -> DIBasicType
Generic)

-- | <https://llvm.org/docs/LangRef.html#disubroutinetype>
data DISubroutineType = SubroutineType
  { DISubroutineType -> [DIFlag]
flags :: [DIFlag]
  , DISubroutineType -> Word8
cc :: Word8
  , DISubroutineType -> [Maybe (MDRef DIType)]
typeArray :: [Maybe (MDRef DIType)]
  -- ^ The first element is the return type, the following are the
  -- operand types. `Nothing` corresponds to @void@.
  } deriving (DISubroutineType -> DISubroutineType -> Bool
(DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> Eq DISubroutineType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DISubroutineType -> DISubroutineType -> Bool
== :: DISubroutineType -> DISubroutineType -> Bool
$c/= :: DISubroutineType -> DISubroutineType -> Bool
/= :: DISubroutineType -> DISubroutineType -> Bool
Eq, Eq DISubroutineType
Eq DISubroutineType
-> (DISubroutineType -> DISubroutineType -> Ordering)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> Bool)
-> (DISubroutineType -> DISubroutineType -> DISubroutineType)
-> (DISubroutineType -> DISubroutineType -> DISubroutineType)
-> Ord DISubroutineType
DISubroutineType -> DISubroutineType -> Bool
DISubroutineType -> DISubroutineType -> Ordering
DISubroutineType -> DISubroutineType -> DISubroutineType
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
$ccompare :: DISubroutineType -> DISubroutineType -> Ordering
compare :: DISubroutineType -> DISubroutineType -> Ordering
$c< :: DISubroutineType -> DISubroutineType -> Bool
< :: DISubroutineType -> DISubroutineType -> Bool
$c<= :: DISubroutineType -> DISubroutineType -> Bool
<= :: DISubroutineType -> DISubroutineType -> Bool
$c> :: DISubroutineType -> DISubroutineType -> Bool
> :: DISubroutineType -> DISubroutineType -> Bool
$c>= :: DISubroutineType -> DISubroutineType -> Bool
>= :: DISubroutineType -> DISubroutineType -> Bool
$cmax :: DISubroutineType -> DISubroutineType -> DISubroutineType
max :: DISubroutineType -> DISubroutineType -> DISubroutineType
$cmin :: DISubroutineType -> DISubroutineType -> DISubroutineType
min :: DISubroutineType -> DISubroutineType -> DISubroutineType
Ord, ReadPrec [DISubroutineType]
ReadPrec DISubroutineType
Int -> ReadS DISubroutineType
ReadS [DISubroutineType]
(Int -> ReadS DISubroutineType)
-> ReadS [DISubroutineType]
-> ReadPrec DISubroutineType
-> ReadPrec [DISubroutineType]
-> Read DISubroutineType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DISubroutineType
readsPrec :: Int -> ReadS DISubroutineType
$creadList :: ReadS [DISubroutineType]
readList :: ReadS [DISubroutineType]
$creadPrec :: ReadPrec DISubroutineType
readPrec :: ReadPrec DISubroutineType
$creadListPrec :: ReadPrec [DISubroutineType]
readListPrec :: ReadPrec [DISubroutineType]
Read, Int -> DISubroutineType -> ShowS
[DISubroutineType] -> ShowS
DISubroutineType -> String
(Int -> DISubroutineType -> ShowS)
-> (DISubroutineType -> String)
-> ([DISubroutineType] -> ShowS)
-> Show DISubroutineType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DISubroutineType -> ShowS
showsPrec :: Int -> DISubroutineType -> ShowS
$cshow :: DISubroutineType -> String
show :: DISubroutineType -> String
$cshowList :: [DISubroutineType] -> ShowS
showList :: [DISubroutineType] -> ShowS
Show, Typeable, Typeable DISubroutineType
Typeable DISubroutineType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DISubroutineType)
-> (DISubroutineType -> Constr)
-> (DISubroutineType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DISubroutineType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DISubroutineType))
-> ((forall b. Data b => b -> b)
    -> DISubroutineType -> DISubroutineType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DISubroutineType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DISubroutineType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType -> m DISubroutineType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType -> m DISubroutineType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DISubroutineType -> m DISubroutineType)
-> Data DISubroutineType
DISubroutineType -> Constr
DISubroutineType -> DataType
(forall b. Data b => b -> b)
-> DISubroutineType -> DISubroutineType
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) -> DISubroutineType -> u
forall u. (forall d. Data d => d -> u) -> DISubroutineType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubroutineType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubroutineType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubroutineType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DISubroutineType -> c DISubroutineType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubroutineType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DISubroutineType
$ctoConstr :: DISubroutineType -> Constr
toConstr :: DISubroutineType -> Constr
$cdataTypeOf :: DISubroutineType -> DataType
dataTypeOf :: DISubroutineType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubroutineType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DISubroutineType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubroutineType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DISubroutineType)
$cgmapT :: (forall b. Data b => b -> b)
-> DISubroutineType -> DISubroutineType
gmapT :: (forall b. Data b => b -> b)
-> DISubroutineType -> DISubroutineType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DISubroutineType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DISubroutineType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DISubroutineType -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DISubroutineType -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DISubroutineType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DISubroutineType -> m DISubroutineType
Data, (forall x. DISubroutineType -> Rep DISubroutineType x)
-> (forall x. Rep DISubroutineType x -> DISubroutineType)
-> Generic DISubroutineType
forall x. Rep DISubroutineType x -> DISubroutineType
forall x. DISubroutineType -> Rep DISubroutineType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DISubroutineType -> Rep DISubroutineType x
from :: forall x. DISubroutineType -> Rep DISubroutineType x
$cto :: forall x. Rep DISubroutineType x -> DISubroutineType
to :: forall x. Rep DISubroutineType x -> DISubroutineType
Generic)

data DerivedTypeTag
  = Typedef
  | PointerType
  | PtrToMemberType
  | ReferenceType
  | RValueReferenceType
  | ConstType
  | VolatileType
  | RestrictType
  | AtomicType
  | Member
  | Inheritance
  | Friend
  deriving (DerivedTypeTag -> DerivedTypeTag -> Bool
(DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool) -> Eq DerivedTypeTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DerivedTypeTag -> DerivedTypeTag -> Bool
== :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c/= :: DerivedTypeTag -> DerivedTypeTag -> Bool
/= :: DerivedTypeTag -> DerivedTypeTag -> Bool
Eq, Eq DerivedTypeTag
Eq DerivedTypeTag
-> (DerivedTypeTag -> DerivedTypeTag -> Ordering)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> Bool)
-> (DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag)
-> (DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag)
-> Ord DerivedTypeTag
DerivedTypeTag -> DerivedTypeTag -> Bool
DerivedTypeTag -> DerivedTypeTag -> Ordering
DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
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
$ccompare :: DerivedTypeTag -> DerivedTypeTag -> Ordering
compare :: DerivedTypeTag -> DerivedTypeTag -> Ordering
$c< :: DerivedTypeTag -> DerivedTypeTag -> Bool
< :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c<= :: DerivedTypeTag -> DerivedTypeTag -> Bool
<= :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c> :: DerivedTypeTag -> DerivedTypeTag -> Bool
> :: DerivedTypeTag -> DerivedTypeTag -> Bool
$c>= :: DerivedTypeTag -> DerivedTypeTag -> Bool
>= :: DerivedTypeTag -> DerivedTypeTag -> Bool
$cmax :: DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
max :: DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
$cmin :: DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
min :: DerivedTypeTag -> DerivedTypeTag -> DerivedTypeTag
Ord, ReadPrec [DerivedTypeTag]
ReadPrec DerivedTypeTag
Int -> ReadS DerivedTypeTag
ReadS [DerivedTypeTag]
(Int -> ReadS DerivedTypeTag)
-> ReadS [DerivedTypeTag]
-> ReadPrec DerivedTypeTag
-> ReadPrec [DerivedTypeTag]
-> Read DerivedTypeTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DerivedTypeTag
readsPrec :: Int -> ReadS DerivedTypeTag
$creadList :: ReadS [DerivedTypeTag]
readList :: ReadS [DerivedTypeTag]
$creadPrec :: ReadPrec DerivedTypeTag
readPrec :: ReadPrec DerivedTypeTag
$creadListPrec :: ReadPrec [DerivedTypeTag]
readListPrec :: ReadPrec [DerivedTypeTag]
Read, Int -> DerivedTypeTag -> ShowS
[DerivedTypeTag] -> ShowS
DerivedTypeTag -> String
(Int -> DerivedTypeTag -> ShowS)
-> (DerivedTypeTag -> String)
-> ([DerivedTypeTag] -> ShowS)
-> Show DerivedTypeTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DerivedTypeTag -> ShowS
showsPrec :: Int -> DerivedTypeTag -> ShowS
$cshow :: DerivedTypeTag -> String
show :: DerivedTypeTag -> String
$cshowList :: [DerivedTypeTag] -> ShowS
showList :: [DerivedTypeTag] -> ShowS
Show, Typeable, Typeable DerivedTypeTag
Typeable DerivedTypeTag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivedTypeTag)
-> (DerivedTypeTag -> Constr)
-> (DerivedTypeTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivedTypeTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivedTypeTag))
-> ((forall b. Data b => b -> b)
    -> DerivedTypeTag -> DerivedTypeTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DerivedTypeTag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DerivedTypeTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DerivedTypeTag -> m DerivedTypeTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivedTypeTag -> m DerivedTypeTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivedTypeTag -> m DerivedTypeTag)
-> Data DerivedTypeTag
DerivedTypeTag -> Constr
DerivedTypeTag -> DataType
(forall b. Data b => b -> b) -> DerivedTypeTag -> DerivedTypeTag
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) -> DerivedTypeTag -> u
forall u. (forall d. Data d => d -> u) -> DerivedTypeTag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivedTypeTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivedTypeTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivedTypeTag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivedTypeTag -> c DerivedTypeTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivedTypeTag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivedTypeTag
$ctoConstr :: DerivedTypeTag -> Constr
toConstr :: DerivedTypeTag -> Constr
$cdataTypeOf :: DerivedTypeTag -> DataType
dataTypeOf :: DerivedTypeTag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivedTypeTag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivedTypeTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivedTypeTag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivedTypeTag)
$cgmapT :: (forall b. Data b => b -> b) -> DerivedTypeTag -> DerivedTypeTag
gmapT :: (forall b. Data b => b -> b) -> DerivedTypeTag -> DerivedTypeTag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivedTypeTag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivedTypeTag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DerivedTypeTag -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivedTypeTag -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivedTypeTag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivedTypeTag -> m DerivedTypeTag
Data, (forall x. DerivedTypeTag -> Rep DerivedTypeTag x)
-> (forall x. Rep DerivedTypeTag x -> DerivedTypeTag)
-> Generic DerivedTypeTag
forall x. Rep DerivedTypeTag x -> DerivedTypeTag
forall x. DerivedTypeTag -> Rep DerivedTypeTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DerivedTypeTag -> Rep DerivedTypeTag x
from :: forall x. DerivedTypeTag -> Rep DerivedTypeTag x
$cto :: forall x. Rep DerivedTypeTag x -> DerivedTypeTag
to :: forall x. Rep DerivedTypeTag x -> DerivedTypeTag
Generic)

-- | <https://llvm.org/docs/LangRef.html#diderivedtype>
data DIDerivedType =
  DerivedType
    { DIDerivedType -> DerivedTypeTag
tag :: DerivedTypeTag
    , DIDerivedType -> ShortByteString
name :: ShortByteString
    , DIDerivedType -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
    , DIDerivedType -> Word32
line :: Word32
    , DIDerivedType -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
    , DIDerivedType -> Maybe (MDRef DIType)
baseType :: Maybe (MDRef DIType)
    -- ^ This can be `Nothing` to represent @void *@
    , DIDerivedType -> Word64
sizeInBits :: Word64
    , DIDerivedType -> Word32
alignInBits :: Word32
    , DIDerivedType -> Word64
offsetInBits :: Word64
    , DIDerivedType -> Maybe Word32
addressSpace :: Maybe Word32
    , DIDerivedType -> [DIFlag]
flags :: [DIFlag]
    } deriving (DIDerivedType -> DIDerivedType -> Bool
(DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> Bool) -> Eq DIDerivedType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIDerivedType -> DIDerivedType -> Bool
== :: DIDerivedType -> DIDerivedType -> Bool
$c/= :: DIDerivedType -> DIDerivedType -> Bool
/= :: DIDerivedType -> DIDerivedType -> Bool
Eq, Eq DIDerivedType
Eq DIDerivedType
-> (DIDerivedType -> DIDerivedType -> Ordering)
-> (DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> Bool)
-> (DIDerivedType -> DIDerivedType -> DIDerivedType)
-> (DIDerivedType -> DIDerivedType -> DIDerivedType)
-> Ord DIDerivedType
DIDerivedType -> DIDerivedType -> Bool
DIDerivedType -> DIDerivedType -> Ordering
DIDerivedType -> DIDerivedType -> DIDerivedType
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
$ccompare :: DIDerivedType -> DIDerivedType -> Ordering
compare :: DIDerivedType -> DIDerivedType -> Ordering
$c< :: DIDerivedType -> DIDerivedType -> Bool
< :: DIDerivedType -> DIDerivedType -> Bool
$c<= :: DIDerivedType -> DIDerivedType -> Bool
<= :: DIDerivedType -> DIDerivedType -> Bool
$c> :: DIDerivedType -> DIDerivedType -> Bool
> :: DIDerivedType -> DIDerivedType -> Bool
$c>= :: DIDerivedType -> DIDerivedType -> Bool
>= :: DIDerivedType -> DIDerivedType -> Bool
$cmax :: DIDerivedType -> DIDerivedType -> DIDerivedType
max :: DIDerivedType -> DIDerivedType -> DIDerivedType
$cmin :: DIDerivedType -> DIDerivedType -> DIDerivedType
min :: DIDerivedType -> DIDerivedType -> DIDerivedType
Ord, ReadPrec [DIDerivedType]
ReadPrec DIDerivedType
Int -> ReadS DIDerivedType
ReadS [DIDerivedType]
(Int -> ReadS DIDerivedType)
-> ReadS [DIDerivedType]
-> ReadPrec DIDerivedType
-> ReadPrec [DIDerivedType]
-> Read DIDerivedType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIDerivedType
readsPrec :: Int -> ReadS DIDerivedType
$creadList :: ReadS [DIDerivedType]
readList :: ReadS [DIDerivedType]
$creadPrec :: ReadPrec DIDerivedType
readPrec :: ReadPrec DIDerivedType
$creadListPrec :: ReadPrec [DIDerivedType]
readListPrec :: ReadPrec [DIDerivedType]
Read, Int -> DIDerivedType -> ShowS
[DIDerivedType] -> ShowS
DIDerivedType -> String
(Int -> DIDerivedType -> ShowS)
-> (DIDerivedType -> String)
-> ([DIDerivedType] -> ShowS)
-> Show DIDerivedType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIDerivedType -> ShowS
showsPrec :: Int -> DIDerivedType -> ShowS
$cshow :: DIDerivedType -> String
show :: DIDerivedType -> String
$cshowList :: [DIDerivedType] -> ShowS
showList :: [DIDerivedType] -> ShowS
Show, Typeable, Typeable DIDerivedType
Typeable DIDerivedType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIDerivedType)
-> (DIDerivedType -> Constr)
-> (DIDerivedType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIDerivedType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIDerivedType))
-> ((forall b. Data b => b -> b) -> DIDerivedType -> DIDerivedType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIDerivedType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIDerivedType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType)
-> Data DIDerivedType
DIDerivedType -> Constr
DIDerivedType -> DataType
(forall b. Data b => b -> b) -> DIDerivedType -> DIDerivedType
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) -> DIDerivedType -> u
forall u. (forall d. Data d => d -> u) -> DIDerivedType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIDerivedType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIDerivedType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIDerivedType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIDerivedType -> c DIDerivedType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIDerivedType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIDerivedType
$ctoConstr :: DIDerivedType -> Constr
toConstr :: DIDerivedType -> Constr
$cdataTypeOf :: DIDerivedType -> DataType
dataTypeOf :: DIDerivedType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIDerivedType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIDerivedType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIDerivedType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIDerivedType)
$cgmapT :: (forall b. Data b => b -> b) -> DIDerivedType -> DIDerivedType
gmapT :: (forall b. Data b => b -> b) -> DIDerivedType -> DIDerivedType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIDerivedType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIDerivedType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIDerivedType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIDerivedType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIDerivedType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIDerivedType -> m DIDerivedType
Data, (forall x. DIDerivedType -> Rep DIDerivedType x)
-> (forall x. Rep DIDerivedType x -> DIDerivedType)
-> Generic DIDerivedType
forall x. Rep DIDerivedType x -> DIDerivedType
forall x. DIDerivedType -> Rep DIDerivedType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIDerivedType -> Rep DIDerivedType x
from :: forall x. DIDerivedType -> Rep DIDerivedType x
$cto :: forall x. Rep DIDerivedType x -> DIDerivedType
to :: forall x. Rep DIDerivedType x -> DIDerivedType
Generic)

-- | <https://llvm.org/docs/LangRef.html#dicompositetype>
data DICompositeType
  = DIArrayType
    { DICompositeType -> [DISubrange]
subscripts :: [DISubrange]
    , DICompositeType -> Maybe (MDRef DIType)
elementTy :: Maybe (MDRef DIType)
    , DICompositeType -> Word64
sizeInBits :: Word64
    , DICompositeType -> Word32
alignInBits :: Word32
    , DICompositeType -> [DIFlag]
flags :: [DIFlag]
    }
  | DIClassType
    { DICompositeType -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
    , DICompositeType -> ShortByteString
name :: ShortByteString
    , DICompositeType -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
    , DICompositeType -> Word32
line :: Word32
    , flags :: [DIFlag]
    , DICompositeType -> Maybe (MDRef DIType)
derivedFrom :: Maybe (MDRef DIType)
    , DICompositeType -> [MDRef (Either DIDerivedType DISubprogram)]
elements :: [MDRef (Either DIDerivedType DISubprogram)]
    -- ^ `DIDerivedType` with tag set to one of `Member`, `Inheritance`, `Friend`
    -- or `DISubprogram` with `definition` set to `True`.
    , DICompositeType -> Maybe (MDRef DIType)
vtableHolder :: Maybe (MDRef DIType)
    , DICompositeType -> [DITemplateParameter]
templateParams :: [DITemplateParameter]
    , DICompositeType -> ShortByteString
identifier :: ShortByteString
    , sizeInBits :: Word64
    , alignInBits :: Word32
    }
  | DIEnumerationType
    { scope :: Maybe (MDRef DIScope)
    , name :: ShortByteString
    , file :: Maybe (MDRef DIFile)
    , line :: Word32
    , DICompositeType -> [DIEnumerator]
values :: [DIEnumerator]
    , DICompositeType -> Maybe (MDRef DIType)
baseType :: Maybe (MDRef DIType)
    , identifier :: ShortByteString
    , sizeInBits :: Word64
    , alignInBits :: Word32
    }
  | DIStructureType
    { scope :: Maybe (MDRef DIScope)
    , name :: ShortByteString
    , file :: Maybe (MDRef DIFile)
    , line :: Word32
    , flags :: [DIFlag]
    , derivedFrom :: Maybe (MDRef DIType)
    , elements :: [MDRef (Either DIDerivedType DISubprogram)]
    -- ^ `DIDerivedType` with tag set to one of `Member`, `Inheritance`, `Friend`
    -- or `DISubprogram` with `definition` set to `True`.
    , DICompositeType -> Word16
runtimeLang :: Word16
    , vtableHolder :: Maybe (MDRef DIType)
    , identifier :: ShortByteString
    , sizeInBits :: Word64
    , alignInBits :: Word32
    }
  | DIUnionType
    { scope :: Maybe (MDRef DIScope)
    , name :: ShortByteString
    , file :: Maybe (MDRef DIFile)
    , line :: Word32
    , flags :: [DIFlag]
    , elements :: [MDRef (Either DIDerivedType DISubprogram)]
    -- ^ `DIDerivedType` with tag set to one of `Member`, `Inheritance`, `Friend`
    -- or `DISubprogram` with `definition` set to `True`.
    , runtimeLang :: Word16
    , identifier :: ShortByteString
    , sizeInBits :: Word64
    , alignInBits :: Word32
    }
  deriving (DICompositeType -> DICompositeType -> Bool
(DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> Bool)
-> Eq DICompositeType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DICompositeType -> DICompositeType -> Bool
== :: DICompositeType -> DICompositeType -> Bool
$c/= :: DICompositeType -> DICompositeType -> Bool
/= :: DICompositeType -> DICompositeType -> Bool
Eq, Eq DICompositeType
Eq DICompositeType
-> (DICompositeType -> DICompositeType -> Ordering)
-> (DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> Bool)
-> (DICompositeType -> DICompositeType -> DICompositeType)
-> (DICompositeType -> DICompositeType -> DICompositeType)
-> Ord DICompositeType
DICompositeType -> DICompositeType -> Bool
DICompositeType -> DICompositeType -> Ordering
DICompositeType -> DICompositeType -> DICompositeType
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
$ccompare :: DICompositeType -> DICompositeType -> Ordering
compare :: DICompositeType -> DICompositeType -> Ordering
$c< :: DICompositeType -> DICompositeType -> Bool
< :: DICompositeType -> DICompositeType -> Bool
$c<= :: DICompositeType -> DICompositeType -> Bool
<= :: DICompositeType -> DICompositeType -> Bool
$c> :: DICompositeType -> DICompositeType -> Bool
> :: DICompositeType -> DICompositeType -> Bool
$c>= :: DICompositeType -> DICompositeType -> Bool
>= :: DICompositeType -> DICompositeType -> Bool
$cmax :: DICompositeType -> DICompositeType -> DICompositeType
max :: DICompositeType -> DICompositeType -> DICompositeType
$cmin :: DICompositeType -> DICompositeType -> DICompositeType
min :: DICompositeType -> DICompositeType -> DICompositeType
Ord, ReadPrec [DICompositeType]
ReadPrec DICompositeType
Int -> ReadS DICompositeType
ReadS [DICompositeType]
(Int -> ReadS DICompositeType)
-> ReadS [DICompositeType]
-> ReadPrec DICompositeType
-> ReadPrec [DICompositeType]
-> Read DICompositeType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DICompositeType
readsPrec :: Int -> ReadS DICompositeType
$creadList :: ReadS [DICompositeType]
readList :: ReadS [DICompositeType]
$creadPrec :: ReadPrec DICompositeType
readPrec :: ReadPrec DICompositeType
$creadListPrec :: ReadPrec [DICompositeType]
readListPrec :: ReadPrec [DICompositeType]
Read, Int -> DICompositeType -> ShowS
[DICompositeType] -> ShowS
DICompositeType -> String
(Int -> DICompositeType -> ShowS)
-> (DICompositeType -> String)
-> ([DICompositeType] -> ShowS)
-> Show DICompositeType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DICompositeType -> ShowS
showsPrec :: Int -> DICompositeType -> ShowS
$cshow :: DICompositeType -> String
show :: DICompositeType -> String
$cshowList :: [DICompositeType] -> ShowS
showList :: [DICompositeType] -> ShowS
Show, Typeable, Typeable DICompositeType
Typeable DICompositeType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DICompositeType -> c DICompositeType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DICompositeType)
-> (DICompositeType -> Constr)
-> (DICompositeType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DICompositeType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DICompositeType))
-> ((forall b. Data b => b -> b)
    -> DICompositeType -> DICompositeType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompositeType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DICompositeType -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DICompositeType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DICompositeType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType -> m DICompositeType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType -> m DICompositeType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DICompositeType -> m DICompositeType)
-> Data DICompositeType
DICompositeType -> Constr
DICompositeType -> DataType
(forall b. Data b => b -> b) -> DICompositeType -> DICompositeType
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) -> DICompositeType -> u
forall u. (forall d. Data d => d -> u) -> DICompositeType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompositeType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompositeType -> c DICompositeType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompositeType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompositeType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompositeType -> c DICompositeType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DICompositeType -> c DICompositeType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompositeType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DICompositeType
$ctoConstr :: DICompositeType -> Constr
toConstr :: DICompositeType -> Constr
$cdataTypeOf :: DICompositeType -> DataType
dataTypeOf :: DICompositeType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompositeType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DICompositeType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompositeType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DICompositeType)
$cgmapT :: (forall b. Data b => b -> b) -> DICompositeType -> DICompositeType
gmapT :: (forall b. Data b => b -> b) -> DICompositeType -> DICompositeType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DICompositeType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DICompositeType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DICompositeType -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DICompositeType -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DICompositeType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DICompositeType -> m DICompositeType
Data, (forall x. DICompositeType -> Rep DICompositeType x)
-> (forall x. Rep DICompositeType x -> DICompositeType)
-> Generic DICompositeType
forall x. Rep DICompositeType x -> DICompositeType
forall x. DICompositeType -> Rep DICompositeType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DICompositeType -> Rep DICompositeType x
from :: forall x. DICompositeType -> Rep DICompositeType x
$cto :: forall x. Rep DICompositeType x -> DICompositeType
to :: forall x. Rep DICompositeType x -> DICompositeType
Generic)

data Encoding
  = AddressEncoding
  | BooleanEncoding
  | FloatEncoding
  | SignedEncoding
  | SignedCharEncoding
  | UnsignedEncoding
  | UnsignedCharEncoding
  | UTFEncoding
  deriving (Encoding -> Encoding -> Bool
(Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool) -> Eq Encoding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Encoding -> Encoding -> Bool
== :: Encoding -> Encoding -> Bool
$c/= :: Encoding -> Encoding -> Bool
/= :: Encoding -> Encoding -> Bool
Eq, Eq Encoding
Eq Encoding
-> (Encoding -> Encoding -> Ordering)
-> (Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Encoding)
-> (Encoding -> Encoding -> Encoding)
-> Ord Encoding
Encoding -> Encoding -> Bool
Encoding -> Encoding -> Ordering
Encoding -> Encoding -> Encoding
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
$ccompare :: Encoding -> Encoding -> Ordering
compare :: Encoding -> Encoding -> Ordering
$c< :: Encoding -> Encoding -> Bool
< :: Encoding -> Encoding -> Bool
$c<= :: Encoding -> Encoding -> Bool
<= :: Encoding -> Encoding -> Bool
$c> :: Encoding -> Encoding -> Bool
> :: Encoding -> Encoding -> Bool
$c>= :: Encoding -> Encoding -> Bool
>= :: Encoding -> Encoding -> Bool
$cmax :: Encoding -> Encoding -> Encoding
max :: Encoding -> Encoding -> Encoding
$cmin :: Encoding -> Encoding -> Encoding
min :: Encoding -> Encoding -> Encoding
Ord, ReadPrec [Encoding]
ReadPrec Encoding
Int -> ReadS Encoding
ReadS [Encoding]
(Int -> ReadS Encoding)
-> ReadS [Encoding]
-> ReadPrec Encoding
-> ReadPrec [Encoding]
-> Read Encoding
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Encoding
readsPrec :: Int -> ReadS Encoding
$creadList :: ReadS [Encoding]
readList :: ReadS [Encoding]
$creadPrec :: ReadPrec Encoding
readPrec :: ReadPrec Encoding
$creadListPrec :: ReadPrec [Encoding]
readListPrec :: ReadPrec [Encoding]
Read, Int -> Encoding -> ShowS
[Encoding] -> ShowS
Encoding -> String
(Int -> Encoding -> ShowS)
-> (Encoding -> String) -> ([Encoding] -> ShowS) -> Show Encoding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Encoding -> ShowS
showsPrec :: Int -> Encoding -> ShowS
$cshow :: Encoding -> String
show :: Encoding -> String
$cshowList :: [Encoding] -> ShowS
showList :: [Encoding] -> ShowS
Show, Typeable, Typeable Encoding
Typeable Encoding
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Encoding -> c Encoding)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Encoding)
-> (Encoding -> Constr)
-> (Encoding -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Encoding))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding))
-> ((forall b. Data b => b -> b) -> Encoding -> Encoding)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Encoding -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Encoding -> r)
-> (forall u. (forall d. Data d => d -> u) -> Encoding -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Encoding -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Encoding -> m Encoding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Encoding -> m Encoding)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Encoding -> m Encoding)
-> Data Encoding
Encoding -> Constr
Encoding -> DataType
(forall b. Data b => b -> b) -> Encoding -> Encoding
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) -> Encoding -> u
forall u. (forall d. Data d => d -> u) -> Encoding -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Encoding
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Encoding -> c Encoding
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Encoding)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Encoding -> c Encoding
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Encoding -> c Encoding
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Encoding
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Encoding
$ctoConstr :: Encoding -> Constr
toConstr :: Encoding -> Constr
$cdataTypeOf :: Encoding -> DataType
dataTypeOf :: Encoding -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Encoding)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Encoding)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding)
$cgmapT :: (forall b. Data b => b -> b) -> Encoding -> Encoding
gmapT :: (forall b. Data b => b -> b) -> Encoding -> Encoding
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Encoding -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Encoding -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Encoding -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Encoding -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Encoding -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Encoding -> m Encoding
Data, (forall x. Encoding -> Rep Encoding x)
-> (forall x. Rep Encoding x -> Encoding) -> Generic Encoding
forall x. Rep Encoding x -> Encoding
forall x. Encoding -> Rep Encoding x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Encoding -> Rep Encoding x
from :: forall x. Encoding -> Rep Encoding x
$cto :: forall x. Rep Encoding x -> Encoding
to :: forall x. Rep Encoding x -> Encoding
Generic)

data TemplateValueParameterTag
  = TemplateValueParameter
  | GNUTemplateTemplateParam
  | GNUTemplateParameterPack
  deriving (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
(TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> Eq TemplateValueParameterTag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
== :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c/= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
/= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
Eq, Eq TemplateValueParameterTag
Eq TemplateValueParameterTag
-> (TemplateValueParameterTag
    -> TemplateValueParameterTag -> Ordering)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag -> TemplateValueParameterTag -> Bool)
-> (TemplateValueParameterTag
    -> TemplateValueParameterTag -> TemplateValueParameterTag)
-> (TemplateValueParameterTag
    -> TemplateValueParameterTag -> TemplateValueParameterTag)
-> Ord TemplateValueParameterTag
TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
TemplateValueParameterTag -> TemplateValueParameterTag -> Ordering
TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
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
$ccompare :: TemplateValueParameterTag -> TemplateValueParameterTag -> Ordering
compare :: TemplateValueParameterTag -> TemplateValueParameterTag -> Ordering
$c< :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
< :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c<= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
<= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c> :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
> :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$c>= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
>= :: TemplateValueParameterTag -> TemplateValueParameterTag -> Bool
$cmax :: TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
max :: TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
$cmin :: TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
min :: TemplateValueParameterTag
-> TemplateValueParameterTag -> TemplateValueParameterTag
Ord, ReadPrec [TemplateValueParameterTag]
ReadPrec TemplateValueParameterTag
Int -> ReadS TemplateValueParameterTag
ReadS [TemplateValueParameterTag]
(Int -> ReadS TemplateValueParameterTag)
-> ReadS [TemplateValueParameterTag]
-> ReadPrec TemplateValueParameterTag
-> ReadPrec [TemplateValueParameterTag]
-> Read TemplateValueParameterTag
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TemplateValueParameterTag
readsPrec :: Int -> ReadS TemplateValueParameterTag
$creadList :: ReadS [TemplateValueParameterTag]
readList :: ReadS [TemplateValueParameterTag]
$creadPrec :: ReadPrec TemplateValueParameterTag
readPrec :: ReadPrec TemplateValueParameterTag
$creadListPrec :: ReadPrec [TemplateValueParameterTag]
readListPrec :: ReadPrec [TemplateValueParameterTag]
Read, Int -> TemplateValueParameterTag -> ShowS
[TemplateValueParameterTag] -> ShowS
TemplateValueParameterTag -> String
(Int -> TemplateValueParameterTag -> ShowS)
-> (TemplateValueParameterTag -> String)
-> ([TemplateValueParameterTag] -> ShowS)
-> Show TemplateValueParameterTag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TemplateValueParameterTag -> ShowS
showsPrec :: Int -> TemplateValueParameterTag -> ShowS
$cshow :: TemplateValueParameterTag -> String
show :: TemplateValueParameterTag -> String
$cshowList :: [TemplateValueParameterTag] -> ShowS
showList :: [TemplateValueParameterTag] -> ShowS
Show, Typeable, Typeable TemplateValueParameterTag
Typeable TemplateValueParameterTag
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> TemplateValueParameterTag
    -> c TemplateValueParameterTag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag)
-> (TemplateValueParameterTag -> Constr)
-> (TemplateValueParameterTag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c TemplateValueParameterTag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TemplateValueParameterTag))
-> ((forall b. Data b => b -> b)
    -> TemplateValueParameterTag -> TemplateValueParameterTag)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> TemplateValueParameterTag
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> TemplateValueParameterTag
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TemplateValueParameterTag -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> TemplateValueParameterTag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TemplateValueParameterTag -> m TemplateValueParameterTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TemplateValueParameterTag -> m TemplateValueParameterTag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TemplateValueParameterTag -> m TemplateValueParameterTag)
-> Data TemplateValueParameterTag
TemplateValueParameterTag -> Constr
TemplateValueParameterTag -> DataType
(forall b. Data b => b -> b)
-> TemplateValueParameterTag -> TemplateValueParameterTag
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) -> TemplateValueParameterTag -> u
forall u.
(forall d. Data d => d -> u) -> TemplateValueParameterTag -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TemplateValueParameterTag
-> c TemplateValueParameterTag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c TemplateValueParameterTag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateValueParameterTag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TemplateValueParameterTag
-> c TemplateValueParameterTag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> TemplateValueParameterTag
-> c TemplateValueParameterTag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TemplateValueParameterTag
$ctoConstr :: TemplateValueParameterTag -> Constr
toConstr :: TemplateValueParameterTag -> Constr
$cdataTypeOf :: TemplateValueParameterTag -> DataType
dataTypeOf :: TemplateValueParameterTag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c TemplateValueParameterTag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c TemplateValueParameterTag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateValueParameterTag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TemplateValueParameterTag)
$cgmapT :: (forall b. Data b => b -> b)
-> TemplateValueParameterTag -> TemplateValueParameterTag
gmapT :: (forall b. Data b => b -> b)
-> TemplateValueParameterTag -> TemplateValueParameterTag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> TemplateValueParameterTag
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> TemplateValueParameterTag -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> TemplateValueParameterTag -> [u]
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> TemplateValueParameterTag -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> TemplateValueParameterTag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TemplateValueParameterTag -> m TemplateValueParameterTag
Data, (forall x.
 TemplateValueParameterTag -> Rep TemplateValueParameterTag x)
-> (forall x.
    Rep TemplateValueParameterTag x -> TemplateValueParameterTag)
-> Generic TemplateValueParameterTag
forall x.
Rep TemplateValueParameterTag x -> TemplateValueParameterTag
forall x.
TemplateValueParameterTag -> Rep TemplateValueParameterTag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
TemplateValueParameterTag -> Rep TemplateValueParameterTag x
from :: forall x.
TemplateValueParameterTag -> Rep TemplateValueParameterTag x
$cto :: forall x.
Rep TemplateValueParameterTag x -> TemplateValueParameterTag
to :: forall x.
Rep TemplateValueParameterTag x -> TemplateValueParameterTag
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DITemplateParameter.html>
data DITemplateParameter
  = DITemplateTypeParameter
    { DITemplateParameter -> ShortByteString
name :: ShortByteString
    , DITemplateParameter -> Maybe (MDRef DIType)
type' :: Maybe (MDRef DIType)
    -- ^ For DITemplateTypeParameter this field is required,
    -- for DITemplateValueParameter it is optional.
    }
  -- ^ <https://llvm.org/docs/LangRef.html#ditemplatetypeparameter>
  | DITemplateValueParameter
    { name :: ShortByteString
    , type' :: Maybe (MDRef DIType)
    , DITemplateParameter -> Maybe Metadata
value :: Maybe Metadata
    , DITemplateParameter -> TemplateValueParameterTag
tag :: TemplateValueParameterTag
    }
  -- ^ <https://llvm.org/docs/LangRef.html#ditemplatevalueparameter>
  deriving (DITemplateParameter -> DITemplateParameter -> Bool
(DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> Eq DITemplateParameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DITemplateParameter -> DITemplateParameter -> Bool
== :: DITemplateParameter -> DITemplateParameter -> Bool
$c/= :: DITemplateParameter -> DITemplateParameter -> Bool
/= :: DITemplateParameter -> DITemplateParameter -> Bool
Eq, Eq DITemplateParameter
Eq DITemplateParameter
-> (DITemplateParameter -> DITemplateParameter -> Ordering)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter -> DITemplateParameter -> Bool)
-> (DITemplateParameter
    -> DITemplateParameter -> DITemplateParameter)
-> (DITemplateParameter
    -> DITemplateParameter -> DITemplateParameter)
-> Ord DITemplateParameter
DITemplateParameter -> DITemplateParameter -> Bool
DITemplateParameter -> DITemplateParameter -> Ordering
DITemplateParameter -> DITemplateParameter -> DITemplateParameter
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
$ccompare :: DITemplateParameter -> DITemplateParameter -> Ordering
compare :: DITemplateParameter -> DITemplateParameter -> Ordering
$c< :: DITemplateParameter -> DITemplateParameter -> Bool
< :: DITemplateParameter -> DITemplateParameter -> Bool
$c<= :: DITemplateParameter -> DITemplateParameter -> Bool
<= :: DITemplateParameter -> DITemplateParameter -> Bool
$c> :: DITemplateParameter -> DITemplateParameter -> Bool
> :: DITemplateParameter -> DITemplateParameter -> Bool
$c>= :: DITemplateParameter -> DITemplateParameter -> Bool
>= :: DITemplateParameter -> DITemplateParameter -> Bool
$cmax :: DITemplateParameter -> DITemplateParameter -> DITemplateParameter
max :: DITemplateParameter -> DITemplateParameter -> DITemplateParameter
$cmin :: DITemplateParameter -> DITemplateParameter -> DITemplateParameter
min :: DITemplateParameter -> DITemplateParameter -> DITemplateParameter
Ord, ReadPrec [DITemplateParameter]
ReadPrec DITemplateParameter
Int -> ReadS DITemplateParameter
ReadS [DITemplateParameter]
(Int -> ReadS DITemplateParameter)
-> ReadS [DITemplateParameter]
-> ReadPrec DITemplateParameter
-> ReadPrec [DITemplateParameter]
-> Read DITemplateParameter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DITemplateParameter
readsPrec :: Int -> ReadS DITemplateParameter
$creadList :: ReadS [DITemplateParameter]
readList :: ReadS [DITemplateParameter]
$creadPrec :: ReadPrec DITemplateParameter
readPrec :: ReadPrec DITemplateParameter
$creadListPrec :: ReadPrec [DITemplateParameter]
readListPrec :: ReadPrec [DITemplateParameter]
Read, Int -> DITemplateParameter -> ShowS
[DITemplateParameter] -> ShowS
DITemplateParameter -> String
(Int -> DITemplateParameter -> ShowS)
-> (DITemplateParameter -> String)
-> ([DITemplateParameter] -> ShowS)
-> Show DITemplateParameter
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DITemplateParameter -> ShowS
showsPrec :: Int -> DITemplateParameter -> ShowS
$cshow :: DITemplateParameter -> String
show :: DITemplateParameter -> String
$cshowList :: [DITemplateParameter] -> ShowS
showList :: [DITemplateParameter] -> ShowS
Show, Typeable, Typeable DITemplateParameter
Typeable DITemplateParameter
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> DITemplateParameter
    -> c DITemplateParameter)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DITemplateParameter)
-> (DITemplateParameter -> Constr)
-> (DITemplateParameter -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DITemplateParameter))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DITemplateParameter))
-> ((forall b. Data b => b -> b)
    -> DITemplateParameter -> DITemplateParameter)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DITemplateParameter -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DITemplateParameter -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DITemplateParameter -> m DITemplateParameter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DITemplateParameter -> m DITemplateParameter)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DITemplateParameter -> m DITemplateParameter)
-> Data DITemplateParameter
DITemplateParameter -> Constr
DITemplateParameter -> DataType
(forall b. Data b => b -> b)
-> DITemplateParameter -> DITemplateParameter
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) -> DITemplateParameter -> u
forall u.
(forall d. Data d => d -> u) -> DITemplateParameter -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DITemplateParameter
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateParameter
-> c DITemplateParameter
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DITemplateParameter)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DITemplateParameter)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateParameter
-> c DITemplateParameter
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DITemplateParameter
-> c DITemplateParameter
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DITemplateParameter
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DITemplateParameter
$ctoConstr :: DITemplateParameter -> Constr
toConstr :: DITemplateParameter -> Constr
$cdataTypeOf :: DITemplateParameter -> DataType
dataTypeOf :: DITemplateParameter -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DITemplateParameter)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DITemplateParameter)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DITemplateParameter)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DITemplateParameter)
$cgmapT :: (forall b. Data b => b -> b)
-> DITemplateParameter -> DITemplateParameter
gmapT :: (forall b. Data b => b -> b)
-> DITemplateParameter -> DITemplateParameter
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DITemplateParameter -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> DITemplateParameter -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> DITemplateParameter -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DITemplateParameter -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DITemplateParameter -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DITemplateParameter -> m DITemplateParameter
Data, (forall x. DITemplateParameter -> Rep DITemplateParameter x)
-> (forall x. Rep DITemplateParameter x -> DITemplateParameter)
-> Generic DITemplateParameter
forall x. Rep DITemplateParameter x -> DITemplateParameter
forall x. DITemplateParameter -> Rep DITemplateParameter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DITemplateParameter -> Rep DITemplateParameter x
from :: forall x. DITemplateParameter -> Rep DITemplateParameter x
$cto :: forall x. Rep DITemplateParameter x -> DITemplateParameter
to :: forall x. Rep DITemplateParameter x -> DITemplateParameter
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DILexicalBlockBase.html>
data DILexicalBlockBase
  = DILexicalBlock
    { DILexicalBlockBase -> MDRef DILocalScope
scope :: MDRef DILocalScope
    , DILexicalBlockBase -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
    , DILexicalBlockBase -> Word32
line :: Word32
    , DILexicalBlockBase -> Word16
column :: Word16
    }
  -- ^ <https://llvm.org/docs/LangRef.html#dilexicalblock>
  | DILexicalBlockFile
    { scope :: MDRef DILocalScope
    , file :: Maybe (MDRef DIFile)
    , DILexicalBlockBase -> Word32
discriminator :: Word32
    }
  -- ^ <https://llvm.org/docs/LangRef.html#dilexicalblockfile>
  deriving (DILexicalBlockBase -> DILexicalBlockBase -> Bool
(DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> Eq DILexicalBlockBase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
== :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c/= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
/= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
Eq, Eq DILexicalBlockBase
Eq DILexicalBlockBase
-> (DILexicalBlockBase -> DILexicalBlockBase -> Ordering)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> Bool)
-> (DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase)
-> (DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase)
-> Ord DILexicalBlockBase
DILexicalBlockBase -> DILexicalBlockBase -> Bool
DILexicalBlockBase -> DILexicalBlockBase -> Ordering
DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
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
$ccompare :: DILexicalBlockBase -> DILexicalBlockBase -> Ordering
compare :: DILexicalBlockBase -> DILexicalBlockBase -> Ordering
$c< :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
< :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c<= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
<= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c> :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
> :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$c>= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
>= :: DILexicalBlockBase -> DILexicalBlockBase -> Bool
$cmax :: DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
max :: DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
$cmin :: DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
min :: DILexicalBlockBase -> DILexicalBlockBase -> DILexicalBlockBase
Ord, ReadPrec [DILexicalBlockBase]
ReadPrec DILexicalBlockBase
Int -> ReadS DILexicalBlockBase
ReadS [DILexicalBlockBase]
(Int -> ReadS DILexicalBlockBase)
-> ReadS [DILexicalBlockBase]
-> ReadPrec DILexicalBlockBase
-> ReadPrec [DILexicalBlockBase]
-> Read DILexicalBlockBase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DILexicalBlockBase
readsPrec :: Int -> ReadS DILexicalBlockBase
$creadList :: ReadS [DILexicalBlockBase]
readList :: ReadS [DILexicalBlockBase]
$creadPrec :: ReadPrec DILexicalBlockBase
readPrec :: ReadPrec DILexicalBlockBase
$creadListPrec :: ReadPrec [DILexicalBlockBase]
readListPrec :: ReadPrec [DILexicalBlockBase]
Read, Int -> DILexicalBlockBase -> ShowS
[DILexicalBlockBase] -> ShowS
DILexicalBlockBase -> String
(Int -> DILexicalBlockBase -> ShowS)
-> (DILexicalBlockBase -> String)
-> ([DILexicalBlockBase] -> ShowS)
-> Show DILexicalBlockBase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DILexicalBlockBase -> ShowS
showsPrec :: Int -> DILexicalBlockBase -> ShowS
$cshow :: DILexicalBlockBase -> String
show :: DILexicalBlockBase -> String
$cshowList :: [DILexicalBlockBase] -> ShowS
showList :: [DILexicalBlockBase] -> ShowS
Show, Typeable, Typeable DILexicalBlockBase
Typeable DILexicalBlockBase
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> DILexicalBlockBase
    -> c DILexicalBlockBase)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase)
-> (DILexicalBlockBase -> Constr)
-> (DILexicalBlockBase -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DILexicalBlockBase))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DILexicalBlockBase))
-> ((forall b. Data b => b -> b)
    -> DILexicalBlockBase -> DILexicalBlockBase)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DILexicalBlockBase -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILexicalBlockBase -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockBase -> m DILexicalBlockBase)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockBase -> m DILexicalBlockBase)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILexicalBlockBase -> m DILexicalBlockBase)
-> Data DILexicalBlockBase
DILexicalBlockBase -> Constr
DILexicalBlockBase -> DataType
(forall b. Data b => b -> b)
-> DILexicalBlockBase -> DILexicalBlockBase
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) -> DILexicalBlockBase -> u
forall u. (forall d. Data d => d -> u) -> DILexicalBlockBase -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockBase
-> c DILexicalBlockBase
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILexicalBlockBase)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILexicalBlockBase)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockBase
-> c DILexicalBlockBase
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> DILexicalBlockBase
-> c DILexicalBlockBase
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILexicalBlockBase
$ctoConstr :: DILexicalBlockBase -> Constr
toConstr :: DILexicalBlockBase -> Constr
$cdataTypeOf :: DILexicalBlockBase -> DataType
dataTypeOf :: DILexicalBlockBase -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILexicalBlockBase)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILexicalBlockBase)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILexicalBlockBase)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILexicalBlockBase)
$cgmapT :: (forall b. Data b => b -> b)
-> DILexicalBlockBase -> DILexicalBlockBase
gmapT :: (forall b. Data b => b -> b)
-> DILexicalBlockBase -> DILexicalBlockBase
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILexicalBlockBase -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DILexicalBlockBase -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DILexicalBlockBase -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILexicalBlockBase -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILexicalBlockBase -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILexicalBlockBase -> m DILexicalBlockBase
Data, (forall x. DILexicalBlockBase -> Rep DILexicalBlockBase x)
-> (forall x. Rep DILexicalBlockBase x -> DILexicalBlockBase)
-> Generic DILexicalBlockBase
forall x. Rep DILexicalBlockBase x -> DILexicalBlockBase
forall x. DILexicalBlockBase -> Rep DILexicalBlockBase x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DILexicalBlockBase -> Rep DILexicalBlockBase x
from :: forall x. DILexicalBlockBase -> Rep DILexicalBlockBase x
$cto :: forall x. Rep DILexicalBlockBase x -> DILexicalBlockBase
to :: forall x. Rep DILexicalBlockBase x -> DILexicalBlockBase
Generic)

-- | <https://llvm.org/doxygen/classllvm_1_1DIVariable.html>
data DIVariable
  = DIGlobalVariable DIGlobalVariable
  | DILocalVariable DILocalVariable
  deriving (DIVariable -> DIVariable -> Bool
(DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> Bool) -> Eq DIVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIVariable -> DIVariable -> Bool
== :: DIVariable -> DIVariable -> Bool
$c/= :: DIVariable -> DIVariable -> Bool
/= :: DIVariable -> DIVariable -> Bool
Eq, Eq DIVariable
Eq DIVariable
-> (DIVariable -> DIVariable -> Ordering)
-> (DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> Bool)
-> (DIVariable -> DIVariable -> DIVariable)
-> (DIVariable -> DIVariable -> DIVariable)
-> Ord DIVariable
DIVariable -> DIVariable -> Bool
DIVariable -> DIVariable -> Ordering
DIVariable -> DIVariable -> DIVariable
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
$ccompare :: DIVariable -> DIVariable -> Ordering
compare :: DIVariable -> DIVariable -> Ordering
$c< :: DIVariable -> DIVariable -> Bool
< :: DIVariable -> DIVariable -> Bool
$c<= :: DIVariable -> DIVariable -> Bool
<= :: DIVariable -> DIVariable -> Bool
$c> :: DIVariable -> DIVariable -> Bool
> :: DIVariable -> DIVariable -> Bool
$c>= :: DIVariable -> DIVariable -> Bool
>= :: DIVariable -> DIVariable -> Bool
$cmax :: DIVariable -> DIVariable -> DIVariable
max :: DIVariable -> DIVariable -> DIVariable
$cmin :: DIVariable -> DIVariable -> DIVariable
min :: DIVariable -> DIVariable -> DIVariable
Ord, ReadPrec [DIVariable]
ReadPrec DIVariable
Int -> ReadS DIVariable
ReadS [DIVariable]
(Int -> ReadS DIVariable)
-> ReadS [DIVariable]
-> ReadPrec DIVariable
-> ReadPrec [DIVariable]
-> Read DIVariable
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIVariable
readsPrec :: Int -> ReadS DIVariable
$creadList :: ReadS [DIVariable]
readList :: ReadS [DIVariable]
$creadPrec :: ReadPrec DIVariable
readPrec :: ReadPrec DIVariable
$creadListPrec :: ReadPrec [DIVariable]
readListPrec :: ReadPrec [DIVariable]
Read, Int -> DIVariable -> ShowS
[DIVariable] -> ShowS
DIVariable -> String
(Int -> DIVariable -> ShowS)
-> (DIVariable -> String)
-> ([DIVariable] -> ShowS)
-> Show DIVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIVariable -> ShowS
showsPrec :: Int -> DIVariable -> ShowS
$cshow :: DIVariable -> String
show :: DIVariable -> String
$cshowList :: [DIVariable] -> ShowS
showList :: [DIVariable] -> ShowS
Show, Typeable, Typeable DIVariable
Typeable DIVariable
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIVariable -> c DIVariable)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIVariable)
-> (DIVariable -> Constr)
-> (DIVariable -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIVariable))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIVariable))
-> ((forall b. Data b => b -> b) -> DIVariable -> DIVariable)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIVariable -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIVariable -> r)
-> (forall u. (forall d. Data d => d -> u) -> DIVariable -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIVariable -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DIVariable -> m DIVariable)
-> Data DIVariable
DIVariable -> Constr
DIVariable -> DataType
(forall b. Data b => b -> b) -> DIVariable -> DIVariable
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) -> DIVariable -> u
forall u. (forall d. Data d => d -> u) -> DIVariable -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIVariable
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIVariable -> c DIVariable
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIVariable)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIVariable)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIVariable -> c DIVariable
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIVariable -> c DIVariable
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIVariable
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIVariable
$ctoConstr :: DIVariable -> Constr
toConstr :: DIVariable -> Constr
$cdataTypeOf :: DIVariable -> DataType
dataTypeOf :: DIVariable -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIVariable)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIVariable)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIVariable)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DIVariable)
$cgmapT :: (forall b. Data b => b -> b) -> DIVariable -> DIVariable
gmapT :: (forall b. Data b => b -> b) -> DIVariable -> DIVariable
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIVariable -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIVariable -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIVariable -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIVariable -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DIVariable -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DIVariable -> m DIVariable
Data, (forall x. DIVariable -> Rep DIVariable x)
-> (forall x. Rep DIVariable x -> DIVariable) -> Generic DIVariable
forall x. Rep DIVariable x -> DIVariable
forall x. DIVariable -> Rep DIVariable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIVariable -> Rep DIVariable x
from :: forall x. DIVariable -> Rep DIVariable x
$cto :: forall x. Rep DIVariable x -> DIVariable
to :: forall x. Rep DIVariable x -> DIVariable
Generic)

-- | <https://llvm.org/docs/LangRef.html#diglobalvariable>
data DIGlobalVariable = GlobalVariable
  { DIGlobalVariable -> ShortByteString
name :: ShortByteString
  , DIGlobalVariable -> Maybe (MDRef DIScope)
scope :: Maybe (MDRef DIScope)
  , DIGlobalVariable -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DIGlobalVariable -> Word32
line :: Word32
  , DIGlobalVariable -> Maybe (MDRef DIType)
type' :: Maybe (MDRef DIType)
  , DIGlobalVariable -> ShortByteString
linkageName :: ShortByteString
  , DIGlobalVariable -> Bool
local :: Bool
  , DIGlobalVariable -> Bool
definition :: Bool
  , DIGlobalVariable -> Maybe (MDRef DIDerivedType)
staticDataMemberDeclaration :: Maybe (MDRef DIDerivedType)
  , DIGlobalVariable -> [MDRef DITemplateParameter]
templateParams :: [MDRef DITemplateParameter]
  , DIGlobalVariable -> Word32
alignInBits :: Word32
  } deriving (DIGlobalVariable -> DIGlobalVariable -> Bool
(DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> Eq DIGlobalVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DIGlobalVariable -> DIGlobalVariable -> Bool
== :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c/= :: DIGlobalVariable -> DIGlobalVariable -> Bool
/= :: DIGlobalVariable -> DIGlobalVariable -> Bool
Eq, Eq DIGlobalVariable
Eq DIGlobalVariable
-> (DIGlobalVariable -> DIGlobalVariable -> Ordering)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> Bool)
-> (DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable)
-> (DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable)
-> Ord DIGlobalVariable
DIGlobalVariable -> DIGlobalVariable -> Bool
DIGlobalVariable -> DIGlobalVariable -> Ordering
DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
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
$ccompare :: DIGlobalVariable -> DIGlobalVariable -> Ordering
compare :: DIGlobalVariable -> DIGlobalVariable -> Ordering
$c< :: DIGlobalVariable -> DIGlobalVariable -> Bool
< :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c<= :: DIGlobalVariable -> DIGlobalVariable -> Bool
<= :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c> :: DIGlobalVariable -> DIGlobalVariable -> Bool
> :: DIGlobalVariable -> DIGlobalVariable -> Bool
$c>= :: DIGlobalVariable -> DIGlobalVariable -> Bool
>= :: DIGlobalVariable -> DIGlobalVariable -> Bool
$cmax :: DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
max :: DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
$cmin :: DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
min :: DIGlobalVariable -> DIGlobalVariable -> DIGlobalVariable
Ord, ReadPrec [DIGlobalVariable]
ReadPrec DIGlobalVariable
Int -> ReadS DIGlobalVariable
ReadS [DIGlobalVariable]
(Int -> ReadS DIGlobalVariable)
-> ReadS [DIGlobalVariable]
-> ReadPrec DIGlobalVariable
-> ReadPrec [DIGlobalVariable]
-> Read DIGlobalVariable
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DIGlobalVariable
readsPrec :: Int -> ReadS DIGlobalVariable
$creadList :: ReadS [DIGlobalVariable]
readList :: ReadS [DIGlobalVariable]
$creadPrec :: ReadPrec DIGlobalVariable
readPrec :: ReadPrec DIGlobalVariable
$creadListPrec :: ReadPrec [DIGlobalVariable]
readListPrec :: ReadPrec [DIGlobalVariable]
Read, Int -> DIGlobalVariable -> ShowS
[DIGlobalVariable] -> ShowS
DIGlobalVariable -> String
(Int -> DIGlobalVariable -> ShowS)
-> (DIGlobalVariable -> String)
-> ([DIGlobalVariable] -> ShowS)
-> Show DIGlobalVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DIGlobalVariable -> ShowS
showsPrec :: Int -> DIGlobalVariable -> ShowS
$cshow :: DIGlobalVariable -> String
show :: DIGlobalVariable -> String
$cshowList :: [DIGlobalVariable] -> ShowS
showList :: [DIGlobalVariable] -> ShowS
Show, Typeable, Typeable DIGlobalVariable
Typeable DIGlobalVariable
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DIGlobalVariable)
-> (DIGlobalVariable -> Constr)
-> (DIGlobalVariable -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DIGlobalVariable))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DIGlobalVariable))
-> ((forall b. Data b => b -> b)
    -> DIGlobalVariable -> DIGlobalVariable)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DIGlobalVariable -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DIGlobalVariable -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable -> m DIGlobalVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable -> m DIGlobalVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DIGlobalVariable -> m DIGlobalVariable)
-> Data DIGlobalVariable
DIGlobalVariable -> Constr
DIGlobalVariable -> DataType
(forall b. Data b => b -> b)
-> DIGlobalVariable -> DIGlobalVariable
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) -> DIGlobalVariable -> u
forall u. (forall d. Data d => d -> u) -> DIGlobalVariable -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariable
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIGlobalVariable)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariable)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DIGlobalVariable -> c DIGlobalVariable
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariable
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DIGlobalVariable
$ctoConstr :: DIGlobalVariable -> Constr
toConstr :: DIGlobalVariable -> Constr
$cdataTypeOf :: DIGlobalVariable -> DataType
dataTypeOf :: DIGlobalVariable -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIGlobalVariable)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DIGlobalVariable)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariable)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DIGlobalVariable)
$cgmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariable -> DIGlobalVariable
gmapT :: (forall b. Data b => b -> b)
-> DIGlobalVariable -> DIGlobalVariable
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DIGlobalVariable -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DIGlobalVariable -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DIGlobalVariable -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIGlobalVariable -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DIGlobalVariable -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DIGlobalVariable -> m DIGlobalVariable
Data, (forall x. DIGlobalVariable -> Rep DIGlobalVariable x)
-> (forall x. Rep DIGlobalVariable x -> DIGlobalVariable)
-> Generic DIGlobalVariable
forall x. Rep DIGlobalVariable x -> DIGlobalVariable
forall x. DIGlobalVariable -> Rep DIGlobalVariable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DIGlobalVariable -> Rep DIGlobalVariable x
from :: forall x. DIGlobalVariable -> Rep DIGlobalVariable x
$cto :: forall x. Rep DIGlobalVariable x -> DIGlobalVariable
to :: forall x. Rep DIGlobalVariable x -> DIGlobalVariable
Generic)

-- | <https://llvm.org/docs/LangRef.html#dilocalvariable>
data DILocalVariable = LocalVariable
  { DILocalVariable -> ShortByteString
name :: ShortByteString
  , DILocalVariable -> MDRef DIScope
scope :: MDRef DIScope
  , DILocalVariable -> Maybe (MDRef DIFile)
file :: Maybe (MDRef DIFile)
  , DILocalVariable -> Word32
line :: Word32
  , DILocalVariable -> Maybe (MDRef DIType)
type' :: Maybe (MDRef DIType)
  , DILocalVariable -> [DIFlag]
flags :: [DIFlag]
  , DILocalVariable -> Word16
arg :: Word16
  , DILocalVariable -> Word32
alignInBits :: Word32
  } deriving (DILocalVariable -> DILocalVariable -> Bool
(DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> Eq DILocalVariable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DILocalVariable -> DILocalVariable -> Bool
== :: DILocalVariable -> DILocalVariable -> Bool
$c/= :: DILocalVariable -> DILocalVariable -> Bool
/= :: DILocalVariable -> DILocalVariable -> Bool
Eq, Eq DILocalVariable
Eq DILocalVariable
-> (DILocalVariable -> DILocalVariable -> Ordering)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> Bool)
-> (DILocalVariable -> DILocalVariable -> DILocalVariable)
-> (DILocalVariable -> DILocalVariable -> DILocalVariable)
-> Ord DILocalVariable
DILocalVariable -> DILocalVariable -> Bool
DILocalVariable -> DILocalVariable -> Ordering
DILocalVariable -> DILocalVariable -> DILocalVariable
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
$ccompare :: DILocalVariable -> DILocalVariable -> Ordering
compare :: DILocalVariable -> DILocalVariable -> Ordering
$c< :: DILocalVariable -> DILocalVariable -> Bool
< :: DILocalVariable -> DILocalVariable -> Bool
$c<= :: DILocalVariable -> DILocalVariable -> Bool
<= :: DILocalVariable -> DILocalVariable -> Bool
$c> :: DILocalVariable -> DILocalVariable -> Bool
> :: DILocalVariable -> DILocalVariable -> Bool
$c>= :: DILocalVariable -> DILocalVariable -> Bool
>= :: DILocalVariable -> DILocalVariable -> Bool
$cmax :: DILocalVariable -> DILocalVariable -> DILocalVariable
max :: DILocalVariable -> DILocalVariable -> DILocalVariable
$cmin :: DILocalVariable -> DILocalVariable -> DILocalVariable
min :: DILocalVariable -> DILocalVariable -> DILocalVariable
Ord, ReadPrec [DILocalVariable]
ReadPrec DILocalVariable
Int -> ReadS DILocalVariable
ReadS [DILocalVariable]
(Int -> ReadS DILocalVariable)
-> ReadS [DILocalVariable]
-> ReadPrec DILocalVariable
-> ReadPrec [DILocalVariable]
-> Read DILocalVariable
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DILocalVariable
readsPrec :: Int -> ReadS DILocalVariable
$creadList :: ReadS [DILocalVariable]
readList :: ReadS [DILocalVariable]
$creadPrec :: ReadPrec DILocalVariable
readPrec :: ReadPrec DILocalVariable
$creadListPrec :: ReadPrec [DILocalVariable]
readListPrec :: ReadPrec [DILocalVariable]
Read, Int -> DILocalVariable -> ShowS
[DILocalVariable] -> ShowS
DILocalVariable -> String
(Int -> DILocalVariable -> ShowS)
-> (DILocalVariable -> String)
-> ([DILocalVariable] -> ShowS)
-> Show DILocalVariable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DILocalVariable -> ShowS
showsPrec :: Int -> DILocalVariable -> ShowS
$cshow :: DILocalVariable -> String
show :: DILocalVariable -> String
$cshowList :: [DILocalVariable] -> ShowS
showList :: [DILocalVariable] -> ShowS
Show, Typeable, Typeable DILocalVariable
Typeable DILocalVariable
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DILocalVariable)
-> (DILocalVariable -> Constr)
-> (DILocalVariable -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DILocalVariable))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DILocalVariable))
-> ((forall b. Data b => b -> b)
    -> DILocalVariable -> DILocalVariable)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DILocalVariable -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DILocalVariable -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable -> m DILocalVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable -> m DILocalVariable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DILocalVariable -> m DILocalVariable)
-> Data DILocalVariable
DILocalVariable -> Constr
DILocalVariable -> DataType
(forall b. Data b => b -> b) -> DILocalVariable -> DILocalVariable
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) -> DILocalVariable -> u
forall u. (forall d. Data d => d -> u) -> DILocalVariable -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalVariable
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalVariable)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalVariable)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DILocalVariable -> c DILocalVariable
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalVariable
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DILocalVariable
$ctoConstr :: DILocalVariable -> Constr
toConstr :: DILocalVariable -> Constr
$cdataTypeOf :: DILocalVariable -> DataType
dataTypeOf :: DILocalVariable -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalVariable)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DILocalVariable)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalVariable)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DILocalVariable)
$cgmapT :: (forall b. Data b => b -> b) -> DILocalVariable -> DILocalVariable
gmapT :: (forall b. Data b => b -> b) -> DILocalVariable -> DILocalVariable
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DILocalVariable -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DILocalVariable -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DILocalVariable -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILocalVariable -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DILocalVariable -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DILocalVariable -> m DILocalVariable
Data, (forall x. DILocalVariable -> Rep DILocalVariable x)
-> (forall x. Rep DILocalVariable x -> DILocalVariable)
-> Generic DILocalVariable
forall x. Rep DILocalVariable x -> DILocalVariable
forall x. DILocalVariable -> Rep DILocalVariable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DILocalVariable -> Rep DILocalVariable x
from :: forall x. DILocalVariable -> Rep DILocalVariable x
$cto :: forall x. Rep DILocalVariable x -> DILocalVariable
to :: forall x. Rep DILocalVariable x -> DILocalVariable
Generic)