@artel/artc 0.6.25223 → 0.6.25224

package/build/{chunk-AX3LQ2CF.js → chunk-62KHK23H.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-LG4Z4SWO.js";
+} from "./chunk-Y6DODJCG.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-DZNNWICP.js";
+} from "./chunk-24QZJOMF.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

package/build/{chunk-LG4Z4SWO.js → chunk-Y6DODJCG.js}

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-DZNNWICP.js";
+} from "./chunk-24QZJOMF.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {

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

@@ -60,6 +60,7 @@ export declare class AnalyzedTranslationPackage {
     private createTranslatedTypeSignature;
     private enumerateTranslationsDeclarations;
     private findTypeTranslation;
+    private createAmbiguousAccessDiagnostic;
 }
 export declare class TranslatedPackageMembers {
     private readonly _namedMembers;

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

@@ -21,7 +21,6 @@ import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
-import { ControlFlowGraphBuildResult } from './ControlFlowGraphBuilder.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
@@ -43,6 +42,7 @@ import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
 import { TargetTypeHint } from './TargetTypeHint.js';
 import * as typeOverloadResolver from './TypeOverloadResolver.js';
+import * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
 export declare class Analyzer {
     static readonly enumeratorMethodName = "\u043F\u0435\u0440\u0435\u0431\u043E\u0440";
@@ -161,7 +161,7 @@ export declare class Analyzer {
      */
     isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
     isExpressionValidOutermostOptionalChaining(node: tree.Expression): boolean;
-    makeNoneAssignableToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
+    includeNoneToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
     checkIdentifierNameIsReserved(name: string, locale: PackageLocale): ReservedIdentifierKind | undefined;
     getReservedIdentifierName(reservedIdentifierKind: ReservedIdentifierKind, locale: PackageLocale): string;
     createNameFromIdentifier(node: tree.Identifier): Name;
@@ -223,7 +223,7 @@ export declare class Analyzer {
      * - Т: Объект?    -> (Т: Объект?) | Пусто (см. метод isNoneAssignableToType)
      * - Т: Объект     -> (Т: Объект) | Пусто
      */
-    makeNoneAssignableToType(type: types.Type): types.Type;
+    includeNoneToType(type: types.Type): types.Type;
     /**
      * Отвечает на вопрос "Совместим ли тип `Пусто` с данным типом?" (Можно ли присвоить `пусто` в переменную с данным типом?).
      * @example Для следующих типов метод вернёт:
@@ -241,7 +241,7 @@ export declare class Analyzer {
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
     getAnalyzedTranslationPackageForPackage(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
     enumerateAnalyzedTranslationPackages(): Iterable<AnalyzedTranslationPackage>;
-    getCommonObjectAndAspectTypesOfUnion(_unionType: types.UnionType): readonly types.StructuredType[];
+    getCommonObjectAndAspectTypesOfUnion(unionType: types.UnionType): readonly types.StructuredType[];
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
     createPackageMembers(pkg: SourcePackage): OriginalPackageMembers;
@@ -263,7 +263,11 @@ export declare class Analyzer {
     checkBodyOfRedefinableAliasTypeMethod(node: tree.TypeMethodDeclaration, diagnostics?: DiagnosticAcceptor): {
         redefinableMethodOfOriginalType: e.TypeMethodEntity;
     } | undefined;
-    getControlFlowGraph(sourceFile: project.SourceFile): ControlFlowGraphBuildResult;
+    getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
+    createAmbiguousEntityAccessDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousMethodAccessDiagnostic(methods: readonly WithLocalization<AccessedMethod>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousTypeMemberAccessDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<scope.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -292,6 +296,7 @@ export declare const enum SyntacticAccessKind {
 declare class Type {
     private readonly _analyzer;
     private readonly _unionTypeSpecifierTypes;
+    private readonly _intersectionTypeSpecifierTypes;
     private readonly _methodLiteralTypes;
     private readonly _methodBlockLiteralTypes;
     constructor(_analyzer: Analyzer);
@@ -330,6 +335,7 @@ declare class Type {
     private ofParenthesizedTypeSpecifier;
     private ofNullableTypeSpecifier;
     private ofUnionTypeSpecifier;
+    private ofIntersectionTypeSpecifier;
     private ofInvalidTypeSpecifier;
     private getTargetlessMethodBlockLiteralType;
     private inferMethodLiteralTypeFromNodeWithFallbackToTargetType;

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

@@ -68,7 +68,7 @@ export declare class DiagnosticCollector {
     private checkTypeSpecialization;
     private checkSpecializationOfDeclarationWithParameters;
     /**
-     * @returns `true` если была ошибка, иначе `false`.
+     * @returns `true` если не было ошибки, иначе `false`.
      */
     private checkTypeArgumentCount;
     private checkParameterDeclaration;

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

@@ -11,6 +11,7 @@ export declare class ImportedPackageNameTree {
 export interface PackageNameTreeNode {
     readonly name: Name;
     readonly package: ImportedPackage | undefined;
+    readonly parent: PackageNameTreeNode | undefined;
     getChild(name: Name): PackageNameTreeNode | undefined;
     hasChild(name: Name): boolean;
     getChildren(): Iterable<PackageNameTreeNode>;

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

@@ -4,6 +4,8 @@ import { QualifiedName } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import { WithLocalization } from './Localization.js';
+import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeResolver {
     private readonly _analyzer;
     private readonly _node;
@@ -16,12 +18,14 @@ export declare class NamedTypeResolver {
     private findTypesOrContainersWithTypesInPackageAccessedViaAlias;
     private findTypesOrContainersWithTypesInPackageNameSegment;
     private convertPackageMember;
+    private createAmbiguousAccessDiagnostic;
 }
 export declare class NamedTypeResolutionResult {
     readonly types: readonly FoundNamedDeclaration<NamedTypeEntity>[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[]);
+    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
+    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }
 export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
 export declare class ResolvedQualifier_packageNameSegment {

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

@@ -3,7 +3,9 @@ import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundNamedDeclaration } from './FoundDeclaration.js';
+import { WithLocalization } from './Localization.js';
 import { ResolvedQualifier } from './NamedTypeResolver.js';
+import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
     private readonly _analyzer;
     private readonly _node;
@@ -15,5 +17,6 @@ export declare class NamedTypeSpecifierResolutionResult {
     readonly type: FoundNamedDeclaration<types.Type> | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[]);
+    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
+    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }

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

@@ -1,11 +1,12 @@
 import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
+import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedMethod } from './AccessedMethod.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
+import { WithLocalization } from './Localization.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
     private readonly _semanticContext;
@@ -41,7 +42,7 @@ export declare class ResolutionResult {
      */
     dependsOnTargetType?: boolean);
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_unresolved;
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageMethodAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
     readonly accessKind: AccessKind;
@@ -102,6 +103,11 @@ declare class Meaning_operatorAccess {
     get singleSuitableOperator(): FoundAnonymousDeclaration<types.Operator> | undefined;
     constructor(candidates: readonly FoundAnonymousDeclaration<types.Operator>[], suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[]);
 }
+declare class Meaning_mixedAmbiguousAccess {
+    readonly entities: readonly WithLocalization<Entity>[];
+    readonly kind = "mixed-ambiguous-access";
+    constructor(entities: readonly WithLocalization<Entity>[]);
+}
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }

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

@@ -6,6 +6,8 @@ import { AccessedMethod } from './AccessedMethod.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;
@@ -25,7 +27,8 @@ 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;
 declare class Meaning_tagType {

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,6 +1,7 @@
 import { Entity, MethodEntity, PackageEntity, StructuredTypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
+import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Tag, TagMethod, 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;
@@ -15,4 +16,15 @@ export declare function getRequiredTypeParameterCount(typeParameters: readonly T
 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/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.PropertyAccessExpression | 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';

package/build/types/common/HelperPhrases.d.ts

@@ -5,7 +5,8 @@ export declare const enum HelperPhraseKind {
     TypeParameter = 2,
     Package = 3,
     PackageAlias = 4,
-    Variable = 5,
-    Overloads = 6
+    PackageNameSegment = 5,
+    Variable = 6,
+    Overloads = 7
 }
 export declare function getHelperPhrase(kind: HelperPhraseKind, locale: PackageLocale): string;

package/build/types/diagnostic/DiagnosticCode.d.ts

@@ -66,7 +66,7 @@ export declare enum DiagnosticCode {
     ParameterForPositionalArgumentNotFound = 64,
     CannotDetermineTargetTypeToCallTheConstructor = 65,
     AmbiguousAccess = 66,
-    PackageNameConflictsWithDeclarationName = 67,
+    AmbiguousAccess0 = 67,
     CanNotAssignValueToContextVariable = 68,
     ExpectedPackageNameOrAliasButFoundType = 69,
     TypeExpected = 70,
@@ -110,10 +110,10 @@ export declare enum DiagnosticCode {
     IncorrectBodyOfRedefinableAliasTypeMethod = 108,
     TheFollowingDeclarationsAreNotTranslated0 = 109,
     TheFollowingDeclarationAreNotTranslated0And1More = 110,
-    OperatorMustNotBeStatic = 111,
-    Operator0MustNotHaveParameters = 112,
-    Operator0MustHaveOneParameter = 113,
-    Operator0MustHaveNoMoreThanOneParameter = 114,
+    OperatorFunctionMustNotBeStatic = 111,
+    OperatorFunction0MustNotHaveParameters = 112,
+    OperatorFunction0MustHaveOneParameter = 113,
+    OperatorFunction0MustHaveNoMoreThanOneParameter = 114,
     CorrespondingRedefinableTypeMemberNotFound = 115,
     ConstructorCanNotBeRedefinable = 116,
     ConstructorCanNotBeRedefined = 117,

package/build/types/emitter/Entities.d.ts

@@ -136,7 +136,7 @@ export declare class PackageEntityDetails {
     isSource: boolean;
     isPackageWithMainMethod: boolean;
 }
-export type Type = SimpleType | UnionType;
+export type Type = SimpleType | UnionOrIntersectionType;
 export declare class SimpleType {
     readonly entity: TypeOrExtensionEntity;
     readonly typeArguments: readonly Type[];
@@ -144,10 +144,11 @@ export declare class SimpleType {
     constructor(entity: TypeOrExtensionEntity, typeArguments: readonly Type[]);
     equals(other: Type): boolean;
 }
-export declare class UnionType {
+export declare class UnionOrIntersectionType {
     readonly types: readonly Type[];
-    readonly kind = "union";
-    constructor(types: readonly Type[]);
+    readonly isUnion: boolean;
+    readonly kind = "union-or-intersection";
+    constructor(types: readonly Type[], isUnion: boolean);
     equals(other: Type): boolean;
 }
 export type Entity = VariableEntity | MethodEntity | TypeOrExtensionEntity | PackageEntity;

package/build/types/emitter/ir/Nodes.d.ts

@@ -205,10 +205,10 @@ export declare class EmptyStatement {
     clone(): EmptyStatement;
 }
 export declare class ErrorStatement {
-    expression: Expression | undefined;
+    expression: Expression;
     sourceLocation: SourceLocation | undefined;
     readonly kind = NodeKind.ErrorStatement;
-    constructor(expression: Expression | undefined, sourceLocation: SourceLocation | undefined);
+    constructor(expression: Expression, sourceLocation: SourceLocation | undefined);
     clone(): ErrorStatement;
 }
 export declare class ImportantStatement {

package/build/types/services/CompletionService.d.ts

@@ -34,7 +34,6 @@ export declare class CompletionService {
     private getCompletionItemInfosForTargetSignaturesValueParameters;
     private getScopeCompletionItemInfos;
     private getTypeCompletionItemInfos;
-    private getEntityFromType;
     private getTypeCompletionItemInfosFromPackage;
     private getTypeCompletionItemInfosFromPackageNameSegment;
     private getTypeCompletionItemInfosFromScope;