@artel/artc 0.6.26039 → 0.9.26001

package/build/types/analysis/m/TypeArgumentInferrer.d.ts

@@ -0,0 +1,52 @@
+import { TypeParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+export type Argument = SourceArgument | IntrinsicArgument;
+export interface SourceArgument {
+    readonly kind: 'source';
+    readonly expression: tree.Expression;
+}
+export interface IntrinsicArgument {
+    readonly kind: 'intrinsic';
+    readonly type: types.Type;
+}
+export declare class ArgumentWithTargetParameterInfo {
+    readonly value: Argument;
+    readonly parameterType: types.Type;
+    constructor(value: Argument, parameterType: types.Type);
+}
+export declare class TypeArgumentInferrer {
+    private readonly analyzer;
+    private readonly typeParameters;
+    private readonly arguments;
+    private readonly analysisOptions;
+    private readonly returnType;
+    private readonly outerSubstitutions;
+    private readonly inferenceStates;
+    /**
+     * Специальный экземпляр типа, который используется как признак того, что вывод аргументов типа не удался.
+     */
+    private readonly unresolvedType;
+    private inferenceHasFailed;
+    constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], args: readonly ArgumentWithTargetParameterInfo[], analysisOptions: ExpressionAnalysisOptions, returnType: types.Type | undefined, outerTypeSubstitutions: types.Substitutions | undefined);
+    infer(): readonly types.Type[] | undefined;
+    private inferFirstStage;
+    private inferSecondStage;
+    private inferFromTypes;
+    private inferToParameterType;
+    private inferToStructuredType;
+    private inferToReducedType;
+    private inferFromSubstitutions;
+    private inferToUnionType;
+    private inferFromFunctionTypes;
+    private inferFromUnionType;
+    private createSubstitutions;
+    private inferFromTargetTypeDependentExpression;
+    private tryGetInferredType;
+    private tryFixTypeParametersContainedByTypesOfFunctionParameters;
+    private typeContainsTypeParameter;
+    private substitutionsContainTypeParameter;
+    private isDefinitelyTargetTypeDependentExpression;
+}

package/build/types/analysis/m/TypeInferrer.d.ts

@@ -0,0 +1,11 @@
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class TypeInferrer {
+    private readonly analyzer;
+    private getType;
+    private typeInferringState;
+    private hasDetectedInferenceCycle_;
+    get hasDetectedInferenceCycle(): boolean;
+    constructor(analyzer: Analyzer, getType: () => types.Type);
+    inferType(): types.Type;
+}

package/build/types/analysis/m/TypeMemberLookup.d.ts

@@ -1,5 +1,5 @@
 import { Name } from '../../common/index.js';
-import { NamedTypeMemberEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
+import { NamedTypeMemberEntity, TypeEntity, TypeExtensionEntity, TypeWithMembersOrExtensionEntity, OperatorKind } from '../../entities/index.js';
 import * as types from '../../types/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { DialectSpecificBoundTypeMemberLookup } from '../DialectSpecificBoundTypeMemberLookup.js';
@@ -10,11 +10,14 @@ export declare class TypeMemberLookupM {
     static ofType(analyzer: Analyzer, type: types.Type): TypeMemberLookupM;
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity): TypeMemberLookupM;
     static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity): TypeMemberLookupM;
+    static ofTypeOrExtensionEntity(analyzer: Analyzer, typeEntity: TypeWithMembersOrExtensionEntity): TypeMemberLookupM;
     getNamedMembers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getNamedMembersByName(name: Name, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getMatchingNamedMembersByName(name: Name, memberToMatch: NamedTypeMemberEntity, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getConstructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
     getDestructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
+    getOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
+    getOperatorsByKind(kind: OperatorKind, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
     getIndexers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Indexer[];
     getDereferenceOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.DereferenceOperator[];
 }

package/build/types/analysis/m/TypeNarrower.d.ts

@@ -0,0 +1,31 @@
+import { PackageLocale } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import * as controlFlow from './control-flow/index.js';
+import { NarrowableReference } from './control-flow/index.js';
+export declare class TypeNarrower {
+    private readonly analyzer;
+    private readonly reference;
+    private readonly initialType;
+    private readonly locale;
+    private readonly controlFlowNode;
+    private readonly typeByNode;
+    private readonly isVariableAssignedInLoopCheckResults;
+    constructor(analyzer: Analyzer, reference: NarrowableReference, locale: PackageLocale, initialType: types.Type, controlFlowNode: controlFlow.Node);
+    static getTypeOfExpression(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node): types.Type;
+    getType(): types.Type;
+    private getTypeAtControlFlowNode;
+    private getTypeAtCondition;
+    private getTypeAtAssignment;
+    private getTypeAtLocalOrPackageVariableDeclaration;
+    private getTypeAtSplit;
+    private getTypeAtLoop;
+    private getTypeAtAssignmentWithImplicitConversionOrToReducedType;
+    private getTypeAtIsFunctionCallExpression;
+    private getTypeAtComparisonWithNull;
+    private getTypeAtAssignmentOrDeclaration;
+    private addTypeIfUnique;
+    private checkIfVariableIsAssignedInLoop;
+    private checkIfVariableIsAssignedAtNode;
+    private isSameReferenceAsNarrowedExpression;
+}

package/build/types/analysis/m/TypeOverloadResolver.d.ts

@@ -0,0 +1,9 @@
+import { NamedTypeEntity } from '../../entities/index.js';
+export declare class Resolver {
+    static resolve<TCandidate extends ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
+    static resolveByNamedTypeEntities<T extends NamedTypeEntity>(candidates: readonly T[], argumentCount: number): readonly T[];
+}
+export interface ICandidate {
+    getParameterCount(): number;
+    getRequiredParameterCount(): number;
+}

package/build/types/analysis/m/UserDefinableBinaryOperatorResolver.d.ts

@@ -0,0 +1,34 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { BinaryOperatorKind } from '../../entities/OperatorKind.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { Analyzer } from './Analyzer.js';
+/**
+ * Определяет подходящую двухместную операцию, определённую пользователем (+, *, == и др.).
+ *
+ * Алгоритм:
+ *
+ * 1. Определить тип левого выражение (targetType = undefined).
+ * 2. Найти в типе операторы необходимого вида.
+ * 3. Если операторы найдены:
+ *    1. Если найден один оператор - проверить, совместимы ли типы выражений с типами операндов.
+ *    2. Если найдено несколько операторов - решить перегрузку, представив двоичное выражение как операцию с
+ *       двумя параметрами.
+ *    3. Если остался один подходящий оператор - алгоритм завершается. Если подошло несколько операторов -
+ *       ошибка неоднозначного доступа. Если не подошёл ни один - алгоритм продолжается.
+ * 4. Определить тип правого выражения (targetType = undefined) и найти операторы в нём. Если операторы найдены -
+ *    выполнить пункт 3.
+ * 5. Если ни один оператор не подошёл - алгоритм завершается с соответствующим сообщением об ошибке.
+ */
+export declare class UserDefinableBinaryOperatorResolver {
+    private readonly analyzer;
+    private readonly left;
+    private readonly right;
+    private readonly operatorKind;
+    private readonly diagnosticLocation;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, left: tree.Expression, right: tree.Expression, operatorKind: BinaryOperatorKind, diagnosticLocation: NodeOrDiagnosticLocation, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): types.Method | undefined;
+    private chooseSuitableOperators;
+}

package/build/types/analysis/m/UserDefinableUnaryOperatorResolver.d.ts

@@ -0,0 +1,23 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+/**
+ * Определяет подходящую одноместную операцию, определённую пользователем (+, -, не).
+ *
+ * Алгоритм:
+ *
+ * 1. Определить тип операнда.
+ * 2. Найти в типе операторы необходимого вида.
+ * 3. Если найден один оператор - проверить, совместим ли тип выражения с типом операнда.
+ *    Если подошло несколько операторов - ошибка неоднозначного доступа.
+ *    Если не подошёл ни один - алгоритм завершается с соответствующим сообщением об ошибке.
+ */
+export declare class UserDefinableUnaryOperatorResolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.PrefixUnaryExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): types.Method | undefined;
+    private getOperatorKind;
+}

package/build/types/analysis/m/VariableIsAssignedChecker.d.ts

@@ -0,0 +1,11 @@
+import { Analyzer } from './Analyzer.js';
+import * as controlFlow from './control-flow/index.js';
+export declare class VariableIsAssignedChecker {
+    private readonly analyzer;
+    private readonly variableReference;
+    private readonly controlFlowNode;
+    private readonly checkResults;
+    constructor(analyzer: Analyzer, variableReference: controlFlow.NarrowableReference, controlFlowNode: controlFlow.Node);
+    checkVariableIsAssigned(): boolean;
+    private checkVariableIsAssignedAtNode;
+}

package/build/types/analysis/m/VariableIsNotAssignedChecker.d.ts

@@ -0,0 +1,12 @@
+import { Analyzer } from './Analyzer.js';
+import * as controlFlow from './control-flow/index.js';
+export declare class VariableIsNotAssignedChecker {
+    private readonly analyzer;
+    private readonly variableReference;
+    private readonly controlFlowNode;
+    private readonly checkResults;
+    private readonly loopNodesBeingChecked;
+    constructor(analyzer: Analyzer, variableReference: controlFlow.NarrowableReference, controlFlowNode: controlFlow.Node);
+    checkVariableIsNotAssigned(): boolean;
+    private checkVariableIsNotAssignedAtNode;
+}

package/build/types/analysis/m/control-flow/GraphBuilder.d.ts

@@ -0,0 +1,52 @@
+import { Diagnostic } from '../../../diagnostic/Diagnostic.js';
+import { SourceFileM } from '../../../project/SourceFile.js';
+import * as tree from '../../../tree/m/index.js';
+import { NarrowableReferenceExpression } from './NarrowableExpression.js';
+import { Node } from './Nodes.js';
+export declare class GraphBuilder {
+    private readonly sourceFile;
+    private readonly controlFlowNodeByReference;
+    private readonly controlFlowNodesPrecedingErrorStatement;
+    private readonly controlFlowNodesEndingSubprogram;
+    private readonly controlFlowNodesEndingSourceFile;
+    private readonly unreachableCodeDiagnostics;
+    private isInRebuildingFinallyClauseGraphMode;
+    private currentPredecessor;
+    private currentContinueLoopTarget;
+    private currentBreakLoopTarget;
+    private currentErrorTarget;
+    private currentReturnTarget;
+    private currentRangeWithReportedUnreachableCodeDiagnostic;
+    constructor(sourceFile: SourceFileM);
+    build(): GraphBuildResult;
+    private visitNode;
+    private visitAssignmentStatement;
+    private visitIfStatement;
+    private visitWhileStatement;
+    private visitLoopStatement;
+    private visitForStatement;
+    private visitContinueLoopStatement;
+    private visitBreakLoopStatement;
+    private visitSwitchStatement;
+    private visitTryStatement;
+    private visitReturnStatement;
+    private visitErrorStatement;
+    private visitLocalVariableDeclaration;
+    private visitPackageVariableDeclaration;
+    private visitConditionalExpression;
+    private visitCondition;
+    private visitBinaryExpression;
+    private visitPrefixUnaryExpressionInCondition;
+    private visitCallExpressionInCondition;
+    private setAssignmentAsCurrentPredecessor;
+    private visitChildren;
+    private addUnreachableCodeDiagnostic;
+}
+export declare class GraphBuildResult {
+    readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>;
+    readonly controlFlowNodesPrecedingErrorStatement: ReadonlyMap<tree.ErrorStatement, Node>;
+    readonly controlFlowNodesEndingSubprogram: ReadonlyMap<tree.SubprogramDeclarationOrLiteral, Node>;
+    readonly controlFlowNodesEndingSourceFile: ReadonlyMap<tree.SourceFile, Node>;
+    readonly unreachableCodeDiagnostics: readonly Diagnostic[];
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, controlFlowNodesPrecedingErrorStatement: ReadonlyMap<tree.ErrorStatement, Node>, controlFlowNodesEndingSubprogram: ReadonlyMap<tree.SubprogramDeclarationOrLiteral, Node>, controlFlowNodesEndingSourceFile: ReadonlyMap<tree.SourceFile, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+}

package/build/types/analysis/m/control-flow/GraphVisualizer.d.ts

@@ -0,0 +1,12 @@
+import { Node } from './Nodes.js';
+export declare class GraphVisualizer {
+    /**
+     * Создаёт описание графа на языке Dot.
+     *
+     * Визуализацию графа можно посмотреть по этой ссылке:
+     * https://dreampuf.github.io/GraphvizOnline/?engine=dot#digraph%20%7B%20%7D
+     */
+    static generateGraphDescriptionInDotLanguage(startNode: Node): string;
+    private static getLabel;
+    private static createGetIdFunction;
+}

package/build/types/analysis/m/control-flow/NarrowableExpression.d.ts

@@ -0,0 +1,5 @@
+import * as tree from '../../../tree/m/index.js';
+export declare function isNarrowableExpression(node: tree.Node): node is tree.Expression;
+export type NarrowableReferenceExpression = tree.IdentifierExpression | tree.MemberAccessExpression | tree.ObjectExpression;
+export declare function isNarrowableReferenceExpression(node: tree.Node): node is NarrowableReferenceExpression;
+export declare function unwrapExpressionForNarrowableReferenceCheck(node: tree.Expression): tree.Expression;

package/build/types/analysis/m/control-flow/NarrowableReference.d.ts

@@ -0,0 +1,72 @@
+import { FieldEntity, LocalVariableEntity, PackageVariableEntity, ParameterEntity } from '../../../entities/index.js';
+import * as tree from '../../../tree/m/index.js';
+import { Analyzer } from '../Analyzer.js';
+import { NarrowableReferenceExpression } from './NarrowableExpression.js';
+export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.InstanceField | NarrowableReference.StaticField | NarrowableReference.ObjectAutoVariable;
+export declare namespace NarrowableReference {
+    export class LocalVariable implements INarrowableReference {
+        private readonly analyzer;
+        readonly entity: LocalVariableEntity | ParameterEntity;
+        readonly kind = "local-variable";
+        constructor(analyzer: Analyzer, entity: LocalVariableEntity | ParameterEntity);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+    }
+    export class PackageVariable implements INarrowableReference {
+        private readonly analyzer;
+        readonly entity: PackageVariableEntity;
+        readonly kind = "package-variable";
+        constructor(analyzer: Analyzer, entity: PackageVariableEntity);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+    }
+    export class InstanceField implements INarrowableReference {
+        private readonly analyzer;
+        readonly field: FieldEntity;
+        readonly receiver: NarrowableReference;
+        readonly kind = "instance-field";
+        constructor(analyzer: Analyzer, field: FieldEntity, receiver: NarrowableReference);
+        equals(other: NarrowableReference): boolean;
+        contains(other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(expression: NarrowableReferenceExpression): boolean;
+    }
+    export class StaticField implements INarrowableReference {
+        private readonly analyzer;
+        readonly field: FieldEntity;
+        readonly kind = "static-field";
+        constructor(analyzer: Analyzer, field: FieldEntity);
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+    }
+    export class ObjectAutoVariable implements INarrowableReference {
+        readonly kind = "object-auto-variable";
+        equals(other: NarrowableReference): boolean;
+        contains(_other: NarrowableReference): boolean;
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+    }
+    interface INarrowableReference {
+        equals(other: NarrowableReference): boolean;
+        contains(other: NarrowableReference): boolean;
+        /**
+         * Отличается от метода `equals` тем, что выполняет сравнение лениво. Например, при сравнении с выражением
+         * `а.б` сперва будут сравнены части слева от точки (выражение `а` с `receiver`), и только при равенстве будет
+         * связано и сравнено имя `б`. Если выражение `а` не равно `receiver`, то сразу будет возвращено `false` и
+         * связывание для имени `б` выполняться не будет. Такое поведение необходимо при анализе циклов,
+         * чтобы избежать рекурсии.
+         */
+        equalsExpression(expression: NarrowableReferenceExpression): boolean;
+        containsExpression(expression: NarrowableReferenceExpression): boolean;
+    }
+    export {};
+}
+export declare function getReferenceAtNarrowableExpression(analyzer: Analyzer, node: NarrowableReferenceExpression): NarrowableReference | undefined;
+export declare function getReferenceAtExpressionIfNarrowable(analyzer: Analyzer, node: tree.Expression): NarrowableReference | undefined;
+export declare function getNarrowableReferenceAtLocalOrPackageVariableDeclaration(analyzer: Analyzer, node: tree.LocalVariableDeclaration | tree.PackageVariableDeclaration): NarrowableReference;

package/build/types/analysis/m/control-flow/Nodes.d.ts

@@ -0,0 +1,112 @@
+import * as tree from '../../../tree/m/index.js';
+export type Node = StartNode | ConditionNode | AssignmentNode | LocalVariableDeclarationNode | SplitNode | LoopNode | UnreachableNode | PackageVariableDeclarationNode;
+declare abstract class ControlFlowNodeBase {
+    protected abstract thisAsNode: Node;
+    /**
+     * Для отладочных целей.
+     */
+    generateVisualizationCode(): string;
+}
+/**
+ * Начальный узел, не имеющий предшественников. Создаётся в начале функций, а также для переменных пакета и полей
+ * объекта с начальным значением, поскольку выражение-инициализатор может иметь собственный граф потока управления
+ * (например, если начальное значение - это трёхместная операция `когда` с проверкой на `пусто`).
+ */
+export declare class StartNode extends ControlFlowNodeBase {
+    readonly kind = "start";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+}
+export type ConditionExpression = tree.BinaryExpression | tree.CallExpression;
+/**
+ * Хранит информацию об истинности некоторого условия. Например, если условие `а != пусто` истинно, то из типа
+ * переменной `а` необходимо исключить тип `Пусто`.
+ */
+export declare class ConditionNode extends ControlFlowNodeBase {
+    readonly predecessor: Node;
+    readonly syntaxNode: ConditionExpression;
+    readonly isTrue: boolean;
+    readonly kind = "condition";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessor: Node, syntaxNode: ConditionExpression, isTrue: boolean);
+}
+/**
+ * Создаётся в местах присваивания значений в переменную. После присваивания тип переменной меняется на тип выражения
+ * справа от равно.
+ */
+export declare class AssignmentNode extends ControlFlowNodeBase {
+    readonly predecessor: Node;
+    readonly syntaxNode: tree.AssignmentStatement;
+    readonly kind = "assignment";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessor: Node, syntaxNode: tree.AssignmentStatement);
+}
+/**
+ * Создаётся в местах объявления локальных переменных. Если переменной присваивается начальное значение, её тип будет
+ * взят как тип присваиваемого выражения.
+ */
+export declare class LocalVariableDeclarationNode extends ControlFlowNodeBase {
+    readonly predecessor: Node;
+    readonly syntaxNode: tree.LocalVariableDeclaration;
+    readonly kind = "local-variable-declaration";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessor: Node, syntaxNode: tree.LocalVariableDeclaration);
+}
+/**
+ * Вспомогательный узел, использующийся в местах, где происходит разветвление графа потока управления. Тип переменной
+ * для этого узла определяется как союзный тип из типов переменных в предшествующих узлах.
+ */
+export declare class SplitNode extends ControlFlowNodeBase {
+    readonly predecessors: readonly Node[];
+    readonly kind = "split";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessors: readonly Node[]);
+}
+/**
+ * Используется для циклов (пока, цикл - повтор пока, для-из). Отличается от узла {@link SplitNode} тем, что предшествующие
+ * узлы, указанные в массиве {@link loopingPredecessors}, образуют циклы в графе потока управления.
+ */
+export declare abstract class LoopNode extends ControlFlowNodeBase {
+    readonly kind = "loop";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    /**
+     * Предшествующий узел, не образующий цикл в графе потока управления. Любой цикл имеет ровно один такой узел.
+     */
+    abstract predecessor: Node;
+    /**
+     * Предшествующие узлы, образующие цикл в графе управление. В простейшем случае имеет один элемент, поскольку
+     * управление в конце цикла возвращается в его начало (т.е. началу цикла предшествует его конец). Может иметь
+     * несколько элементов, если в теле цикла используются инструкции `следующий цикл`, или не иметь ни одного элемента,
+     * если это бесконечный цикл, содержащий инструкцию `прервать цикл`, или любую другую, прерывающую поток управления.
+     */
+    abstract loopingPredecessors: readonly Node[];
+}
+/**
+ * Обозначает недостижимый код. Соответствующая диагностика добавляется в
+ * {@link GraphBuildResult.unreachableCodeDiagnostics}. Класс {@link GraphBuilder} создаёт эти
+ * узлы для кода, недостижимость которого можно определить анализируя только синтаксическое дерево и не использую
+ * семантическую информацию. Например, инструкции, находящиеся после инструкции `возврат`, помечаются как недостижимые.
+ */
+export declare class UnreachableNode extends ControlFlowNodeBase {
+    readonly kind = "unreachable";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+}
+/**
+ * Создаётся в местах объявления пакетных переменных М. Если переменной присваивается начальное значение, её тип будет
+ * взят как тип присваиваемого выражения.
+ */
+export declare class PackageVariableDeclarationNode extends ControlFlowNodeBase {
+    readonly predecessor: Node;
+    readonly syntaxNode: tree.PackageVariableDeclaration;
+    readonly kind = "package-variable-declaration";
+    get debuggerDisplay(): string;
+    protected get thisAsNode(): Node;
+    constructor(predecessor: Node, syntaxNode: tree.PackageVariableDeclaration);
+}
+export {};

package/build/types/analysis/m/control-flow/index.d.ts

@@ -0,0 +1,5 @@
+export * from './GraphBuilder.js';
+export * from './GraphVisualizer.js';
+export * from './NarrowableExpression.js';
+export * from './NarrowableReference.js';
+export * from './Nodes.js';

package/build/types/analysis/m/semantic-context/Declarations.d.ts

@@ -0,0 +1,94 @@
+import { Name } from '../../../common/index.js';
+import { EntityHidingLevel, MethodEntity, NamedFunctionEntity, NamedTypeEntity, PackageAliasEntity, PackageOrLocalOrParameterVariableEntity, PackageOrNestedFunctionEntity, VariableEntity } from '../../../entities/index.js';
+import * as types from '../../../types/index.js';
+import { PackageNameTreeNode } from '../../ImportedPackageNameTree.js';
+export type TypeOrContainerWithTypes = NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+export type TagOrContainerWithTags = NamedDeclaration_function | NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+export type NamedDeclaration = NamedDeclaration_function | NamedDeclaration_variable | NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
+export declare class NamedDeclaration_function implements INamedDeclaration {
+    readonly value: NamedDeclarationFunction;
+    readonly kind = "function";
+    constructor(value: NamedDeclarationFunction);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type NamedDeclarationFunction = NamedDeclarationFunction_entity | NamedDeclarationFunction_typeMember;
+export declare class NamedDeclarationFunction_entity implements INamedDeclarationFunction {
+    readonly kind = "entity";
+    readonly value: PackageOrNestedFunctionEntity;
+    constructor(value: PackageOrNestedFunctionEntity);
+    getName(): Name;
+    getEntity(): PackageOrNestedFunctionEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclarationFunction_typeMember implements INamedDeclarationFunction {
+    readonly kind = "type-member";
+    readonly value: types.Method;
+    constructor(value: types.Method);
+    getName(): Name;
+    getEntity(): MethodEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface INamedDeclarationFunction {
+    getName(): Name;
+    getEntity(): NamedFunctionEntity;
+    getTypeParameterArity(): number;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_variable implements INamedDeclaration {
+    readonly value: NamedDeclarationVariable;
+    readonly kind = "variable";
+    constructor(value: NamedDeclarationVariable);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export type NamedDeclarationVariable = NamedDeclarationVariable_entity | NamedDeclarationVariable_typeMember;
+export declare class NamedDeclarationVariable_entity implements INamedDeclarationVariable {
+    readonly value: PackageOrLocalOrParameterVariableEntity;
+    readonly kind = "entity";
+    constructor(value: PackageOrLocalOrParameterVariableEntity);
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclarationVariable_typeMember implements INamedDeclarationVariable {
+    readonly value: types.Field;
+    readonly kind = "type-member";
+    constructor(value: types.Field);
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface INamedDeclarationVariable {
+    getName(): Name;
+    getEntity(): VariableEntity;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_type implements INamedDeclaration {
+    readonly value: NamedTypeEntity;
+    readonly kind = "type";
+    constructor(value: NamedTypeEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_packageAlias implements INamedDeclaration {
+    readonly value: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(value: PackageAliasEntity);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export declare class NamedDeclaration_packageNameSegment implements INamedDeclaration {
+    readonly value: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(value: PackageNameTreeNode);
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+interface INamedDeclaration {
+    getName(): Name;
+    isHidden(): EntityHidingLevel | undefined;
+}
+export {};

package/build/types/analysis/m/semantic-context/FieldWithInitializerSemanticContext.d.ts

@@ -0,0 +1,28 @@
+import { Name } from '../../../common/index.js';
+import * as tree from '../../../tree/m/index.js';
+import { TypeMemberLookupContext } from '../../TypeMemberLookup.js';
+import { Analyzer } from '../Analyzer.js';
+import { NamedDeclaration, TagOrContainerWithTags, TypeOrContainerWithTypes } from './Declarations.js';
+import { SemanticContext } from './SemanticContext.js';
+import { NamedDeclarationLookupResult, SemanticContextLookupState } from './SemanticContextBase.js';
+import { SemanticContextWithParent } from './SemanticContextWithParent.js';
+import { StaticDeclarationSemanticContext } from './StaticDeclarationSemanticContext.js';
+import { TypeOrExtensionMembersSemanticContext } from './TypeSemanticContext.js';
+export type FieldWithInitializerSemanticContextParent = TypeOrExtensionMembersSemanticContext | StaticDeclarationSemanticContext;
+export type FieldWithInitializerDeclaration = tree.FieldDeclaration | tree.StaticFieldDeclaration;
+export declare class FieldWithInitializerSemanticContext extends SemanticContextWithParent {
+    readonly kind = "field-initializer";
+    readonly outer: FieldWithInitializerSemanticContextParent;
+    protected readonly asContext: SemanticContext;
+    private readonly analyzer;
+    private readonly node;
+    constructor(analyzer: Analyzer, node: FieldWithInitializerDeclaration, outer: FieldWithInitializerSemanticContextParent);
+    isStatic(): boolean;
+    getTypeMemberLookupContext(): TypeMemberLookupContext;
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTagsOrContainersWithTags(_initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnTagsOrContainersWithTagsByName(_name: Name, _initialContext: SemanticContext): readonly TagOrContainerWithTags[];
+    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupState: SemanticContextLookupState): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers: boolean, _lookupResult: NamedDeclarationLookupResult): void;
+}

package/build/types/analysis/m/semantic-context/SemanticContext.d.ts

@@ -0,0 +1,14 @@
+import { FieldWithInitializerSemanticContext } from './FieldWithInitializerSemanticContext.js';
+import { SourceFileSemanticContext } from './SourceFileSemanticContext.js';
+import { StaticDeclarationSemanticContext } from './StaticDeclarationSemanticContext.js';
+import { ForStatementSemanticContext, StatementBlockSemanticContext, SubprogramParameterListSemanticContext, SubprogramTypeParameterSemanticContext, CatchClauseSemanticContext } from './SubprogramBodyAndParametersSemanticContext.js';
+import { OutermostSemanticContextOfSubprogram } from './SubprogramSemanticContext.js';
+import { OutermostSemanticContextOfTypeOrExtension, ParametersOfFunctionTypeSemanticContext, TypeOrExtensionMembersSemanticContext, TypeParametersOfTypeSemanticContext } from './TypeSemanticContext.js';
+/**
+ * Позволяет получить информацию, общую для определённой области
+ * исходного кода (блока инструкций, списка членов типа и др.) с учётом
+ * всех вышестоящих (родительских) контекстов.
+ * Чтобы получить семантический контекст, в котором находится определённый узел,
+ * используйте `analyzer.semanticContext.containing(node)`.
+ */
+export type SemanticContext = SourceFileSemanticContext | OutermostSemanticContextOfTypeOrExtension | TypeParametersOfTypeSemanticContext | TypeOrExtensionMembersSemanticContext | ParametersOfFunctionTypeSemanticContext | OutermostSemanticContextOfSubprogram | SubprogramTypeParameterSemanticContext | SubprogramParameterListSemanticContext | StatementBlockSemanticContext | FieldWithInitializerSemanticContext | ForStatementSemanticContext | CatchClauseSemanticContext | StaticDeclarationSemanticContext;