@artel/artc 0.6.25226 → 0.6.25227

package/build/{chunk-MHPX52MT.js → chunk-VD6OPILI.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-YNR2KYMJ.js";
+} from "./chunk-74TFH7TE.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-VRQPLLYS.js";
+} from "./chunk-NOECPQMV.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -216,7 +216,7 @@ var NodeCompiler = class {
       const standardLibraryUri = yield this.findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath);
       if (standardLibraryUri === void 0) {
         const diagnostic = new Diagnostic(DiagnosticData.withCode(
-          301 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
+          301 /* CannotFindTsLibDirectoryBaseSearchPaths0 */,
           [nodeModulesSearchPaths.map((p) => `'${p}'`).join(", ")]
         ), void 0);
         diagnostics?.addDiagnostic(diagnostic);

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { CancellationToken, Name, PackageLocale, Range, SearchName, WithDiagnostics } from '../common/index.js';
+import { CancellationToken, Lazy, Name, PackageLocale, Range, SearchName, WithDiagnostics } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
@@ -35,8 +35,6 @@ import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver
 import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
 import * as operationOverloadResolver from './OperationOverloadResolver.js';
-import * as scope from './Scope.js';
-import { SemanticContextBuilder } from './SemanticContextBuilder.js';
 import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
 import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
@@ -44,6 +42,7 @@ import { TargetTypeHint } from './TargetTypeHint.js';
 import * as typeOverloadResolver from './TypeOverloadResolver.js';
 import * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
+import * as semanticContext from './semantic-context/index.js';
 export declare class Analyzer {
     static readonly enumeratorMethodName = "\u043F\u0435\u0440\u0435\u0431\u043E\u0440";
     static readonly functionTypeInvokeMethodName = "\u0432\u044B\u043F\u043E\u043B\u043D\u0438\u0442\u044C";
@@ -60,8 +59,7 @@ export declare class Analyzer {
     readonly entity: Entity;
     readonly resultLocalVariableEntity: ResultLocalVariableEntity;
     readonly valueLocalVariableEntity: ValueLocalVariableEntity;
-    readonly scope: Scope;
-    readonly semanticContext: SemanticContextBuilder;
+    readonly semanticContext: semanticContext.SemanticContextBuilder;
     readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
     readonly defaultConstructors: DefaultConstructors;
     readonly overriddenMember: OverriddenMember;
@@ -96,6 +94,7 @@ export declare class Analyzer {
     private readonly _functionBlockWithYieldStatementCheckResults;
     private readonly _namedDeclarationsUsageCountResults;
     private readonly _controlFlowGraphs;
+    private readonly _diagnosticsComputedLazily;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
@@ -124,6 +123,7 @@ export declare class Analyzer {
     enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
     getSourceFileMembers(node: tree.SourceFile): ActualSourceFileMembers;
     getCallExpressionMeaning(node: tree.CallExpression): callExpressionMeaning.Meaning;
+    getCallExpressionType(node: tree.CallExpression): types.Type;
     getRespectiveParameter(node: tree.Argument): MatchResultValueParameter | undefined;
     resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.ResolutionResult;
     getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
@@ -157,7 +157,7 @@ export declare class Analyzer {
      * а?[1]
      * а?^
      * а?()
-     * (а)?.б
+     * (а?.б)
      * ```
      */
     isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
@@ -237,7 +237,7 @@ export declare class Analyzer {
     isValueParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(): types.Type;
     getOriginalSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
-    getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.VariableEntity[];
+    getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterVariableEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
     getAnalyzedTranslationPackageForPackage(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
@@ -265,9 +265,15 @@ export declare class Analyzer {
     } | undefined;
     getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
     createAmbiguousEntityAccessDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousEntityAccessLazyDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
     createAmbiguousFunctionAccessDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousFunctionAccessLazyDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Lazy<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;
+    createAmbiguousTypeMemberAccessLazyDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
+    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
+    createAmbiguousNamedScopeDeclarationAccessLazyDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
+    addNodeDiagnosticComputedLazily(node: tree.Node, diagnostic: Diagnostic): void;
+    getDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -322,6 +328,7 @@ declare class Type {
     private ofReferenceExpression;
     private ofDereferenceExpression;
     private ofWhenTernaryExpression;
+    private ofConditionalExpression;
     private ofTextTemplateLiteral;
     private ofIdentifierExpression;
     private ofTokenExpression;
@@ -452,66 +459,10 @@ declare class ValueLocalVariableEntity {
     private readonly _analyzer;
     private readonly _entities;
     constructor(_analyzer: Analyzer);
-    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.VariableEntity;
-    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.VariableEntity;
-    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.VariableEntity;
-    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.VariableEntity;
-}
-declare class Scope {
-    private readonly _analyzer;
-    private readonly _sourceFileScopes;
-    private readonly _functionBlockLiteralScopes;
-    private readonly _packageFunctionDeclarationTypeParametersScopes;
-    private readonly _packageFunctionDeclarationValueParametersScopes;
-    private readonly _structuredMethodDeclarationTypeParametersScopes;
-    private readonly _structuredMethodDeclarationValueParametersScopes;
-    private readonly _nestedFunctionDeclarationTypeParametersScopes;
-    private readonly _nestedFunctionDeclarationValueParametersScopes;
-    private readonly _functionLiteralScopes;
-    private readonly _functionBlockScopes;
-    private readonly _statementBlockScopes;
-    private readonly _forEachStatementScopes;
-    private readonly _catchClauseScopes;
-    private readonly _packageStructuredTypeDeclarationTypeParametersScopes;
-    private readonly _structuredTypeDeclarationBodyScopes;
-    private readonly _packageFunctionTypeDeclarationTypeParametersScopes;
-    private readonly _functionTypeDeclarationBodyScopes;
-    private readonly _packageVariantTypeDeclarationTypeParametersScopes;
-    private readonly _variantTypeDeclarationBodyScopes;
-    private readonly _aliasTypeDeclarationBodyScopes;
-    private readonly _packageAliasTypeDeclarationTypeParametersScopes;
-    private readonly _operatorDeclarationScopes;
-    private readonly _structuredConstructorDeclarationScopes;
-    private readonly _structuredDestructorDeclarationScopes;
-    private readonly _indexedElementAccessorDeclarationParametersScopes;
-    private readonly _typeExtensionDeclarationScopes;
-    constructor(_analyzer: Analyzer);
-    ofSourceFile(node: tree.SourceFile): scope.IScope;
-    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): scope.IScope;
-    ofPackageFunctionDeclarationTypeParameters(node: tree.PackageFunctionDeclaration): scope.IScope;
-    ofPackageFunctionDeclarationValueParameters(node: tree.PackageFunctionDeclaration): scope.IScope;
-    ofMethodDeclarationTypeParameters(node: tree.MethodDeclaration): scope.IScope;
-    ofMethodDeclarationValueParameters(node: tree.MethodDeclaration): scope.IScope;
-    ofNestedFunctionDeclarationTypeParameters(node: tree.NestedFunctionDeclaration): scope.IScope;
-    ofNestedFunctionDeclarationValueParameters(node: tree.NestedFunctionDeclaration): scope.IScope;
-    ofFunctionLiteral(node: tree.FunctionLiteral): scope.IScope;
-    ofFunctionBlock(node: tree.FunctionBlock): scope.IScope;
-    ofStatementBlock(node: tree.StatementBlock): scope.IScope;
-    ofForStatement(node: tree.ForStatement): scope.IScope;
-    ofCatchClause(node: tree.CatchClause): scope.IScope;
-    ofPackageStructuredTypeDeclarationTypeParameters(node: tree.PackageStructuredTypeDeclaration): scope.IScope;
-    ofStructuredTypeDeclarationBody(node: tree.StructuredTypeDeclarationBody): scope.IScope;
-    ofPackageFunctionTypeDeclarationTypeParameters(node: tree.PackageFunctionTypeDeclaration): scope.IScope;
-    ofFunctionTypeDeclarationBody(node: tree.FunctionTypeDeclarationBody): scope.IScope;
-    ofPackageVariantTypeDeclarationTypeParameters(node: tree.PackageVariantTypeDeclaration): scope.IScope;
-    ofVariantTypeDeclarationBody(node: tree.VariantTypeDeclarationBody): scope.IScope;
-    ofAliasTypeDeclarationBody(node: tree.AliasTypeDeclarationBody): scope.IScope;
-    ofPackageAliasTypeDeclarationTypeParameters(node: tree.PackageAliasTypeDeclaration): scope.IScope;
-    ofOperatorDeclaration(node: tree.OperatorDeclaration): scope.IScope;
-    ofConstructorDeclaration(node: tree.ConstructorDeclaration): scope.IScope;
-    ofDestructorDeclaration(node: tree.DestructorDeclaration): scope.IScope;
-    ofIndexedElementAccessorDeclarationParameters(node: IndexedElementAccessorDeclaration): scope.IScope;
-    ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): scope.IScope;
+    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.LocalVariableEntity;
+    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.LocalVariableEntity;
+    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.LocalVariableEntity;
+    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
 }
 declare class DefaultConstructors {
     private readonly _analyzer;
@@ -662,10 +613,13 @@ export declare class TypeUtils {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
     getCommonObjectAndAspectTypesOfUnion(unionType: types.UnionType): readonly types.StructuredType[];
-    private getTypesForCommonTypesSearch;
+    removeBaseTypesInPlace(types: types.Type[]): void;
+    removeDerivedTypesInPlace(types: types.Type[]): void;
+    private getBaseTypesForCommonTypesSearch;
     private addTypeAndCollectAllBaseTypes;
     private addTypeIfUnique;
-    private removeBaseTypes;
+    private getFlattenedConstituentTypesForCommonTypesSearch;
+    private flattenTypeParameterConstraint;
 }
 export declare class ExpressionDenotesFunctionCheckResult {
     readonly candidates: readonly WithLocalization<AccessedFunction>[];

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

@@ -0,0 +1,11 @@
+import { Analyzer } from './Analyzer.js';
+import * as controlFlow from './control-flow/index.js';
+export declare class AssignmentChecker {
+    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/CallExpressionMeaning.d.ts

@@ -11,8 +11,10 @@ export declare class Resolver {
     constructor(_analyzer: Analyzer, _node: CallExpression);
     private get callee();
     resolve(): Meaning;
+    resolveType(meaning: Meaning | undefined): types.Type;
     private resolveConstructorCallExpressionMeaning;
     private getNodeForDiagnostics;
+    private getTypeFromMeaning;
 }
 export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_functionCall {

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

@@ -47,10 +47,11 @@ export declare class DiagnosticCollector {
     private checkTypeMemberBodyPresence;
     private tryGetTypeMemberDeclarationEntity;
     private isAspectTypeMemberDeclaration;
-    private collectIdentifierExpressionDiagnostics;
-    private collectMemberAccessExpressionDiagnostics;
+    private checkIdentifierExpression;
+    private checkLocalVariableUsedBeforeDeclaration;
+    private checkLocalVariableIsUsedBeforeBeingAssigned;
+    private checkMemberAccessExpression;
     private addDiagnosticsFromMatchResult;
-    private checkStatementForVariablesUsedBeforeBeingAssigned;
     private checkExpressionTypeAssignableToTargetType;
     private addTypeAssignabilityDiagnosticIfBothTypesResolved;
     private checkAssignmentIsValid;
@@ -75,4 +76,6 @@ export declare class DiagnosticCollector {
     private checkIfVariableIsUnused;
     private addDiagnostic;
     private addDiagnostics;
+    private addMaybeLazyDiagnostic;
+    private addMaybeLazyDiagnostics;
 }

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

@@ -1,4 +1,4 @@
-import { AccessKind, Name } from '../common/index.js';
+import { AccessKind, MaybeLazy, Name } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
@@ -6,8 +6,8 @@ import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import * as scope from './Scope.js';
 import { Analyzer, TargetTypeHint } from './index.js';
+import { NamedDeclaration } from './semantic-context/index.js';
 export declare class Resolver {
     private readonly _semanticContext;
     private readonly _analyzer;
@@ -23,12 +23,12 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
+    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
+    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined, 
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
@@ -73,9 +73,9 @@ declare class Meaning_typeAccess {
     constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<types.Type>[]);
 }
 declare class Meaning_mixedAmbiguousAccess {
-    readonly declarations: readonly FoundNamedDeclaration<scope.NamedDeclaration>[];
+    readonly declarations: readonly FoundNamedDeclaration<NamedDeclaration>[];
     readonly kind = "mixed-ambiguous-access";
-    constructor(declarations: readonly FoundNamedDeclaration<scope.NamedDeclaration>[]);
+    constructor(declarations: readonly FoundNamedDeclaration<NamedDeclaration>[]);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";

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

@@ -1,4 +1,4 @@
-import { AccessKind } from '../common/index.js';
+import { AccessKind, MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { IndexedAccessExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -16,8 +16,8 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
+    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
+    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined);
 }
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {

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

@@ -1,4 +1,4 @@
-import { AccessKind } from '../common/index.js';
+import { AccessKind, MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
@@ -6,8 +6,8 @@ import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { WithLocalization } from './Localization.js';
 import { Analyzer, TargetTypeHint } from './index.js';
+import { WithLocalization } from './Localization.js';
 export declare class Resolver {
     private readonly _semanticContext;
     private readonly _analyzer;
@@ -31,18 +31,18 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
+    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
+    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined, 
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     dependsOnTargetType?: boolean);
 }
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticVariableAccess | Meaning_staticMethodAccess | Meaning_instanceVariableAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
     readonly accessKind: AccessKind;
@@ -68,11 +68,11 @@ declare class Meaning_packageNameSegmentAccess {
     readonly kind = "package-name-segment-access";
     constructor(packageTreeNode: PackageNameTreeNode);
 }
-declare class Meaning_staticVariableAccess {
+declare class Meaning_staticFieldAccess {
     readonly type: types.Type;
     readonly variable: FoundNamedDeclaration<types.Variable>;
     readonly accessKind: AccessKind;
-    readonly kind = "static-variable-access";
+    readonly kind = "static-field-access";
     constructor(type: types.Type, variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_staticMethodAccess {
@@ -83,10 +83,10 @@ declare class Meaning_staticMethodAccess {
     get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
     constructor(type: types.Type, candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
 }
-declare class Meaning_instanceVariableAccess {
+declare class Meaning_instanceFieldAccess {
     readonly variable: FoundNamedDeclaration<types.Variable>;
     readonly accessKind: AccessKind;
-    readonly kind = "instance-variable-access";
+    readonly kind = "instance-field-access";
     constructor(variable: FoundNamedDeclaration<types.Variable>, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {

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

@@ -1,3 +1,4 @@
+import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { QualifiedName } from '../tree/index.js';
@@ -23,9 +24,9 @@ export declare class NamedTypeResolver {
 export declare class NamedTypeResolutionResult {
     readonly types: readonly FoundNamedDeclaration<NamedTypeEntity>[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly Diagnostic[];
+    readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
     readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<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

@@ -1,3 +1,4 @@
+import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -16,7 +17,7 @@ export declare class NamedTypeSpecifierResolver {
 export declare class NamedTypeSpecifierResolutionResult {
     readonly type: FoundNamedDeclaration<types.Type> | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly Diagnostic[];
+    readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
     readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }

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

@@ -12,7 +12,6 @@ export declare class NodeTypeUtils {
     static isFunctionDeclaration(node: tree.Node): node is FunctionDeclaration;
     static isVariableDeclaration(node: tree.Node): node is VariableDeclaration;
     static isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
-    static isSubprogramDeclaration(node: tree.Node): node is SubprogramDeclaration;
     static isNoneLiteral(node: tree.Node): boolean;
 }
 export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
@@ -29,4 +28,6 @@ export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDecla
 export type FieldAccessorDeclaration = tree.FieldGetterDeclaration | tree.FieldSetterDeclaration;
 export type IndexedElementAccessorDeclaration = tree.IndexedElementGetterDeclaration | tree.IndexedElementSetterDeclaration;
 export type DereferencedVariableAccessorDeclaration = tree.DereferencedVariableGetterDeclaration | tree.DereferencedVariableSetterDeclaration;
-export type SubprogramDeclaration = tree.FunctionBlockParent | tree.FunctionLiteral | tree.FunctionBlockLiteral;
+export type SubprogramDeclaration = tree.FunctionBlockParent;
+export type RegularOrBlockFunctionLiteral = tree.FunctionLiteral | tree.FunctionBlockLiteral;
+export type SubprogramDeclarationOrLiteral = SubprogramDeclaration | RegularOrBlockFunctionLiteral;

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

@@ -1,3 +1,4 @@
+import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { FunctionEntity, NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
@@ -26,9 +27,9 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostic?: Diagnostic | undefined;
+    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
     readonly ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined, ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: MaybeLazy<Diagnostic> | undefined, ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {

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

@@ -4,7 +4,7 @@ import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { LocalizationContext } from './LocalizationContext.js';
-import { Lookup } from './Lookup.js';
+import { SemanticContext } from './semantic-context/SemanticContext.js';
 export declare class TypeMemberLookup {
     private readonly _analyzer;
     private readonly _typeOrExtension;
@@ -19,13 +19,13 @@ export declare class TypeMemberLookup {
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
     static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
     static ofTypeOrExtension(analyzer: Analyzer, typeOrExtension: TypeOrExtension, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
-    getNamedMembers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getNamedMembersByName(name: SearchName, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Constructor>[];
-    getIndexers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.Indexer>[];
-    getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionsLookup?: Lookup): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
+    getNamedMembers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
+    getNamedMembersByName(name: SearchName, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
+    getOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getOperatorsByKind(kind: OperatorKind, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Operator>[];
+    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Constructor>[];
+    getIndexers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Indexer>[];
+    getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
     private getLocaleOfTypeEntity;
 }
 export declare class BoundTypeMemberLookup {
@@ -34,9 +34,9 @@ export declare class BoundTypeMemberLookup {
     private readonly _hidingMatcher;
     private readonly _typeExtensionLookup;
     private constructor();
-    static ofType(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined): BoundTypeMemberLookup;
-    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined): BoundTypeMemberLookup;
-    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: Lookup | undefined): BoundTypeMemberLookup;
+    static ofType(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
+    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
+    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
     getNamedMembers(): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
     getNamedMembersByName(name: SearchName): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
     getOperators(): readonly FoundAnonymousDeclaration<types.Operator>[];

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

@@ -1,4 +1,3 @@
-import { LocalVariableEntity, PackageVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import * as controlFlow from './control-flow/index.js';
@@ -26,72 +25,4 @@ export declare class TypeNarrower {
     private checkIfVariableIsAssignedInLoop;
     private checkIfVariableIsAssignedAtNode;
     private isSameReferenceAsNarrowedExpression;
-    private getReferenceAtNodeIfNarrowable;
-    private getReferenceAtNode;
-    private getReferenceAtLocalVariableDeclaration;
-}
-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;
-        readonly entity: LocalVariableEntity | ParameterVariableEntity;
-        readonly kind = "local-variable";
-        constructor(_analyzer: Analyzer, entity: LocalVariableEntity | ParameterVariableEntity);
-        equals(other: NarrowableReference): boolean;
-        contains(_other: NarrowableReference): boolean;
-        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: controlFlow.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: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    export class ObjectField implements INarrowableReference {
-        private readonly _analyzer;
-        readonly variable: types.Variable;
-        readonly receiver: NarrowableReference;
-        readonly kind = "object-field";
-        constructor(_analyzer: Analyzer, variable: types.Variable, receiver: NarrowableReference);
-        equals(other: NarrowableReference): boolean;
-        contains(other: NarrowableReference): boolean;
-        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    export class StaticField implements INarrowableReference {
-        private readonly _analyzer;
-        readonly variable: types.Variable;
-        readonly kind = "static-field";
-        constructor(_analyzer: Analyzer, variable: types.Variable);
-        equals(other: NarrowableReference): boolean;
-        contains(_other: NarrowableReference): boolean;
-        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    export class ObjectAutoVariable implements INarrowableReference {
-        readonly kind = "object-auto-variable";
-        equals(other: NarrowableReference): boolean;
-        contains(_other: NarrowableReference): boolean;
-        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(_expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    interface INarrowableReference {
-        equals(other: NarrowableReference): boolean;
-        contains(other: NarrowableReference): boolean;
-        /**
-         * Отличается от метода `equals` тем, что выполняет сравнение лениво. Например, при сравнении с выражением
-         * `а.б` сперва будут сравнены части слева от точки (выражение `а` с `receiver`), и только при равенстве будет
-         * связано и сравнено имя `б`. Если выражение `а` не равно `receiver`, то сразу будет возвращено `false` и
-         * связывание для имени `б` выполняться не будет. Такое поведение необходимо при анализе циклов,
-         * чтобы избежать рекурсии.
-         */
-        equalsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-        containsExpression(expression: controlFlow.NarrowableReferenceExpression): boolean;
-    }
-    export {};
 }

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

@@ -28,6 +28,7 @@ export declare class GraphBuilder {
     private visitErrorStatement;
     private visitLocalVariableDeclaration;
     private visitWhenTernaryExpression;
+    private visitConditionalExpression;
     private visitCondition;
     private visitBinaryExpression;
     private visitPrefixUnaryExpressionInCondition;