{-# 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 H2JVM.ConstantPool (ConstantPoolEntry (..), MethodHandleEntry (..), FieldRef (..), MethodRef (..), BootstrapMethod (..), BootstrapArgument (..), bmArgToCPEntry) where

import Data.Data
import Data.Int (Int32, Int64)
import Data.Text (Text)

import H2JVM.Descriptor (MethodDescriptor)
import H2JVM.Internal.Pretty
import H2JVM.Type (ClassInfoType, FieldType)

{- | 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 Int32
    | 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 (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, 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)

-- | A reference to a field, consisting of the containing class type, field name, and field type.
data FieldRef = FieldRef ClassInfoType Text FieldType
    deriving (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, 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, 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)

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

-- | A reference to a method, consisting of the containing class type, method name, and descriptor signature.
data MethodRef
    = MethodRef
        -- | The class containing the method
        ClassInfoType
        -- | The name of the method
        Text
        -- | The descriptor of the method
        MethodDescriptor
    deriving (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, 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, 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)

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

-- | A Bootstrap Method specification, used in @invokedynamic@ call sites (§4.7.23).
data BootstrapMethod
    = -- | Construct a bootstrap method referencing a method handle and its static arguments.
      BootstrapMethod MethodHandleEntry [BootstrapArgument]
    deriving (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, 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, 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)

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)

-- | A static argument for a bootstrap method.
data BootstrapArgument
    = -- | A Class reference argument.
      BMClassArg ClassInfoType
    | -- | A String constant argument.
      BMStringArg Text
    | -- | An integer constant argument.
      BMIntArg Int32
    | -- | A Method type descriptor argument.
      BMMethodArg MethodDescriptor
    | -- | A Method handle argument.
      BMMethodHandleArg MethodHandleEntry
    deriving (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, 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, 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)

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 Int32
i) = Int32 -> Doc ann
forall ann. Int32 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int32
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

-- | Convert a bootstrap argument to its equivalent constant pool entry.
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 Int32
i) = Int32 -> ConstantPoolEntry
CPIntegerEntry Int32
i
bmArgToCPEntry (BMMethodArg MethodDescriptor
m) = MethodDescriptor -> ConstantPoolEntry
CPMethodTypeEntry MethodDescriptor
m
bmArgToCPEntry (BMMethodHandleArg MethodHandleEntry
m) = MethodHandleEntry -> ConstantPoolEntry
CPMethodHandleEntry MethodHandleEntry
m

-- | A Method Handle type entry in the constant pool (§4.4.8).
data MethodHandleEntry
    = -- | read field
      MHGetField FieldRef
    | -- | read static field
      MHGetStatic FieldRef
    | -- | write field
      MHPutField FieldRef
    | -- | write static field
      MHPutStatic FieldRef
    | -- | invoke virtual method
      MHInvokeVirtual MethodRef
    | -- | invoke special method (e.g. @<init>@)
      MHNewInvokeSpecial MethodRef
    | -- | invoke static method
      MHInvokeStatic MethodRef
    | -- | invoke private/super method
      MHInvokeSpecial MethodRef
    | -- | invoke interface method
      MHInvokeInterface MethodRef
    deriving (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, 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, 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)

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