---
id: qg:AI-01
title: Запись набора с удалением по неполному отбору
severity: critical
group: model
tool: null
archetypes: [record-set]
std: []
---

## Триггер

`НаборЗаписей…Записать(Истина)` с отбором не по всем ключевым измерениям.

## Почему

Для периодического регистра тот же дефект — отсутствие `Период` в отборе. `Записать(Истина)`
сначала **удаляет из базы все записи, удовлетворяющие установленному отбору**, и лишь затем
пишет набор. Отбор по части измерений и без периода уничтожает всю накопленную историю по
этим измерениям, а не «перезаписывает текущий снимок». Симптом обнаруживается спустя
недели — когда историю уже не восстановить.

**Признак в сравнении версий, который часто сопровождает ошибку.** В одном модуле соседние
процедуры используют разные режимы записи, причём у одной стоит комментарий вида «здесь
`Истина` стёрло бы всё». Самопротиворечивый код — сигнал, что режим выбран не по механике, а
по совпадению.

## Как чинить

- перезапись снимка на конкретный момент — `Записать(Истина)` с отбором по `Период` **и**
  всем измерениям, постоянным для набора; измерение, варьирующееся внутри набора, в отбор не
  ставится, иначе удаление станет точечным и не вычистит устаревшие строки;
- одиночная запись — `СоздатьМенеджерЗаписи()`: ключ включает период и измерения, стереть
  историю физически не может;
- накопление новых срезов — `Записать(Ложь)`;
- период задавать детерминированно (дата документа, дата события), не
  `ТекущаяДатаСеанса()` — иначе повторный запуск плодит дубли;
- перезапись без периода нельзя называть безопасной для повторного запуска: она удаляет
  данные, а не обновляет их.

#### Неправильно

```bsl
// Отбор по одному измерению: Записать(Истина) удалит ВСЕ записи по этой номенклатуре
// за все периоды, а запишет только текущий набор.
Набор = РегистрыСведений.ЦеныНоменклатуры.СоздатьНаборЗаписей();
Набор.Отбор.Номенклатура.Установить(Номенклатура);
Набор.Записать(Истина);
```

#### Правильно

```bsl
// В отборе период и все измерения, постоянные для набора: удалится ровно то,
// что перезаписывается.
Набор = РегистрыСведений.ЦеныНоменклатуры.СоздатьНаборЗаписей();
Набор.Отбор.Период.Установить(ДатаДокумента);
Набор.Отбор.Номенклатура.Установить(Номенклатура);
Набор.Записать(Истина);
```

## Когда это не дефект

- правило требует не «побольше измерений в отборе», а совпадения отбора с тем, что должно
  исчезнуть — проверять надо не число измерений, а ответ на вопрос «что удалит этот отбор»;
- у регистра, подчинённого регистратору, отбор по регистратору и есть полный ключ: удалить
  все записи документа перед перезаписью — правильно.

## Что проверяет инструмент

Ничего: смысл отбора инструменту недоступен. Проверяется чтением.

---
id: qg:AI-02
title: Чтение реквизита ссылки через точку
severity: critical
group: model
tool: null
archetypes: [always]
std: [std453]
---

## Триггер

`Ссылка.Реквизит` в новом или изменённом коде, где объект не нужен целиком.

## Почему

Обращение через точку загружает **весь объект** — все реквизиты и табличные части. Для
единичного чтения это лишняя нагрузка и заполнение кеша.

**Отдельно про ревью.** «Так написан соседний код» не является основанием понизить эту
находку. Легаси чинится отдельно; новый код пишется правильно сразу. Идиома окружения — не
аргумент против механики платформы.

## Как чинить

`ОбщегоНазначения.ЗначениеРеквизитаОбъекта(Ссылка, "Имя")`, а для нескольких полей —
`ЗначенияРеквизитовОбъекта(Ссылка, "Имя1,Имя2")` одним вызовом (возвращает структуру).

#### Неправильно

```bsl
Валюта = ДокументСсылка.Валюта;  // загружается весь документ вместе с табличными частями
```

#### Правильно

```bsl
Валюта = ОбщегоНазначения.ЗначениеРеквизитаОбъекта(ДокументСсылка, "Валюта");
// несколько полей - одним вызовом, а не несколькими
Реквизиты = ОбщегоНазначения.ЗначенияРеквизитовОбъекта(ДокументСсылка, "Валюта,Организация");
```

## Когда это не дефект

- объект уже получен как объект — например, в обработчике события — и точка на нём не
  вызывает лишнюю загрузку;
- имя после точки — поле выборки результата запроса, а не обращение через ссылку.

## Что проверяет инструмент

**Механизированная часть — `qg:BSL-REF-DOT-ACCESS`** (`tools/bsl-lint.mjs`): ссылочность
доказывается присваиванием в том же методе, типом параметра из описания #std453 либо именем
на «Ссылка». Это нижняя граница проверки, а не верхняя — ссылку из чужой функции инструмент
не распознаёт; основания, контр-сигналы и разбор — в `references/catalog/BSL-REF-DOT-ACCESS.md`.

---
id: qg:AI-03
title: Реквизиты и свойства заводятся кодом во время работы, минуя метаданные
severity: critical
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

Программное создание видов характеристик/доп. свойств из кода; запись в регистры в обход
API.

## Почему

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

**Диагностический признак.** Мысль «стандартное API отбросит мои данные» означает не дефект
API, а неверную модель данных. Чинить нужно модель.

## Как чинить

Сначала инвентаризировать существующие реквизиты объекта — нужное часто уже есть в типовой
конфигурации. Если нужен новый реквизит, он добавляется как объект метаданных, а не из кода.
Запись значений — только через публичное API подсистемы.

#### Неправильно

```bsl
// Вид характеристики создаётся кодом при первом обращении.
Свойство = ПланыВидовХарактеристик.ДополнительныеРеквизитыИСведения.СоздатьЭлемент();
Свойство.Наименование = "Код партнёра";
Свойство.Записать();
```

#### Правильно

```bsl
// Свойство заведено в метаданных (или найдено среди типовых), код только читает его
// по программному имени - запросом сразу для всех нужных имён, см. AI-13.
Свойства = СвойстваПоИменам("КодПартнёра,СрокГодности");  // имя -> ссылка
```

## Когда это не дефект

- правило не про перенос данных обменом: при загрузке из другой базы элементы плана видов
  характеристик создаются программно — это перенос уже существующих объектов, а не
  изобретение новых во время работы.

## Что проверяет инструмент

Ничего, правило проверяется чтением.

---
id: qg:AI-04
title: Отчёт о проверке, которая не прогонялась
severity: critical
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

Утверждения «проверено», «собирается», «проходит» без следа фактического прогона.

## Почему

Слово-маркер этого антипаттерна — не только «проверено», но и «зарегистрировано». Ложно-
уверенный отчёт хуже честного «не проверял» — он закрывает вопрос фальшивой зеленью. Именно
этот антипаттерн делает бессмысленной любую систему контроля качества, включая эту.

## Как чинить

Такие слова допустимы только после реального прогона — поиска по файлу конфигурации,
настоящей сборки, прогона на подготовленном образце данных. Не прогонял — так и пиши. В
следе прогона для этого есть отдельная запись `not_verified`.

Частный случай той же ошибки: строить логику на догадке о том, что означают поля во внешнем
ответе («это, наверное, идентификатор», «оно приходит в этом методе»). Тип, наличие и смысл
поля сверяются по настоящему ответу сервиса **до** написания кода, иначе код переписывается
два-три раза.

## Когда это не дефект

- отчёт прямо называет проверку непрогнанной и причину — это заявленный пропуск, а не
  дефект: для этого в следе прогона есть запись `not_verified`, а не молчание.

## Что проверяет инструмент

След прогона: `tools/evidence-validator.mjs` не принимает вердикт без записи о запуске
проверки, а неизвестный идентификатор `qg:*` считает ошибкой. Слова «проверено» в свободном
тексте отчёта не проверяет никто — за них отвечает автор.

---
id: qg:AI-05
title: «Зелёная» сборка принята за доказательство компилируемости
severity: critical
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

Вывод «код компилируется» по загрузке/выгрузке конфигурации, валидатору XML или
анализатору.

## Почему

Речь именно об успешной загрузке конфигурации **из файлов** — не о прогоне платформой.
Загрузка и выгрузка конфигурации работают со **структурой** и не компилируют тела модулей.
Синтаксическая ошибка внутри процедуры проходит их все, а всплывает при инициализации модуля
в базе. Статический анализатор тоже толерантен к части конструкций, где платформенный
компилятор строже.

## Как чинить

Компилируемость подтверждает только проверка конфигурации платформой (`/CheckConfig`) либо
реальный прогон в базе. Если ни то ни другое не выполнялось — запись
`[qg not_verified: dimension=compilation, reason=no_platform]`.

**Конкретная ловушка, породившая правило.** У блочных операторов (`КонецПопытки`,
`КонецЕсли`, `КонецЦикла`) точка с запятой необязательна, **пока они последние в своём
блоке**. Как только после такого оператора вставляется ещё один, он перестаёт быть
последним — и требует `;`. При вставке кода после закрывающего оператора всегда проверяй
строку прямо над местом вставки.

```bsl
// Было: КонецЕсли последний в блоке, точка с запятой не нужна.
Если Условие Тогда
    Обработать();
КонецЕсли
```

```bsl
// Стало: после КонецЕсли добавили ещё один оператор - теперь точка с запятой обязательна.
Если Условие Тогда
    Обработать();
КонецЕсли;
ЗаписатьВЖурнал();
```

## Когда это не дефект

- прогон платформой не требуется, если правка не трогала тела модулей: переименование
  файла, комментарий в XML, право в роли — тогда так и пишется: тела модулей не менялись,
  компиляция ни при чём.

## Что проверяет инструмент

Компилируемость не проверяет ни один инструмент гейта: ни анализатор кода, ни валидаторы XML
тела модулей не компилируют. Нужен прогон платформой (`/CheckConfig`) либо запуск в базе.

---
id: qg:AI-06
title: Самодельный флаг отмены вместо Отказ
severity: major
group: model
tool: null
archetypes: [object-event, form-module]
std: []
---

## Триггер

Выходные параметры «ЕстьПроблемы», структуры «Прервать»/«Текст» вместо отмены операции.

## Почему

Речь о структурах-мешках с полями «Прервать» и «Текст» там, где по смыслу это обычная отмена
операции. `Отказ` — конвенция платформы и библиотек, её понимают все стандартные обработчики
и все читатели кода. Своя конструкция требует изучения и не стыкуется с типовым поведением.

## Как чинить

Выходной параметр провала называется `Отказ` и имеет тип Булево; подробности пишутся в
журнал регистрации.

#### Неправильно

```bsl
Процедура ПроверитьЗаполнение(Документ, ЕстьПроблемы, ТекстПроблемы)
```

#### Правильно

```bsl
Процедура ПроверитьЗаполнение(Документ, Отказ)
```

## Когда это не дефект

- наружу нужен не только факт отказа, но и разбор — что именно не прошло и по каким
  строкам, — результат возвращается структурой; но признак провала в ней всё равно
  называется `Отказ` и имеет тип Булево: по нему принимают решение стандартные обработчики.

## Что проверяет инструмент

Ничего, правило проверяется чтением.

---
id: qg:AI-07
title: У параметров, которые метод не изменяет, не стоит Знач
severity: major
group: model
tool: null
archetypes: [always]
std: [std487, std640]
---

## Триггер

Структура/массив/ТЗ без `Знач` в методе, который их не меняет — особенно у серверного
метода из клиента.

## Почему

Параметр, который метод только читает, объявляется с `Знач`. Это заявление о намерении, и у
него есть измеримое следствие: у серверного метода, вызываемого с клиента, параметр без
`Знач` после вызова передаётся обратно на клиент — лишний трафик (АПК:1412, #std487).

**Чего `Знач` не делает — это важнее того, что делает.** `Знач` защищает саму
переменную-параметр от присваивания: `Параметр = ДругоеЗначение` внутри метода не изменит
переменную вызывающего. Содержимое переданной коллекции он не защищает:
`Параметр.Добавить(…)`, `Параметр.Вставить(…)`, `Параметр.Очистить()`, удаление колонок
таблицы вызывающий увидит — объект остаётся тем же самым. Разбор этого — в методической
статье ИТС «Передача параметров по ссылке и по значению при вызове процедур и функций», на
которую ссылается #std640 в разделе «См. также».

Отсюда практическое следствие: `Знач` — объявление намерения и защита от подмены значения, но
не гарантия неизменности данных. Если неизменность нужна по-настоящему, передают копию
(`Скопировать()` у таблицы значений, обход с `Вставить` у структуры) либо фиксированную
коллекцию (`Новый ФиксированнаяСтруктура(Структура)`, `Новый ФиксированныйМассив(Массив)`).

## Как чинить

#### Неправильно

```bsl
// Метод только читает таблицу, но объявлен так, будто может подменить её целиком.
Функция ПодобратьЦены(ТаблицаТоваров)
```

#### Правильно

```bsl
Функция ПодобратьЦены(Знач ТаблицаТоваров)
```

**Смежная ошибка:** `Знач` — модификатор **параметра**, а не локальной переменной.
`Знач Переменная = …` внутри тела процедуры даёт синтаксическую ошибку.

**Смежная ошибка:** `ЗаполнитьЗначенияСвойств(Приёмник, Источник)` копией структуры не
является — метод переносит значения только в **уже существующие** свойства приёмника, и
пустая структура после вызова останется пустой. Копия собирается обходом с `Вставить`. Ошибка
живучая: на объектах и наборах записей метод работает как ожидается, поэтому перенос той же
привычки на структуру даёт молчаливо пустой результат, а не отказ.

**Как проявляется, когда метод меняет полученную коллекцию.** Метод, удаляющий ключ из
полученной структуры, портит её для второго вызова с тем же аргументом: первый вызов
проходит, второй падает на отсутствующем поле. Пока сценарий вызывает такой метод однократно,
дефект невидим — он проявляется на ветке, где вызовов два подряд.

## Когда это не дефект

- метод обязан изменить переданную коллекцию: заполнить таблицу результата, дописать структуру
  параметров, снять признак у строк — тогда `Знач` не ставится, а в описании параметра прямо
  сказано, что он изменяется (#std453);
- параметр примитивного типа, который метод не меняет: `Знач` ничего не даёт по существу, но
  и не мешает; правило про коллекции.

## Что проверяет инструмент

Диагностика для серверного метода, вызываемого с клиента, есть — АПК:1412, — но печатает её
автоматизированная проверка конфигураций, а не инструменты гейта. В прогоне гейта правило
проверяется чтением: изменяет метод коллекцию или нет, видно только по телу метода.

---
id: qg:AI-08
title: Ответ внешней системы разбирают по одному полю в разных местах
severity: major
group: model
tool: null
archetypes: [always]
std: [std641]
---

## Триггер

Набор функций-помощников, каждая достаёт из ответа одно поле и приводит его к нужному типу.

## Почему

Набор мелких функций-помощников: своя для строки, своя для даты, своя для числа. Вызовы
разбросаны по коду заполнения документов и регистров. Ответ сервиса
превращается в данные 1С один раз и в одном месте. Дальше код работает с результатом
разбора — структурой или таблицей значений, — а в исходный ответ больше не заглядывает.

**Чем это плохо — три конкретные вещи.**

1. **Переименование поля во внешней системе правится во всех местах, где это поле достают.**
   Одно пропущенное место — молча пустое значение вместо ошибки.
2. **Нигде не видно целиком, что из ответа берут и во что превращают.** Проверить разбор
   нечем: каждый помощник проверяется отдельно, а вместе они не проверяются никак.
3. **Типы расходятся.** В одном помощнике дата разбирается как дата, в другом то же поле
   остаётся строкой — и дальше по коду одно и то же значение ведёт себя по-разному.

## Как чинить

```bsl
// Разбор один раз, на границе с внешней системой.
ДанныеЗаказа = РазобратьОтветЗаказа(Ответ);  // структура с известным составом полей
// Дальше по коду - работа с результатом разбора, а не с ответом.
ЗаполнитьДокумент(Документ, ДанныеЗаказа);
```

Состав полей результата объявляется отдельной функцией-конструктором (#std641): там видно и
перечень полей, и тип каждого. Приведение типов делается платформенными средствами —
`XMLЗначение` и `XMLСтрока`, — а не разбором формата даты вручную.

## Когда это не дефект

- из ответа берут одно-два поля, и больше он нигде не нужен: отдельная функция разбора не
  окупится;
- ответ разнородный: разные виды событий с разным составом полей — тогда разбор пишется по
  одному на вид события, но не по одному на поле.

## Что проверяет инструмент

Ничего, правило проверяется чтением кода.

---
id: qg:AI-09
title: Настройки и значения по умолчанию вычисляются внутри цикла
severity: major
group: model
tool: null
archetypes: [always]
std: [std724]
---

## Триггер

Чтение константы или поиск предопределённого элемента внутри цикла по строкам.

## Почему

Триггер — не только чтение внутри цикла по строкам документа, но и обращение к настройкам
или к регистру сведений внутри процедуры, которую вызывают для каждой строки. Всё, что не
меняется от строки к строке — константы, настройки, ссылки по умолчанию, курс валюты, —
вычисляется один раз до цикла и передаётся внутрь готовым. Каждое чтение внутри цикла —
обращение к базе данных: на документе в тысячу строк это тысяча обращений вместо одного.
Вторая беда не про скорость: одна и та же настройка оказывается вычислена в трёх местах, а в
четвёртом про неё забывают, и поведение в этих местах расходится.

## Как чинить

```bsl
// Неправильно
Для Каждого СтрокаТоваров Из Документ.Товары Цикл
    СтрокаТоваров.СтавкаНДС = Константы.СтавкаНДСПоУмолчанию.Получить();
КонецЦикла;
```

```bsl
// Правильно
СтавкаПоУмолчанию = Константы.СтавкаНДСПоУмолчанию.Получить();
Для Каждого СтрокаТоваров Из Документ.Товары Цикл
    СтрокаТоваров.СтавкаНДС = СтавкаПоУмолчанию;
КонецЦикла;
```

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

## Когда это не дефект

- значение зависит от строки — ему и место в цикле;
- значение отдаёт модуль с повторным использованием возвращаемых значений (#std724):
  повторный вызов в цикле дёшев, но первый вызов платный, а результат живёт до конца сеанса —
  если значение должно быть строго на момент выполнения, кэш не подходит.

## Что проверяет инструмент

Ничего.

---
id: qg:AI-10
title: Сопоставление в памяти вместо соединения в запросе
severity: major
group: model
tool: null
archetypes: [query]
std: []
---

## Триггер

Вложенные циклы поиска соответствий и построение `Соответствие` для связывания наборов.

## Почему

Речь о наборах, которые оба приходят из базы. Движок запросов делает это короче и быстрее.

## Как чинить

Одним запросом с временными таблицами и соединениями, затем `ЗаполнитьЗначенияСвойств` —
если выровнять псевдонимы колонок запроса под имена реквизитов приёмника, заполнение
становится однострочным.

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

#### Неправильно

```bsl
// Два набора из базы сопоставляются вложенными циклами.
Для Каждого СтрокаЗаказа Из Заказы Цикл
    Для Каждого СтрокаОстатка Из Остатки Цикл
        Если СтрокаОстатка.Номенклатура = СтрокаЗаказа.Номенклатура Тогда
            СтрокаЗаказа.Остаток = СтрокаОстатка.Количество;
            Прервать;
        КонецЕсли;
    КонецЦикла;
КонецЦикла;
```

#### Правильно

```sdbl
ВЫБРАТЬ
    Заказы.Номенклатура КАК Номенклатура,
    ЕСТЬNULL(Остатки.КоличествоОстаток, 0) КАК Остаток
ИЗ
    ВТ_Заказы КАК Заказы
    ЛЕВОЕ СОЕДИНЕНИЕ РегистрНакопления.ТоварыНаСкладах.Остатки(&Дата, ) КАК Остатки
        ПО Заказы.Номенклатура = Остатки.Номенклатура
```

## Когда это не дефект

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

## Что проверяет инструмент

Ничего, правило проверяется чтением.

---
id: qg:AI-11
title: При упрощении кода молча исчезают проверки и служебные записи
severity: major
group: model
tool: null
archetypes: [always]
std: []
needs: [diff]
---

## Триггер

В `git diff` — исчезнувшие проверки редких случаев и записи без читаемого результата.

## Почему

Когда метод сокращают, вместе с лишним уходят проверки редких случаев перед основной
работой (`Если … Тогда Возврат КонецЕсли`) и записи, которые нужны не как результат, а как
след: заполненный идентификатор, начальное состояние, отметка в регистре — их результат в
этом же методе нигде не читается. Автор правки этого не замечает: код стал короче и
по-прежнему работает на основном сценарии.

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

## Как чинить

Сокращая метод, выписать всё удаляемое и по каждому пункту ответить на один вопрос: кто это
читал. Нет ответа — удалять можно. Есть — оставлять.

## Когда это не дефект

- не всякое сокращение — потеря: если у проверки нет ни одного случая, в котором она
  сработает — условие невозможно по типу данных либо уже проверено выше, — она мёртвая, и
  удаление правильно;
- записывать правку в поломку, не выяснив, кто читал удалённое, так же неверно, как удалять
  не выяснив.

## Что проверяет инструмент

Пропажу проверок — ничего: для инструмента это просто более короткий код. Смежный случай —
вызов метода, объявление которого исчезло в той же правке, — ловит
`qg:BSL-STALE-LOCAL-CALL` (`tools/rename-check.mjs`).

---
id: qg:AI-12
title: Проведение внутри транзакции записи
severity: major
group: model
tool: null
archetypes: [object-event, transaction]
std: []
---

## Триггер

Запись документа и его проведение в одной транзакции «ради атомарности».

## Почему

Проведение проверяет остатки и может законно не пройти. Внутри общей транзакции такой сбой
откатывает всё и **маскирует причину** — вместо понятной ошибки проведения получается пустой
результат.

## Как чинить

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

#### Неправильно

```bsl
НачатьТранзакцию();
Попытка
    ДокументОбъект.Записать(РежимЗаписиДокумента.Запись);
    ЗаписатьСлед(ДокументОбъект.Ссылка);
    ДокументОбъект.Записать(РежимЗаписиДокумента.Проведение);  // остатков не хватило
    ЗафиксироватьТранзакцию();
Исключение
    ОтменитьТранзакцию();  // откатилось всё, включая запись; причина потеряна
КонецПопытки;
```

#### Правильно

```bsl
НачатьТранзакцию();
Попытка
    ДокументОбъект.Записать(РежимЗаписиДокумента.Запись);
    ЗаписатьСлед(ДокументОбъект.Ссылка);
    ЗафиксироватьТранзакцию();
Исключение
    ОтменитьТранзакцию();
    ВызватьИсключение;
КонецПопытки;

// Отдельным шагом: документ уже сохранён, ошибка проведения видна и разбираема.
ПровестиДокумент(ДокументОбъект.Ссылка);
```

## Когда это не дефект

- бизнес-правило требует, чтобы документ без успешного проведения вообще не сохранялся
  (незаписанный черновик недопустим) — тогда общая транзакция и есть нужная атомарность, а
  не маскировка: результат «ничего не сохранилось» соответствует замыслу.

## Что проверяет инструмент

Собственную транзакцию внутри обработчика события объекта ловит `qg:BSL-TXN-IN-HANDLER`
(`tools/bsl-lint.mjs`). Проведение внутри транзакции инструменту не видно — это проверяется
чтением.

---
id: qg:AI-13
title: Поиск дополнительного свойства по наименованию
severity: minor
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

`НайтиПоНаименованию` у доп. реквизита; `НайтиПоКоду` у справочника в теле механизма.

## Почему

У плана видов характеристик дополнительных реквизитов **программное имя** и
**пользовательское наименование** — разные реквизиты. Библиотека ищет свойство только по
имени. Поиск по наименованию работает случайно и ломается при первом же переименовании
заголовка.

**То же самое — поиск любого справочного значения по коду.** `НайтиПоКоду("XX-000017")` в
теле механизма имеет ту же природу: код элемента меняется в пользовательском режиме, ссылка
при этом остаётся прежней, и ветка перестаёт находить документы — молча, без ошибки. Замена
выбирается по тому, одно ли значение на всю базу: предопределённый элемент
(`ПредопределённоеЗначение`), константа или реквизит настройки, если у каждой точки
применения значение своё. Довод «так же ищет соседний механизм» аргументом не является: у
соседа та же уязвимость.

## Как чинить

Правильно — запрос по реквизиту `Имя`, сразу пакетом для всех нужных имён, с получением
соответствия «имя → ссылка».

#### Неправильно

```bsl
Свойство = ПланыВидовХарактеристик.ДополнительныеРеквизитыИСведения.НайтиПоНаименованию("Код партнёра");
```

#### Правильно

```sdbl
ВЫБРАТЬ
    Свойства.Имя КАК Имя,
    Свойства.Ссылка КАК Ссылка
ИЗ
    ПланВидовХарактеристик.ДополнительныеРеквизитыИСведения КАК Свойства
ГДЕ
    Свойства.Имя В (&Имена)
```

Результат разворачивается в соответствие «имя → ссылка» один раз на все нужные свойства.

## Когда это не дефект

- наименование используют, когда его показывают пользователю — ключом поиска оно не служит
  никогда: его меняют в пользовательском режиме, и код ломается молча;
- поиск по коду законен в разовых обработках и миграциях, живущих один прогон, по значению,
  введённому пользователем, и при загрузке из внешнего источника, где код и есть ключ
  сопоставления.

## Что проверяет инструмент

Ничего, правило проверяется чтением.

---
id: qg:AI-14
title: Чтение ячейки табличного документа несуществующим методом
severity: minor
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

У табличного документа нет метода `Получить` — ячейка читается через
`Область(Строка, Колонка)`.

## Почему

Для текстовых ячеек, пришедших из внешнего файла, читать нужно `.Текст`, а не `.Значение`:
свойство значения доступно, только когда в ячейке лежит объект-значение, иначе — ошибка
чтения поля. `.Текст` не выбрасывает исключение никогда, пустая ячейка даёт пустую строку;
типизацию выполняет вызывающий код.

## Как чинить

#### Неправильно

```bsl
Значение = Макет.Получить(1, 1);        // такого метода у табличного документа нет
ТекстЯчейки = Макет.Область(1, 1).Значение;  // для текстовой ячейки даст ошибку чтения
```

#### Правильно

```bsl
Ячейка = Макет.Область(1, 1);
ТекстЯчейки = Ячейка.Текст;  // пустая ячейка даст пустую строку, исключения не будет
```

## Когда это не дефект

- ячейка гарантированно содержит объект-значение (не текст из внешнего файла) — тогда
  `.Значение` читается штатно, и `.Текст` не нужен.

## Что проверяет инструмент

Ничего: тип значения переменной по тексту кода не выводится. Ошибка появляется при
выполнении, на первом же обращении к ячейке.

---
id: qg:AI-15
title: Присваивание read-only свойствам параметров записи
severity: minor
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

`Новый ПараметрыЗаписиJSON` без аргументов, затем присваивание свойству — read-only.

## Почему

У параметров записи JSON свойства доступны только для чтения — значения передаются **в
конструктор**. Попытка присвоить свойство после создания объекта без аргументов даёт ошибку
недоступности поля для записи.

## Как чинить

#### Неправильно

```bsl
Параметры = Новый ПараметрыЗаписиJSON;
Параметры.ПереносСтрок = ПереносСтрокJSON.Авто;  // свойство только для чтения
```

#### Правильно

```bsl
Параметры = Новый ПараметрыЗаписиJSON(ПереносСтрокJSON.Авто, Символы.Таб);
```

## Когда это не дефект

- правило касается объектов-настроек, чьи значения задаются конструктором;
- у большинства других объектов платформы свойства доступны для записи — доступность
  смотрится в справочнике платформы по конкретному типу, а не выводится по аналогии.

## Что проверяет инструмент

Ничего: доступность свойства на запись проверяется по справочнику платформы при написании
кода.

---
id: qg:AI-16
title: Колонки неограниченной длины в запросе
severity: major
group: model
tool: null
archetypes: [query]
std: [std432, std434]
---

## Триггер

Строковая колонка ТЗ без `КвалификаторыСтроки` уходит в запрос — ошибка при выполнении.

## Почему

Колонка таблицы значений, объявленная как строка **без квалификатора длины**
(`Новый ОписаниеТипов("Строка")`), имеет неограниченную длину. Помещённая во временную
таблицу, она даёт ошибку выполнения в `РАЗЛИЧНЫЕ`, `ОБЪЕДИНИТЬ` без `ВСЕ` (оно тоже устраняет
дубли, #std434), `СГРУППИРОВАТЬ ПО`, соединении (`ПО`) и сравнении в `ГДЕ`. Корень один —
движок не работает с полями неограниченной длины там, где значения приходится сравнивать
между собой, — а сообщений у него несколько: «Нельзя сравнивать поля неограниченной длины»,
«Недопустимое поле для группировки», «Недопустимое поле для упорядочивания» (`УПОРЯДОЧИТЬ
ПО` под тот же запрет попадает), «Индексируемое поле не может иметь составной тип и тип
неограниченной длины» (`ИНДЕКСИРОВАТЬ ПО`). Якорь — #std432 п. 3.1: для сравнения,
группировки и `РАЗЛИЧНЫЕ` стандарт предписывает приводить такие поля к строке определённой
длины. Условие соединения — то же сравнение, поэтому список конструкций шире перечисленного
в стандарте.

Ошибку не видит ни один статический слой — она доживает до первого выполнения запроса.
Коварная форма: таблицу в запрос отправляет **другой метод**, по месту объявления колонки
использование не видно, и автор не знает, что типизация вообще имеет значение. Реальный
случай: колонка без квалификатора ушла параметром в общий метод подбора номенклатуры, а тот
соединил её с ресурсом регистра — «Нельзя сравнивать поля неограниченной длины».

**Почему 🟠, а не 🔴.** Запрос действительно не выполнится — но только если таблица дойдёт до
перечисленных конструкций. По месту объявления колонки это неизвестно, и часть объявлений
без квалификатора законна; правило одного класса с `qg:QRY-ALIAS-SHADOWS-FIELD`: ошибка
появляется только при выполнении.

## Как чинить

Правило по умолчанию: строковая колонка таблицы, передаваемой параметром в запрос,
объявляется с квалификатором —
`Новый ОписаниеТипов("Строка", , Новый КвалификаторыСтроки(N))`; как её использует вызываемый
код, снаружи не видно. Повторяя существующий вызов, копируй объявление колонок у того кода,
который уже работает. И не ставить `РАЗЛИЧНЫЕ` там, где ключ уникален по построению.

#### Неправильно

```bsl
Таблица.Колонки.Добавить("Артикул", Новый ОписаниеТипов("Строка"));
```

#### Правильно

```bsl
Таблица.Колонки.Добавить("Артикул",
    Новый ОписаниеТипов("Строка", , Новый КвалификаторыСтроки(50)));
```

## Когда это не дефект

- квалификатор молча режет значение по длине, поэтому «дописать `КвалификаторыСтроки`
  везде» решением не является;
- колонка, несущая длинный текст (комментарий пользователя, XML, JSON, тело ответа сервиса),
  неограниченной длины **законно** (#std432 п. 2);
- если такое поле всё-таки нужно в запросе, длина назначается на стороне запроса —
  `ВЫРАЗИТЬ(Т.Поле КАК СТРОКА(N))`, в СКД вместо этого задаётся тип значения поля набора
  данных (#std432 п. 3.2), — а данные в таблице остаются целыми;
- частое приведение к длине само по себе сигнал, что поле в запросе лишнее.

## Что проверяет инструмент

Механическая половина проверяется инструментом: `qg:BSL-UNBOUNDED-STRING-COLUMN`
(`tools/bsl-lint.mjs`) — колонка без квалификатора у таблицы, которая **в том же модуле**
уходит в `УстановитьПараметр`. Уход таблицы в чужой метод инструменту не виден: графа вызовов
он не строит, и эта половина остаётся за читателем.

---
id: qg:AI-17
title: Результат запроса переложен циклом в массив структур
severity: major
group: model
tool: null
archetypes: [query]
std: []
---

## Триггер

Цикл по выборке запроса собирает структуру и кладёт в массив — список полей задублирован.

## Почему

В цикле по выборке результата запроса делается ровно три вещи и больше ничего: создаётся
структура со списком полей, в неё копируются значения (`ЗаполнитьЗначенияСвойств`), структура
добавляется в массив. Дополнительный признак: список полей написан в модуле дважды — сначала
в тексте запроса, потом строкой в конструкторе структуры.

Набор однотипных записей, полученный запросом, не нужно перекладывать в массив структур.
Результат запроса выгружается в таблицу значений одной строкой:
`Запрос.Выполнить().Выгрузить()`. Признак, которого в запросе нет, добавляется отдельной
колонкой.

**Чем это плохо — три конкретные вещи.**

1. **Список полей написан дважды.** Поле, добавленное в запрос, но забытое во втором списке,
   в структуру не попадёт, и никакого сообщения об этом не будет: `ЗаполнитьЗначенияСвойств`
   копирует значения только в те свойства, которые в приёмнике уже есть, а о лишних полях
   источника молчит. Ошибка проявится позже и в другом месте — там, где к пропавшему полю
   обратятся.
2. **У структуры нет типов.** У колонок таблицы, полученной через `Выгрузить()`, типы берутся
   из полей запроса. У свойств структуры типа нет вообще, поэтому положить в поле не то
   значение ничто не помешает.
3. **Всё, что таблица умеет сама, приходится писать руками.** Поиск строк по значениям
   колонок, отсев повторов, сумма по колонке, сортировка, выгрузка колонки в массив, копия
   части строк — у таблицы значений это готовые методы (`НайтиСтроки`, `Свернуть`, `Итог`,
   `Сортировать`, `ВыгрузитьКолонку`, `Скопировать`). У массива структур их нет, и каждый
   следующий разработчик пишет очередной цикл.

**Почему замена обычно не ломает вызывающий код.** Строка таблицы значений ведёт себя как
структура: обращение по индексу (`Записи[0].Поле`), `Количество()`, обход `Для Каждого`,
присваивание полю работают одинаково. Строку можно положить в отдельный массив и править
через него — меняться будет та же строка в таблице, потому что строка это не копия данных, а
ссылка на них. Отличий ровно два, и оба видны по коду:

- у строки таблицы нет методов структуры `Свойство`, `Вставить`, `Удалить` — места, где они
  вызываются, придётся переписать;
- `Добавить()` у таблицы не принимает готовый элемент: он создаёт пустую строку и возвращает
  её, поэтому заполнять поля надо после вызова, а не до.

## Как чинить

#### Неправильно

```bsl
Выборка = Запрос.Выполнить().Выбрать();
Записи = Новый Массив;
Пока Выборка.Следующий() Цикл
    Запись = Новый Структура("Идентификатор, Операция, Основание, Склад,
        |Статус, КоличествоПопыток, ДатаПостановки, Сумма");
    ЗаполнитьЗначенияСвойств(Запись, Выборка);
    Запись.Вставить("Обработана", Ложь);
    Записи.Добавить(Запись);
КонецЦикла;
```

#### Правильно

```bsl
Записи = Запрос.Выполнить().Выгрузить();
Записи.Колонки.Добавить("Обработана", Новый ОписаниеТипов("Булево"));
```

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

**Тип колонки указывать обязательно.** Если написать
`Записи.Колонки.Добавить("Обработана")` без `ОписаниеТипов`, то в уже существующих строках
новая колонка получит значение `Неопределено`. Первое же `Если Строка.Обработана Тогда`
завершится ошибкой преобразования значения к типу Булево. Ни анализатор кода, ни загрузка
конфигурации этого не покажут: ошибка появится только при выполнении.

**Ловушка при работе с таблицей.** Метод `Свернуть` удаляет из таблицы все колонки, которые
не перечислены ни в списке группировок, ни в списке суммируемых. Если ту же таблицу читают
другие процедуры, они молча потеряют поля. Сворачивать нужно копию: сначала `Скопировать()`,
потом `Свернуть` у копии.

## Когда это не дефект

- **записи разного вида**, у каждой свой набор полей — у таблицы значений колонки общие для
  всех строк, разнородные записи в неё не ложатся;
- **набор дальше превращается в JSON или XML** для отправки во внешнюю систему —
  `ЗаписатьJSON` принимает ограниченный набор типов и для остальных требует функцию
  преобразования; проверять надо не в том методе, где коллекция создана, а дойдя по вызовам
  до места отправки;
- **данные используются на клиенте или передаются между клиентом и сервером** — там способ
  передачи выбирают по другим соображениям: реквизит формы, временное хранилище;
- **в наборе две-три записи**, и над ними не делают ни поиска, ни группировки, ни итогов —
  менять нечего, выигрыша не будет.

## Что проверяет инструмент

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

---
id: qg:AI-18
title: Ключ, склеенный из значений в одну строку, вместо поиска по колонкам
severity: major
group: model
tool: null
archetypes: [query]
std: [std452]
---

## Триггер

Ключ соответствия склеен из значений строкой, либо цикл ради поиска по двум-трём полям.

## Почему

Когда запись опознаётся по нескольким полям сразу, эти поля не нужно склеивать в одну строку
и делать её ключом соответствия — например,
`Соответствие.Вставить(Идентификатор + "|" + Операция, Значение)` с последующим обратным
разбором ключа через `СтрРазделить`. У таблицы значений есть поиск сразу по нескольким
колонкам: `НайтиСтроки(Новый Структура("Поле1, Поле2", Значение1, Значение2))`.

**Чем это плохо — четыре конкретные вещи.**

1. **Значения теряют тип.** Чтобы попасть в строку-ключ, ссылка, дата или число приводятся к
   строке. `Строка(Ссылка)` даёт представление, а оно не обязано быть уникальным: два
   элемента справочника с одинаковым наименованием дадут одинаковую строку, а пустая ссылка —
   пустую. Если приводить через `XMLСтрока`, значение остаётся различимым, но три следующих
   недостатка никуда не деваются.
2. **Ключ ломается о собственный разделитель.** Если выбранный разделитель встретится внутри
   значения, части ключа склеятся не так, как задумано: две разные записи могут совпасть, а
   нужная — не найтись.
3. **Ключ одноразовый.** Он годится только для того сочетания полей, из которого склеен.
   Понадобится поиск по другому сочетанию — придётся строить второе соответствие по тем же
   данным.
4. **Код нечитаем.** По выражению `А + "|" + Б + "|" + XMLСтрока(В)` не видно, что считается
   ключом; чтобы понять, нужно найти все места, где такой ключ собирают и разбирают.

## Как чинить

Цикл по таблице ради того, чтобы найти в ней строку, не пишется никогда, если условие
поиска — равенство: для этого есть
`НайтиСтроки(Новый Структура("Поле1, Поле2", Значение1, Значение2))`. Само условие задаётся
структурой: имена свойств это имена колонок, значения свойств — то, что ищем. Метод
возвращает массив строк таблицы, подходящих под условие, в том же порядке, в каком строки
лежат в таблице, — поэтому «первая подходящая» это просто первый элемент результата.
Готовить что-либо заранее не нужно: поиск работает и без индекса.

**Главная ошибка при переходе: ключ — это набор колонок, а не колонка.** Соблазн — оставить
прежнюю склейку, положив её в отдельную колонку таблицы. Тип коллекции при этом сменится, а
искусственный ключ со всеми своими недостатками останется на месте и вдобавок будет
дублировать данные соседних колонок.

```bsl
// Неправильно: склейка переехала в колонку.
Строки.Колонки.Добавить("Ключ", Новый ОписаниеТипов("Строка", , Новый КвалификаторыСтроки(100)));
СтрокаНабора.Ключ = СтрокаНабора.Идентификатор + Символы.ПС + СтрокаНабора.НомерСтроки
    + Символы.ПС + XMLСтрока(СтрокаНабора.Период);
Найденные = Строки.НайтиСтроки(Новый Структура("Ключ", ИскомыйКлюч));

// Правильно: запись опознаётся набором колонок, каждая со своим типом.
Найденные = Строки.НайтиСтроки(Новый Структура("Идентификатор, НомерСтроки, Период",
    Идентификатор, НомерСтроки, Период));
```

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

**Про индексы — отдельно, потому что это про скорость, а не про правильность.** Сам совет
искать `НайтиСтроки` от индексов не зависит: метод работает и без них, и цикл вместо него не
пишется никогда. Выбор здесь другой — добавлять индекс к таблице или нет. Индекс нужен не
всегда: его построение само стоит времени и памяти, поэтому ради одного-двух поисков его не
заводят — `НайтиСтроки` и без индекса найдёт строки, просто просмотрит их подряд. #std452 п.
1 называет ориентиром тысячу строк и больше, а для таблицы в сотню строк — сотню поисков по
ней; там же сказано, что индексировать имеет смысл только колонки, у которых каждому
значению соответствует немного строк, иначе выигрыша не будет. Если индекс добавляют, есть
условие, о котором легко забыть. Синтакс-помощник платформы 8.3.27 про метод `НайтиСтроки`
говорит дословно:

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

То же сказано в #std452 п. 2.2. Практический вывод: состав колонок индекса должен совпадать
с набором полей в условии поиска — иначе индекс не будет использован, и `НайтиСтроки`
просмотрит строки подряд. Результат при этом останется правильным, изменится только время
работы. Если есть сомнение, срабатывает ли индекс на вашей версии платформы, это проверяется
замером, а не чтением документации.

## Когда это не дефект

- **по одному и тому же ключу обращаются многократно из кода, который сам выполняется много
  раз** — в цикле по строкам документа, в проведении, в регламентном задании по большому списку.
  Тогда соответствие остаётся правильным выбором: выборка из него по ключу не зависит от числа
  элементов, а `НайтиСтроки` по неиндексированной таблице просматривает строки подряд;
- **условие поиска — не равенство:** диапазон дат, вхождение подстроки, сравнение с
  `Неопределено` — `НайтиСтроки` умеет только равенство, и обычный цикл здесь законен;
- **в цикле, кроме поиска, делается работа над каждым элементом** — это обход, а не поиск, и
  правило не про него.

## Что проверяет инструмент

Ничего. Склейку с разделителем-литералом в аргументе `Вставить` или `Получить` по тексту
кода распознать можно, но проверки пока нет.

---
id: qg:AI-19
title: Проверка существования того, что существует всегда
severity: minor
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

Обращение к реквизиту/ТЧ обложено проверкой наличия по метаданным «на всякий случай».

## Почему

Модель, написав обращение к реквизиту или табличной части, часто обкладывает его проверкой
наличия по метаданным — «на всякий случай». Для объектов конфигурации и для собственных
объектов того расширения, где лежит код, она вредна дважды: выдаёт за необязательное то, без
чего механизм не работает, и прячет опечатку в имени под видом штатной ветки — вместо ошибки
получается тихий пропуск части данных.

## Как чинить

#### Неправильно

```bsl
// Табличная часть принадлежит конфигурации, её не может не быть
ТабличнаяЧасть = Метаданные.Документы.РасходДокумент.ТабличныеЧасти.Найти("Строки");
Если ТабличнаяЧасть = Неопределено Тогда
    Возврат Ложь;
КонецЕсли;
```

#### Правильно

```bsl
ТабличнаяЧасть = Метаданные.Документы.РасходДокумент.ТабличныеЧасти.Строки;
Возврат ТабличнаяЧасть.Реквизиты.Найти(ИмяРеквизита) <> Неопределено;  // реквизит из чужого расширения
```

## Когда это не дефект

- проверка уместна ровно в одном случае: объект принадлежит **чужому** расширению, которое
  можно отключить;
- имя объявлено в другом расширении — проверка обязательна, а прямое обращение, наоборот,
  находка: отключение чужого расширения уронит весь механизм, а не одну необязательную
  часть; то же для кода, который заявлен переносимым между конфигурациями.

## Что проверяет инструмент

Ничего. Признак упирается в вопрос «кому принадлежит имя»: тег `ObjectBelonging` для
собственных объектов расширения Конфигуратор не пишет, поэтому принадлежность определяется
по файлам выгрузки — есть ли имя в XML основной конфигурации и в XML какого расширения оно
объявлено. Детектор без этого шага пометит как находку ровно те проверки, которые законны.

---
id: qg:AI-20
title: Результат собственной функции читается цепочкой через точку
severity: minor
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

Результат своей функции читается цепочкой через точку, особенно повторно в методе.

## Почему

`МойМодуль.Суммы(Документ).Деньгами` в одном выражении прячет и сам вызов, и его стоимость: в
отладке негде остановиться и посмотреть, что вернулось, а второе такое же обращение молча
выполняет функцию заново — вместе с запросом внутри неё.

## Как чинить

#### Неправильно

```bsl
Деньгами = РасчетыСервер.СуммыДокумента(Документ, Заказ).Деньгами;
...
Если Остаток > РасчетыСервер.СуммыДокумента(Документ, Заказ).Деньгами Тогда  // второй запрос
```

#### Правильно

```bsl
Суммы = РасчетыСервер.СуммыДокумента(Документ, Заказ);
Деньгами = Суммы.Деньгами;
```

## Когда это не дефект

- результат нужен один-два раза и функция дешёвая — цепочка короче и читается лучше, чем
  переменная, живущая ради одной строки;
- правило не касается платформенной идиоматики: `Запрос.Выполнить().Выбрать()`,
  `Метаданные...Найти()`, `ОбщегоНазначения.ЗначенияРеквизитовОбъекта(...).Реквизит` — это
  устойчивые обороты, а не сокрытие своего вызова.

## Что проверяет инструмент

Ничего. Механически различимый случай — два и более одинаковых разыменования результата
одного и того же вызова в пределах метода либо вызов функции, в теле которой есть
`Новый Запрос`.

---
id: qg:AI-21
title: Индекс известного элемента вычисляется от границы коллекции
severity: minor
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

Элемент известной коллекции берётся расчётом от `ВГраница()` вместо явного индекса.

## Почему

Порядок задан тут же в коде — например, текстом пакетного запроса, — а элемент берётся
расчётом от `ВГраница()`. Выглядит как защита от изменения состава, но защитой не является:
при вставке запроса в середину пакета расчёт так же молча возьмёт не ту таблицу, только
заметить это будет труднее, чем ошибку в явном числе.

## Как чинить

#### Неправильно

```bsl
Пакет = Запрос.ВыполнитьПакет();
Диагностика = Пакет[Пакет.ВГраница() - 1].Выгрузить();
Кандидаты = Пакет[Пакет.ВГраница()].Выгрузить();
```

#### Правильно

```bsl
Пакет = Запрос.ВыполнитьПакет();

// Индексы заданы порядком запросов в тексте: всего 12 запросов, 0-9 - временные таблицы,
// 10 - диагностика, 11 - результат. Меняются только вместе с текстом запроса.
Диагностика = Пакет[10].Выгрузить();
Кандидаты = Пакет[11].Выгрузить();
```

Числовой индекс с комментарием честнее расчёта: он сразу виден и проверяется по тексту
запроса.

## Когда это не дефект

- коллекция собрана динамически — текст запроса склеен из фрагментов по условию, и число
  запросов заранее неизвестно;
- `ВГраница()` как граница цикла — это его прямое назначение, правило не про него.

## Что проверяет инструмент

Ничего. Механически различим узкий случай: `ВГраница()` как индекс той же коллекции,
полученной в этом же методе из `ВыполнитьПакет()` или литерального конструктора.

---
id: qg:AI-22
title: Значение по умолчанию не объявлено в сигнатуре
severity: minor
group: model
tool: null
archetypes: [always]
std: []
---

## Триггер

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

## Почему

Речь о служебном методе: в его параметр во всех точках вызова уходит одно и то же значение —
чаще всего `Неопределено`, `Истина`, `Ложь` или пустая строка. У параметра есть типовое
значение — объяви его в сигнатуре метода. Передавать это значение из каждой точки вызова не
нужно.

**Чем это плохо.** Договорённость «не передали — значит вот это» есть в обоих случаях, но в
первом она нигде не записана: она держится тем, что все вызовы передают одинаковое значение.
Новая точка вызова восстанавливает её по соседнему коду и ошибается молча — метод получает
осмысленное с виду значение и отрабатывает не так, как задумано. Читателю же каждый такой
аргумент приходится сверять с объявлением: значимое это значение или заполнение места.

## Как чинить

#### Неправильно

```bsl
Функция ЗаписиОчереди(Среда, УчитыватьСроки, КлючЗаписи)
    // …
КонецФункции

Записи = ЗаписиОчереди(Среда, Истина, Неопределено);   // регламентное задание
Записи = ЗаписиОчереди(Среда, Ложь, КлючЗаписи);       // команда формы
```

#### Правильно

```bsl
Функция ЗаписиОчереди(Среда, УчитыватьСроки = Истина, КлючЗаписи = Неопределено)
    // …
КонецФункции

Записи = ЗаписиОчереди(Среда);                         // регламентное задание
Записи = ЗаписиОчереди(Среда, Ложь, КлючЗаписи);       // команда формы
```

## Когда это не дефект

- значения по умолчанию у параметра нет по существу: метод обязан получить решение от
  вызывающего, и умолчание скрыло бы забытый аргумент;
- значение передаётся явно ради читаемости там, где смысл иначе неочевиден:
  `Записать(Истина)` рядом с `Записать()` говорит читателю, что режим выбран, а не унаследован;
- параметр стоит в середине списка, а вызывающему нужен следующий за ним: пропуск
  позиционного аргумента (`Метод(А, , В)`) платформа допускает, но читается он хуже явного
  значения — лечится это перестановкой параметра в конец списка, а не отказом от умолчания.

## Что проверяет инструмент

Ничего. Механически правило требует всех точек вызова по проекту: внутри одного файла двух
вызовов слишком мало, чтобы отличить умолчание от совпадения, и проверка на таком основании
давала бы находки на нормальном коде.

---
id: qg:BSL-CONTEXT-CALL-UNNEEDED
title: &НаСервере вместо &НаСервереБезКонтекста
severity: major
group: platform
tool: null
archetypes: [client-server, form-module]
std: []
---

## Триггер

`&НаСервере` там, где метод не читает и не пишет контекст формы.

## Почему

Ненужная передача контекста формы — лишняя нагрузка на вызов там, где она не используется.

## Как чинить

Заменить директиву на `&НаСервереБезКонтекста` и передавать нужные данные параметрами.

#### Неправильно

```bsl
// HIGH: ненужная передача контекста формы
&НаСервере
Функция ПолучитьДанныеНаСервере()
	Возврат ВыполнитьЗапрос();
КонецФункции
```

#### Правильно

```bsl
&НаСервереБезКонтекста
Функция ПолучитьДанныеНаСервере(Параметры)
	Возврат ВыполнитьЗапрос(Параметры);
КонецФункции
```

## Когда это не дефект

- метод читает или пишет реквизиты формы или её элементы;
- метод вызывает другие контекстные методы.

## Что проверяет инструмент

Ничего: инструмента нет. Проверяется чтением тела метода.

---
id: qg:BSL-CORRELATED-SUBQUERY
title: Коррелированный подзапрос в условии
severity: critical
group: platform
tool: null
archetypes: [query]
std: []
---

## Триггер

Вложенный `ВЫБРАТЬ` в `ГДЕ`, ссылающийся на поле внешнего запроса.

## Почему

Влияние: подзапрос выполняется для каждой строки внешнего источника — тот же O(n) обращений,
что и запрос в цикле, только спрятанный внутри одного запроса и потому незаметный при чтении.

## Как чинить

Вынести агрегат во временную таблицу и один раз соединить с ней.

#### Неправильно

```sql
-- CRITICAL: подзапрос вычисляется заново для каждой строки Заказы
ВЫБРАТЬ Заказы.Ссылка
ИЗ Документ.Заказ КАК Заказы
ГДЕ Заказы.Сумма > (ВЫБРАТЬ СРЕДНЕЕ(О.Сумма) ИЗ Документ.Заказ КАК О
                    ГДЕ О.Контрагент = Заказы.Контрагент)
```

#### Правильно

```sql
-- Оптимально: агрегат считается один раз во временной таблице, дальше — соединение
ВЫБРАТЬ Контрагент, СРЕДНЕЕ(Сумма) КАК СредняяСумма
ПОМЕСТИТЬ ВТСредние
ИЗ Документ.Заказ
СГРУППИРОВАТЬ ПО Контрагент
;
ВЫБРАТЬ Заказы.Ссылка
ИЗ Документ.Заказ КАК Заказы
	ВНУТРЕННЕЕ СОЕДИНЕНИЕ ВТСредние КАК Средние
	ПО Заказы.Контрагент = Средние.Контрагент
ГДЕ Заказы.Сумма > Средние.СредняяСумма
```

## Когда это не дефект

- `СУЩЕСТВУЕТ` в условии по индексированному полю на малой таблице; проверка наличия, где
  соединение дало бы дубли;
- **не путать с некоррелированным подзапросом** — тем, который не ссылается на внешние поля и
  вычисляется однократно. Такой подзапрос допустим, хотя временная таблица обычно читается
  лучше.

## Что проверяет инструмент

Ничего: текст запроса — строковый литерал, разбор доступен только чтением.

---
id: qg:BSL-DB-READ-IN-LOOP
title: Чтение базы, достижимое из цикла через вызов
severity: major
group: platform
tool: tools/bsl-lint.mjs
archetypes: [always]
std: [std436, std724]
---

## Триггер

В теле цикла ни одного запроса — чтение прячется в методе, достижимом из цикла через вызов.

## Почему

То же число обращений к базе, что при прямом запросе в цикле, только распределённое по
методам. Чтение прячется за помощником библиотеки или за собственной функцией, цикл остаётся
этажом или двумя выше — и глазами связь не видна: в теле цикла один вызов, в вызванном методе
один запрос, и оба фрагмента по отдельности выглядят нормально.

## Как чинить

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

#### Неправильно

```bsl
// в цикле ни одного запроса — они этажом ниже
Для Каждого Запись Из Записи Цикл
	ОбработатьСтроку(Запись);            // → ПроверитьГотовность(Запись)
КонецЦикла;                              //   → ОбщегоНазначения.ЗначенияРеквизитовОбъекта(…)
```

#### Правильно

```bsl
// данные по всему набору собраны до цикла и переданы внутрь готовыми
Реквизиты = ОбщегоНазначения.ЗначенияРеквизитовОбъектов(ДокументыНабора, "Проведен, ПометкаУдаления");
Для Каждого Запись Из Записи Цикл
	ОбработатьСтроку(Запись, Реквизиты);
КонецЦикла;
```

## Когда это не дефект

- цикл идёт по коллекции, собранной здесь же (`Новый Массив` плюс `Добавить`): обращений в нём
  столько, сколько различных ключей, — ровно ради этого набор и сворачивали;
- вызванный метод живёт в модуле с повторным использованием возвращаемых значений
  (`…ПовтИсп`): повторный вызов дёшев. Первый при этом платный, а результат живёт до конца
  сеанса — если значение должно быть строго на момент выполнения, кэш не подходит (#std724,
  тот же разбор в `AI-09.md`);
- чтение стоит в теле самого цикла — случай `bslls:CreateQueryInCycle`, соседний признак
  `qg:BSL-QUERY-IN-LOOP`.

## Что проверяет инструмент

`qg:BSL-DB-READ-IN-LOOP` (`tools/bsl-lint.mjs`), 🟠 — из тела цикла достижим (через вызовы,
глубина до 4) метод, в теле которого есть `Новый Запрос`, чтение реквизитов помощником
библиотеки, поиск по коду или наименованию, чтение константы либо среза регистра сведений.
**Правило не перекрывает `bslls:CreateQueryInCycle`, а дополняет его.** Та диагностика ловит
`Новый Запрос` **прямо в теле цикла**; здесь проверка начинается с первого вызова, иначе на
одну строку приходили бы две находки и одну из них справедливо отключили бы.

**Чего не ловит.** `ПолучитьОбъект` и `Прочитать()` в список обращений намеренно не входят:
обработка, меняющая каждый элемент набора, обязана прочитать каждый объект — это работа над
разными данными, а не повторное чтение одних и тех же. На корпусе в 114 общих модулей двух
расширений эти два маркера дали больше половины находок, и все они были формой «прочитать
документ, чтобы его записать». Не видны и вызовы по вычисляемому имени.

**Граф вызовов строится только по файлам одного прогона.** Метод из модуля, который в прогон
не попал, инструменту не виден: вердикт «чисто» здесь означает «в переданном составе цепочек
не нашлось», а не «чтений из цикла нет».

**Достижимость — не место.** Инструмент утверждает, что из цикла есть путь до чтения, но не
то, что чтение выполняется на каждом витке: в вызванном методе оно может стоять до его
собственного цикла и выполняться однократно. Цепочку из текста находки нужно пройти глазами.

---
id: qg:BSL-DEEP-NESTING
title: Глубокая вложенность
severity: minor
group: platform
tool: null
archetypes: [always]
std: []
---

## Триггер

Более 4 уровней вложенности условий и циклов в одном методе.

## Почему

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

## Как чинить

Применять ранний выход из метода — см. `bsl-refactoring.md`.

## Когда это не дефект

- вложенность образована одним длинным условием с `И`, а не лестницей;
- обработчик с обязательной структурой платформы (например, `Попытка` внутри цикла внутри
  транзакции).

## Что проверяет инструмент

Ничего: инструмента нет. Проверяется чтением тела метода — подсчётом уровней вложенности.

---
id: qg:BSL-DISPATCH-NO-FALLBACK
title: Разбор значения по веткам без завершающего «Иначе»
severity: major
group: platform
tool: tools/bsl-lint.mjs
archetypes: [always]
std: []
---

## Триггер

Цепочка `Если … ИначеЕсли …` по значениям/типам в трёх и более ветках без `Иначе`.

## Почему

Цепочка `Если … ИначеЕсли …`, перебирающая значения перечисления или типы документа, — это
разбор: автор перечислил случаи, которые знал. Значение, не попавшее ни в одну ветку — новое
значение перечисления, незаполненная ссылка, запись, поставленная вручную, — проходит цепочку
молча, и метод работает дальше так, будто разбор состоялся.

Дальше происходит одно из двух. Либо падение в месте, не связанном с причиной: переменная
осталась неинициализированной, и текст ошибки говорит про `Выгрузить()`, а не про неучтённый
тип. Либо, что хуже, падения нет вовсе: в коде, который отправляет документ во внешнюю систему,
проводит или пробивает фискальный чек, необработанное значение означает пропуск проверки —
действие выполняется, а разбор, который должен был его запретить, не выполнялся.

**Порог — три ветки.** Две ветки без `Иначе` — обычная двоичная развилка («если аванс — так,
если нет — эдак»), и требование закрывать её дало бы находку в каждом втором модуле.

## Как чинить

#### Неправильно

```bsl
Функция ПолучитьДанныеДокумента(Документ)
    Если ТипЗнч(Документ) = Тип("ДокументСсылка.ЗаявкаНаВозвратТоваровОтКлиента") Тогда
        РезультатЗапроса = ВыгрузитьЗаявкуНаВозврат(Документ);
    ИначеЕсли ТипЗнч(Документ) = Тип("ДокументСсылка.ЗаказНаПеремещение") Тогда
        РезультатЗапроса = ВыгрузитьЗаказНаПеремещение(Документ);
    ИначеЕсли ТипЗнч(Документ) = Тип("ДокументСсылка.ЗаказПоставщику") Тогда
        РезультатЗапроса = ВыгрузитьЗаказПоставщику(Документ);
    КонецЕсли;

    ТаблицаСтрок = РезультатЗапроса.Выгрузить();   // четвёртый тип: «Значение не является
                                                   // значением объектного типа»
```

#### Правильно

```bsl
    ИначеЕсли ТипЗнч(Документ) = Тип("ДокументСсылка.ЗаказПоставщику") Тогда
        РезультатЗапроса = ВыгрузитьЗаказПоставщику(Документ);
    Иначе
        ВызватьИсключение СтрШаблон(
            НСтр("ru = 'Документ %1 контуру неизвестен: выгрузка для его типа не описана.'"), Документ);
    КонецЕсли;
```

**Лечение — ветка `Иначе` с явным решением**, а не с пустым телом. Три законные формы: отказ
с текстом, называющим неучтённое значение; значение по умолчанию, записанное явно; запись в
журнал регистрации, если работу можно продолжать. Пустой `Иначе` тем и плох, что выглядит
принятым решением, не будучи им.

## Когда это не дефект

- у цепочки есть `Иначе` — неважно, что в нём: решение о неучтённом значении принято;
- охранная форма: каждая ветка заканчивается `Возврат`, а после `КонецЕсли` в том же методе
  стоит `Возврат` или `ВызватьИсключение`. Формально ветки `Иначе` нет, по существу умолчание
  есть, и оно стоит на видном месте;
- веток меньше трёх либо в них сравниваются разные выражения: это не перебор одного признака,
  а последовательность независимых условий.

## Что проверяет инструмент

Проверка: `qg:BSL-DISPATCH-NO-FALLBACK` (`tools/bsl-lint.mjs`), 🟠 — одно и то же выражение
сравнивается со значениями перечисления либо с типом в трёх и более ветках одной цепочки, а
ветки `Иначе` у цепочки нет.

**Чего не ловит.** Перебор строковых кодов и чисел: у сравнения с литералом нет признака,
отличающего разбор от обычного условия, и правило дало бы находку на любом ветвлении. Не
разбирается и обратный порядок сравнения (`Перечисления.ТипыЧеков.Аванс = Запись.ТипЧека`) —
в прикладном коде он не встречается. Что делает ветка, инструмент не смотрит: цепочка перед
записью в базу и цепочка, после которой метод сразу возвращает значение, для него одинаковы.

---
id: qg:BSL-ENUM-STRING-ASSIGN
title: Примитив в поле строго ссылочного типа
severity: major
group: platform
tool: tools/bsl-lint.mjs
archetypes: [always]
std: []
---

## Триггер

Присваивание примитива (`""`, `0`, `Ложь`, `Истина`) полю строго ссылочного типа.

## Почему

Сборка на это молчит — тела модулей не компилируются, — и падение приходит при записи, часто в
редко исполняемой ветке. В живом расширении класс выглядел так: одно `= ""` против семнадцати
корректных `.ПустаяСсылка()` по соседству — след смены типа реквизита, при которой код не
пересмотрели.

## Как чинить

#### Неправильно

```bsl
// HIGH: реквизит имеет тип ПеречислениеСсылка.СтатусыДоставки
Запись.СтатусДоставки = "";
```

#### Правильно

```bsl
Запись.СтатусДоставки = Перечисления.СтатусыДоставки.ПустаяСсылка();
```

## Когда это не дефект

- Составные типы: у поля «Строка или Ссылка» присваивание `""` законно;
- сравнение вместо присваивания (`Если Запись.Статус = "" Тогда`) — другой класс: оно всегда
  ложно, но записи не роняет;
- приёмник инструмент не разрешает: если `Запись` — структура с одноимённым ключом, находка
  ложная, и это сказано в её тексте.

## Что проверяет инструмент

Проверяется механически: `qg:BSL-ENUM-STRING-ASSIGN` (`tools/bsl-lint.mjs`), 🟠.

---
id: qg:BSL-FORM-ATTR-SHADOW
title: Локальная переменная под именем реквизита формы
severity: critical
group: platform
tool: tools/bsl-lint.mjs
archetypes: [form-module]
std: []
---

## Триггер

Переменная с именем реквизита формы получает объектное значение — пишет реквизит, не переменную.

## Почему

В модуле управляемой формы имя реквизита — свойство самой формы. Присваивание локальную
переменную НЕ создаёт: значение уходит в реквизит и приводится к его типу, поэтому обращение
через точку падает. Локальное имя создают только объявление `Перем`, параметр метода и
переменная цикла — потому обработчик `Процедура Завершение(Результат, ДопПараметры)` работает
и переименования не требует.

Коварство в выборочности: половина методов модуля исправна, половина падает, и по симптому
это читается как случайный сбой. Разницу даёт директива компиляции — в `…БезКонтекста`
контекста формы нет.

Не ловится ничем, кроме исполнения: анализатор молчит, `form-validate` доволен, сборка `.epf`
проходит (тела модулей она не компилирует), стандарта на такую коллизию на v8std нет вовсе.
Случай из практики: три разные обработки одного проекта за два дня, все три — реквизит-журнал
с именем `Результат` и одноимённые локальные переменные почти в каждой функции.

## Как чинить

```bsl
// Реквизит формы «Результат» — строка, журнал прогона.

&НаСервере
Функция ПодготовитьКонтекст()
    Результат = Новый Структура;             // пишет В РЕКВИЗИТ, а не в переменную
    Результат.Вставить("Границы", Границы);  // «Значение не является значением объектного типа»
    Возврат Результат;
КонецФункции

&НаСервереБезКонтекста
Функция ОписаниеПериода()
    Результат = Новый Структура;             // здесь контекста формы нет — работает
    Возврат Результат;
КонецФункции
```

**Лечение — переименование реквизита**, а не переменных: реквизит один, переменных десятки.
Имя ему давать предметное (`Журнал`), а не «Результат»: именно универсальные имена
сталкиваются с локальными.

## Когда это не дефект

- директива без контекста формы (`…БезКонтекста`);
- имя, объявленное параметром или `Перем`;
- реквизит непримитивного типа (у таблицы формы обращение через точку законно);
- присваивание примитива — намеренная запись в реквизит;
- явное `ЭтотОбъект.<Имя>`;
- обращение через точку выше присваивания;
- имя КОЛОНКИ реквизита-таблицы реквизитом формы не является и в проверку не попадает.

## Что проверяет инструмент

Проверка: `qg:BSL-FORM-ATTR-SHADOW` (`tools/bsl-lint.mjs`), 🔴 — реквизит примитивного типа из
`Ext/Form.xml` получает объектное значение (`Новый …` либо результат вызова) в методе с
контекстом формы, и ниже к нему обращаются через точку.

**Чего не ловит.** Присваивание ПРИМИТИВА с последующим обращением через точку — тоже падение,
но по нему не отличить путаницу с реквизитом от намеренной записи в него, и правило такой
случай пропускает намеренно. Не видит оно и коллизии по реквизиту составного типа, и модуль,
у которого рядом нет `Ext/Form.xml` (в последнем случае говорит об этом записью следа, а не
молчит). Реквизит объекта обработки, доступный в модуле формы через `Объект.<Имя>`, к этому
классу не относится: там обращение через точку обязательно.

---
id: qg:BSL-MESSAGE-AS-NOTIFY
title: Сообщить() как механизм уведомления
severity: major
group: platform
tool: null
archetypes: [always]
std: []
---

## Триггер

`Сообщить(...)` вместо `ОбщегоНазначения.СообщитьПользователю` или записи в журнал регистрации.

## Почему

Влияние: сообщение не привязано к объекту и полю, не попадает в журнал регистрации, теряется
в фоновом задании и не может быть обработано вызывающим кодом. При выполнении на сервере
пользователь может не увидеть его вовсе.

**Правило разделения:** сообщение пользователю — через механизм с привязкой к реквизиту;
диагностика для разбора инцидентов — в журнал регистрации. `Сообщить()` не делает ни того,
ни другого.

## Как чинить

#### Неправильно

```bsl
// HIGH: сообщение никуда не привязано и нигде не сохранено
Сообщить("Не заполнен склад");
```

#### Правильно

```bsl
// Оптимально: привязка к объекту и полю — пользователь видит, где именно ошибка
ОбщегоНазначения.СообщитьПользователю("Не заполнен склад", , "Объект.Склад", , Отказ);

// Для диагностики, а не для пользователя — журнал регистрации
ЗаписьЖурналаРегистрации("Загрузка.Ошибка", УровеньЖурналаРегистрации.Ошибка, , ,
	ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()));
```

## Когда это не дефект

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

## Что проверяет инструмент

Ничего: инструмента нет. Проверяется чтением тела метода.

---
id: qg:BSL-MULTI-SERVER-CALLS
title: Множественные клиент-серверные вызовы
severity: major
group: platform
tool: null
archetypes: [client-server, form-module]
std: []
---

## Триггер

Несколько последовательных `...НаСервере()`-вызовов подряд с клиента в одном обработчике.

## Почему

Несколько серверных вызовов вместо одного — каждый вызов платит за отдельный клиент-серверный
переход.

## Как чинить

Собрать данные на сервере одним вызовом и вернуть структурой.

#### Неправильно

```bsl
// HIGH: несколько серверных вызовов вместо одного
&НаКлиенте
Процедура Обработать(Команда)
	Данные1 = ПолучитьДанные1НаСервере();
	Данные2 = ПолучитьДанные2НаСервере();
	Данные3 = ПолучитьДанные3НаСервере();
КонецПроцедуры
```

#### Правильно

```bsl
&НаКлиенте
Процедура Обработать(Команда)
	ВсеДанные = ПолучитьВсеДанныеНаСервере();
КонецПроцедуры

&НаСервереБезКонтекста
Функция ПолучитьВсеДанныеНаСервере()
	Результат = Новый Структура;
	Результат.Вставить("Данные1", ПолучитьДанные1());
	Результат.Вставить("Данные2", ПолучитьДанные2());
	Результат.Вставить("Данные3", ПолучитьДанные3());
	Возврат Результат;
КонецФункции
```

## Когда это не дефект

- вызовы разделены ожиданием ответа пользователя (диалог между ними);
- второй вызов зависит от результата первого и выполняется не всегда.

## Что проверяет инструмент

Ничего: инструмента нет. Проверяется чтением модуля формы.

---
id: qg:BSL-NESTED-LOOP-SEARCH
title: Алгоритм O(n²)
severity: minor
group: platform
tool: null
archetypes: [always]
std: []
---

## Триггер

Вложенный цикл поиска совпадений между двумя коллекциями вместо `Соответствие`.

## Почему

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

## Как чинить

Построить индекс по ключу одной коллекции через `Соответствие` и искать по нему.

#### Неправильно

```bsl
// MEDIUM: вложенный цикл поиска — экспоненциальная деградация
Для Каждого Строка1 Из Таблица1 Цикл
	Для Каждого Строка2 Из Таблица2 Цикл
		Если Строка1.Ключ = Строка2.Ключ Тогда
			// Обработка
		КонецЕсли;
	КонецЦикла;
КонецЦикла;
```

#### Правильно

```bsl
// Оптимально: O(n) через Соответствие
ИндексТаблицы2 = Новый Соответствие;
Для Каждого Строка2 Из Таблица2 Цикл
	ИндексТаблицы2.Вставить(Строка2.Ключ, Строка2);
КонецЦикла;

Для Каждого Строка1 Из Таблица1 Цикл
	Строка2 = ИндексТаблицы2.Получить(Строка1.Ключ);
	Если Строка2 <> Неопределено Тогда
		// Обработка
	КонецЕсли;
КонецЦикла;
```

## Когда это не дефект

- обе коллекции до 50 элементов;
- внешняя коллекция обходится один раз, а внутренняя уже соответствие.

## Что проверяет инструмент

Ничего: инструмента нет. Проверяется чтением тела метода.

---
id: qg:BSL-NO-CACHE
title: Отсутствие кеширования
severity: minor
group: platform
tool: null
archetypes: [always]
std: []
---

## Триггер

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

## Почему

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

## Как чинить

Кешировать через `Соответствие`.

#### Неправильно

```bsl
// MEDIUM: повторные дорогие вызовы
Для Каждого Строка Из ТаблицаДанных Цикл
	Курс = ПолучитьКурсВалюты(Строка.Валюта, Строка.Дата);
КонецЦикла;
```

#### Правильно

```bsl
// Оптимально: кеширование через Соответствие
КэшКурсов = Новый Соответствие;
Для Каждого Строка Из ТаблицаДанных Цикл
	Ключ = Строка.Валюта + "|" + Формат(Строка.Дата, "ДФ=yyyyMMdd");
	Курс = КэшКурсов.Получить(Ключ);
	Если Курс = Неопределено Тогда
		Курс = ПолучитьКурсВалюты(Строка.Валюта, Строка.Дата);
		КэшКурсов.Вставить(Ключ, Курс);
	КонецЕсли;
КонецЦикла;
```

## Когда это не дефект

- вызов дешёвый (чтение константы модуля, арифметика);
- вызов с побочным эффектом;
- параметры между вызовами меняются.

## Что проверяет инструмент

Ничего: инструмента нет. Проверяется чтением тела метода.

---
id: qg:BSL-NO-TOP-LIMIT
title: Отсутствие ПЕРВЫЕ N
severity: major
group: platform
tool: null
archetypes: [query]
std: []
---

## Триггер

Большой запрос без `ПЕРВЫЕ N` — загрузка всех записей без ограничения.

## Почему

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

## Как чинить

Добавить `ПЕРВЫЕ N` вместе с `УПОРЯДОЧИТЬ ПО` (порядок строк — соседний признак
`qg:QRY-TOP-WITHOUT-ORDER`).

#### Неправильно

```sql
-- HIGH: загрузка всех записей без ограничения
ВЫБРАТЬ
	Контрагенты.Ссылка КАК Ссылка
ИЗ
	Справочник.Контрагенты КАК Контрагенты
```

#### Правильно

```sql
ВЫБРАТЬ ПЕРВЫЕ 10
	Контрагенты.Ссылка КАК Ссылка
ИЗ
	Справочник.Контрагенты КАК Контрагенты
УПОРЯДОЧИТЬ ПО
	Контрагенты.Наименование
```

## Когда это не дефект

- запрос по ключу с заведомо одной строкой;
- запрос с агрегатами без группировки;
- запрос уже ограничен параметрами периода и отбора.

## Что проверяет инструмент

Ничего: текст запроса — строковый литерал, разбор доступен только чтением. Порядок строк при
ограничении проверяется отдельно и механически — `qg:QRY-TOP-WITHOUT-ORDER`.

---
id: qg:BSL-QUERY-IN-LOOP
title: Запрос в цикле
severity: critical
group: platform
tool: null
archetypes: [always]
std: []
---

## Триггер

`Для Каждого` с `Новый Запрос` внутри тела цикла — обращение к базе на каждой итерации.

## Почему

Влияние: O(n) обращений к БД вместо O(1) — при N итерациях цикла выполняется N обращений к
базе данных вместо одного.

## Как чинить

Собрать ключи до цикла и выполнить один запрос с условием `В (&СписокСсылок)`.

#### Неправильно

```bsl
// CRITICAL: N обращений к БД
Для Каждого Строка Из Данные Цикл
	Запрос = Новый Запрос("ВЫБРАТЬ ... ГДЕ Ссылка = &Ссылка");
	Запрос.УстановитьПараметр("Ссылка", Строка.Ссылка);
	РезультатЗапроса = Запрос.Выполнить();
КонецЦикла;
```

#### Правильно

```bsl
// Оптимально: 1 обращение к БД
Запрос = Новый Запрос;
Запрос.Текст =
"ВЫБРАТЬ ...
|ГДЕ
|	Ссылка В (&СписокСсылок)";
Запрос.УстановитьПараметр("СписокСсылок",
	Данные.ВыгрузитьКолонку("Ссылка"));
РезультатЗапроса = Запрос.Выполнить();
```

## Когда это не дефект

- цикл по пакетам, где один запрос обрабатывает пакет строк (пакетная схема);
- цикл по узлам обмена или базам, у которых разные источники;
- запрос с разными текстами на витке.

## Что проверяет инструмент

Ничего в этом наборе инструментов: прямую форму (`Новый Запрос` в теле цикла) ловит статический
анализатор — диагностика `bslls:CreateQueryInCycle`. Чтение, достижимое из цикла через вызов
метода, а не напрямую, покрывает соседний признак `qg:BSL-DB-READ-IN-LOOP`.

---
id: qg:BSL-REF-DOT-ACCESS
title: Обращение к реквизитам через точку
severity: critical
group: platform
tool: tools/bsl-lint.mjs
archetypes: [always]
std: [std437, std453]
---

## Триггер

`.Реквизит` у ссылочного значения — загрузка всего объекта из БД ради одного поля.

## Почему

Влияние: загрузка всего объекта из БД. `qg:BSL-REF-DOT-ACCESS` доказывает ссылочность тремя
способами, и каждое основание печатается в тексте находки — они разной силы:

| Основание | Пример | Sev |
|---|---|---|
| присваивание в этом же методе | `Заказ = Выборка.Ссылка;` далее `Заказ.Контрагент` | 🔴 |
| описание метода #std453 | `// УчётнаяЗапись - СправочникСсылка.УчётныеЗаписи - …` | 🟠 |
| имя оканчивается на «Ссылка» | `ЗаказКлиентаСсылка.Дата` | 🔴 |

Доказательство живёт от присваивания до следующего: `Заказ = Выборка.Ссылка` → чтение
реквизитов → `Заказ = Заказ.ПолучитьОбъект()` — находки будут только в середине, у объекта
точка законна. Описание метода даёт 🟠, а не 🔴, потому что комментарий переживает смену типа
параметра, а код нет.

**Имена переменных с именами объектов конфигурации инструмент не сопоставляет.** Переменную
называют как угодно, и такое сопоставление давало бы находки на совпадении слов, а не на типе
значения.

Статический анализатор эту форму не видит в принципе: чтобы понять, что база цепочки —
ссылка, нужен вывод типов через границы методов и модулей, а синтаксически `Структура.Ключ.Поле`
неотличимо от обращения к вложенной структуре. До появления правила проверка закрывалась
только чтением глазами — и её вердикт «чисто» ничем не фальсифицировалось.

## Как чинить

Методы БСП:

| Метод | Назначение |
|---|---|
| `ОбщегоНазначения.ЗначениеРеквизитаОбъекта` | Один реквизит одной ссылки |
| `ОбщегоНазначения.ЗначенияРеквизитовОбъекта` | Несколько реквизитов одной ссылки |
| `ОбщегоНазначения.ЗначениеРеквизитаОбъектов` | Один реквизит нескольких ссылок |

#### Неправильно

```bsl
// CRITICAL: полная загрузка объекта для каждого реквизита
ИНН         = Контрагент.ИНН;
КПП         = Контрагент.КПП;
Наименование = Контрагент.Наименование;
```

#### Правильно

```bsl
// Оптимально: один целевой запрос через БСП
Реквизиты    = ОбщегоНазначения.ЗначенияРеквизитовОбъекта(
	Контрагент, "ИНН, КПП, Наименование");
ИНН          = Реквизиты.ИНН;
КПП          = Реквизиты.КПП;
Наименование = Реквизиты.Наименование;
```

## Когда это не дефект

- вызов метода (`Ссылка.ПолучитьОбъект()`, `Ссылка.Пустая()`) — объект при этом читается
  осознанно и целиком;
- `Ссылка.Ссылка` — поле возвращает саму ссылку без чтения;
- элементы отбора (`Отбор.Ссылка.Значение`, `НаборЗаписей.Отбор.Регистратор.Использование`) —
  имя сегмента совпадает с именем реквизита по построению;
- менеджеры (`Документы.ЗаказКлиента.ПустаяСсылка()`);
- текст запроса — там действует своя диагностика.

## Что проверяет инструмент

Механизированная часть: `qg:BSL-REF-DOT-ACCESS` (`tools/bsl-lint.mjs`) — три основания из
таблицы выше. Это **нижняя граница** проверки #std437, а не верхняя: ссылка, пришедшая
параметром недокументированного метода или из чужой функции, остаётся неопознанной — разбор
глазами инструмент не отменяет.

---
id: qg:BSL-STALE-LOCAL-CALL
title: Вызов метода, объявление которого исчезло из модуля
severity: critical
group: platform
tool: tools/rename-check.mjs
archetypes: [always]
std: []
---

## Триггер

Вызов метода, чьё объявление было в HEAD и исчезло после правки.

## Почему

Ловится это плохо, и случай из практики показывает, чем именно: гейт был чист, `bsl-analyzer`
дал 29 диагностик и ни одной про этот вызов, сборка внешней обработки прошла с кодом 0 — тела
модулей она не компилирует, — а форма упала при первом открытии: «Процедура или функция с
указанным именем не определена».

## Как чинить

Довести переименование до всех точек вызова: найти оставшиеся обращения к старому имени и
привести их к новому — либо, если правка ошибочна, вернуть прежнее объявление.

```bsl
// было в HEAD
Процедура ОбновитьСводкуНаСервере()

// стало после рефакторинга
Функция ТекстСводки()

// а вызов остался прежним — модуль не скомпилируется
ОбновитьСводкуНаСервере();
```

## Когда это не дефект

- метод, оставшийся в модуле базовой формы или в расширяемом модуле, — вызов законен, и
  близнец из основной конфигурации проверяется;
- вхождение имени в комментарии и в строковом литерале вызовом не считается;
- вызов через точку не разбирается вовсе — это зона `UnresolvedMethodCall` анализатора.

## Что проверяет инструмент

Прямая проверка «имя не разрешается» здесь не строится: она требует словаря глобального
контекста платформы (замер на живом проекте — 281 различное имя после всех исключений), а
каждое пропущенное имя словаря даёт взрыв ложных 🔴. Отдельно мешает слияние модулей
расширения с расширяемым: 1 837 голых вызовов разрешаются только через базовый модуль,
которого в репозитории расширения может не быть вовсе.

Поэтому проверка инверсная: `qg:BSL-STALE-LOCAL-CALL` (`tools/rename-check.mjs`), 🔴 —
сравнивается текущий файл с его же версией в HEAD. Имя, которое ЭТОТ модуль объявлял до
правки, платформенным глобальным быть не могло, и словарь не нужен.

**Чего не ловит.** Вызов имени, которого не было никогда (опечатка в новом коде), и вызов,
протухший в прежних коммитах: сравнение идёт с HEAD, а не по всей истории. Третий случай
важнее обоих на правках форм: обработчик, названный СТРОКОЙ, —
`Новый ОписаниеОповещения("СтароеИмя", ЭтотОбъект)`, `ПодключитьОбработчикОжидания("СтароеИмя", 1)`.
Литералы гасятся до разбора (иначе текст сообщения стал бы вызовом), поэтому переименование,
разведённое по строкам, инструмент не увидит, а платформа уронит уже в работе, а не при
компиляции. Проверка закрывает класс «переименовал и не довёл до голых вызовов», а не
разрешение имён целиком.

---
id: qg:BSL-SUBQUERY-IN-SELECT
title: Подзапрос в SELECT
severity: critical
group: platform
tool: null
archetypes: [query]
std: []
---

## Триггер

Вложенный `ВЫБРАТЬ` в списке полей — считается заново для каждой строки внешнего запроса.

## Почему

Влияние: выполнение N+1 запросов.

## Как чинить

Заменить подзапрос временной таблицей и соединением.

#### Неправильно

```sql
-- CRITICAL: подзапрос выполняется для каждой строки
ВЫБРАТЬ
	Заказы.Ссылка,
	(ВЫБРАТЬ СУММА(Оплаты.Сумма)
	 ИЗ Документ.Оплата КАК Оплаты
	 ГДЕ Оплаты.Заказ = Заказы.Ссылка) КАК СуммаОплат
ИЗ
	Документ.Заказ КАК Заказы
```

#### Правильно

```sql
-- Оптимально: временная таблица + соединение
ВЫБРАТЬ
	Оплаты.Заказ КАК Заказ,
	СУММА(Оплаты.Сумма) КАК СуммаОплат
ПОМЕСТИТЬ ВТИтогиОплат
ИЗ
	Документ.Оплата КАК Оплаты
СГРУППИРОВАТЬ ПО
	Оплаты.Заказ
ИНДЕКСИРОВАТЬ ПО
	Заказ
;
ВЫБРАТЬ
	Заказы.Ссылка КАК Ссылка,
	ЕСТЬNULL(ИтогиОплат.СуммаОплат, 0) КАК СуммаОплат
ИЗ
	Документ.Заказ КАК Заказы
	    ЛЕВОЕ СОЕДИНЕНИЕ ВТИтогиОплат КАК ИтогиОплат
	    ПО Заказы.Ссылка = ИтогиОплат.Заказ
```

## Когда это не дефект

- подзапрос по константе или параметру без связи с внешней строкой (вычисляется один раз).

## Что проверяет инструмент

Ничего: текст запроса — строковый литерал, разбор доступен только чтением.

---
id: qg:BSL-TEMPTABLE-NO-INDEX
title: Временная таблица без индекса в соединении
severity: major
group: platform
tool: null
archetypes: [query]
std: []
---

## Триггер

`ПОМЕСТИТЬ ВТ...` без `ИНДЕКСИРОВАТЬ ПО`, а таблица дальше участвует в соединении.

## Почему

Влияние: соединение по неиндексированному полю временной таблицы даёт полный перебор её строк
на каждую строку второго источника. На больших выборках это основная причина того, что «запрос
без единой ошибки работает минуты».

## Как чинить

Добавить `ИНДЕКСИРОВАТЬ ПО` по полю, задействованному в соединении.

#### Неправильно

```sql
-- HIGH: ВТ соединяется по Номенклатура, но индекса нет
ВЫБРАТЬ Номенклатура, Количество ПОМЕСТИТЬ ВТОстатки ИЗ ...
```

#### Правильно

```sql
ВЫБРАТЬ Номенклатура, Количество ПОМЕСТИТЬ ВТОстатки ИЗ ...
ИНДЕКСИРОВАТЬ ПО Номенклатура
```

## Когда это не дефект

- временная таблица до 100 строк;
- таблица, которая далее не участвует в соединении;
- таблица заведомо мала (десятки строк) либо используется однократно без соединений —
  построение индекса тогда дороже выигрыша.

## Что проверяет инструмент

Ничего: текст запроса — строковый литерал, разбор доступен только чтением.

---
id: qg:BSL-TXN-IN-HANDLER
title: Своя транзакция внутри неявной транзакции обработчика
severity: major
group: platform
tool: tools/bsl-lint.mjs
archetypes: [transaction, object-event]
std: [std783]
---

## Триггер

Своя `НачатьТранзакцию` внутри обработчика, который платформа уже выполняет в транзакции.

## Почему

Влияние: платформа открывает транзакцию сама — вокруг записи и удаления ссылочного объекта
(`ПередЗаписью` → запись → `ПриЗаписи`), вокруг проведения (`ОбработкаПроведения`) и вокруг
записи набора записей. Вложенных транзакций платформа **не поддерживает**: собственная
`НачатьТранзакцию` внутри обработчика создаёт видимость точки сохранения, а
`ОтменитьТранзакцию` отменяет внешнюю транзакцию целиком. Дальше внешний код продолжает
работать с уже отменённой транзакцией и получает «В этой транзакции уже происходили ошибки» —
в месте, никак не связанном с причиной. Якорь: **#std783 п. 1.4 и 1.4.1**.

Обработчиков, внутри которых транзакция уже открыта платформой, ровно пять: `ПередЗаписью`,
`ПриЗаписи`, `ПередУдалением`, `ОбработкаПроведения`, `ОбработкаУдаленияПроведения`. Удаление и
отмена проведения в этот список входят наравне с записью — их обычно и забывают.

## Как чинить

#### Неправильно

```bsl
// HIGH: транзакция внутри обработчика, который платформа и так выполняет в транзакции
Процедура ОбработкаПроведения(Отказ, РежимПроведения)

	НачатьТранзакцию();
	Попытка
		Движения.ТоварыНаСкладах.Записать();
		ЗафиксироватьТранзакцию();
	Исключение
		ОтменитьТранзакцию();   // отменяет транзакцию ПРОВЕДЕНИЯ, а не «свою»
	КонецПопытки;

КонецПроцедуры
```

#### Правильно

```bsl
// Правильно: обработчик работает в уже открытой транзакции, отказ выражается через Отказ
Процедура ОбработкаПроведения(Отказ, РежимПроведения)

	Движения.ТоварыНаСкладах.Записывать = Истина;
	// ... заполнение движений; при ошибке — Отказ = Истина и ВызватьИсключение

КонецПроцедуры
```

Отдельная транзакция нужна вызывающему коду — там, где несколько объектов пишутся атомарно.
Тогда её открывают **снаружи**, до `Записать()`, по паттерну #std783 п.1.3.

## Когда это не дефект

- `ПередЗаписью` **модуля формы** — другое событие, транзакции вокруг него нет, и
  `НачатьТранзакцию` там законна. Инструмент модули форм не проверяет; при разборе глазами не
  спутай их по совпадению имени обработчика.

## Что проверяет инструмент

Проверяется механически: `qg:BSL-TXN-IN-HANDLER` (`tools/bsl-lint.mjs`), 🟠. Инструмент
смотрит модули объекта и набора записей; вынесенную в общий модуль логику он не видит.

---
id: qg:BSL-TXN-INSIDE-TRY
title: НачатьТранзакцию() внутри Попытка
severity: major
group: platform
tool: null
archetypes: [transaction]
std: [std783]
---

## Триггер

`Попытка` раньше `НачатьТранзакцию()` в одном блоке.

## Почему

`ОтменитьТранзакцию()` вызовется в обработчике исключения, даже если `НачатьТранзакцию()` не
успела выполниться — например, исключение произошло до неё.

## Как чинить

`НачатьТранзакцию()` должна стоять строго до `Попытка`.

#### Неправильно

```bsl
// HIGH: ОтменитьТранзакцию() вызовется, даже если НачатьТранзакцию() не выполнялась
Попытка
	НачатьТранзакцию();
	// ...
	ЗафиксироватьТранзакцию();
Исключение
	ОтменитьТранзакцию();
КонецПопытки;
```

#### Правильно

```bsl
// Правильно: НачатьТранзакцию() строго ДО Попытка
НачатьТранзакцию();
Попытка
	// ...
	ЗафиксироватьТранзакцию();
Исключение
	ОтменитьТранзакцию();
	ЗаписьЖурналаРегистрации(
		"Модуль.Функция",
		УровеньЖурналаРегистрации.Ошибка, , ,
		ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()));
	ВызватьИсключение;
КонецПопытки;
```

## Когда это не дефект

- `НачатьТранзакцию()` стоит строго до `Попытка`, а `ОтменитьТранзакцию()` — в `Исключение`:
  это штатная форма по #std783, находки нет. Дефект — только когда открытие транзакции попало
  внутрь блока `Попытка`: тогда `ОтменитьТранзакцию()` в `Исключение` может выполниться по
  исключению, возникшему до `НачатьТранзакцию()`, и уронить чужую транзакцию либо упасть само.
- Внешняя `Попытка` оборачивает целый метод ради записи в журнал регистрации или преобразования
  ошибки, а транзакция внутри оформлена штатно (своя `Попытка` ниже `НачатьТранзакцию()`,
  `ОтменитьТранзакцию()` в её `Исключение`): вложенность блоков здесь не признак, важен порядок
  внутри транзакционного блока.

## Что проверяет инструмент

Ничего: инструмента нет. Проверяется чтением тела метода.

---
id: qg:BSL-UNBOUNDED-STRING-COLUMN
title: Строковая колонка без квалификатора у таблицы-параметра запроса
severity: major
group: platform
tool: tools/bsl-lint.mjs
archetypes: [query]
std: [std432]
---

## Триггер

Колонка ТЗ без `КвалификаторыСтроки` уходит в запрос через `УстановитьПараметр`.

## Почему

Колонка неограниченной длины ломает `РАЗЛИЧНЫЕ`, `СГРУППИРОВАТЬ ПО`, соединение и сравнение в
`ГДЕ` — движок запросов не умеет сравнивать поля неограниченной длины там, где значения нужно
сопоставлять между собой. Полный разбор со всеми сообщениями об ошибках и якорем #std432 п. 3.1
— в `AI-16.md`.

## Как чинить

`Новый ОписаниеТипов("Строка", , Новый КвалификаторыСтроки(N))` — образец и оба случая
(неправильно/правильно) в `AI-16.md`.

## Когда это не дефект

- передача таблицы в чужой метод: инструмент видит только тот же модуль, что не значит
  «дефекта нет» — эта половина остаётся за читателем;
- колонка с длинным текстом, которой на стороне запроса назначают длину через `ВЫРАЗИТЬ`
  (#std432 п. 2) — разбор в `AI-16.md`.

## Что проверяет инструмент

Проверяется механически: `qg:BSL-UNBOUNDED-STRING-COLUMN` (`tools/bsl-lint.mjs`), 🟠. Уход
таблицы в чужой метод инструменту не виден: графа вызовов он не строит.

---
id: qg:BSL-VT-FILTER-IN-WHERE
title: Фильтр виртуальной таблицы в ГДЕ
severity: major
group: platform
tool: null
archetypes: [query]
std: []
---

## Триггер

Условие в `ГДЕ` на результате виртуальной таблицы вместо передачи фильтра в её параметры.

## Почему

Влияние: полный перебор таблицы вместо использования индекса.

## Как чинить

Переносить фильтр в параметры виртуальной таблицы.

#### Неправильно

```sql
-- HIGH: фильтр после вычисления виртуальной таблицы
ВЫБРАТЬ
	Остатки.Номенклатура КАК Номенклатура,
	Остатки.КоличествоОстаток КАК Остаток
ИЗ
	РегистрНакопления.ТоварыНаСкладах.Остатки() КАК Остатки
ГДЕ
	Остатки.Склад = &Склад
```

#### Правильно

```sql
-- Оптимально: фильтр в параметрах виртуальной таблицы
ВЫБРАТЬ
	Остатки.Номенклатура КАК Номенклатура,
	Остатки.КоличествоОстаток КАК Остаток
ИЗ
	РегистрНакопления.ТоварыНаСкладах.Остатки(, Склад = &Склад) КАК Остатки
```

## Когда это не дефект

- условие по полю, которого нет среди параметров виртуальной таблицы (ресурсы, вычисляемые
  поля);
- условие с `ИЛИ` между измерениями, которое параметры не выражают.

## Что проверяет инструмент

Ничего: текст запроса — строковый литерал, разбор доступен только чтением.

# Индекс триггеров каталога антипаттернов

Производный файл — источник истины карточки `catalog/<ID>.md`. Правки вносить в карточки,
индекс перегенерировать: `node tools/gen-catalog-index.mjs`.

Здесь только то, что нужно для обнаружения: идентификатор, важность и триггер. Разбор,
способ исправления и законные формы — в карточке; она читается по попаданию, а не заранее.
Карточки с инструментом перечислены ради «как чинить»: их находки печатает инструмент,
своих находок этого класса не добавляй. `*` — нужен `git diff`.

Уроки об устройстве программы ведёт `bsl-architecture-review`: доверие результату своей
функции, одна граница проверки, общий механизм вместо копии на каждый вариант входа,
подготовка данных отдельным методом, поле под будущий признак, конструктор внешней
структуры. Регистрацию объекта в составе конфигурации — `xml-structure-review`. Здесь их
не отмечай.

| Признак | Важность | Группа | Архетипы | Инструмент | Триггер |
|---|---|---|---|---|---|
| `qg:AI-01` | 🔴 | model | record-set | чтение | `НаборЗаписей…Записать(Истина)` с отбором не по всем ключевым измерениям. |
| `qg:AI-02` | 🔴 | model | always | чтение | `Ссылка.Реквизит` в новом или изменённом коде, где объект не нужен целиком. |
| `qg:AI-03` | 🔴 | model | always | чтение | Программное создание видов характеристик/доп. свойств из кода; запись в регистры в обход API. |
| `qg:AI-04` | 🔴 | model | always | чтение | Утверждения «проверено», «собирается», «проходит» без следа фактического прогона. |
| `qg:AI-05` | 🔴 | model | always | чтение | Вывод «код компилируется» по загрузке/выгрузке конфигурации, валидатору XML или анализатору. |
| `qg:AI-06` | 🟠 | model | object-event, form-module | чтение | Выходные параметры «ЕстьПроблемы», структуры «Прервать»/«Текст» вместо отмены операции. |
| `qg:AI-07` | 🟠 | model | always | чтение | Структура/массив/ТЗ без `Знач` в методе, который их не меняет — особенно у серверного метода из клиента. |
| `qg:AI-08` | 🟠 | model | always | чтение | Набор функций-помощников, каждая достаёт из ответа одно поле и приводит его к нужному типу. |
| `qg:AI-09` | 🟠 | model | always | чтение | Чтение константы или поиск предопределённого элемента внутри цикла по строкам. |
| `qg:AI-10` | 🟠 | model | query | чтение | Вложенные циклы поиска соответствий и построение `Соответствие` для связывания наборов. |
| `qg:AI-11`* | 🟠 | model | always | чтение | В `git diff` — исчезнувшие проверки редких случаев и записи без читаемого результата. |
| `qg:AI-12` | 🟠 | model | object-event, transaction | чтение | Запись документа и его проведение в одной транзакции «ради атомарности». |
| `qg:AI-13` | 🟡 | model | always | чтение | `НайтиПоНаименованию` у доп. реквизита; `НайтиПоКоду` у справочника в теле механизма. |
| `qg:AI-14` | 🟡 | model | always | чтение | У табличного документа нет метода `Получить` — ячейка читается через `Область(Строка, Колонка)`. |
| `qg:AI-15` | 🟡 | model | always | чтение | `Новый ПараметрыЗаписиJSON` без аргументов, затем присваивание свойству — read-only. |
| `qg:AI-16` | 🟠 | model | query | чтение | Строковая колонка ТЗ без `КвалификаторыСтроки` уходит в запрос — ошибка при выполнении. |
| `qg:AI-17` | 🟠 | model | query | чтение | Цикл по выборке запроса собирает структуру и кладёт в массив — список полей задублирован. |
| `qg:AI-18` | 🟠 | model | query | чтение | Ключ соответствия склеен из значений строкой, либо цикл ради поиска по двум-трём полям. |
| `qg:AI-19` | 🟡 | model | always | чтение | Обращение к реквизиту/ТЧ обложено проверкой наличия по метаданным «на всякий случай». |
| `qg:AI-20` | 🟡 | model | always | чтение | Результат своей функции читается цепочкой через точку, особенно повторно в методе. |
| `qg:AI-21` | 🟡 | model | always | чтение | Элемент известной коллекции берётся расчётом от `ВГраница()` вместо явного индекса. |
| `qg:AI-22` | 🟡 | model | always | чтение | Во все точки вызова метода уходит одно и то же значение параметра, а в сигнатуре умолчания нет. |
| `qg:BSL-CONTEXT-CALL-UNNEEDED` | 🟠 | platform | client-server, form-module | чтение | `&НаСервере` там, где метод не читает и не пишет контекст формы. |
| `qg:BSL-CORRELATED-SUBQUERY` | 🔴 | platform | query | чтение | Вложенный `ВЫБРАТЬ` в `ГДЕ`, ссылающийся на поле внешнего запроса. |
| `qg:BSL-DB-READ-IN-LOOP` | 🟠 | platform | always | `bsl-lint.mjs` | В теле цикла ни одного запроса — чтение прячется в методе, достижимом из цикла через вызов. |
| `qg:BSL-DEEP-NESTING` | 🟡 | platform | always | чтение | Более 4 уровней вложенности условий и циклов в одном методе. |
| `qg:BSL-DISPATCH-NO-FALLBACK` | 🟠 | platform | always | `bsl-lint.mjs` | Цепочка `Если … ИначеЕсли …` по значениям/типам в трёх и более ветках без `Иначе`. |
| `qg:BSL-ENUM-STRING-ASSIGN` | 🟠 | platform | always | `bsl-lint.mjs` | Присваивание примитива (`""`, `0`, `Ложь`, `Истина`) полю строго ссылочного типа. |
| `qg:BSL-FORM-ATTR-SHADOW` | 🔴 | platform | form-module | `bsl-lint.mjs` | Переменная с именем реквизита формы получает объектное значение — пишет реквизит, не переменную. |
| `qg:BSL-MESSAGE-AS-NOTIFY` | 🟠 | platform | always | чтение | `Сообщить(...)` вместо `ОбщегоНазначения.СообщитьПользователю` или записи в журнал регистрации. |
| `qg:BSL-MULTI-SERVER-CALLS` | 🟠 | platform | client-server, form-module | чтение | Несколько последовательных `...НаСервере()`-вызовов подряд с клиента в одном обработчике. |
| `qg:BSL-NESTED-LOOP-SEARCH` | 🟡 | platform | always | чтение | Вложенный цикл поиска совпадений между двумя коллекциями вместо `Соответствие`. |
| `qg:BSL-NO-CACHE` | 🟡 | platform | always | чтение | Повторные дорогие вызовы с одинаковыми параметрами внутри цикла без кеширования результата. |
| `qg:BSL-NO-TOP-LIMIT` | 🟠 | platform | query | чтение | Большой запрос без `ПЕРВЫЕ N` — загрузка всех записей без ограничения. |
| `qg:BSL-QUERY-IN-LOOP` | 🔴 | platform | always | чтение | `Для Каждого` с `Новый Запрос` внутри тела цикла — обращение к базе на каждой итерации. |
| `qg:BSL-REF-DOT-ACCESS` | 🔴 | platform | always | `bsl-lint.mjs` | `.Реквизит` у ссылочного значения — загрузка всего объекта из БД ради одного поля. |
| `qg:BSL-STALE-LOCAL-CALL` | 🔴 | platform | always | `rename-check.mjs` | Вызов метода, чьё объявление было в HEAD и исчезло после правки. |
| `qg:BSL-SUBQUERY-IN-SELECT` | 🔴 | platform | query | чтение | Вложенный `ВЫБРАТЬ` в списке полей — считается заново для каждой строки внешнего запроса. |
| `qg:BSL-TEMPTABLE-NO-INDEX` | 🟠 | platform | query | чтение | `ПОМЕСТИТЬ ВТ...` без `ИНДЕКСИРОВАТЬ ПО`, а таблица дальше участвует в соединении. |
| `qg:BSL-TXN-IN-HANDLER` | 🟠 | platform | transaction, object-event | `bsl-lint.mjs` | Своя `НачатьТранзакцию` внутри обработчика, который платформа уже выполняет в транзакции. |
| `qg:BSL-TXN-INSIDE-TRY` | 🟠 | platform | transaction | чтение | `Попытка` раньше `НачатьТранзакцию()` в одном блоке. |
| `qg:BSL-UNBOUNDED-STRING-COLUMN` | 🟠 | platform | query | `bsl-lint.mjs` | Колонка ТЗ без `КвалификаторыСтроки` уходит в запрос через `УстановитьПараметр`. |
| `qg:BSL-VT-FILTER-IN-WHERE` | 🟠 | platform | query | чтение | Условие в `ГДЕ` на результате виртуальной таблицы вместо передачи фильтра в её параметры. |
| `qg:QRY-ALIAS-RESERVED-WORD` | 🔴 | platform | query | `query-lint.mjs` | Псевдоним — служебное слово языка запросов (`КАК Первые`). |
| `qg:QRY-ALIAS-SHADOWS-FIELD` | 🔴 | platform | query | `query-lint.mjs` | Псевдоним источника совпадает с именем колонки, видимой в этом же запросе. |
| `qg:QRY-ALIAS-SHADOWS-NESTED-TABLE` | 🔴 | platform | query | `query-lint.mjs` | Псевдоним источника-ТЧ совпадает с именем самой табличной части при соединённом владельце. |
| `qg:QRY-TOP-WITHOUT-ORDER` | 🟡 | platform | query | `query-lint.mjs` | `ПЕРВЫЕ N` (N > 1) без `УПОРЯДОЧИТЬ ПО` в тексте запроса. |

---
id: qg:QRY-ALIAS-RESERVED-WORD
title: Служебное слово языка запросов в псевдониме
severity: critical
group: platform
tool: tools/query-lint.mjs
archetypes: [query]
std: []
---

## Триггер

Псевдоним — служебное слово языка запросов (`КАК Первые`).

## Почему

Платформа отвергает такой запрос при разборе, целиком. Текст при этом собирается, статический
анализ молчит, сборка расширения проходит: литерал остаётся литералом до первого выполнения.
Ветка кода с таким запросом не работает ни разу с момента написания.

## Как чинить

Уточнить имя по предмету.

```sql
ВЫБРАТЬ Заказы.Ссылка КАК Ссылка
ИЗ Документ.ЗаказКлиента КАК Заказы
    ЛЕВОЕ СОЕДИНЕНИЕ ВТПервыеСтроки КАК Первые
    ПО Первые.Заказ = Заказы.Ссылка
-- запрос не разбирается: «Первые» — служебное слово
```

`Первые` → `ПервыеСтроки`, `Выбор` → `ВыборПользователя`.

## Когда это не дефект

- `Ссылка` и `Представление` в списке выборки (`Заказы.Ссылка КАК Ссылка`): запрещены только
  псевдонимом источника;
- слова, которые платформа псевдонимом принимает, — `Итоги`, `Соединение`, `Сумма`,
  `Количество`, `Значение`, `Дата` и другие: список ломающих слов измерен, а не выведен из
  синтаксиса;
- приведение типа: `ВЫРАЗИТЬ(Х КАК Документ.Заказ)`, `КАК Число(15,2)`.

## Что проверяет инструмент

Проверяется механически: `qg:QRY-ALIAS-RESERVED-WORD` (`tools/query-lint.mjs`) — 🔴. Списки
слов по позициям и способ их замера — в `bsl-query-reference.md`.

---
id: qg:QRY-ALIAS-SHADOWS-FIELD
title: Псевдоним источника совпадает с именем колонки
severity: critical
group: platform
tool: tools/query-lint.mjs
archetypes: [query]
std: []
---

## Триггер

Псевдоним источника совпадает с именем колонки, видимой в этом же запросе.

## Почему

`Псевдоним.Поле` тогда читается двояко — как поле источника и как разыменование одноимённой
колонки. Ошибка не синтаксическая, а разбора: до выполнения запроса её не видит ни один
инструмент, кроме платформы — «Неоднозначное поле».

## Как чинить

Переименовать источник.

```sql
-- ВТ_Связи содержит колонку «Перемещение», а источник назван так же:
ВЫБРАТЬ
    Связи.Перемещение КАК Перемещение
ИЗ
    ВТ_Связи КАК Связи
        ВНУТРЕННЕЕ СОЕДИНЕНИЕ Документ.ПеремещениеТоваров КАК Перемещение
        ПО Связи.Перемещение = Перемещение.Ссылка
-- {(N, M)}: Неоднозначное поле "Перемещение.Ссылка"
```

Лечится переименованием источника (`КАК ДокументПеремещения`).

## Когда это не дефект

- псевдоним совпадает с именем колонки, но `Псевдоним.Поле` нигде не используется — коллизия
  имени есть, а разыменования нет.

## Что проверяет инструмент

Проверяется механически: `qg:QRY-ALIAS-SHADOWS-FIELD` (`tools/query-lint.mjs`) — 🔴, если
псевдоним разыменован (`Псевдоним.Поле` встречается в тексте), иначе 🟠. Полный разбор
конструкции — в `bsl-query-reference.md`.

---
id: qg:QRY-ALIAS-SHADOWS-NESTED-TABLE
title: Псевдоним источника совпадает с именем табличной части
severity: critical
group: platform
tool: tools/query-lint.mjs
archetypes: [query]
std: []
---

## Триггер

Псевдоним источника-ТЧ совпадает с именем самой табличной части при соединённом владельце.

## Почему

Табличная часть — поле объектной таблицы: язык умеет выбирать вложенные таблицы
(`Ордер.Строки.(Номенклатура, Количество)`). Пока владелец в ветке, имя `Строки` занято, и
псевдоним с ним сталкивается.

## Как чинить

Переименовать псевдоним источника-табличной-части.

```sdbl
ИЗ
    Документ.РасходныйОрдер.Строки КАК Строки
        ВНУТРЕННЕЕ СОЕДИНЕНИЕ Документ.РасходныйОрдер КАК Ордер
        ПО Строки.Ссылка = Ордер.Ссылка
-- {(N, M)}: Неоднозначное поле "Строки.Ссылка"
```

## Когда это не дефект

- без владельца в ветке та же запись законна — это обычный и распространённый стиль.

## Что проверяет инструмент

Проверяется механически: `qg:QRY-ALIAS-SHADOWS-NESTED-TABLE` (`tools/query-lint.mjs`) — 🔴 при
разыменовании, иначе 🟠. Коллизию псевдонима с именем реквизита реальной таблицы инструмент не
ловит — это остаётся глазам.

---
id: qg:QRY-TOP-WITHOUT-ORDER
title: ПЕРВЫЕ N без УПОРЯДОЧИТЬ ПО
severity: minor
group: platform
tool: tools/query-lint.mjs
archetypes: [query]
std: []
---

## Триггер

`ПЕРВЫЕ N` (N > 1) без `УПОРЯДОЧИТЬ ПО` в тексте запроса.

## Почему

`ПЕРВЫЕ N` ставится **вместе с `УПОРЯДОЧИТЬ ПО`**. Без явного порядка неизвестно, какие
именно N строк вернутся: порядок задаёт СУБД, и он меняется между прогонами, версиями
платформы и движками базы. «Первые десять договоров» на тестовой базе стабильны, в продуктиве
— нет.

## Как чинить

Добавить `УПОРЯДОЧИТЬ ПО` по детерминирующему полю рядом с `ПЕРВЫЕ N`.

#### Неправильно

```sql
ВЫБРАТЬ ПЕРВЫЕ 10 Контрагенты.Ссылка ИЗ Справочник.Контрагенты КАК Контрагенты
```

#### Правильно

```sql
ВЫБРАТЬ ПЕРВЫЕ 10 Контрагенты.Ссылка
ИЗ Справочник.Контрагенты КАК Контрагенты
УПОРЯДОЧИТЬ ПО Контрагенты.Наименование
```

Помещение результата во временную таблицу законной формой **не является** — недетерминированным
оказывается сам отбор, ещё до `ПОМЕСТИТЬ`.

## Когда это не дефект

- **Законные формы:** `ПЕРВЫЕ 1` в проверке существования (важно только «пусто или нет»);
- `АВТОУПОРЯДОЧИВАНИЕ`.

## Что проверяет инструмент

Проверяется механически: `qg:QRY-TOP-WITHOUT-ORDER` (`tools/query-lint.mjs`), 🟡 —
лексический разбор текста запроса.