Класс MethodHandle

При просмотре этого метода через API Core Reflection он будет выглядеть как один нативный метод, принимающий массив объектов и возвращающий объект. При прямом вызове этого нативного метода через java.lang.reflect.Method.invoke, через JNI или косвенно через Lookup.unreflect он выбросит UnsupportedOperationException.

Если символьный дескриптор типа в точке вызова в точности совпадает с type этого дескриптора метода, вызов выполняется так же, как при использовании invokeExact.

В противном случае вызов выполняется так, как если бы этот дескриптор метода сначала был скорректирован вызовом asType, чтобы привести его к требуемому типу, а затем вызов выполнялся так же, как при использовании invokeExact для скорректированного дескриптора метода.

Нет гарантии, что вызов asType действительно будет выполнен. Если JVM может предсказать результаты вызова, она может напрямую применить преобразования к аргументам вызывающей стороны и вызвать целевой дескриптор метода в соответствии с его собственным точным типом.

Разрешённый дескриптор типа в точке вызова invoke должен быть допустимым аргументом для метода получателя asType. В частности, если вызываемый метод не является сборщиком переменного числа аргументов, вызывающая сторона должна указать такое же количество аргументов, как и тип вызываемого метода.

При просмотре этого метода через API Core Reflection он будет выглядеть как один нативный метод, принимающий массив объектов и возвращающий объект. При прямом вызове этого нативного метода через java.lang.reflect.Method.invoke, через JNI или косвенно через Lookup.unreflect он выбросит UnsupportedOperationException.

В частности, выполнение происходит в соответствии со следующими шагами, хотя нет гарантии, что методы будут вызваны, если JVM может предсказать их эффекты.

• Определить длину массива аргументов как N. Для нулевой ссылки — N=0.
• Собрать N элементы массива в логический список аргументов, статический тип каждого аргумента — Object.
• Определить количество параметров типа этого дескриптора метода как M.
• Определить общий тип TN для N аргументов или M аргументов, если это число меньше N, как TN=MethodType.genericMethodType(Math.min(N, M)).
• Если N больше M, выполнить следующие проверки и действия, чтобы сократить логический список аргументов:
  • Проверить, что этот дескриптор метода принимает переменное число аргументов и имеет последний параметр некоторого типа массива A[]. В противном случае завершиться с ошибкой WrongMethodTypeException.
  • Собрать конечные элементы (их N-M+1) из логического списка аргументов в один массив типа A[], применяя преобразования asType для преобразования каждого конечного аргумента к типу A.
  • Если какое-либо из этих преобразований невозможно, завершиться с ошибкой ClassCastException, если какой-либо конечный элемент нельзя привести к A, или с ошибкой NullPointerException, если какой-либо конечный элемент — это null, а A не является ссылочным типом.
  • Заменить логические аргументы, собранные в массив типа A[], самим массивом, сократив тем самым список аргументов до длины M. Этот последний аргумент сохраняет статический тип A[].
  • Скорректировать тип TN, изменив тип параметра номер N с Object на A[].
• Привести исходный целевой дескриптор метода MH0 к требуемому типу, как MH1 = MH0.asType(TN).
• Развернуть список аргументов в N отдельных аргументов A0, ....
• Вызвать дескриптор метода с приведённым типом, передав ему развёрнутые аргументы: MH1.invokeExact(A0, ...).
• Получить возвращаемое значение как ссылку Object.

Если целевой дескриптор метода принимает переменное число аргументов и список аргументов длиннее этого числа, избыточные аргументы, начиная с позиции последнего аргумента-массива, будут собраны (если возможно, с помощью преобразований asType) в массив соответствующего типа, после чего вызов будет выполнен с сокращённым списком аргументов. Таким образом можно единообразно обрабатывать очень длинные списки аргументов, которые иначе заняли бы более 254 слотов.

В отличие от режима вызова generic, который может повторно использовать аргумент-массив, передавая его целевому методу напрямую, этот режим вызова всегда создаёт новый параметр-массив, даже если исходный массив, переданный в invokeWithArguments, можно было бы передать целевому методу как прямой аргумент. Даже если количество M фактических аргументов равно арности N, а последний аргумент динамически является подходящим массивом типа A[], он всё равно будет упакован в новый массив из одного элемента, поскольку точка вызова статически задаёт тип аргумента как Object, а не как тип массива. Это не особое правило для данного метода, а обычное следствие прав вызова с переменным числом аргументов.

Вследствие шага asType при необходимости применяются следующие преобразования аргументов:

• приведение ссылок
• распаковка
• примитивные расширяющие преобразования
• преобразование для переменного числа аргументов

Возвращаемый вызовом результат упаковывается, если он имеет примитивный тип, или принудительно заменяется на null, если тип возвращаемого значения — void.

В отличие от методов с полиморфной сигнатурой invokeExact и invoke, к invokeWithArguments можно обращаться обычным образом через API Core Reflection и JNI. Поэтому его можно использовать как мост между нативным или рефлексивным кодом и дескрипторами методов.

Этот метод также эквивалентен следующему коду:

  invokeWithArguments(arguments.toArray())

Допускаются списки очень большого размера, если этот дескриптор метода принимает переменное число аргументов. Подробности см. в описании invokeWithArguments(Object[]).

Если исходный и новый типы равны, возвращает this.

При вызове новый дескриптор метода выполнит следующие действия:

• Преобразует входящий список аргументов в соответствии со списком аргументов исходного дескриптора метода.
• Вызывает исходный дескриптор метода с преобразованным списком аргументов.
• Преобразует результат, возвращённый исходным дескриптором метода, в тип возвращаемого значения нового дескриптора метода.

Этот метод обеспечивает принципиальное поведенческое различие между invokeExact и обычным неточным вызовом invoke. Оба метода выполняют одинаковые действия, если дескриптор типа вызывающей стороны в точности совпадает с типом вызываемого метода. Но если типы различаются, обычный вызов invoke также вызывает asType (или некоторый внутренний эквивалент), чтобы согласовать типы вызывающей и вызываемой сторон.

Если текущий метод является дескриптором метода с переменным числом аргументов, преобразование списка аргументов может включать преобразование и сбор нескольких аргументов в массив, как описано в другом месте. Во всех остальных случаях все преобразования применяются попарно: каждый аргумент или возвращаемое значение преобразуется ровно в один аргумент или возвращаемое значение (либо в отсутствие возвращаемого значения). Применяемые преобразования определяются с учётом соответствующих компонентных типов старого и нового типов дескриптора метода.

Пусть T0 и T1 — соответствующие типы параметров нового и старого методов либо типы возвращаемых значений старого и нового методов. В частности, для некоторого допустимого индекса i пусть T0=newType.parameterType(i) и T1=this.type().parameterType(i). Или, если рассматривать обратное направление для возвращаемых значений, пусть T0=this.type().returnType() и T1=newType.returnType(). Если типы совпадают, новый дескриптор метода не изменяет соответствующий аргумент или возвращаемое значение (если оно есть). В противном случае по возможности применяется одно из следующих преобразований:

• Если T0 и T1 являются ссылочными типами, выполняется приведение к типу T1. (Типы не обязаны быть каким-либо образом связаны. Это связано с тем, что динамическое значение null можно преобразовать в любой ссылочный тип.)
• Если T0 и T1 являются примитивными типами, применяется преобразование при вызове метода Java (JLS 5.3), если оно существует. (В частности, T0 должен преобразовываться в T1 посредством примитивного расширяющего преобразования.)
• Если T0 является примитивным типом, а T1 — ссылочным, применяется преобразование приведения Java (JLS 5.5), если оно существует. (В частности, значение упаковывается из T0 в соответствующий класс-оболочку, который затем при необходимости расширяется до T1.)
• Если T0 является ссылочным типом, а T1 — примитивным, во время выполнения применяется распаковка, за которой может следовать преобразование при вызове метода Java (JLS 5.3) к примитивному значению. (Это примитивные расширяющие преобразования.) T0 должен быть классом-оболочкой или его супертипом. (Если T0 — Object, это преобразования, разрешённые методом java.lang.reflect.Method.invoke.) Распаковка должна иметь возможность завершиться успешно: если T0 сам не является классом-оболочкой, должен существовать хотя бы один класс-оболочка TW, являющийся подтипом T0, примитивное значение из которого можно расширить до T1.
• Если тип возвращаемого значения T1 помечен как void, любое возвращаемое значение отбрасывается.
• Если тип возвращаемого значения T0 — void, а T1 является ссылочным типом, вводится значение null.
• Если тип возвращаемого значения T0 — void, а T1 является примитивным типом, вводится нулевое значение.

Преобразование дескриптора метода невозможно, если невозможно выполнить хотя бы одно из требуемых попарных преобразований.

Во время выполнения преобразования ссылочных аргументов или возвращаемых значений могут требовать дополнительных проверок, которые могут завершиться неудачно. Операция распаковки может завершиться неудачно, если исходная ссылка равна null, и в этом случае возникает NullPointerException. Операция распаковки или приведение ссылки также могут завершиться неудачно, если ссылка указывает на объект неправильного типа; в этом случае возникает ClassCastException. Хотя операция распаковки может принимать несколько типов классов-оболочек, если ни один из них не подходит, будет выброшено ClassCastException.

Если тип элемента массива отличается от любого из соответствующих типов аргументов исходного целевого дескриптора, исходный целевой дескриптор адаптируется для непосредственного принятия элементов массива, как если бы был вызван asType.

При вызове адаптер заменяет последний аргумент-массив его элементами, передавая каждый из них целевому методу как отдельный аргумент. (Порядок аргументов сохраняется.) Они преобразуются попарно посредством приведения и/или распаковки к типам последних параметров целевого метода. Затем вызывается целевой метод. Адаптер без изменений возвращает результат, полученный от целевого метода.

Перед вызовом целевого метода адаптер проверяет, что массив содержит ровно столько элементов, сколько необходимо для правильного количества аргументов целевого дескриптора метода. (Массив также может быть нулевым, если требуется ноль элементов.)

При вызове адаптера длина переданного аргумента array запрашивается так, как если бы использовался байткод array.length или arraylength. Если адаптер принимает конечный аргумент-массив нулевой длины, переданный аргумент array может быть как массивом нулевой длины, так и null; в противном случае, если массив равен null, адаптер выбросит NullPointerException, а если массив содержит неправильное количество элементов — IllegalArgumentException.

Ниже приведены простые примеры дескрипторов методов с разворачиванием массива:

MethodHandle equals = publicLookup()
  .findVirtual(String.class, "equals", methodType(boolean.class, Object.class));
assert( (boolean) equals.invokeExact("me", (Object)"me"));
assert(!(boolean) equals.invokeExact("me", (Object)"thee"));
// spread both arguments from a 2-array:
MethodHandle eq2 = equals.asSpreader(Object[].class, 2);
assert( (boolean) eq2.invokeExact(new Object[]{ "me", "me" }));
assert(!(boolean) eq2.invokeExact(new Object[]{ "me", "thee" }));
// try to spread from anything but a 2-array:
for (int n = 0; n <= 10; n++) {
  Object[] badArityArgs = (n == 2 ? new Object[0] : new Object[n]);
  try { assert((boolean) eq2.invokeExact(badArityArgs) && false); }
  catch (IllegalArgumentException ex) { } // OK
}
// spread both arguments from a String array:
MethodHandle eq2s = equals.asSpreader(String[].class, 2);
assert( (boolean) eq2s.invokeExact(new String[]{ "me", "me" }));
assert(!(boolean) eq2s.invokeExact(new String[]{ "me", "thee" }));
// spread second arguments from a 1-array:
MethodHandle eq1 = equals.asSpreader(Object[].class, 1);
assert( (boolean) eq1.invokeExact("me", new Object[]{ "me" }));
assert(!(boolean) eq1.invokeExact("me", new Object[]{ "thee" }));
// spread no arguments from a 0-array or null:
MethodHandle eq0 = equals.asSpreader(Object[].class, 0);
assert( (boolean) eq0.invokeExact("me", (Object)"me", new Object[0]));
assert(!(boolean) eq0.invokeExact("me", (Object)"thee", (Object[])null));
// asSpreader and asCollector are approximate inverses:
for (int n = 0; n <= 2; n++) {
    for (Class<?> a : new Class<?>[]{Object[].class, String[].class, CharSequence[].class}) {
        MethodHandle equals2 = equals.asSpreader(a, n).asCollector(a, n);
        assert( (boolean) equals2.invokeWithArguments("me", "me"));
        assert(!(boolean) equals2.invokeWithArguments("me", "thee"));
    }
}
MethodHandle caToString = publicLookup()
  .findStatic(Arrays.class, "toString", methodType(String.class, char[].class));
assertEquals("[A, B, C]", (String) caToString.invokeExact("ABC".toCharArray()));
MethodHandle caString3 = caToString.asCollector(char[].class, 3);
assertEquals("[A, B, C]", (String) caString3.invokeExact('A', 'B', 'C'));
MethodHandle caToString2 = caString3.asSpreader(char[].class, 2);
assertEquals("[A, B, C]", (String) caToString2.invokeExact('A', "BC".toCharArray()));

Этот метод очень похож на asSpreader(Class, int), но принимает дополнительный аргумент spreadArgPos, указывающий позицию в списке параметров, с которой следует выполнять разворачивание.

Если тип массива отличается от типа последнего аргумента исходного целевого дескриптора, исходный целевой дескриптор адаптируется для непосредственного принятия типа массива, как если бы был вызван asType.

При вызове адаптер заменяет свои последние аргументы arrayLength одним новым массивом типа arrayType, элементы которого содержат заменённые аргументы в исходном порядке. Затем вызывается целевой метод. Адаптер без изменений возвращает результат, полученный от целевого метода.

(Если arrayLength равно нулю, массив также может быть общей константой.)

(Примечание: arrayType часто совпадает с типом последнего параметра исходного целевого метода. Это явный аргумент для симметрии с asSpreader, а также для того, чтобы целевой метод мог использовать простой Object в качестве типа последнего параметра.)

Чтобы создать адаптер со сбором аргументов, не ограниченный определённым их количеством, используйте вместо этого asVarargsCollector или withVarargs.

Ниже приведены примеры дескрипторов методов со сбором в массив:

MethodHandle deepToString = publicLookup()
  .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
assertEquals("[won]",   (String) deepToString.invokeExact(new Object[]{"won"}));
MethodHandle ts1 = deepToString.asCollector(Object[].class, 1);
assertEquals(methodType(String.class, Object.class), ts1.type());
//assertEquals("[won]", (String) ts1.invokeExact(         new Object[]{"won"})); //FAIL
assertEquals("[[won]]", (String) ts1.invokeExact((Object) new Object[]{"won"}));
// arrayType can be a subtype of Object[]
MethodHandle ts2 = deepToString.asCollector(String[].class, 2);
assertEquals(methodType(String.class, String.class, String.class), ts2.type());
assertEquals("[two, too]", (String) ts2.invokeExact("two", "too"));
MethodHandle ts0 = deepToString.asCollector(Object[].class, 0);
assertEquals("[]", (String) ts0.invokeExact());
// collectors can be nested, Lisp-style
MethodHandle ts22 = deepToString.asCollector(Object[].class, 3).asCollector(String[].class, 2);
assertEquals("[A, B, [C, D]]", ((String) ts22.invokeExact((Object)'A', (Object)"B", "C", "D")));
// arrayType can be any primitive array type
MethodHandle bytesToString = publicLookup()
  .findStatic(Arrays.class, "toString", methodType(String.class, byte[].class))
  .asCollector(byte[].class, 3);
assertEquals("[1, 2, 3]", (String) bytesToString.invokeExact((byte)1, (byte)2, (byte)3));
MethodHandle longsToString = publicLookup()
  .findStatic(Arrays.class, "toString", methodType(String.class, long[].class))
  .asCollector(long[].class, 1);
assertEquals("[123]", (String) longsToString.invokeExact((long)123));

Примечание: полученный адаптер никогда не является дескриптором метода с переменным числом аргументов, даже если исходный целевой дескриптор метода им был.

Этот метод очень похож на asCollector(Class, int), но отличается тем, что его аргумент collectArgPos указывает позицию в списке параметров, с которой следует собирать аргументы. Индекс отсчитывается от нуля.

Тип и поведение адаптера будут такими же, как у цели, за исключением того, что некоторые запросы invoke и asType могут привести к сбору завершающих позиционных аргументов в завершающий параметр цели. Кроме того, типом последнего параметра адаптера будет arrayType, даже если тип последнего параметра цели отличается.

Это преобразование может вернуть this, если дескриптор метода уже принимает переменное число аргументов, а тип его завершающего параметра совпадает с arrayType.

При вызове с помощью invokeExact адаптер вызывает цель без изменения аргументов. (Примечание: это поведение отличается от поведения сборщика с фиксированным числом аргументов, поскольку он принимает целый массив неопределенной длины, а не фиксированное число аргументов.)

При обычном неточном вызове invoke, если тип вызывающего кода совпадает с типом адаптера, адаптер вызывает цель так же, как при invokeExact. (Это обычное поведение для invoke при совпадении типов.)

В противном случае, если арность вызывающего кода совпадает с арностью адаптера, а тип завершающего параметра вызывающего кода является ссылочным типом, идентичным типу завершающего параметра адаптера или присваиваемым ему, аргументы и возвращаемые значения преобразуются попарно, как при вызове asType для дескриптора метода с фиксированным числом аргументов.

В противном случае арности различаются или тип завершающего параметра адаптера не является супертипом соответствующего типа вызывающего кода. В этом случае адаптер заменяет все завершающие аргументы, начиная с исходной позиции завершающего аргумента, новым массивом типа arrayType, элементы которого состоят из замененных аргументов в исходном порядке.

Тип вызывающего кода должен предоставлять как минимум достаточное количество аргументов правильного типа, чтобы удовлетворить требование цели к позиционным аргументам, предшествующим завершающему аргументу-массиву. Таким образом, вызывающий код должен передавать как минимум N-1 аргументов, где N — арность цели. Кроме того, должны существовать преобразования входящих аргументов в аргументы цели. Как и в других случаях обычного вызова invoke, если эти основные требования не выполнены, может быть выброшено исключение WrongMethodTypeException.

Во всех случаях адаптер возвращает без изменений значение, в конечном итоге возвращенное целью.

В последнем случае поведение в точности такое, как если бы целевой дескриптор метода был временно адаптирован с помощью сборщика с фиксированным числом аргументов к арности, требуемой типом вызывающего кода. (Как и при asCollector, если длина массива равна нулю, вместо нового массива может использоваться общая константа. Если предполагаемый вызов asCollector выбросил бы исключение IllegalArgumentException или WrongMethodTypeException, вызов адаптера с переменным числом аргументов должен выбросить WrongMethodTypeException.)

Поведение asType также специализировано для адаптеров с переменным числом аргументов, чтобы сохранять инвариант: обычный неточный вызов invoke всегда эквивалентен вызову asType для изменения типа цели с последующим вызовом invokeExact. Поэтому адаптер с переменным числом аргументов отвечает на запрос asType созданием сборщика с фиксированным числом аргументов тогда и только тогда, когда адаптер и запрошенный тип различаются арностью или типом завершающего аргумента. Полученный сборщик с фиксированным числом аргументов дополнительно адаптируется к запрошенному типу (если необходимо) посредством попарного преобразования, как при еще одном применении asType.

Если дескриптор метода получен выполнением инструкции ldc для константы CONSTANT_MethodHandle, а целевой метод помечен как метод с переменным числом аргументов (с битом-модификатором 0x0080), дескриптор метода будет принимать аргументы с разной арностью, как если бы константа дескриптора метода была создана вызовом asVarargsCollector.

Чтобы создать собирающий адаптер, который собирает заранее заданное количество аргументов и тип которого отражает это количество, используйте вместо этого asCollector.

Ни одно преобразование дескриптора метода не создает новые дескрипторы методов с переменным числом аргументов, если в документации не указано обратное. Поэтому, кроме asVarargsCollector и withVarargs, все методы в MethodHandle и MethodHandles возвращают дескриптор метода с фиксированным числом аргументов, за исключением случаев, когда указано, что они возвращают исходный операнд (например, asType дескриптора метода собственного типа).

Вызов asVarargsCollector для дескриптора метода, который уже принимает переменное число аргументов, приведет к созданию дескриптора метода с теми же типом и поведением. При этом может быть возвращен исходный дескриптор метода с переменным числом аргументов, но это не гарантируется.

Ниже приведен пример дескриптора метода с переменным числом аргументов, создающего список:

MethodHandle deepToString = publicLookup()
  .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
MethodHandle ts1 = deepToString.asVarargsCollector(Object[].class);
assertEquals("[won]",   (String) ts1.invokeExact(    new Object[]{"won"}));
assertEquals("[won]",   (String) ts1.invoke(         new Object[]{"won"}));
assertEquals("[won]",   (String) ts1.invoke(                      "won" ));
assertEquals("[[won]]", (String) ts1.invoke((Object) new Object[]{"won"}));
// findStatic of Arrays.asList(...) produces a variable arity method handle:
MethodHandle asList = publicLookup()
  .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class));
assertEquals(methodType(List.class, Object[].class), asList.type());
assert(asList.isVarargsCollector());
assertEquals("[]", asList.invoke().toString());
assertEquals("[1]", asList.invoke(1).toString());
assertEquals("[two, too]", asList.invoke("two", "too").toString());
String[] argv = { "three", "thee", "tee" };
assertEquals("[three, thee, tee]", asList.invoke(argv).toString());
assertEquals("[three, thee, tee]", asList.invoke((Object[])argv).toString());
List ls = (List) asList.invoke((Object)argv);
assertEquals(1, ls.size());
assertEquals("[three, thee, tee]", Arrays.toString((Object[])ls.get(0)));

Обсуждение: Эти правила представляют собой динамически типизированный вариант правил Java для методов с переменным числом аргументов. В обоих случаях вызывающие код метода или дескриптора метода с переменным числом аргументов могут передать ноль или более позиционных аргументов либо заранее собранные массивы произвольной длины. Пользователям следует учитывать особую роль последнего аргумента и то, как совпадение типов этого аргумента определяет, будет ли один завершающий аргумент интерпретироваться как целый массив или как отдельный элемент массива, в который он будет собран. Обратите внимание: динамический тип завершающего аргумента не влияет на это решение; учитывается только сравнение символьного дескриптора типа точки вызова с дескриптором типа дескриптора метода.

• вызовом asVarargsCollector
• вызовом метода поиска, который разрешается в метод или конструктор Java с переменным числом аргументов
• инструкцией ldc для CONSTANT_MethodHandle, которая разрешается в метод или конструктор Java с переменным числом аргументов

Если текущий дескриптор метода не принимает переменное число аргументов, возвращается текущий дескриптор метода. Это верно, даже если текущий дескриптор метода нельзя использовать в качестве допустимого входного значения для asVarargsCollector.

В противном случае полученный дескриптор метода с фиксированным числом аргументов будет иметь тот же тип и поведение, что и текущий дескриптор метода, за исключением того, что isVarargsCollector вернет false. Дескриптор метода с фиксированным числом аргументов может совпадать с прежним аргументом для asVarargsCollector, но это не гарантируется.

Ниже приведен пример дескриптора метода с переменным числом аргументов, создающего список:

MethodHandle asListVar = publicLookup()
  .findStatic(Arrays.class, "asList", methodType(List.class, Object[].class))
  .asVarargsCollector(Object[].class);
MethodHandle asListFix = asListVar.asFixedArity();
assertEquals("[1]", asListVar.invoke(1).toString());
Exception caught = null;
try { asListFix.invoke((Object)1); }
catch (Exception ex) { caught = ex; }
assert(caught instanceof ClassCastException);
assertEquals("[two, too]", asListVar.invoke("two", "too").toString());
try { asListFix.invoke("two", "too"); }
catch (Exception ex) { caught = ex; }
assert(caught instanceof WrongMethodTypeException);
Object[] argv = { "three", "thee", "tee" };
assertEquals("[three, thee, tee]", asListVar.invoke(argv).toString());
assertEquals("[three, thee, tee]", asListFix.invoke(argv).toString());
assertEquals(1, ((List) asListVar.invoke((Object)argv)).size());
assertEquals("[three, thee, tee]", asListFix.invoke((Object)argv).toString());

При вызове привязанный дескриптор вставляет заданное значение x в качестве нового ведущего аргумента цели. Остальные аргументы также передаются без изменений. Привязанный дескриптор без изменений возвращает значение, в конечном итоге возвращенное целью.

Ссылка x должна преобразовываться к типу первого параметра цели.

Примечание: Поскольку дескрипторы методов неизменяемы, целевой дескриптор метода сохраняет исходные тип и поведение.

Примечание: Полученный адаптер никогда не является дескриптором метода с переменным числом аргументов, даже если исходный целевой дескриптор метода был таким.

"MethodHandle" + type().toString()

(Примечание: В будущих версиях этого API в строковое представление может быть добавлена дополнительная информация. Поэтому приложениям не следует анализировать синтаксис текущей версии.)