@artel/artc 0.6.25223 → 0.6.25225

package/build/types/analysis/SemanticContextBuilder.d.ts

@@ -1,13 +1,13 @@
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { MethodDeclaration } from './NodeTypeUtils.js';
-import { RegularOrBlockMethodLiteral, SemanticContext, TypeDeclarationBody, TypeDeclarationCreatingSemanticContext } from './SemanticContext.js';
+import { FunctionDeclaration } from './NodeTypeUtils.js';
+import { RegularOrBlockFunctionLiteral, SemanticContext, TypeDeclarationBody, TypeDeclarationCreatingSemanticContext } from './SemanticContext.js';
 export declare class SemanticContextBuilder {
     private readonly _analyzer;
     private readonly _semanticContexts;
-    private readonly _methodDeclarationTypeParametersContexts;
-    private readonly _methodDeclarationValueParametersContexts;
-    private readonly _indexerParametersContexts;
+    private readonly _functionDeclarationTypeParametersContexts;
+    private readonly _functionDeclarationValueParametersContexts;
+    private readonly _indexParametersContexts;
     constructor(analyzer: Analyzer);
     /**
      * Возвращает контекст, содержащий узел. Если в качестве узла передан исходный файл,
@@ -17,9 +17,9 @@ export declare class SemanticContextBuilder {
     containingWithOffset(node: tree.Node, offset: number): SemanticContext;
     ofSourceFile(node: tree.SourceFile): SemanticContext;
     /**
-     * Контекст заголовка метода. Включает параметры-типы и параметры-значения (в зависимости от указанного `hint`).
+     * Контекст заголовка функции. Включает параметры-типы и параметры-значения (в зависимости от указанного `hint`).
      */
-    ofMethodDeclarationHeader(node: MethodDeclaration, hint: 'type-parameters' | 'value-parameters'): SemanticContext;
+    ofFunctionDeclarationHeader(node: FunctionDeclaration, hint: 'type-parameters' | 'value-parameters'): SemanticContext;
     ofOperatorDeclaration(node: tree.OperatorDeclaration): SemanticContext;
     ofTypeDeclarationBody(node: TypeDeclarationBody): SemanticContext;
     /**
@@ -27,31 +27,31 @@ export declare class SemanticContextBuilder {
      */
     ofTypeDeclarationHeader(node: TypeDeclarationCreatingSemanticContext): SemanticContext;
     ofTypeExtensionDeclarationBody(node: tree.TypeExtensionDeclaration): SemanticContext;
-    ofVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration | tree.TypeVariableGetterDeclaration | tree.TypeDereferencedVariableGetterDeclaration): SemanticContext;
-    ofVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration | tree.TypeVariableSetterDeclaration | tree.TypeDereferencedVariableSetterDeclaration): SemanticContext;
+    ofVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration | tree.FieldGetterDeclaration | tree.DereferencedVariableGetterDeclaration): SemanticContext;
+    ofVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration | tree.FieldSetterDeclaration | tree.DereferencedVariableSetterDeclaration): SemanticContext;
     ofPackageConstructorDeclaration(node: tree.PackageConstructorDeclaration): SemanticContext;
     ofPackageEntryPointDeclaration(node: tree.PackageEntryPointDeclaration): SemanticContext;
-    ofRegularOrBlockMethodLiteral(node: RegularOrBlockMethodLiteral): SemanticContext;
+    ofRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral): SemanticContext;
     ofForStatement(node: tree.ForStatement): SemanticContext;
     ofStatementBlock(node: tree.StatementBlock): SemanticContext;
     ofFunctionBlock(node: tree.FunctionBlock): SemanticContext;
-    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): SemanticContext;
-    ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): SemanticContext;
-    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
-    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
+    ofConstructorDeclaration(node: tree.ConstructorDeclaration): SemanticContext;
+    ofDestructorDeclaration(node: tree.DestructorDeclaration): SemanticContext;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
+    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration, hint: 'body' | 'parameters'): SemanticContext;
     ofCatchClause(node: tree.CatchClause): SemanticContext;
-    ofTypeVariableDeclarationWithInitializer(node: tree.TypeVariableDeclaration): SemanticContext;
+    ofFieldDeclarationWithInitializer(node: tree.FieldDeclaration): SemanticContext;
     private containingInternal;
-    private ofChildOfMethodDeclaration;
+    private ofChildOfFunctionDeclaration;
     private ofChildOfTypeDeclarationWithMemberBlock;
     private ofChildOfTypeDeclarationBodyWithMemberBlock;
-    private ofChildOfMethodTypeDeclarationBody;
-    private ofChildOfMethodLiteral;
+    private ofChildOfFunctionTypeDeclarationBody;
+    private ofChildOfFunctionLiteral;
     private ofOperatorDeclarationChild;
-    private ofTypeConstructorDeclarationChild;
-    private ofTypeDestructorDeclarationChild;
-    private ofTypeIndexedGetterDeclarationChild;
-    private ofTypeIndexedSetterDeclarationChild;
+    private ofConstructorDeclarationChild;
+    private ofDestructorDeclarationChild;
+    private ofIndexedElementGetterDeclarationChild;
+    private ofIndexedElementSetterDeclarationChild;
     private ofChildOfTypeExtensionDeclaration;
     private isOffsetBetweenNodes;
     private isOffsetInsideStatementBlock;

package/build/types/analysis/SourceFileMembers.d.ts

@@ -1,5 +1,5 @@
 import { SearchName } from '../common/index.js';
-import { PackageAliasEntity, PackageMethodEntity, PackageTypeEntity, PackageVariableEntity, TypeExtensionEntity } from '../entities/index.js';
+import { PackageAliasEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeExtensionEntity } from '../entities/index.js';
 export declare class SourceFileMembers {
     private readonly _namedMembers;
     private readonly _typeExtensions;
@@ -12,4 +12,4 @@ export declare class SourceFileMembers {
     getPackageAliasesByName(name: SearchName): readonly PackageAliasEntity[];
     getTypeExtensions(): readonly TypeExtensionEntity[];
 }
-export type NamedSourceFileMemberEntity = PackageTypeEntity | PackageVariableEntity | PackageMethodEntity | PackageAliasEntity;
+export type NamedSourceFileMemberEntity = PackageTypeEntity | PackageVariableEntity | PackageFunctionEntity | PackageAliasEntity;

package/build/types/analysis/StatementBlockScopeBuilder.d.ts

@@ -6,20 +6,20 @@ export declare class StatementBlockScopeBuilder {
     static buildStatementBlockScope(analyzer: Analyzer, node: tree.StatementBlock): IScope;
     static buildGenericScopeForFunctionBlock(analyzer: Analyzer, node: tree.FunctionBlock): IScope;
     static buildGenericScopeForStatementBlock(analyzer: Analyzer, node: tree.StatementBlock): IScope;
-    static buildScopeForMethodBlockLiteral(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.MethodBlockLiteral): IScope;
-    static buildScopeForPackageMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageMethodDeclaration): IScope;
-    static buildScopeForTypeVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeVariableGetterDeclaration): IScope;
-    static buildScopeForTypeVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeVariableSetterDeclaration): IScope;
+    static buildScopeForFunctionBlockLiteral(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.FunctionBlockLiteral): IScope;
+    static buildScopeForPackageFunctionDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageFunctionDeclaration): IScope;
+    static buildScopeForFieldGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.FieldGetterDeclaration): IScope;
+    static buildScopeForFieldSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.FieldSetterDeclaration): IScope;
     static buildScopeForPackageVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageVariableGetterDeclaration): IScope;
     static buildScopeForPackageVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.PackageVariableSetterDeclaration): IScope;
-    static buildScopeForTypeIndexedGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeIndexedGetterDeclaration): IScope;
-    static buildScopeForTypeIndexedSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeIndexedSetterDeclaration): IScope;
-    static buildScopeForTypeDereferencedVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeDereferencedVariableGetterDeclaration): IScope;
-    static buildScopeForTypeDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeDereferencedVariableSetterDeclaration): IScope;
-    static buildScopeForNestedMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.NestedMethodDeclaration): IScope;
-    static buildScopeForMethodLiteral(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.MethodLiteral): IScope;
-    static buildScopeForTypeConstructorDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeConstructorDeclaration): IScope;
-    static buildScopeForTypeMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.TypeMethodDeclaration): IScope;
+    static buildScopeForIndexedElementGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.IndexedElementGetterDeclaration): IScope;
+    static buildScopeForIndexedElementSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.IndexedElementSetterDeclaration): IScope;
+    static buildScopeForDereferencedVariableGetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.DereferencedVariableGetterDeclaration): IScope;
+    static buildScopeForDereferencedVariableSetterDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.DereferencedVariableSetterDeclaration): IScope;
+    static buildScopeForNestedFunctionDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.NestedFunctionDeclaration): IScope;
+    static buildScopeForFunctionLiteral(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.FunctionLiteral): IScope;
+    static buildScopeForConstructorDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.ConstructorDeclaration): IScope;
+    static buildScopeForMethodDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.MethodDeclaration): IScope;
     static buildScopeForOperatorDeclaration(analyzer: Analyzer, node: tree.FunctionBlock, parent: tree.OperatorDeclaration): IScope;
     private static getLocalNamedDeclarationsOfFunctionBlock;
     private static getLocalNamedDeclarations;

package/build/types/analysis/{SubstitutedMethod.d.ts → SubstitutedFunction.d.ts}

@@ -1,17 +1,17 @@
 import { Name } from '../common/index.js';
-import { MethodEntity, ParameterVariableEntity } from '../entities/index.js';
+import { FunctionEntity, ParameterVariableEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
-export type SubstitutedMethod = SubstitutedMethod_entity | SubstitutedMethod_typeMember;
-export declare class SubstitutedMethod_entity implements ISubstitutedMethod {
-    readonly entity: MethodEntity;
-    readonly entitySignatureType: types.MethodType;
+export type SubstitutedFunction = SubstitutedFunction_entity | SubstitutedFunction_typeMember;
+export declare class SubstitutedFunction_entity implements ISubstitutedFunction {
+    readonly entity: FunctionEntity;
+    readonly entitySignatureType: types.FunctionType;
     readonly substitutions: types.Substitutions;
     readonly kind = "entity";
     private readonly _signatureType;
-    constructor(entity: MethodEntity, entitySignatureType: types.MethodType, substitutions: types.Substitutions);
-    getEntity(): MethodEntity;
+    constructor(entity: FunctionEntity, entitySignatureType: types.FunctionType, substitutions: types.Substitutions);
+    getEntity(): FunctionEntity;
     getName(): Name;
-    getSignatureType(): types.MethodType;
+    getSignatureType(): types.FunctionType;
     getSubstitutions(): types.Substitutions;
     getValueParameters(): readonly {
         entity: ParameterVariableEntity;
@@ -19,15 +19,15 @@ export declare class SubstitutedMethod_entity implements ISubstitutedMethod {
     }[];
     isAsync(): boolean;
 }
-export declare class SubstitutedMethod_typeMember implements ISubstitutedMethod {
+export declare class SubstitutedFunction_typeMember implements ISubstitutedFunction {
     readonly method: types.Method;
     readonly substitutions: types.Substitutions;
     readonly kind = "type-member";
     private readonly _signatureType;
     constructor(method: types.Method, substitutions: types.Substitutions);
-    getEntity(): MethodEntity;
+    getEntity(): FunctionEntity;
     getName(): Name;
-    getSignatureType(): types.MethodType;
+    getSignatureType(): types.FunctionType;
     getSubstitutions(): types.Substitutions;
     getValueParameters(): readonly {
         entity: ParameterVariableEntity;
@@ -35,10 +35,10 @@ export declare class SubstitutedMethod_typeMember implements ISubstitutedMethod
     }[];
     isAsync(): boolean;
 }
-interface ISubstitutedMethod {
-    getEntity(): MethodEntity;
+interface ISubstitutedFunction {
+    getEntity(): FunctionEntity;
     getName(): Name;
-    getSignatureType(): types.MethodType;
+    getSignatureType(): types.FunctionType;
     getSubstitutions(): types.Substitutions;
     getValueParameters(): readonly {
         entity: ParameterVariableEntity;

package/build/types/analysis/TagMeaning.d.ts

@@ -1,11 +1,13 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { MethodEntity, NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
+import { FunctionEntity, NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedMethod } from './AccessedMethod.js';
+import { AccessedFunction } from './AccessedFunction.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer } from './index.js';
+import { WithLocalization } from './Localization.js';
+import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
@@ -17,17 +19,18 @@ export declare class Resolver {
     private resolveNameInPackage;
     private resolveTypeOverload;
     private resolveTagType;
-    private resolveTagMethod;
-    private createAccessedMethod;
-    private resolveMethodOverload;
+    private resolveTagFunction;
+    private createAccessedFunction;
+    private resolveFunctionOverload;
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined);
+    readonly ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined, ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }
-export type Meaning = Meaning_tagType | Meaning_tagMethod | Meaning_unresolved;
+export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {
     readonly type: types.Type;
     readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
@@ -36,17 +39,17 @@ declare class Meaning_tagType {
     get singleSuitableConstructor(): FoundAnonymousDeclaration<types.Constructor> | undefined;
     constructor(type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
 }
-declare class Meaning_tagMethod {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];
-    readonly suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[];
-    readonly kind = "tag-method";
-    get singleSuitableMethod(): FoundNamedDeclaration<AccessedMethod> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<AccessedMethod>[], suitableMethods: readonly FoundNamedDeclaration<AccessedMethod>[]);
+declare class Meaning_tagFunction {
+    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly kind = "tag-function";
+    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type | ResolvedQualifier_method;
+export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type | ResolvedQualifier_function;
 export declare class ResolvedQualifier_packageNameSegment {
     readonly packageTreeNode: PackageNameTreeNode;
     readonly kind = "package-name-segment";
@@ -64,11 +67,11 @@ export declare class ResolvedQualifier_type {
     get singleSuitableType(): FoundNamedDeclaration<NamedTypeEntity> | undefined;
     constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[]);
 }
-export declare class ResolvedQualifier_method {
-    readonly candidates: readonly FoundNamedDeclaration<MethodEntity>[];
-    readonly suitableMethods: readonly FoundNamedDeclaration<MethodEntity>[];
-    readonly kind = "method";
-    get singleSuitableMethod(): FoundNamedDeclaration<MethodEntity> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<MethodEntity>[], suitableMethods: readonly FoundNamedDeclaration<MethodEntity>[]);
+export declare class ResolvedQualifier_function {
+    readonly candidates: readonly FoundNamedDeclaration<FunctionEntity>[];
+    readonly suitableFunctions: readonly FoundNamedDeclaration<FunctionEntity>[];
+    readonly kind = "function";
+    get singleSuitableFunction(): FoundNamedDeclaration<FunctionEntity> | undefined;
+    constructor(candidates: readonly FoundNamedDeclaration<FunctionEntity>[], suitableFunctions: readonly FoundNamedDeclaration<FunctionEntity>[]);
 }
 export {};

package/build/types/analysis/Tags.d.ts

@@ -1,7 +1,7 @@
 import { ParameterVariableEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
-import { AccessedMethod } from './AccessedMethod.js';
-export type Tag = TagType | TagMethod;
+import { AccessedFunction } from './AccessedFunction.js';
+export type Tag = TagType | TagFunction;
 declare abstract class TagBase {
     readonly argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>;
     private readonly _argumentByName;
@@ -14,10 +14,10 @@ export declare class TagType extends TagBase {
     readonly constructor_: types.Constructor;
     constructor(type: types.Type, constructor_: types.Constructor, argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
 }
-export declare class TagMethod extends TagBase {
-    readonly kind = "method";
-    readonly method: AccessedMethod;
-    constructor(method: AccessedMethod, argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
+export declare class TagFunction extends TagBase {
+    readonly kind = "function";
+    readonly func: AccessedFunction;
+    constructor(func: AccessedFunction, argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
 }
 export type TagArgument = TagArgument_string | TagArgument_numeric | TagArgument_boolean | TagArgument_invalid;
 export declare class TagArgument_string {

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

@@ -1,7 +1,7 @@
 import { LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { ControlFlowNode, NarrowableReferenceExpression } from './ControlFlowGraphBuilder.js';
+import * as controlFlow from './control-flow/index.js';
 export declare class TypeNarrower {
     private readonly _analyzer;
     private readonly _referenceExpression;
@@ -10,7 +10,7 @@ export declare class TypeNarrower {
     private _reference;
     private readonly _typeByNode;
     private readonly _isVariableAssignedInLoopCheckResults;
-    constructor(analyzer: Analyzer, referenceExpression: NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: ControlFlowNode);
+    constructor(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node);
     getType(): types.Type;
     private getTypeAtControlFlowNode;
     private getTypeAtCondition;
@@ -30,7 +30,7 @@ export declare class TypeNarrower {
     private getReferenceAtNode;
     private getReferenceAtLocalVariableDeclaration;
 }
-export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.InstanceTypeVariable | NarrowableReference.StaticTypeVariable | NarrowableReference.Object;
+export type NarrowableReference = NarrowableReference.LocalVariable | NarrowableReference.PackageVariable | NarrowableReference.ObjectField | NarrowableReference.StaticField | NarrowableReference.ObjectAutoVariable;
 export declare namespace NarrowableReference {
     export class LocalVariable implements INarrowableReference {
         private readonly _analyzer;
@@ -39,8 +39,8 @@ export declare namespace NarrowableReference {
         constructor(_analyzer: Analyzer, entity: LocalVariableEntity | ParameterVariableEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
-        equalsExpression(expression: NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
     export class PackageVariable implements INarrowableReference {
         private readonly _analyzer;
@@ -49,36 +49,36 @@ export declare namespace NarrowableReference {
         constructor(_analyzer: Analyzer, entity: PackageVariableEntity);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
-        equalsExpression(expression: NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
-    export class InstanceTypeVariable implements INarrowableReference {
+    export class ObjectField implements INarrowableReference {
         private readonly _analyzer;
         readonly variable: types.Variable;
         readonly receiver: NarrowableReference;
-        readonly kind = "instance-type-variable";
+        readonly kind = "object-field";
         constructor(_analyzer: Analyzer, variable: types.Variable, receiver: NarrowableReference);
         equals(other: NarrowableReference): boolean;
         contains(other: NarrowableReference): boolean;
-        equalsExpression(expression: NarrowableReferenceExpression): boolean;
-        containsExpression(expression: NarrowableReferenceExpression): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
-    export class StaticTypeVariable implements INarrowableReference {
+    export class StaticField implements INarrowableReference {
         private readonly _analyzer;
         readonly variable: types.Variable;
-        readonly kind = "static-type-variable";
+        readonly kind = "static-field";
         constructor(_analyzer: Analyzer, variable: types.Variable);
         equals(other: NarrowableReference): boolean;
         contains(_other: NarrowableReference): boolean;
-        equalsExpression(expression: NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: NarrowableReferenceExpression): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
-    export class Object implements INarrowableReference {
-        readonly kind = "object";
+    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;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
     interface INarrowableReference {
         equals(other: NarrowableReference): boolean;
@@ -90,8 +90,8 @@ export declare namespace NarrowableReference {
          * связывание для имени `б` выполняться не будет. Такое поведение необходимо при анализе циклов,
          * чтобы избежать рекурсии.
          */
-        equalsExpression(expression: NarrowableReferenceExpression): boolean;
-        containsExpression(expression: NarrowableReferenceExpression): boolean;
+        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
+        containsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
     }
     export {};
 }

package/build/types/analysis/Utils.d.ts

@@ -1,7 +1,8 @@
-import { Entity, MethodEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
+import { Entity, FunctionEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { Tag, TagMethod, TagType } from './Tags.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import { Tag, TagFunction, TagType } from './Tags.js';
 type TextToken = tree.Token<tree.TokenKind.TextLiteral> | tree.Token<tree.TokenKind.TextTemplateHead> | tree.Token<tree.TokenKind.TextTemplatePart> | tree.Token<tree.TokenKind.TextTemplateTail>;
 export declare function getUnescapedTextFromTextToken(token: TextToken): string;
 export declare function unwrapParenthesizedExpressions(expression: tree.Expression): tree.Expression;
@@ -10,9 +11,20 @@ export declare function unaliasType(type: types.Type): types.Type;
 export declare function unaliasType(type: types.Type | undefined): types.Type | undefined;
 export declare function getPackageContainingEntity(entity: Entity): PackageEntity;
 export declare function findTag(tagTypeEntity: StructuredTypeEntity, tags: readonly Tag[]): TagType | undefined;
-export declare function findTag(tagMethodEntity: MethodEntity, tags: readonly Tag[]): TagMethod | undefined;
+export declare function findTag(tagFunctionEntity: FunctionEntity, tags: readonly Tag[]): TagFunction | undefined;
 export declare function getRequiredTypeParameterCount(typeParameters: readonly TypeParameterEntity[]): number;
 export declare function flattenPackageMemberDeclarationList(list: tree.PackageMemberDeclarationList): Iterable<Exclude<tree.PackageMemberDeclaration, tree.PackageMemberGroupDeclaration>>;
 export declare function flattenTypeMemberDeclarationList(list: tree.TypeMemberDeclarationList): Iterable<Exclude<tree.TypeMemberDeclaration, tree.TypeMemberGroupDeclaration>>;
 export declare function isComputedVariableEntity(entity: VariableEntity): boolean;
+export type EntityOrPackageNameTreeNode = EntityOrPackageNameTreeNode_entity | EntityOrPackageNameTreeNode_node;
+export declare class EntityOrPackageNameTreeNode_entity {
+    readonly entity: Entity;
+    readonly kind = "entity";
+    constructor(entity: Entity);
+}
+export declare class EntityOrPackageNameTreeNode_node {
+    readonly node: PackageNameTreeNode;
+    readonly kind = "node";
+    constructor(node: PackageNameTreeNode);
+}
 export {};

package/build/types/analysis/WellKnownDeclarations.d.ts

@@ -1,5 +1,5 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { AliasTypeEntity, StructuredTypeEntity, TypeMethodEntity } from '../entities/index.js';
+import { AliasTypeEntity, StructuredTypeEntity, MethodEntity } from '../entities/index.js';
 export declare class WellKnownDeclarationsLoadError extends Error {
     readonly diagnostic: Diagnostic;
     constructor(diagnostic: Diagnostic);
@@ -16,7 +16,7 @@ export declare class WellKnownDeclarations {
     none: StructuredTypeEntity;
     enumerable: StructuredTypeEntity;
     enumerator: StructuredTypeEntity;
-    enumeratorMethod: TypeMethodEntity;
+    enumeratorMethod: MethodEntity;
     array: StructuredTypeEntity;
     readonlyArray: StructuredTypeEntity;
     map: StructuredTypeEntity;
@@ -27,11 +27,11 @@ export declare class WellKnownDeclarations {
     reference: StructuredTypeEntity;
     task: StructuredTypeEntity;
     error: StructuredTypeEntity;
-    method: StructuredTypeEntity;
+    func: StructuredTypeEntity;
     parameterArray: AliasTypeEntity;
     defaultImport: StructuredTypeEntity;
     realName: StructuredTypeEntity;
     builtIntoPlatform: StructuredTypeEntity;
-    typeVariableProxy: StructuredTypeEntity;
+    fieldProxy: StructuredTypeEntity;
     javaScriptDecorator: StructuredTypeEntity;
 }

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

@@ -0,0 +1,43 @@
+import { Diagnostic } from '../../diagnostic/Diagnostic.js';
+import { SourceFile } from '../../project/SourceFile.js';
+import { NarrowableReferenceExpression } from './NarrowableExpression.js';
+import { Node } from './Nodes.js';
+export declare class GraphBuilder {
+    private readonly _sourceFile;
+    private readonly _controlFlowNodeByReference;
+    private readonly _unreachableCodeDiagnostics;
+    private _isInRebuildingFinallyClauseGraphMode;
+    private _currentPredecessor;
+    private _currentContinueLoopTarget;
+    private _currentBreakLoopTarget;
+    private _currentErrorTarget;
+    private _currentReturnTarget;
+    constructor(sourceFile: SourceFile);
+    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 visitWhenTernaryExpression;
+    private visitCondition;
+    private visitBinaryExpression;
+    private visitPrefixUnaryExpressionInCondition;
+    private visitIsExpressionInCondition;
+    private setAssignmentAsCurrentPredecessor;
+    private visitChildren;
+    private addUnreachableCodeDiagnostic;
+}
+export declare class GraphBuildResult {
+    readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>;
+    readonly unreachableCodeDiagnostics: readonly Diagnostic[];
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+}

package/build/types/analysis/{ControlFlowGraphVisualizer.d.ts → control-flow/GraphVisualizer.d.ts}

@@ -1,12 +1,12 @@
-import { ControlFlowNode } from './ControlFlowGraphBuilder.js';
-export declare class ControlFlowGraphVisualizer {
+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: ControlFlowNode): string;
+    static generateGraphDescriptionInDotLanguage(startNode: Node): string;
     private static getLabel;
     private static createGetIdFunction;
 }

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

@@ -0,0 +1,5 @@
+import * as tree from '../../tree/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/control-flow/Nodes.d.ts

@@ -0,0 +1,91 @@
+import * as tree from '../../tree/index.js';
+export type Node = StartNode | ConditionNode | AssignmentNode | LocalVariableDeclarationNode | SplitNode | LoopNode | UnreachableNode;
+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.IsExpression;
+/**
+ * Хранит информацию об истинности некоторого условия. Например, если условие `а != пусто` истинно, то из типа
+ * переменной `а` необходимо исключить тип `Пусто`.
+ */
+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 {};

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

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