JEP draft: Code Reflection (Incubator)
Code Reflection (рефлексия кода), версия Incubator (инкубационный модуль)
| Ответственный | Paul Sandoz |
| Тип | Feature |
| Область | JDK |
| Статус | Submitted |
| Компонент | core-libs |
| Обсуждение | babylon dash dev at openjdk dot org |
| Трудоёмкость | L |
| Длительность | L |
| Рецензенты | Adam Sotona, Gary Frost, Juan Fumero, Maurizio Cimadamore |
| Создан | 2025/06/30 19:54 |
| Обновлён | 2026/10/15 14:47 |
| Задача | 8361105 |
Аннотация
Расширить Core Reflection API, чтобы с его помощью можно было моделировать код на Java, строить и преобразовывать модели кода на Java, а также получать доступ к моделям кода на Java в методах и лямбда-выражениях. Это позволит библиотекам анализировать код на Java и расширять область его применения, например выполнять его на GPU. Это API в статусе Incubator.
Цели
-
Дать разработчикам на Java возможность взаимодействовать с внешними (не Java) моделями программирования с помощью привычных абстракций Java, таких как лямбда-выражения и статическая типизация.
-
Побудить библиотеки предоставлять Java-разработчикам новые программные модели, не требуя от разработчиков встраивать не-Java-код в Java-код или писать утомительный Java-код, который строит структуры данных для моделирования Java-кода или другого (внешнего) кода.
Что не является целью
-
Не менять смысл программ на Java, заданный Java Language Specification; не компилировать исходный код на Java ни во что, кроме набора инструкций байт-кода, заданного спецификацией Java Virtual Machine; не менять набор инструкций JVM и не менять HotSpot JVM для поддержки наборов инструкций специализированных вычислительных устройств, таких как GPU.
-
Целью не является расширение модели программирования Java для поддержки конкретных внешних моделей программирования.
-
Целью не является добавление новых возможностей языка, облегчающих доступ к моделям кода на Java. Возможно, мы предложим это в будущем.
-
Целью не является доступ к моделям кода на Java через байт-код этого кода, преобразованный в модели кода на Java. Возможно, мы предложим это в будущем.
Мотивация
Многие программы на Java обрабатывают большие объёмы данных. Например, в алгоритме распознавания лиц, который обрабатывает изображения высокого разрешения, нужно преобразовывать пиксели RGB в оттенки серого; вот упрощённый код, который делает это с помощью цикла for.
for (int i = 0; i < N; i++) {
byte r = rgbImage[i * 3 + 0];
byte g = rgbImage[i * 3 + 1];
byte b = rgbImage[i * 3 + 2];
grayImage[i] = gray(r, g, b);
}
Если число пикселей N достаточно велико и/или вычисление каждого пикселя достаточно трудоёмко, то можно использовать лямбда-выражение с параллельными потоками данных (streams) и вычислить результат быстрее, чем однопоточным циклом for, даже с учётом накладных расходов на запуск и координацию нескольких потоков.
IntConsumer rgbToGray = i -> {
byte r = rgbImage[i * 3 + 0];
byte g = rgbImage[i * 3 + 1];
byte b = rgbImage[i * 3 + 2];
grayImage[i] = gray(r, g, b);
};
IntStream.range(0, N)
.parallel()
.forEach(rgbToGray);
Из закона Густафсона следует, что при увеличении числа потоков M, каждый из которых обрабатывает достаточно большое число пикселей, оценка ускорения программы будет приближаться к M по мере роста доли времени, затрачиваемого на параллельные задачи.
К сожалению, число потоков, способных выполнять ресурсоёмкие вычислительные задачи, ограничено процессором: например, у AMD EPYC 9005 Zen 5c 384 потока. В Java 21 появились Virtual Threads (виртуальные потоки) для параллельного выполнения большого числа задач, интенсивно использующих ввод-вывод, но Virtual Threads не создают новых вычислительных ресурсов и не могут ускорить код, который, как этот, уже упирается в процессор.
Вычисления общего назначения на графических процессорах
Существует класс вычислительных устройств — графический процессор (Graphics Processing Unit, GPU), архитектура которого сильно отличается от CPU: вместо нескольких сотен потоков современный GPU, например NVIDIA Blackwell B200, может одновременно выполнять несколько сотен тысяч потоков.
Изначально GPU были предназначены для отрисовки изображений и видеоигр, но теперь их можно использовать для вычислений общего назначения, таких как распознавание лиц, общее матричное умножение (General Matrix Multiplication, GEMM), быстрое преобразование Фурье (Fast Fourier Transformation, FFT), а также инференс и обучение больших языковых моделей (Large Language Models, LLM).
Если бы мы могли выполнять параллельные задачи на GPU, а не на CPU, с числом потоков на порядки больше, мы могли бы либо значительно сократить время выполнения, либо выполнить больше вычислений за то же время.
Исторически одним из подходов было написать многопоточное вычисление на языке, который поддерживает GPU, например на CUDA C, и встроить его в Java-программу в виде строки. С помощью JNI можно было запустить компилятор CUDA C и передать скомпилированный код на GPU для выполнения.
static void gpuComputation(int N, byte[] rgbImage, float[] grayImage) {
var cudaCCode = """
__device__
float gray(char r, char g, char b) { return ...; }
__global__
void computeGrayImage(int N, char* rgbImage, float* grayImage) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < N) {
char r = rgbImage[i * 3 + 0];
char g = rgbImage[i * 3 + 1];
char b = rgbImage[i * 3 + 2];
grayImage[i] = gray(r, g, b);
}
}
""";
var gpuCode = compileGpuCode(cudaCCode);
runGpuCode(N, gpuCode, rgbImage, grayImage);
}
Этот подход проблематичен: он даёт «протекающую» абстракцию, которая вынуждает разработчиков разбираться в артефактах CUDA, и код перестаёт быть независимым от оборудования. Ожидать, что разработчики будут писать Java-код, который лишь переносит не-Java-код, ошибочно, поскольку javac не может скомпилировать и проверить этот код; для переноса кода на CUDA C они могут выбрать любой язык, не только Java.
Прозрачная поддержка GPU в платформе
На самом деле мы хотим написать что-то похожее на код с параллельными потоками данных и чтобы он автоматически преобразовывался в CUDA C. В 2010-х мы пытались сделать это полностью прозрачно, внутри платформы Java, в проекте OpenJDK Sumatra.
Sumatra ставил целью дать разработчикам на Java возможность использовать GPU за счёт доработки JVM и параллельных потоков данных. JVM из Sumatra могла генерировать код для GPU AMD и размещать части кучи JVM в памяти GPU. Этот подход, при котором платформа Java скрывает присутствие GPU от кода на Java, резко отличается от ручного встраивания кода для GPU в программу на Java.
GPU лучше всего работают с программами без динамического поведения, где каждый поток должен выполнять одинаковый код синхронно на разных элементах данных согласно модели выполнения Single Instruction Multiple Thread (SIMT). В такой модели трудно эффективно выполнять код на Java, поскольку он по своей природе динамичен. Во-первых, память разделена между CPU и GPU. Динамическое управление кучей JVM на CPU и GPU в соответствии с моделью памяти Java — сложная задача, и оно может постоянно снижать производительность. Во-вторых, идиоматичный код на Java полиморфен. Методы обычно вызываются через интерфейсы, а не через классы, и каждый вызов запускает поиск виртуального метода и, возможно, загрузку класса, инициализацию и т. д. Это значит, что потоки с большей вероятностью рассинхронизируются, что ещё больше снижает производительность.
Sumatra не удался. В нём пытались прозрачно поддержать GPU внутри платформы Java за счёт расширения JVM, и это не получилось. Но мы по-прежнему хотим достичь главной цели Sumatra: написать что-то похожее на код с параллельными потоками данных и выполнить его на GPU.
Поддержка GPU через библиотеки
Вместо этого можно поддерживать GPU непрозрачно и вне платформы Java. При генерации кода для GPU не нужно сохранять всё динамическое поведение Java. Более того, это можно сделать с помощью библиотеки на Java, которая преобразует код на Java в код для GPU и выполняет его на GPU. Не нужно расширять платформу Java или её реализации, чтобы они знали что-то конкретно о GPU. Библиотека может оптимизировать генерируемый ею код для GPU, выборочно отображая абстракции Java на абстракции, подходящие для GPU, то есть абстракции, внешние по отношению к Java.
Модели программирования
Модель программирования — это набор абстракций, с помощью которых программист структурирует программы, выполняет их и рассуждает о них.
Модель программирования Java — это набор абстракций, с помощью которых структурируют программы на Java, выполняют их и рассуждают о них. Например, оператор while — это абстракция языка Java для одного из видов цикла. Синтаксис оператора while и его поведение во время выполнения заданы в Java Language Specification. Платформенные потоки Java и Virtual Threads — это абстракции Java для конкурентных и параллельных программ на Java. Поведение потока Java во время выполнения описано в спецификациях платформы Java, таких как Java Language Specification, спецификации Java API и Java Virtual Machine Specification.
Внешняя модель программирования — это любая модель, отличная от модели программирования Java. Примеры внешних моделей программирования: модели программирования GPU, например модель программирования CUDA C, заданная NVIDIA, модель программирования для автоматического дифференцирования программ на Java или даже модель программирования SQL. У каждой из этих моделей программирования свой набор абстракций, отличный от абстракций модели программирования Java.
Библиотека, которая транслирует код на Java в код внешней модели программирования, может отвергать одни абстракции Java и принимать другие, возможно, меняя их смысл.
Библиотека, которая транслирует код на Java в код для GPU, может отвергать такие абстракции, как выражения new, сохранять абстракции циклов, менять поведение абстракций чисел с плавающей точкой и ограничивать набор методов, которые можно вызывать. Библиотека, которая автоматически дифференцирует код на Java, превращая его в код на Java, вычисляющий производную, может отвергать такие абстракции, как операторы try, и сохранять другие, нужные для математических вычислений.
Платформе Java не нужны расширения, специфичные для конкретных моделей, ради множества внешних моделей программирования, в том числе ещё не известных.
Ограничения рефлексии
Чтобы библиотека для GPU могла транслировать код на Java в код для GPU, ей нужен доступ к коду на Java внутри методов и лямбда-выражений. К счастью, в платформе Java давно есть примитив — Core Reflection, — который позволяет библиотеке исследовать структуру программ на Java. В Java 1.1 появилась рефлексия во время выполнения, Core Reflection API, которая дала толчок развитию экосистемы библиотек для доступа к данным, модульного тестирования, обмена сообщениями и т. д. В Java 5 появилась рефлексия во время компиляции, позволяющая обработчикам аннотаций генерировать код, который расширяет приложение без затрат на сопровождение.
К сожалению, Core Reflection API ограничен и не даёт доступа к коду в методах и лямбда-выражениях. С помощью Core Reflection API можно узнать, какие методы объявляет класс, но заглянуть глубже и исследовать код этих методов нельзя.
Библиотека может получить доступ к исходному коду методов и лямбда-выражений через внутренние API javac, но это возможно только во время компиляции и слишком сложно, поскольку исходный код содержит много лишних синтаксических деталей. Во время выполнения библиотека может получить доступ к байт-коду методов (но не лямбда-выражений) с помощью Class-File API, но байт-код — плохая замена исходному коду, а class-файлы доступны не всегда.
Code Reflection
Мы предлагаем расширить Core Reflection, чтобы она предоставляла доступ не только к классам, полям и методам, но и к коду методов и лямбда-выражений. Мы называем это Code Reflection.
Библиотека для GPU может использовать Code Reflection API, чтобы получить доступ к коду на Java в методах и лямбда-выражениях и преобразовать его в код для GPU, выборочно отображая абстракции модели программирования Java на абстракции внешней модели программирования GPU.
Библиотека для GPU может также использовать Foreign Function & Memory (FFM) API, чтобы выполнять код для GPU, взаимодействуя с внешней нативной средой выполнения GPU.
Таким образом, с помощью Code Reflection можно задействовать внешнюю модель программирования, а с помощью Foreign Function & Memory API — внешнюю среду выполнения. Используя их вместе, можно охватить внешний мир и организовать сложное взаимодействие между двумя мирами.
Описание
Code Reflection поддерживает доступ во время выполнения к модели кода метода или лямбда-выражения — модели кода, — пригодной для анализа и преобразования.
Модель кода — это неизменяемое дерево элементов кода, экземпляров интерфейса CodeElement. У неё есть некоторые свойства абстрактного синтаксического дерева (Abstract Syntax Tree, AST), которое использует компилятор исходного кода, такой как javac, например представление кода в виде дерева произвольной глубины. У неё есть и другие свойства промежуточного представления в форме статического единственного присваивания (Static Single Assignment, SSA), которое использует оптимизирующий компилятор, такой как HotSpot, например представление потока управления и потока данных в виде графов. Эти свойства гарантируют, что модели кода могут сохранять многие важные детали моделируемого кода и пригодны для анализа и преобразования.
Модель кода Java — это модель кода, создаваемая javac, которая моделирует рефлексируемый код на Java и сохраняет смысл программы этого кода на Java; её уровень абстракции близок к уровню AST этого кода на Java в javac. Модель кода Java можно преобразовать в модель кода с более низким уровнем абстракции, сохраняющую смысл программы.
С помощью Code Reflection библиотека может преобразовать код на Java в код на CUDA C: получить доступ к модели кода Java для этого кода и транслировать модель кода в код на CUDA C. Вспомним лямбда-выражение, использованное в примере с параллельным потоком данных.
IntConsumer rgbToGray = i -> {
byte r = rgbImage[i * 3 + 0];
byte g = rgbImage[i * 3 + 1];
byte b = rgbImage[i * 3 + 2];
grayImage[i] = gray(r, g, b);
};
static int gray(int r, int g, int b) {
return (29 * r + 60 * g + 11 * b) / 100;
}
Обратите внимание, что лямбда-выражение вызывает метод gray. Этот метод нужно включить в код на Java, который мы хотим выполнить на GPU.
Библиотеке для GPU нужен доступ к моделям кода лямбда-выражения и метода gray. Чтобы открыть доступ, мы объявляем лямбда-выражение рефлексируемым лямбда-выражением, а метод — рефлексируемым методом. Для этого лямбда-выражение и метод помечаются аннотацией @Reflect.
final byte[] rgbImage = ...
final float[] grayImage = ...
@Reflect
IntConsumer rgbToGray = i -> {
byte r = rgbImage[i * 3 + 0];
byte g = rgbImage[i * 3 + 1];
byte b = rgbImage[i * 3 + 2];
grayImage[i] = gray(r, g, b);
};
@Reflect
static int gray(int r, int g, int b) {
return (29 * r + 60 * g + 11 * b) / 100;
}
Когда javac компилирует лямбда-выражение и метод, он транслирует свою внутреннюю модель этих рефлексируемых языковых конструкций в модели кода и сохраняет модели кода во вложенном class-файле внешнего class-файла, содержащего байт-код скомпилированных конструкций.
Затем мы с помощью библиотеки запускаем нашу программу на GPU, вызывая метод run библиотеки с аргументами N (количество индексов для обработки) и rgbToGray (результат рефлексируемого лямбда-выражения).
int N = grayImage.length;
GPU.run(N, rgbToGray);
GPU-библиотека использует API Code Reflection, чтобы получить доступ к моделям кода лямбда-выражения и метода gray, сохранённым во вложенном class-файле, и сгенерировать код для GPU путём анализа и преобразования этих моделей кода. Затем GPU-библиотека использует FFM API, чтобы обеспечить доступность памяти, занимаемой массивами изображений, и для CPU, и для GPU, а также чтобы выполнить код на GPU. После выполнения grayImage будет содержать изображение в оттенках серого.
Мы не передаём rgbImage и grayImage как аргументы методу run. Они выводятся как аргументы, поскольку лямбда-выражение их захватывает. Библиотека использует API Code Reflection, чтобы получить захваченные значения rgbImage и grayImage.
Благодаря этому GPU-библиотека может скрыть подробности генерации и выполнения. Например, вместо генерации CUDA C библиотека может генерировать промежуточное представление SPIR-V — стандартный двоичный формат обмена для кроссплатформенных вычислений на GPU.
Что ещё важнее, библиотека может выбирать, где выполнять код. Если производительность не важна, библиотеку можно настроить так, чтобы она напрямую вызывала лямбда-выражение в JVM, используя всего несколько платформенных потоков, например, внутренне применяя последовательный или параллельный поток (stream). Тогда разработчик может отлаживать свой код существующими инструментами Java и писать для него модульные тесты. После должной отладки и тестирования код можно запускать на GPU с большей уверенностью и производительностью, а на GPU отлаживать и тестировать код гораздо сложнее.
Включение API в статусе Incubator
Code Reflection — это API в статусе Incubator, по умолчанию отключённый. Code Reflection предоставляется в Incubator-модуле jdk.incubator.code. Чтобы попробовать Code Reflection, нужно запросить, чтобы Incubator-модуль jdk.incubator.code был разрешён (resolved):
- Скомпилируйте программу с
javac --add-modules jdk.incubator.code Main.javaи запустите её сjava --add-modules jdk.incubator.code Main; или - При использовании лаунчера исходного кода запускайте программу с
java --add-modules jdk.incubator.code Main.java; или - При использовании jshell запускайте его с
jshell --add-modules jdk.incubator.code.
Объявление рефлексируемого кода
Выше мы показали, как объявить рефлексируемое лямбда-выражение и рефлексируемый метод с помощью аннотации @Reflect. Однако мы считаем, что объявлять рефлексируемый код лучше всего было бы с помощью нового ключевого слова в языке Java, но модуль в статусе Incubator не может вводить возможности языка. Поэтому пока достаточно аннотации. В каком-нибудь будущем JEP, уже не в статусе Incubator, мы, возможно, разработаем необходимую возможность языка.
Объявление служит двум целям. Во-первых, мы явно разрешаем другим частям нашего Java-приложения, например библиотеке, за которую мы можем не отвечать напрямую, получать доступ к коду во время выполнения. Не весь код нужно рефлексировать, и не весь код следует, поэтому мы можем ограничиться только тем, чем необходимо поделиться. Во-вторых, объявление сообщает javac, что нужно выполнить дополнительные задачи, чтобы модель кода была построена и стала доступна во время выполнения.
Всего существует четыре синтаксических позиции, где может стоять @Reflect; они образуют три случая в порядке расширения области того, что объявляется рефлексируемым.
-
Если аннотация встречается в выражении приведения типа для лямбда-выражения и аннотирует использование типа в операторе приведения этого выражения, то лямбда-выражение и все содержащиеся в нём лямбда-выражения объявляются reflectable. Например,
GPU.run(N, (@Reflect IntConsumer) i -> { ... }); -
Если аннотация указана как модификатор объявления поля или локальной переменной и аннотирует это поле или локальную переменную, то все лямбда-выражения в выражении-инициализаторе переменной (если оно есть) объявляются reflectable. Это полезно, когда выражения приведения типа становятся громоздкими и/или в типах становится трудно разобраться. Например, в fluent-выражениях, похожих на потоки (stream), где в качестве аргументов передаётся много reflectable-лямбда-выражений. Например,
@Reflect IntConsumer rgbToGray = i -> { ... }; GPU.run(N, rgbToGray); -
Наконец, если аннотация указана как модификатор объявления неабстрактного и не-native метода и аннотирует этот метод, то метод и все содержащиеся в нём лямбда-выражения объявляются reflectable. Например,
@Reflect static int gray(int r, int g, int b) { ... }
Если метод или лямбда-выражение объявлены reflectable, но не могут быть смоделированы из-за ограничений моделирования, то javac выдаёт предупреждение, и метод или лямбда-выражение не считаются reflectable.
Если аннотация стоит в любой другой допустимой синтаксической позиции, она игнорируется.
Объявление reflectable-метода или лямбда-выражения не расширяет неявно область reflectable-кода на вызываемые ими методы. В нашем примере с GPU нам приходится аннотировать метод gray. Кроме того, объявление reflectable-лямбда-выражения не расширяет эту область на код окружающих объявлений final или фактически final переменных, которые используются, но не объявлены в лямбда-выражении.
Подробнее о доступе к моделям кода reflectable-методов и лямбда-выражений см. документацию API для @Reflect.
Подробнее о создании и обработке моделей кода см. документацию API для пакета jdk.incubator.code.
Дальнейшая работа
Мы изучим доступ к моделям кода во время компиляции. Code Reflection предоставляет самую базовую поддержку доступа обработчиков аннотаций к моделям кода элементов программы; она полезна для продвинутых экспериментов, но требует дальнейшего осмысления.
По мере развития языка мы будем искать возможности улучшить Code Reflection, чтобы использовать новые возможности языка, особенно связанные с Pattern Matching (сопоставление с образцом) и data-oriented programming (программирование, ориентированное на данные). Мы ожидаем, что Pattern Matching сильно повлияет на Code Reflection и улучшит выполнение запросов к моделям кода. Кроме того, это возможность дать обратную связь по возможностям языка.
Мы изучим возможность языка для объявления reflectable-кода. Использование аннотации @Reflect — временное решение, достаточное для статуса Incubator, но недостаточное для статуса Preview (предварительная версия).
Мы должны гарантировать, что библиотека, использующая Code Reflection, может работать с моделями кода, созданными версией JDK более новой, чем та, с которой библиотека была скомпилирована. Такая прямая совместимость — сложная задача. Мы изучим решения, например объявление библиотекой верхней границы версий JDK для поддерживаемого ею reflectable-кода или возможность преобразовать смоделированную возможность языка, которую библиотека не умеет обрабатывать, в смоделированные возможности, которые она обрабатывать умеет (возможно, со снижением уровня абстракции, но с сохранением смысла программы).
Мы изучим альтернативные механизмы хранения моделей кода в class-файлах. Сейчас модели кода хранятся в виде байт-кода, который при выполнении строит модель кода. Кроме того, для одного и того же reflectable-кода на Java мы храним две формы байт-кода.
Альтернативы
Compiler Tree API
Пакет com.sun.source модуля jdk.compiler содержит API javac для доступа к абстрактным деревьям (AST), представляющим исходный код на Java. Javac использует реализацию этого API при разборе исходного кода. Этот API не подходит для стандартизации, поскольку слишком тесно переплетён с реализацией javac, так как javac оставляет за собой право вносить в этот API несовместимые изменения по мере развития языка. В более общем смысле AST бывает трудно анализировать и преобразовывать. Например, современный оптимизирующий компилятор преобразует своё AST, представляющее исходный код, в другое представление с меньшим уровнем абстракции — промежуточное представление, — которое проще анализировать и преобразовывать в исполняемый код.
Байт-код
Байт-код нелегко получить во время выполнения, и его доступность в это время не гарантирована; но даже если бы мы сделали его доступным, это не было бы идеальным решением. При трансляции исходного кода на Java в байт-код с помощью javac многие возможности языка Java исчезают, и восстановить их трудно: например, лямбда-выражения транслируются в инструкции invoke dynamic и синтетические методы. Кроме того, байт-код по умолчанию слишком низкоуровневый, поэтому его трудно анализировать и преобразовывать. Например, компилятор HotSpot C2 преобразует байт-код в другую, более высокоуровневую форму — промежуточное представление, — которую проще анализировать и преобразовывать в исполняемый код.
Деревья выражений C#
Деревья выражений C# представляют код в виде древовидной структуры данных, каждый узел которой является выражением. Компилятор C# поддерживает объявление выразимого кода на C#, чтобы можно было получить доступ к дереву выражений этого кода. Деревья выражений можно также строить напрямую.
Деревья выражений C# во многом похожи на Code Reflection. Однако C# ограничен в наборе инструкций и выражений C#, которые он может моделировать, и поэтому ограничен в том, к какому коду на C# он может получить доступ в виде деревьев выражений. Code Reflection может моделировать почти все инструкции и выражения Java и поэтому может получить доступ к более широкому кругу кода на Java в виде моделей кода. Кроме того, модели кода лучше подходят для анализа и преобразования, поскольку сочетают свойства моделей, которые используются компиляторами исходного кода и оптимизирующими компиляторами.
Возможность языка C# для объявления выразимого кода превосходит используемый в Code Reflection способ объявления reflectable-кода с помощью аннотации @Reflect. Разрабатывая аналогичную возможность языка Java, мы можем поучиться у C#.
Тестирование
Тестирование будет сосредоточено на наборе модульных тестов для компилятора и среды выполнения, которые обеспечивают высокое покрытие моделирования и кода. Где возможно, мы стараемся повторно использовать возможности Code Reflection в работе, например при сохранении и загрузке моделей в class-файлах.
Мы должны гарантировать, что модели кода Java, создаваемые компилятором, сохраняют смысл программы на Java. Мы выберем существующий набор тестов Java и перекомпилируем исходный код, который они тестируют, с помощью специального внутреннего флага javac, так чтобы байт-код генерировался из моделей кода, созданных компилятором. Тестирование этих специально скомпилированных исходников должно давать те же результаты, что и тестирование исходников, скомпилированных обычным образом.
Риски и допущения
Пока возможность находится в статусе Incubator, мы будем стремиться свести к минимуму число изменений, которые требуется внести в код модулей java.base и jdk.compiler, чтобы уменьшить нагрузку на сопровождающих и рецензентов. Пока изменения скромные.
Введение новой возможности языка, даже скромной, требует значительных усилий и множества задач по обновлению многих областей платформы. Code Reflection добавит задач в этот список, поскольку возможность языка нужно будет моделировать и поддерживать так же, как уже смоделированные возможности. Есть риск, что её моделирование, особенно с высокой точностью, потребует значительных усилий. Мы считаем, что этот риск снижается благодаря универсальным возможностям моделирования, которые есть у моделей кода, и тому, что уже сейчас мы можем моделировать все инструкции и выражения Java с высокой точностью.