{-# LANGUAGE PartialTypeSignatures #-}

{- | Provides a monadic interface to the constant pool.
 This aims to eliminate the need to manually specify the index of the constant
-}
module JVM.Data.Abstract.ConstantPool (ConstantPoolEntry (..), MethodHandleEntry (..), FieldRef (..), MethodRef (..), BootstrapMethod (..), BootstrapArgument (..), bmArgToCPEntry) where

import Data.Int (Int64)
import Data.Text (Text)
import JVM.Data.Abstract.Descriptor (MethodDescriptor)

import Data.Data
import JVM.Data.Abstract.Type (ClassInfoType, FieldType)
import JVM.Data.Pretty

{- | High-level, type-safe representation of a constant pool entry
 This tries to hide indexes as much as possible, instead just allowing the values to be provided directly.
 These are transformed into the correct indexes when the constant pool is built, which uses a state monad to avoid repeating entries.
-}
data ConstantPoolEntry
    = -- | A class reference
      CPClassEntry
        -- | The class being referenced
        ClassInfoType
    | CPFieldRefEntry FieldRef
    | CPMethodRefEntry MethodRef
    | CPInterfaceMethodRefEntry MethodRef
    | CPStringEntry Text
    | CPIntegerEntry Int
    | CPFloatEntry Float
    | CPLongEntry Int64
    | CPDoubleEntry Double
    | CPNameAndTypeEntry Text Text
    | CPUTF8Entry Text
    | CPMethodHandleEntry MethodHandleEntry
    | CPMethodTypeEntry MethodDescriptor
    | -- | CONSTANT_InvokeDynamic_info
      CPInvokeDynamicEntry
        -- | bootstrap_method_attr(_index)
        BootstrapMethod
        -- | name(_and_type_index)
        Text
        -- | (name_and_)type(_index)
        MethodDescriptor
    deriving (Int -> ConstantPoolEntry -> ShowS
[ConstantPoolEntry] -> ShowS
ConstantPoolEntry -> String
(Int -> ConstantPoolEntry -> ShowS)
-> (ConstantPoolEntry -> String)
-> ([ConstantPoolEntry] -> ShowS)
-> Show ConstantPoolEntry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ConstantPoolEntry -> ShowS
showsPrec :: Int -> ConstantPoolEntry -> ShowS
$cshow :: ConstantPoolEntry -> String
show :: ConstantPoolEntry -> String
$cshowList :: [ConstantPoolEntry] -> ShowS
showList :: [ConstantPoolEntry] -> ShowS
Show, ConstantPoolEntry -> ConstantPoolEntry -> Bool
(ConstantPoolEntry -> ConstantPoolEntry -> Bool)
-> (ConstantPoolEntry -> ConstantPoolEntry -> Bool)
-> Eq ConstantPoolEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
== :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
$c/= :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
/= :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
Eq, Eq ConstantPoolEntry
Eq ConstantPoolEntry =>
(ConstantPoolEntry -> ConstantPoolEntry -> Ordering)
-> (ConstantPoolEntry -> ConstantPoolEntry -> Bool)
-> (ConstantPoolEntry -> ConstantPoolEntry -> Bool)
-> (ConstantPoolEntry -> ConstantPoolEntry -> Bool)
-> (ConstantPoolEntry -> ConstantPoolEntry -> Bool)
-> (ConstantPoolEntry -> ConstantPoolEntry -> ConstantPoolEntry)
-> (ConstantPoolEntry -> ConstantPoolEntry -> ConstantPoolEntry)
-> Ord ConstantPoolEntry
ConstantPoolEntry -> ConstantPoolEntry -> Bool
ConstantPoolEntry -> ConstantPoolEntry -> Ordering
ConstantPoolEntry -> ConstantPoolEntry -> ConstantPoolEntry
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 :: ConstantPoolEntry -> ConstantPoolEntry -> Ordering
compare :: ConstantPoolEntry -> ConstantPoolEntry -> Ordering
$c< :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
< :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
$c<= :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
<= :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
$c> :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
> :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
$c>= :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
>= :: ConstantPoolEntry -> ConstantPoolEntry -> Bool
$cmax :: ConstantPoolEntry -> ConstantPoolEntry -> ConstantPoolEntry
max :: ConstantPoolEntry -> ConstantPoolEntry -> ConstantPoolEntry
$cmin :: ConstantPoolEntry -> ConstantPoolEntry -> ConstantPoolEntry
min :: ConstantPoolEntry -> ConstantPoolEntry -> ConstantPoolEntry
Ord)

data FieldRef = FieldRef ClassInfoType Text FieldType
    deriving (Int -> FieldRef -> ShowS
[FieldRef] -> ShowS
FieldRef -> String
(Int -> FieldRef -> ShowS)
-> (FieldRef -> String) -> ([FieldRef] -> ShowS) -> Show FieldRef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FieldRef -> ShowS
showsPrec :: Int -> FieldRef -> ShowS
$cshow :: FieldRef -> String
show :: FieldRef -> String
$cshowList :: [FieldRef] -> ShowS
showList :: [FieldRef] -> ShowS
Show, FieldRef -> FieldRef -> Bool
(FieldRef -> FieldRef -> Bool)
-> (FieldRef -> FieldRef -> Bool) -> Eq FieldRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldRef -> FieldRef -> Bool
== :: FieldRef -> FieldRef -> Bool
$c/= :: FieldRef -> FieldRef -> Bool
/= :: FieldRef -> FieldRef -> Bool
Eq, Eq FieldRef
Eq FieldRef =>
(FieldRef -> FieldRef -> Ordering)
-> (FieldRef -> FieldRef -> Bool)
-> (FieldRef -> FieldRef -> Bool)
-> (FieldRef -> FieldRef -> Bool)
-> (FieldRef -> FieldRef -> Bool)
-> (FieldRef -> FieldRef -> FieldRef)
-> (FieldRef -> FieldRef -> FieldRef)
-> Ord FieldRef
FieldRef -> FieldRef -> Bool
FieldRef -> FieldRef -> Ordering
FieldRef -> FieldRef -> FieldRef
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 :: FieldRef -> FieldRef -> Ordering
compare :: FieldRef -> FieldRef -> Ordering
$c< :: FieldRef -> FieldRef -> Bool
< :: FieldRef -> FieldRef -> Bool
$c<= :: FieldRef -> FieldRef -> Bool
<= :: FieldRef -> FieldRef -> Bool
$c> :: FieldRef -> FieldRef -> Bool
> :: FieldRef -> FieldRef -> Bool
$c>= :: FieldRef -> FieldRef -> Bool
>= :: FieldRef -> FieldRef -> Bool
$cmax :: FieldRef -> FieldRef -> FieldRef
max :: FieldRef -> FieldRef -> FieldRef
$cmin :: FieldRef -> FieldRef -> FieldRef
min :: FieldRef -> FieldRef -> FieldRef
Ord, Typeable FieldRef
Typeable FieldRef =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FieldRef -> c FieldRef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FieldRef)
-> (FieldRef -> Constr)
-> (FieldRef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FieldRef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldRef))
-> ((forall b. Data b => b -> b) -> FieldRef -> FieldRef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldRef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FieldRef -> r)
-> (forall u. (forall d. Data d => d -> u) -> FieldRef -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> FieldRef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FieldRef -> m FieldRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldRef -> m FieldRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FieldRef -> m FieldRef)
-> Data FieldRef
FieldRef -> Constr
FieldRef -> DataType
(forall b. Data b => b -> b) -> FieldRef -> FieldRef
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) -> FieldRef -> u
forall u. (forall d. Data d => d -> u) -> FieldRef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldRef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldRef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldRef -> m FieldRef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldRef -> m FieldRef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldRef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldRef -> c FieldRef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldRef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldRef)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldRef -> c FieldRef
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldRef -> c FieldRef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldRef
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldRef
$ctoConstr :: FieldRef -> Constr
toConstr :: FieldRef -> Constr
$cdataTypeOf :: FieldRef -> DataType
dataTypeOf :: FieldRef -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldRef)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldRef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldRef)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldRef)
$cgmapT :: (forall b. Data b => b -> b) -> FieldRef -> FieldRef
gmapT :: (forall b. Data b => b -> b) -> FieldRef -> FieldRef
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldRef -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldRef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldRef -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldRef -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldRef -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FieldRef -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldRef -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldRef -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldRef -> m FieldRef
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldRef -> m FieldRef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldRef -> m FieldRef
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldRef -> m FieldRef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldRef -> m FieldRef
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldRef -> m FieldRef
Data)

instance Pretty FieldRef where
    pretty :: forall ann. FieldRef -> Doc ann
pretty (FieldRef ClassInfoType
c Text
n FieldType
t) = ClassInfoType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ClassInfoType -> Doc ann
pretty ClassInfoType
c Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"." Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
n Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> FieldType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. FieldType -> Doc ann
pretty FieldType
t

data MethodRef
    = MethodRef
        -- | The class containing the method
        ClassInfoType
        -- | The name of the method
        Text
        -- | The descriptor of the method
        MethodDescriptor
    deriving (Int -> MethodRef -> ShowS
[MethodRef] -> ShowS
MethodRef -> String
(Int -> MethodRef -> ShowS)
-> (MethodRef -> String)
-> ([MethodRef] -> ShowS)
-> Show MethodRef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MethodRef -> ShowS
showsPrec :: Int -> MethodRef -> ShowS
$cshow :: MethodRef -> String
show :: MethodRef -> String
$cshowList :: [MethodRef] -> ShowS
showList :: [MethodRef] -> ShowS
Show, MethodRef -> MethodRef -> Bool
(MethodRef -> MethodRef -> Bool)
-> (MethodRef -> MethodRef -> Bool) -> Eq MethodRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodRef -> MethodRef -> Bool
== :: MethodRef -> MethodRef -> Bool
$c/= :: MethodRef -> MethodRef -> Bool
/= :: MethodRef -> MethodRef -> Bool
Eq, Eq MethodRef
Eq MethodRef =>
(MethodRef -> MethodRef -> Ordering)
-> (MethodRef -> MethodRef -> Bool)
-> (MethodRef -> MethodRef -> Bool)
-> (MethodRef -> MethodRef -> Bool)
-> (MethodRef -> MethodRef -> Bool)
-> (MethodRef -> MethodRef -> MethodRef)
-> (MethodRef -> MethodRef -> MethodRef)
-> Ord MethodRef
MethodRef -> MethodRef -> Bool
MethodRef -> MethodRef -> Ordering
MethodRef -> MethodRef -> MethodRef
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 :: MethodRef -> MethodRef -> Ordering
compare :: MethodRef -> MethodRef -> Ordering
$c< :: MethodRef -> MethodRef -> Bool
< :: MethodRef -> MethodRef -> Bool
$c<= :: MethodRef -> MethodRef -> Bool
<= :: MethodRef -> MethodRef -> Bool
$c> :: MethodRef -> MethodRef -> Bool
> :: MethodRef -> MethodRef -> Bool
$c>= :: MethodRef -> MethodRef -> Bool
>= :: MethodRef -> MethodRef -> Bool
$cmax :: MethodRef -> MethodRef -> MethodRef
max :: MethodRef -> MethodRef -> MethodRef
$cmin :: MethodRef -> MethodRef -> MethodRef
min :: MethodRef -> MethodRef -> MethodRef
Ord, Typeable MethodRef
Typeable MethodRef =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MethodRef -> c MethodRef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MethodRef)
-> (MethodRef -> Constr)
-> (MethodRef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MethodRef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodRef))
-> ((forall b. Data b => b -> b) -> MethodRef -> MethodRef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MethodRef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MethodRef -> r)
-> (forall u. (forall d. Data d => d -> u) -> MethodRef -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MethodRef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MethodRef -> m MethodRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MethodRef -> m MethodRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MethodRef -> m MethodRef)
-> Data MethodRef
MethodRef -> Constr
MethodRef -> DataType
(forall b. Data b => b -> b) -> MethodRef -> MethodRef
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) -> MethodRef -> u
forall u. (forall d. Data d => d -> u) -> MethodRef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodRef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodRef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MethodRef -> m MethodRef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodRef -> m MethodRef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodRef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodRef -> c MethodRef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodRef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodRef)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodRef -> c MethodRef
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodRef -> c MethodRef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodRef
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodRef
$ctoConstr :: MethodRef -> Constr
toConstr :: MethodRef -> Constr
$cdataTypeOf :: MethodRef -> DataType
dataTypeOf :: MethodRef -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodRef)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodRef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodRef)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodRef)
$cgmapT :: (forall b. Data b => b -> b) -> MethodRef -> MethodRef
gmapT :: (forall b. Data b => b -> b) -> MethodRef -> MethodRef
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodRef -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodRef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodRef -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodRef -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MethodRef -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MethodRef -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MethodRef -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MethodRef -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MethodRef -> m MethodRef
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MethodRef -> m MethodRef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodRef -> m MethodRef
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodRef -> m MethodRef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodRef -> m MethodRef
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodRef -> m MethodRef
Data)

instance Pretty MethodRef where
    pretty :: forall ann. MethodRef -> Doc ann
pretty (MethodRef ClassInfoType
c Text
n MethodDescriptor
d) = ClassInfoType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ClassInfoType -> Doc ann
pretty ClassInfoType
c Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"." Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
n Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> MethodDescriptor -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodDescriptor -> Doc ann
pretty MethodDescriptor
d

data BootstrapMethod
    = BootstrapMethod MethodHandleEntry [BootstrapArgument]
    deriving (Int -> BootstrapMethod -> ShowS
[BootstrapMethod] -> ShowS
BootstrapMethod -> String
(Int -> BootstrapMethod -> ShowS)
-> (BootstrapMethod -> String)
-> ([BootstrapMethod] -> ShowS)
-> Show BootstrapMethod
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BootstrapMethod -> ShowS
showsPrec :: Int -> BootstrapMethod -> ShowS
$cshow :: BootstrapMethod -> String
show :: BootstrapMethod -> String
$cshowList :: [BootstrapMethod] -> ShowS
showList :: [BootstrapMethod] -> ShowS
Show, BootstrapMethod -> BootstrapMethod -> Bool
(BootstrapMethod -> BootstrapMethod -> Bool)
-> (BootstrapMethod -> BootstrapMethod -> Bool)
-> Eq BootstrapMethod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BootstrapMethod -> BootstrapMethod -> Bool
== :: BootstrapMethod -> BootstrapMethod -> Bool
$c/= :: BootstrapMethod -> BootstrapMethod -> Bool
/= :: BootstrapMethod -> BootstrapMethod -> Bool
Eq, Eq BootstrapMethod
Eq BootstrapMethod =>
(BootstrapMethod -> BootstrapMethod -> Ordering)
-> (BootstrapMethod -> BootstrapMethod -> Bool)
-> (BootstrapMethod -> BootstrapMethod -> Bool)
-> (BootstrapMethod -> BootstrapMethod -> Bool)
-> (BootstrapMethod -> BootstrapMethod -> Bool)
-> (BootstrapMethod -> BootstrapMethod -> BootstrapMethod)
-> (BootstrapMethod -> BootstrapMethod -> BootstrapMethod)
-> Ord BootstrapMethod
BootstrapMethod -> BootstrapMethod -> Bool
BootstrapMethod -> BootstrapMethod -> Ordering
BootstrapMethod -> BootstrapMethod -> BootstrapMethod
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 :: BootstrapMethod -> BootstrapMethod -> Ordering
compare :: BootstrapMethod -> BootstrapMethod -> Ordering
$c< :: BootstrapMethod -> BootstrapMethod -> Bool
< :: BootstrapMethod -> BootstrapMethod -> Bool
$c<= :: BootstrapMethod -> BootstrapMethod -> Bool
<= :: BootstrapMethod -> BootstrapMethod -> Bool
$c> :: BootstrapMethod -> BootstrapMethod -> Bool
> :: BootstrapMethod -> BootstrapMethod -> Bool
$c>= :: BootstrapMethod -> BootstrapMethod -> Bool
>= :: BootstrapMethod -> BootstrapMethod -> Bool
$cmax :: BootstrapMethod -> BootstrapMethod -> BootstrapMethod
max :: BootstrapMethod -> BootstrapMethod -> BootstrapMethod
$cmin :: BootstrapMethod -> BootstrapMethod -> BootstrapMethod
min :: BootstrapMethod -> BootstrapMethod -> BootstrapMethod
Ord, Typeable BootstrapMethod
Typeable BootstrapMethod =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BootstrapMethod -> c BootstrapMethod)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BootstrapMethod)
-> (BootstrapMethod -> Constr)
-> (BootstrapMethod -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BootstrapMethod))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BootstrapMethod))
-> ((forall b. Data b => b -> b)
    -> BootstrapMethod -> BootstrapMethod)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BootstrapMethod -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BootstrapMethod -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BootstrapMethod -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BootstrapMethod -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BootstrapMethod -> m BootstrapMethod)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BootstrapMethod -> m BootstrapMethod)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BootstrapMethod -> m BootstrapMethod)
-> Data BootstrapMethod
BootstrapMethod -> Constr
BootstrapMethod -> DataType
(forall b. Data b => b -> b) -> BootstrapMethod -> BootstrapMethod
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) -> BootstrapMethod -> u
forall u. (forall d. Data d => d -> u) -> BootstrapMethod -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapMethod -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapMethod -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BootstrapMethod -> m BootstrapMethod
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapMethod -> m BootstrapMethod
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BootstrapMethod
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BootstrapMethod -> c BootstrapMethod
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BootstrapMethod)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BootstrapMethod)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BootstrapMethod -> c BootstrapMethod
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BootstrapMethod -> c BootstrapMethod
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BootstrapMethod
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BootstrapMethod
$ctoConstr :: BootstrapMethod -> Constr
toConstr :: BootstrapMethod -> Constr
$cdataTypeOf :: BootstrapMethod -> DataType
dataTypeOf :: BootstrapMethod -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BootstrapMethod)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BootstrapMethod)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BootstrapMethod)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BootstrapMethod)
$cgmapT :: (forall b. Data b => b -> b) -> BootstrapMethod -> BootstrapMethod
gmapT :: (forall b. Data b => b -> b) -> BootstrapMethod -> BootstrapMethod
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapMethod -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapMethod -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapMethod -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapMethod -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BootstrapMethod -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BootstrapMethod -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BootstrapMethod -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BootstrapMethod -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BootstrapMethod -> m BootstrapMethod
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BootstrapMethod -> m BootstrapMethod
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapMethod -> m BootstrapMethod
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapMethod -> m BootstrapMethod
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapMethod -> m BootstrapMethod
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapMethod -> m BootstrapMethod
Data)

instance Pretty BootstrapMethod where
    pretty :: forall ann. BootstrapMethod -> Doc ann
pretty (BootstrapMethod MethodHandleEntry
mh [BootstrapArgument]
args) = MethodHandleEntry -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodHandleEntry -> Doc ann
pretty MethodHandleEntry
mh Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ((BootstrapArgument -> Doc ann) -> [BootstrapArgument] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map BootstrapArgument -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. BootstrapArgument -> Doc ann
pretty [BootstrapArgument]
args)

data BootstrapArgument
    = BMClassArg ClassInfoType
    | BMStringArg Text
    | BMIntArg Int
    | BMMethodArg MethodDescriptor
    | BMMethodHandleArg MethodHandleEntry
    deriving (Int -> BootstrapArgument -> ShowS
[BootstrapArgument] -> ShowS
BootstrapArgument -> String
(Int -> BootstrapArgument -> ShowS)
-> (BootstrapArgument -> String)
-> ([BootstrapArgument] -> ShowS)
-> Show BootstrapArgument
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BootstrapArgument -> ShowS
showsPrec :: Int -> BootstrapArgument -> ShowS
$cshow :: BootstrapArgument -> String
show :: BootstrapArgument -> String
$cshowList :: [BootstrapArgument] -> ShowS
showList :: [BootstrapArgument] -> ShowS
Show, BootstrapArgument -> BootstrapArgument -> Bool
(BootstrapArgument -> BootstrapArgument -> Bool)
-> (BootstrapArgument -> BootstrapArgument -> Bool)
-> Eq BootstrapArgument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BootstrapArgument -> BootstrapArgument -> Bool
== :: BootstrapArgument -> BootstrapArgument -> Bool
$c/= :: BootstrapArgument -> BootstrapArgument -> Bool
/= :: BootstrapArgument -> BootstrapArgument -> Bool
Eq, Eq BootstrapArgument
Eq BootstrapArgument =>
(BootstrapArgument -> BootstrapArgument -> Ordering)
-> (BootstrapArgument -> BootstrapArgument -> Bool)
-> (BootstrapArgument -> BootstrapArgument -> Bool)
-> (BootstrapArgument -> BootstrapArgument -> Bool)
-> (BootstrapArgument -> BootstrapArgument -> Bool)
-> (BootstrapArgument -> BootstrapArgument -> BootstrapArgument)
-> (BootstrapArgument -> BootstrapArgument -> BootstrapArgument)
-> Ord BootstrapArgument
BootstrapArgument -> BootstrapArgument -> Bool
BootstrapArgument -> BootstrapArgument -> Ordering
BootstrapArgument -> BootstrapArgument -> BootstrapArgument
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 :: BootstrapArgument -> BootstrapArgument -> Ordering
compare :: BootstrapArgument -> BootstrapArgument -> Ordering
$c< :: BootstrapArgument -> BootstrapArgument -> Bool
< :: BootstrapArgument -> BootstrapArgument -> Bool
$c<= :: BootstrapArgument -> BootstrapArgument -> Bool
<= :: BootstrapArgument -> BootstrapArgument -> Bool
$c> :: BootstrapArgument -> BootstrapArgument -> Bool
> :: BootstrapArgument -> BootstrapArgument -> Bool
$c>= :: BootstrapArgument -> BootstrapArgument -> Bool
>= :: BootstrapArgument -> BootstrapArgument -> Bool
$cmax :: BootstrapArgument -> BootstrapArgument -> BootstrapArgument
max :: BootstrapArgument -> BootstrapArgument -> BootstrapArgument
$cmin :: BootstrapArgument -> BootstrapArgument -> BootstrapArgument
min :: BootstrapArgument -> BootstrapArgument -> BootstrapArgument
Ord, Typeable BootstrapArgument
Typeable BootstrapArgument =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> BootstrapArgument
 -> c BootstrapArgument)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BootstrapArgument)
-> (BootstrapArgument -> Constr)
-> (BootstrapArgument -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BootstrapArgument))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BootstrapArgument))
-> ((forall b. Data b => b -> b)
    -> BootstrapArgument -> BootstrapArgument)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BootstrapArgument -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BootstrapArgument -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> BootstrapArgument -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BootstrapArgument -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> BootstrapArgument -> m BootstrapArgument)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BootstrapArgument -> m BootstrapArgument)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> BootstrapArgument -> m BootstrapArgument)
-> Data BootstrapArgument
BootstrapArgument -> Constr
BootstrapArgument -> DataType
(forall b. Data b => b -> b)
-> BootstrapArgument -> BootstrapArgument
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) -> BootstrapArgument -> u
forall u. (forall d. Data d => d -> u) -> BootstrapArgument -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapArgument -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapArgument -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BootstrapArgument -> m BootstrapArgument
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapArgument -> m BootstrapArgument
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BootstrapArgument
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BootstrapArgument -> c BootstrapArgument
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BootstrapArgument)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BootstrapArgument)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BootstrapArgument -> c BootstrapArgument
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BootstrapArgument -> c BootstrapArgument
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BootstrapArgument
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BootstrapArgument
$ctoConstr :: BootstrapArgument -> Constr
toConstr :: BootstrapArgument -> Constr
$cdataTypeOf :: BootstrapArgument -> DataType
dataTypeOf :: BootstrapArgument -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BootstrapArgument)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BootstrapArgument)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BootstrapArgument)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BootstrapArgument)
$cgmapT :: (forall b. Data b => b -> b)
-> BootstrapArgument -> BootstrapArgument
gmapT :: (forall b. Data b => b -> b)
-> BootstrapArgument -> BootstrapArgument
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapArgument -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapArgument -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapArgument -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BootstrapArgument -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BootstrapArgument -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BootstrapArgument -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BootstrapArgument -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> BootstrapArgument -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BootstrapArgument -> m BootstrapArgument
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> BootstrapArgument -> m BootstrapArgument
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapArgument -> m BootstrapArgument
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapArgument -> m BootstrapArgument
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapArgument -> m BootstrapArgument
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> BootstrapArgument -> m BootstrapArgument
Data)

instance Pretty BootstrapArgument where
    pretty :: forall ann. BootstrapArgument -> Doc ann
pretty (BMClassArg ClassInfoType
c) = ClassInfoType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ClassInfoType -> Doc ann
pretty ClassInfoType
c
    pretty (BMStringArg Text
s) = Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
s
    pretty (BMIntArg Int
i) = Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i
    pretty (BMMethodArg MethodDescriptor
m) = MethodDescriptor -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodDescriptor -> Doc ann
pretty MethodDescriptor
m
    pretty (BMMethodHandleArg MethodHandleEntry
m) = MethodHandleEntry -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodHandleEntry -> Doc ann
pretty MethodHandleEntry
m

bmArgToCPEntry :: BootstrapArgument -> ConstantPoolEntry
bmArgToCPEntry :: BootstrapArgument -> ConstantPoolEntry
bmArgToCPEntry (BMClassArg ClassInfoType
c) = ClassInfoType -> ConstantPoolEntry
CPClassEntry ClassInfoType
c
bmArgToCPEntry (BMStringArg Text
s) = Text -> ConstantPoolEntry
CPStringEntry Text
s
bmArgToCPEntry (BMIntArg Int
i) = Int -> ConstantPoolEntry
CPIntegerEntry Int
i
bmArgToCPEntry (BMMethodArg MethodDescriptor
m) = MethodDescriptor -> ConstantPoolEntry
CPMethodTypeEntry MethodDescriptor
m
bmArgToCPEntry (BMMethodHandleArg MethodHandleEntry
m) = MethodHandleEntry -> ConstantPoolEntry
CPMethodHandleEntry MethodHandleEntry
m

data MethodHandleEntry
    = MHGetField FieldRef
    | MHGetStatic FieldRef
    | MHPutField FieldRef
    | MHPutStatic FieldRef
    | MHInvokeVirtual MethodRef
    | MHNewInvokeSpecial MethodRef
    | MHInvokeStatic MethodRef
    | MHInvokeSpecial MethodRef
    | MHInvokeInterface MethodRef
    deriving (Int -> MethodHandleEntry -> ShowS
[MethodHandleEntry] -> ShowS
MethodHandleEntry -> String
(Int -> MethodHandleEntry -> ShowS)
-> (MethodHandleEntry -> String)
-> ([MethodHandleEntry] -> ShowS)
-> Show MethodHandleEntry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MethodHandleEntry -> ShowS
showsPrec :: Int -> MethodHandleEntry -> ShowS
$cshow :: MethodHandleEntry -> String
show :: MethodHandleEntry -> String
$cshowList :: [MethodHandleEntry] -> ShowS
showList :: [MethodHandleEntry] -> ShowS
Show, MethodHandleEntry -> MethodHandleEntry -> Bool
(MethodHandleEntry -> MethodHandleEntry -> Bool)
-> (MethodHandleEntry -> MethodHandleEntry -> Bool)
-> Eq MethodHandleEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodHandleEntry -> MethodHandleEntry -> Bool
== :: MethodHandleEntry -> MethodHandleEntry -> Bool
$c/= :: MethodHandleEntry -> MethodHandleEntry -> Bool
/= :: MethodHandleEntry -> MethodHandleEntry -> Bool
Eq, Eq MethodHandleEntry
Eq MethodHandleEntry =>
(MethodHandleEntry -> MethodHandleEntry -> Ordering)
-> (MethodHandleEntry -> MethodHandleEntry -> Bool)
-> (MethodHandleEntry -> MethodHandleEntry -> Bool)
-> (MethodHandleEntry -> MethodHandleEntry -> Bool)
-> (MethodHandleEntry -> MethodHandleEntry -> Bool)
-> (MethodHandleEntry -> MethodHandleEntry -> MethodHandleEntry)
-> (MethodHandleEntry -> MethodHandleEntry -> MethodHandleEntry)
-> Ord MethodHandleEntry
MethodHandleEntry -> MethodHandleEntry -> Bool
MethodHandleEntry -> MethodHandleEntry -> Ordering
MethodHandleEntry -> MethodHandleEntry -> MethodHandleEntry
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 :: MethodHandleEntry -> MethodHandleEntry -> Ordering
compare :: MethodHandleEntry -> MethodHandleEntry -> Ordering
$c< :: MethodHandleEntry -> MethodHandleEntry -> Bool
< :: MethodHandleEntry -> MethodHandleEntry -> Bool
$c<= :: MethodHandleEntry -> MethodHandleEntry -> Bool
<= :: MethodHandleEntry -> MethodHandleEntry -> Bool
$c> :: MethodHandleEntry -> MethodHandleEntry -> Bool
> :: MethodHandleEntry -> MethodHandleEntry -> Bool
$c>= :: MethodHandleEntry -> MethodHandleEntry -> Bool
>= :: MethodHandleEntry -> MethodHandleEntry -> Bool
$cmax :: MethodHandleEntry -> MethodHandleEntry -> MethodHandleEntry
max :: MethodHandleEntry -> MethodHandleEntry -> MethodHandleEntry
$cmin :: MethodHandleEntry -> MethodHandleEntry -> MethodHandleEntry
min :: MethodHandleEntry -> MethodHandleEntry -> MethodHandleEntry
Ord, Typeable MethodHandleEntry
Typeable MethodHandleEntry =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> MethodHandleEntry
 -> c MethodHandleEntry)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MethodHandleEntry)
-> (MethodHandleEntry -> Constr)
-> (MethodHandleEntry -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MethodHandleEntry))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MethodHandleEntry))
-> ((forall b. Data b => b -> b)
    -> MethodHandleEntry -> MethodHandleEntry)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MethodHandleEntry -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MethodHandleEntry -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MethodHandleEntry -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MethodHandleEntry -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MethodHandleEntry -> m MethodHandleEntry)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MethodHandleEntry -> m MethodHandleEntry)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MethodHandleEntry -> m MethodHandleEntry)
-> Data MethodHandleEntry
MethodHandleEntry -> Constr
MethodHandleEntry -> DataType
(forall b. Data b => b -> b)
-> MethodHandleEntry -> MethodHandleEntry
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) -> MethodHandleEntry -> u
forall u. (forall d. Data d => d -> u) -> MethodHandleEntry -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodHandleEntry -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodHandleEntry -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MethodHandleEntry -> m MethodHandleEntry
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodHandleEntry -> m MethodHandleEntry
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodHandleEntry
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodHandleEntry -> c MethodHandleEntry
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodHandleEntry)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MethodHandleEntry)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodHandleEntry -> c MethodHandleEntry
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodHandleEntry -> c MethodHandleEntry
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodHandleEntry
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodHandleEntry
$ctoConstr :: MethodHandleEntry -> Constr
toConstr :: MethodHandleEntry -> Constr
$cdataTypeOf :: MethodHandleEntry -> DataType
dataTypeOf :: MethodHandleEntry -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodHandleEntry)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodHandleEntry)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MethodHandleEntry)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MethodHandleEntry)
$cgmapT :: (forall b. Data b => b -> b)
-> MethodHandleEntry -> MethodHandleEntry
gmapT :: (forall b. Data b => b -> b)
-> MethodHandleEntry -> MethodHandleEntry
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodHandleEntry -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodHandleEntry -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodHandleEntry -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodHandleEntry -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MethodHandleEntry -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MethodHandleEntry -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MethodHandleEntry -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MethodHandleEntry -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MethodHandleEntry -> m MethodHandleEntry
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MethodHandleEntry -> m MethodHandleEntry
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodHandleEntry -> m MethodHandleEntry
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodHandleEntry -> m MethodHandleEntry
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodHandleEntry -> m MethodHandleEntry
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodHandleEntry -> m MethodHandleEntry
Data)

instance Pretty MethodHandleEntry where
    pretty :: forall ann. MethodHandleEntry -> Doc ann
pretty (MHGetField FieldRef
f) = Doc ann
"getField" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> FieldRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. FieldRef -> Doc ann
pretty FieldRef
f
    pretty (MHGetStatic FieldRef
f) = Doc ann
"getStatic" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> FieldRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. FieldRef -> Doc ann
pretty FieldRef
f
    pretty (MHPutField FieldRef
f) = Doc ann
"putField" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> FieldRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. FieldRef -> Doc ann
pretty FieldRef
f
    pretty (MHPutStatic FieldRef
f) = Doc ann
"putStatic" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> FieldRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. FieldRef -> Doc ann
pretty FieldRef
f
    pretty (MHInvokeVirtual MethodRef
m) = Doc ann
"invokeVirtual" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> MethodRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodRef -> Doc ann
pretty MethodRef
m
    pretty (MHNewInvokeSpecial MethodRef
m) = Doc ann
"newInvokeSpecial" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> MethodRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodRef -> Doc ann
pretty MethodRef
m
    pretty (MHInvokeStatic MethodRef
m) = Doc ann
"invokeStatic" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> MethodRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodRef -> Doc ann
pretty MethodRef
m
    pretty (MHInvokeSpecial MethodRef
m) = Doc ann
"invokeSpecial" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> MethodRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodRef -> Doc ann
pretty MethodRef
m
    pretty (MHInvokeInterface MethodRef
m) = Doc ann
"invokeInterface" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> MethodRef -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. MethodRef -> Doc ann
pretty MethodRef
m