Макросы и compile-time программирование — бесплатный тест онлайн

Вопрос 1 из 30

В теме «Цитирование выражений» на ревью спорят о причине наблюдаемого результата. Какое объяснение корректно?

import scala.quoted.*
def inspect[T: Type](x: Expr[T])(using Quotes): Expr[String] = Expr(Type.show[T])

Compile-time макрос работает с исходным кодом проекта и может раскрыть секрет, путь или структуру сборочной машины в артефакте. Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции. Чтение файлов и окружения из макроса не влияет на воспроизводимость, потому что результат сохраняется в TASTy. Макрос может вернуть дерево произвольного типа: параметр `Expr[T]` не связывает результат с ожидаемой сигнатурой.

Вопрос 2 из 30

Для темы «Цитирование выражений» вход перестал быть константой времени компиляции, хотя прежний пример продолжает работать. Какой дефект остаётся возможным при корректном синтаксисе?

// Дополнительный контекст: Сгенерированное дерево выросло вместе с размером модели и заметно замедлило сборку.
import scala.quoted.*
def inspect[T: Type](x: Expr[T])(using Quotes): Expr[String] = Expr(Type.show[T])

Сопоставление с хрупкой формой дерева ломается при эквивалентном синтаксисе или изменении компилятора. Квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку. Генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции. Макрос автоматически проверяет предметные ограничения входа, даже если реализация их явно не кодирует. Рост дерева кода влияет только на размер исходников, но не на время компиляции и размер артефакта.

Вопрос 3 из 30

При исправлении темы «Цитирование выражений» на ревью уже воспроизвели проблему: Сопоставление с хрупкой формой дерева ломается при эквивалентном синтаксисе или изменении компилятора. Какую правку стоит принять?

import scala.quoted.*
def inspect[T: Type](x: Expr[T])(using Quotes): Expr[String] = Expr(Type.show[T])
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Использовать полный reflection-обход для простой константной проверки, не сравнивая с `inline` и `constValue`. Ограничьте входы макроса явными константами, не читайте секреты и документируйте все build-time зависимости. Повторно обходить одно и то же дерево для каждого поля вместо накопления результата за один проход. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции. Опирайтесь на публичный Quotes API, типы и семантические признаки, а не на случайную форму дерева.

Вопрос 4 из 30

В контракте темы «Цитирование выражений» какое решение не превращает частный успешный случай в общее обещание?

stage_{compile}\ne stage_{runtime}

Оставить в контракте правило «compile-time макрос работает с исходным кодом проекта и может раскрыть секрет, путь или структуру сборочной машины в артефакте»; проверяемое ограничение — «генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции». Оставить в контракте правило «quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции»; проверяемое ограничение — «квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку». Оставить в контракте правило «контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов»; проверяемое ограничение — «сопоставление с хрупкой формой дерева ломается при эквивалентном синтаксисе или изменении компилятора». Оставить в контракте правило «quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции»; проверяемое ограничение — «совпадение результата на одном наборе данных подтверждает все обещания публичного API». Оставить в контракте правило «quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции»; проверяемое ограничение — «сопоставление с хрупкой формой дерева ломается при эквивалентном синтаксисе или изменении компилятора».

Вопрос 5 из 30

При проверке темы «Цитирование выражений» какой контроль остаётся полезным после рефакторинга и переименования кода?

Quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции. Проверить только ветвь без ошибки и принять изменение. Опирайтесь на публичный Quotes API, типы и семантические признаки, а не на случайную форму дерева. В проверке воспроизвести ситуацию: сопоставление с хрупкой формой дерева ломается при эквивалентном синтаксисе или изменении компилятора. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции. В проверке воспроизвести ситуацию: сопоставление с хрупкой формой дерева ломается при эквивалентном синтаксисе или изменении компилятора. В теме «Цитирование выражений» исправить один показанный вызов по рекомендации «Ограничьте входы макроса явными константами, не читайте секреты и документируйте все build-time зависимости». Общий контракт и прежнюю границу отдельно не воспроизводить. Опирайтесь на публичный Quotes API, типы и семантические признаки, а не на случайную форму дерева. В проверке воспроизвести ситуацию: квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку.

Вопрос 6 из 30

Какая характеристика конструкции «Вставки кода» подтверждается показанным фрагментом?

import scala.quoted.*
inline def doubled(inline x: Int): Int = ${ doubledImpl('x) }
def doubledImpl(x: Expr[Int])(using Quotes): Expr[Int] =
  '{ $x * 2 }
println(doubled(21))

Splice `${...}` вставляет сгенерированное выражение в quoted-код, соблюдая уровни staging. Вызов `errorAndAbort` создаёт исключение в готовой программе, но не останавливает компиляцию. Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Quoted-код выполняется как обычный runtime-код и может безопасно обращаться к любому значению, известному только после запуска. Безопасная генерация сохраняет тип результата и использует Expr-конструкторы вместо склейки исходного текста.

Вопрос 7 из 30

Для темы «Вставки кода» что здесь требует отдельного теста или компиляционного примера?

// Дополнительный контекст: Макрос вызвали из другого модуля с выражением иной формы, но того же статического типа.
import scala.quoted.*
inline def doubled(inline x: Int): Int = ${ doubledImpl('x) }
def doubledImpl(x: Expr[Int])(using Quotes): Expr[Int] =
  '{ $x * 2 }
println(doubled(21))

`Expr` переносит синтаксис между стадиями; обычное значение времени выполнения нельзя напрямую использовать в коде, исполняемом при компиляции. Рост дерева кода влияет только на размер исходников, но не на время компиляции и размер артефакта. Секрет, прочитанный во время компиляции, не может попасть в байткод или диагностическое сообщение. Без измерений inline раздувает байткод и ухудшает время компиляции, не гарантируя ускорение. Квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку.

Вопрос 8 из 30

При исправлении темы «Вставки кода» нужно устранить причину, а не замаскировать симптом. Какое изменение подходит лучше?

import scala.quoted.*
inline def doubled(inline x: Int): Int = ${ doubledImpl('x) }
def doubledImpl(x: Expr[Int])(using Quotes): Expr[Int] =
  '{ $x * 2 }
println(doubled(21))
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Возвращать широкое `Expr[Any]` и приводить результат в вызывающем коде. Читать секреты и произвольные файлы из окружения сборки, чтобы генерировать конфигурацию без дополнительных входов. Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности. Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции.

Вопрос 9 из 30

В контракте темы «Вставки кода» после изменения окружения команда пересматривает контракт. Какой вариант корректен?

size(bytecode)\propto generated\ nodes

Безопасная генерация сохраняет тип результата и использует Expr-конструкторы вместо склейки исходного текста; значение времени выполнения нельзя напрямую захватить в коде, который исполняется при компиляции; для переноса синтаксиса нужен `Expr` и корректный уровень staging. Splice `${...}` вставляет сгенерированное выражение в quoted-код, соблюдая уровни staging; успешный запуск без ошибок гарантирует сохранение статического типа при будущих изменениях. Splice `${...}` вставляет сгенерированное выражение в quoted-код, соблюдая уровни staging; без измерений inline раздувает байткод и ухудшает время компиляции, не гарантируя ускорение. Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов; генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции. Splice `${...}` вставляет сгенерированное выражение в quoted-код, соблюдая уровни staging; значение времени выполнения нельзя напрямую захватить в коде, который исполняется при компиляции; для переноса синтаксиса нужен `Expr` и корректный уровень staging.

Вопрос 10 из 30

При проверке темы «Вставки кода» какая проверка связывает принятую правку с реальной границей решения?

Splice `${...}` вставляет сгенерированное выражение в quoted-код, соблюдая уровни staging. Сравнить вывод на одном наборе данных, не меняя условия выполнения. Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности. В проверке воспроизвести ситуацию: значение времени выполнения нельзя напрямую захватить в коде, который исполняется при компиляции; для переноса синтаксиса нужен `Expr` и корректный уровень staging. Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. В проверке воспроизвести ситуацию: значение времени выполнения нельзя напрямую захватить в коде, который исполняется при компиляции; для переноса синтаксиса нужен `Expr` и корректный уровень staging. Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. В проверке воспроизвести ситуацию: без измерений inline раздувает байткод и ухудшает время компиляции, не гарантируя ускорение. В теме «Вставки кода» исправить один показанный вызов по рекомендации «Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции». Общий контракт и прежнюю границу отдельно не воспроизводить.

Вопрос 11 из 30

В теме «Встраиваемые определения» проследите типы и порядок вычисления. Какой вывод выдерживает такую проверку?

inline def choose(inline flag: Boolean) = inline if flag then 1 else 2

Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции. Макрос может вернуть дерево произвольного типа: параметр `Expr[T]` не связывает результат с ожидаемой сигнатурой. `Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`. `Inline if` выбирает ветвь во время выполнения, поэтому условие не обязано быть известно компилятору.

Вопрос 12 из 30

Что требует отдельной проверки при работе с «Встраиваемые определения»?

// Дополнительный контекст: Вход перестал быть константой времени компиляции, хотя прежний пример продолжает работать.
inline def choose(inline flag: Boolean) = inline if flag then 1 else 2

Секрет, прочитанный во время компиляции, не может попасть в байткод или диагностическое сообщение. Без измерений inline раздувает байткод и ухудшает время компиляции, не гарантируя ускорение. Значение времени выполнения нельзя напрямую захватить в коде, который исполняется при компиляции; для переноса синтаксиса нужен `Expr` и корректный уровень staging. Чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки. Рост дерева кода влияет только на размер исходников, но не на время компиляции и размер артефакта.

Вопрос 13 из 30

Что исправляет пример по теме «Встраиваемые определения» без побочного изменения API?

inline def choose(inline flag: Boolean) = inline if flag then 1 else 2
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности. Использовать полный reflection-обход для простой константной проверки, не сравнивая с `inline` и `constValue`. Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции. Читать секреты и произвольные файлы из окружения сборки, чтобы генерировать конфигурацию без дополнительных входов.

Вопрос 14 из 30

В контракте темы «Встраиваемые определения» какая формулировка учитывает и семантику конструкции, и реальный риск?

Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов; без измерений inline раздувает байткод и ухудшает время компиляции, не гарантируя ускорение. `Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`; достаточно проверить путь без ошибки, поскольку остальные ветви следуют той же семантике. Quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции; чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки. `Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`; значение времени выполнения нельзя напрямую захватить в коде, который исполняется при компиляции; для переноса синтаксиса нужен `Expr` и корректный уровень staging. `Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`; без измерений inline раздувает байткод и ухудшает время компиляции, не гарантируя ускорение.

Вопрос 15 из 30

При проверке темы «Встраиваемые определения» какой итог ревью содержит и действие, и способ заметить возврат риска?

В теме «Встраиваемые определения» исправить один показанный вызов по рекомендации «Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции». Общий контракт и прежнюю границу отдельно не воспроизводить. Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности. В проверке воспроизвести ситуацию: значение времени выполнения нельзя напрямую захватить в коде, который исполняется при компиляции; для переноса синтаксиса нужен `Expr` и корректный уровень staging. Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности. В проверке воспроизвести ситуацию: без измерений inline раздувает байткод и ухудшает время компиляции, не гарантируя ускорение. `Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`. Оставить единственный тест на штатный вход без проверки отмены и повтора. Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. В проверке воспроизвести ситуацию: без измерений inline раздувает байткод и ухудшает время компиляции, не гарантируя ускорение.

Вопрос 16 из 30

В теме «Безопасность генерации» какое утверждение не переносит в Scala правило из другого языка или другой конструкции?

import scala.quoted.*
inline def positive(inline n: Int): Int = ${ positiveImpl('n) }
def positiveImpl(n: Expr[Int])(using Quotes): Expr[Int] =
  n.value match
    case Some(value) if value > 0 => Expr(value)
    case Some(_) => quotes.reflect.report.errorAndAbort("expected a positive constant")
    case None => quotes.reflect.report.errorAndAbort("expected a constant")

`Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`. Безопасная генерация сохраняет тип результата и использует Expr-конструкторы вместо склейки исходного текста. Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Reflection API сохраняет стабильность между всеми версиями компилятора, как обычная стандартная библиотека. Чтение файлов и окружения из макроса не влияет на воспроизводимость, потому что результат сохраняется в TASTy.

Вопрос 17 из 30

Вход перестал быть константой времени компиляции, хотя прежний пример продолжает работать. Какое ограничение темы «Безопасность генерации» становится существенным?

// Дополнительный контекст: Вход перестал быть константой времени компиляции, хотя прежний пример продолжает работать.
import scala.quoted.*
inline def positive(inline n: Int): Int = ${ positiveImpl('n) }
def positiveImpl(n: Expr[Int])(using Quotes): Expr[Int] =
  n.value match
    case Some(value) if value > 0 => Expr(value)
    case Some(_) => quotes.reflect.report.errorAndAbort("expected a positive constant")
    case None => quotes.reflect.report.errorAndAbort("expected a constant")

Чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки. Макрос автоматически проверяет предметные ограничения входа, даже если реализация их явно не кодирует. Генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции. Секрет, прочитанный во время компиляции, не может попасть в байткод или диагностическое сообщение. Квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку.

Вопрос 18 из 30

При исправлении темы «Безопасность генерации» какое решение уменьшает вероятность повторения обнаруженного дефекта?

import scala.quoted.*
inline def positive(inline n: Int): Int = ${ positiveImpl('n) }
def positiveImpl(n: Expr[Int])(using Quotes): Expr[Int] =
  n.value match
    case Some(value) if value > 0 => Expr(value)
    case Some(_) => quotes.reflect.report.errorAndAbort("expected a positive constant")
    case None => quotes.reflect.report.errorAndAbort("expected a constant")
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. Сообщать об ошибке общей фразой без позиции и ожидаемой формы входа. Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции. Повторно обходить одно и то же дерево для каждого поля вместо накопления результата за один проход.

Вопрос 19 из 30

В контракте темы «Безопасность генерации» новый сценарий не отменяет основное правило, но делает заметной его границу. Какой ответ это отражает?

Оставить в контракте правило «`inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`»; проверяемое ограничение — «чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки». Оставить в контракте правило «безопасная генерация сохраняет тип результата и использует Expr-конструкторы вместо склейки исходного текста»; проверяемое ограничение — «одна зелёная проверка заменяет отдельные тесты на отмену, повтор и освобождение ресурса». Оставить в контракте правило «контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов»; проверяемое ограничение — «генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции». Оставить в контракте правило «безопасная генерация сохраняет тип результата и использует Expr-конструкторы вместо склейки исходного текста»; проверяемое ограничение — «квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку». Оставить в контракте правило «безопасная генерация сохраняет тип результата и использует Expr-конструкторы вместо склейки исходного текста»; проверяемое ограничение — «генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции».

Вопрос 20 из 30

При проверке темы «Безопасность генерации» что нужно оставить после исправления, кроме комментария в исходном файле?

В теме «Безопасность генерации» исправить один показанный вызов по рекомендации «Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности». Общий контракт и прежнюю границу отдельно не воспроизводить. Безопасная генерация сохраняет тип результата и использует Expr-конструкторы вместо склейки исходного текста. Убедиться лишь в успешном запуске, не фиксируя статический тип. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции. В проверке воспроизвести ситуацию: квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку. Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. В проверке воспроизвести ситуацию: генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции. В проверке воспроизвести ситуацию: генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции.

Вопрос 21 из 30

В теме «Риски безопасности» что компилятор или среда выполнения обязаны обеспечить в этом случае?

inline def buildInfo: String = ${ buildInfoImpl }
// Реализация не должна читать произвольные секреты окружения.

Quoted-код выполняется как обычный runtime-код и может безопасно обращаться к любому значению, известному только после запуска. `Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`. Compile-time макрос работает с исходным кодом проекта и может раскрыть секрет, путь или структуру сборочной машины в артефакте. Макрос может вернуть дерево произвольного типа: параметр `Expr[T]` не связывает результат с ожидаемой сигнатурой. Quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции.

Вопрос 22 из 30

Для темы «Риски безопасности» обычный пример прошёл, затем изменились условия использования. Какой риск нужно проверить первым?

// Дополнительный контекст: Макрос вызвали из другого модуля с выражением иной формы, но того же статического типа.
inline def buildInfo: String = ${ buildInfoImpl }
// Реализация не должна читать произвольные секреты окружения.

Ошибка макроса проявится только у конечного пользователя при запуске сгенерированного участка. Чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки. Изменение внутреннего Reflection API не затрагивает библиотеку макросов после публикации TASTy. Генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции. Квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку.

Вопрос 23 из 30

При исправлении темы «Риски безопасности» команда сравнивает несколько правок. Какая из них делает допущение явным и проверяемым?

inline def buildInfo: String = ${ buildInfoImpl }
// Реализация не должна читать произвольные секреты окружения.
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Ограничьте входы макроса явными константами, не читайте секреты и документируйте все build-time зависимости. Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции. Тестировать макрос только успешным примером, не компилируя заведомо неверные входы. Читать секреты и произвольные файлы из окружения сборки, чтобы генерировать конфигурацию без дополнительных входов.

Вопрос 24 из 30

В контракте темы «Риски безопасности» вход перестал быть константой времени компиляции, хотя прежний пример продолжает работать. Какой анализ пригоден для публичного API?

В проектном решении сохранить утверждение «`inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`» и риск «квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку». В проектном решении сохранить утверждение «compile-time макрос работает с исходным кодом проекта и может раскрыть секрет, путь или структуру сборочной машины в артефакте» и риск «если код компилируется, дополнительные проверки вывода типов и поиска `given` не нужны». В проектном решении сохранить утверждение «compile-time макрос работает с исходным кодом проекта и может раскрыть секрет, путь или структуру сборочной машины в артефакте» и риск «генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции». В проектном решении сохранить утверждение «compile-time макрос работает с исходным кодом проекта и может раскрыть секрет, путь или структуру сборочной машины в артефакте» и риск «чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки». В проектном решении сохранить утверждение «quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции» и риск «чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки».

Вопрос 25 из 30

Какой критерий готовности по теме «Риски безопасности» действительно поймает повтор прежнего дефекта?

Ограничьте входы макроса явными константами, не читайте секреты и документируйте все build-time зависимости. В проверке воспроизвести ситуацию: квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку. В теме «Риски безопасности» исправить один показанный вызов по рекомендации «Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии». Общий контракт и прежнюю границу отдельно не воспроизводить. Стройте типизированное дерево, проверяйте размер входа и выдавайте понятную ошибку времени компиляции. В проверке воспроизвести ситуацию: чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки. Ограничьте входы макроса явными константами, не читайте секреты и документируйте все build-time зависимости. В проверке воспроизвести ситуацию: чтение произвольных файлов и окружения делает сборку невоспроизводимой и создаёт канал утечки. Compile-time макрос работает с исходным кодом проекта и может раскрыть секрет, путь или структуру сборочной машины в артефакте. Запустить пример один раз и не проверять порядок событий.

Вопрос 26 из 30

В теме «Контроль производительности» как сформулировать семантику примера так, чтобы она сохранилась после переименования переменных?

import scala.quoted.*
def fieldNames[T: Type](using Quotes): Vector[String] =
  import quotes.reflect.*
  TypeRepr.of[T].typeSymbol.caseFields.iterator.map(_.name).toVector

`Inline if` выбирает ветвь во время выполнения, поэтому условие не обязано быть известно компилятору. Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Чтение файлов и окружения из макроса не влияет на воспроизводимость, потому что результат сохраняется в TASTy. Quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции. `Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`.

Вопрос 27 из 30

Какое внешнее изменение делает прежнее ожидание от «Контроль производительности» ненадёжным?

// Дополнительный контекст: Вход перестал быть константой времени компиляции, хотя прежний пример продолжает работать.
import scala.quoted.*
def fieldNames[T: Type](using Quotes): Vector[String] =
  import quotes.reflect.*
  TypeRepr.of[T].typeSymbol.caseFields.iterator.map(_.name).toVector

Генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции. Сопоставление с хрупкой формой дерева ломается при эквивалентном синтаксисе или изменении компилятора. Рост дерева кода влияет только на размер исходников, но не на время компиляции и размер артефакта. Квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку. Недетерминированный обход полей даёт стабильный результат, если исходный case class не менялся.

Вопрос 28 из 30

При исправлении темы «Контроль производительности» какой вариант не переносит проблему в вызывающий код?

import scala.quoted.*
def fieldNames[T: Type](using Quotes): Vector[String] =
  import quotes.reflect.*
  TypeRepr.of[T].typeSymbol.caseFields.iterator.map(_.name).toVector
// На ревью требуется устранить причину дефекта, не скрывая её приведением типа или значением по умолчанию.

Использовать полный reflection-обход для простой константной проверки, не сравнивая с `inline` и `constValue`. Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности. Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии. Кэшируйте безопасные вычисления в рамках запуска, ограничивайте рекурсию и измеряйте полную сборку с нуля на большом модуле. Читать секреты и произвольные файлы из окружения сборки, чтобы генерировать конфигурацию без дополнительных входов.

Вопрос 29 из 30

В контракте темы «Контроль производительности» какой вариант не теряет существенную часть технической картины?

Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Пограничный сценарий: квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку. Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Пограничный сценарий: генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции. Quotes предоставляют типизированное представление кода `Expr[T]` внутри макроса и позволяют анализировать структуру на этапе компиляции. Пограничный сценарий: сопоставление с хрупкой формой дерева ломается при эквивалентном синтаксисе или изменении компилятора. `Inline` подставляет тело в место вызова и открывает ветвление во время компиляции через `inline if` или `erasedValue`. Пограничный сценарий: квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку. Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Пограничный сценарий: штатный пример доказывает корректность порядка событий при любой нагрузке.

Вопрос 30 из 30

При проверке темы «Контроль производительности» какую гарантию важно превратить в повторяемую проверку?

Кэшируйте безопасные вычисления в рамках запуска, ограничивайте рекурсию и измеряйте полную сборку с нуля на большом модуле. В проверке воспроизвести ситуацию: генерация строкового кода создаёт проблемы экранирования, имён, области видимости и потенциальной инъекции. Контроль производительности макроса включает время компиляции, размер TASTy/байткода и число сгенерированных членов. Проверить только новую реализацию, не воспроизводя прежний дефект. Кэшируйте безопасные вычисления в рамках запуска, ограничивайте рекурсию и измеряйте полную сборку с нуля на большом модуле. В проверке воспроизвести ситуацию: квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку. В теме «Контроль производительности» исправить один показанный вызов по рекомендации «Следите, на каком этапе доступно значение; передавайте данные времени компиляции как `Expr` и не смешивайте стадии». Общий контракт и прежнюю границу отдельно не воспроизводить. Используйте `inline` для специализации и доступа к данным времени компиляции, а не как общий атрибут производительности. В проверке воспроизвести ситуацию: квадратичный обход большого дерева или генерация метода на каждое поле каждого типа резко замедляет сборку.