@artel/artc 0.6.25283 → 0.6.25284

package/build/{chunk-MJ2ZVHII.js → chunk-OBX375YX.js}

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

package/build/{chunk-7RAZAZE6.js → chunk-ZV3UW5X6.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-MJ2ZVHII.js";
+} from "./chunk-OBX375YX.js";
 import {
   ArtelVersion,
   Cached,
@@ -15,7 +15,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-2Q4QKW7T.js";
+} from "./chunk-CGOSDN2E.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";

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

@@ -0,0 +1,20 @@
+import { AccessorEntity, PackageMemberEntity, TypeMemberEntity } from '../entities/index.js';
+import * as types from '../types/index.js';
+import { PackageMemberLookupContext } from './PackageMemberLookup.js';
+import { TypeMemberLookupContext } from './TypeMemberLookup.js';
+export declare class AccessibilityCheck {
+    static isPackageMemberAccessible(entity: PackageMemberEntity | AccessorEntity, context: PackageMemberLookupContext): boolean;
+    /**
+     * Проверяет, доступен ли член типа в заданном контексте (в точке, где происходит обращение).
+     *
+     * Помимо контекста, на доступность членов типа, скрытых в иерархии типов, влияет тип объекта (`receiverType`),
+     * через который происходит обращение. Тип объекта должен быть равным или производным от типа, в рамках которого
+     * происходит доступ (`context.typeOrExtensionEntity`). Для всеобщих членов типа тип объекта не влияет на доступность.
+     * Это правило также не применяется при доступе через "основа", поскольку несмотря на то, что тип основы не является
+     * производным от типа, в котором происходит обращение, члены основы должны быть доступны в производном типе.
+     * Поэтому в случае доступа через "основа" в качестве значения параметра `ignoreReceiverType` передавать `true`.
+     */
+    static isTypeMemberAccessible(entity: TypeMemberEntity | AccessorEntity, context: TypeMemberLookupContext | undefined, receiverType: types.Type | undefined, ignoreReceiverType: boolean): boolean;
+    private static isTypeDerivedFromOrEquals;
+    private static isStaticTypeMemberOrAccessorEntity;
+}

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

@@ -6,7 +6,6 @@ import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js
 import { WithDiagnostics } from '../diagnostic/WithDiagnostics.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
 import * as e from '../entities/index.js';
-import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
 import * as project from '../project/index.js';
 import { PackageName, PlatformKind, SourcePackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
@@ -31,12 +30,16 @@ import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver
 import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, StructuredTypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
 import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
+import { ReachabilityChecker } from './ReachabilityChecker.js';
+import { ReductionSourceMemberFinder } from './ReductionSourceMemberFinder.js';
+import { ReservedNameKind } from './ReservedNameDictionary.js';
 import { ResolvedImplementationPackage } from './ResolvedImplementationPackage.js';
 import { ResolvedTextTranslationPackage } from './ResolvedTextTranslationPackage.js';
 import * as tags from './Tag.js';
 import * as tagMeaning from './TagMeaning.js';
 import { TypeWithMembersOrTypeExtensionDeclaration } from './TreeQuery.js';
 import { TypeMemberImplementationCheckResult } from './TypeMemberImplementationChecker.js';
+import { TypeMemberLookupContext } from './TypeMemberLookup.js';
 import * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
 import * as semanticContext from './semantic-context/index.js';
@@ -73,6 +76,8 @@ export declare class Analyzer {
     readonly signatureComparer: SignatureComparer;
     readonly conflictsCheck: ConflictsCheck;
     readonly typeAssignabilityCheck: TypeAssignabilityCheck;
+    readonly reachabilityChecker: ReachabilityChecker;
+    readonly reductionSourceMemberFinder: ReductionSourceMemberFinder;
     private readonly tsInteropInputs;
     private readonly targetType;
     private readonly tsInterop_;
@@ -179,10 +184,11 @@ export declare class Analyzer {
     isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
     isExpressionValidOutermostOptionalChaining(node: tree.Expression): boolean;
     includeNullToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
-    checkIdentifierNameIsReserved(name: string, locale: PackageLocale): ReservedIdentifierKind | undefined;
-    getReservedIdentifierName(reservedIdentifierKind: ReservedIdentifierKind, locale: PackageLocale): string;
+    checkIdentifierNameIsReserved(name: Name, locale: PackageLocale): ReservedNameKind | undefined;
+    getReservedName(reservedNameKind: ReservedNameKind, locale: PackageLocale): Name;
     createNameFromIdentifier(node: tree.Identifier): Name;
     getImplicitBaseTypeForStructuredType(entity: e.StructuredTypeEntity): types.StructuredType | undefined;
+    getImplicitBaseTypeForReducedType(entity: e.ReducedTypeEntity): types.StructuredType;
     getImplicitBaseTypeForVariantType(locale: PackageLocale): types.StructuredType;
     getImplicitBaseTypeForFunctionType(locale: PackageLocale): types.StructuredType;
     resolveNamedTypeSpecifier(node: tree.NamedTypeSpecifier): NamedTypeSpecifierResolutionResult;
@@ -278,6 +284,8 @@ export declare class Analyzer {
     instantiateTypeMemberByIdentitySubstitution(entity: e.OperatorEntity): types.Operator;
     instantiateTypeMemberByIdentitySubstitution(entity: e.IndexerEntity): types.Indexer;
     instantiateTypeMemberByIdentitySubstitution(entity: e.DereferenceOperatorEntity): types.DereferenceOperator;
+    instantiateTypeMemberByIdentitySubstitution(entity: e.ConstructorEntity): types.Constructor;
+    instantiateTypeMemberByIdentitySubstitution(entity: e.DestructorEntity): types.Destructor;
     instantiateTypeMemberByIdentitySubstitution(entity: e.TypeMemberEntity): types.TypeMember;
     createPackageMemberHiding(node: tree.PackageMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
@@ -320,10 +328,8 @@ export declare class Analyzer {
     checkTypeArgumentCount(typeArgumentCount: number, typeParameters: readonly e.TypeParameterEntity[], diagnostics?: DiagnosticAcceptor, nodeForDiagnostic?: tree.Node): boolean;
     checkTypeCanBeUsedAsValue(typeAccess: tree.Expression): boolean;
     getEntityDiagnosticLocation(entity: e.Entity, chooseSetter?: boolean): DiagnosticLocation | undefined;
-    createTypeMemberLookupContextWithinType(type: e.TypeEntity): {
-        hidingMatcher: e.IEntityHidingMatcher;
-        typeExtensionLookup: semanticContext.SemanticContext | undefined;
-    };
+    createTypeMemberLookupContextWithinType(type: e.TypeEntity): TypeMemberLookupContext;
+    isPossiblyCastedBaseExpression(node: tree.Expression): boolean;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -388,7 +394,6 @@ declare class Type {
     constructor(analyzer: Analyzer);
     ofExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
-    ofAccessedOperator(operator: types.Operator): types.Type;
     private ofExpressionWithoutGuard;
     private ofFunctionBlockLiteral;
     private ofFunctionLiteral;
@@ -472,6 +477,7 @@ declare class Entity {
     private readonly packageFunctionTypeEntities;
     private readonly anonymousFunctionTypeEntities;
     private readonly aliasTypeEntities;
+    private readonly reducedTypeEntities;
     private readonly packageFunctionEntities;
     private readonly methodEntities;
     private readonly nestedFunctionEntities;
@@ -508,6 +514,7 @@ declare class Entity {
     ofAnonymousVariantTypeDeclaration(node: tree.AnonymousVariantTypeDeclaration): e.AnonymousVariantTypeEntity;
     ofVariantTypeDeclaration(node: VariantTypeDeclaration): e.VariantTypeEntity;
     ofPackageAliasTypeDeclaration(node: tree.PackageAliasTypeDeclaration): e.AliasTypeEntity;
+    ofPackageReducedTypeDeclaration(node: tree.PackageReducedTypeDeclaration): e.ReducedTypeEntity;
     ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.PackageFunctionEntity;
     ofMethodDeclaration(node: tree.MethodDeclaration): e.MethodEntity;
     ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.NestedFunctionEntity;
@@ -701,6 +708,7 @@ declare class TypeAssignabilityCheck {
     getSingleFlagScore(flag: TypeAssignabilityFlags): number;
     getLowestFlagsScore(flags: TypeAssignabilityFlags): number;
     private getAssignabilityFlagsForStructuredTypes;
+    private isStructuredTypeDerivedFromOrEqualsTo;
     /**
      * @example
      * ```artel

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

@@ -1,16 +1,15 @@
 import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { IEntityHidingMatcher, TypeEntityWithMembers } from '../entities/index.js';
+import { TypeEntityWithMembers } from '../entities/index.js';
 import { Node } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
 import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
 export declare class BaseMemberConflictsValidator {
     private readonly analyzer;
     private readonly typeEntity;
-    private readonly hidingMatcher;
     private readonly diagnosticArgumentFactory;
     private readonly diagnostics;
     private readonly nodeForDiagnostic;
-    constructor(analyzer: Analyzer, typeEntity: TypeEntityWithMembers, hidingMatcher: IEntityHidingMatcher, diagnosticArgumentFactory: DiagnosticArgumentFactory, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: Node);
+    constructor(analyzer: Analyzer, typeEntity: TypeEntityWithMembers, diagnosticArgumentFactory: DiagnosticArgumentFactory, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: Node);
     validate(): void;
     private getAllNotShadowedNotOverriddenMembers;
     private validateMemberConflicts;
@@ -20,7 +19,6 @@ export declare class BaseMemberConflictsValidator {
     private reportMembersConflictDiagnostic;
     private reportMembersOriginalNameConflictConflictDiagnostic;
     private addOverriddenMembersRecursively;
-    private typeMemberMatchesHiding;
     private getOriginalTypeMemberNameConsideringOverriddenMembers;
     private getLeastOverriddenNamedMember;
 }

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

@@ -1,13 +1,12 @@
-import { PackageLocale } from '../common/index.js';
 import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
-import { IEntityHidingMatcher, NamedTypeEntity } from '../entities/index.js';
+import { NamedTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
-import { SemanticContext } from './semantic-context/SemanticContext.js';
+import { TypeMemberLookupContext } from './TypeMemberLookup.js';
 export declare class Resolver {
     static resolve(analyzer: Analyzer, candidates: readonly types.Constructor[], argumentList: tree.ArgumentList | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): readonly types.Constructor[];
-    static resolveByNamedTypes(analyzer: Analyzer, typeEntities: readonly NamedTypeEntity[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, locale: PackageLocale, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    static resolveByNamedTypes(analyzer: Analyzer, typeEntities: readonly NamedTypeEntity[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, typeMemberLookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
     private static typeCanBeConstructed;
 }
 export declare class ResolutionResult {

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

@@ -24,7 +24,8 @@ export declare class FirstStageResolver {
     private resolveStaticMemberOrVariantAccessMeaning;
     private resolveInstanceMemberAccessMeaning;
     private tryResolveInstanceOperatorAccessMeaning;
-    private convertSyntacticAccessKind;
+    private convertPackageVariableSyntacticAccessKind;
+    private convertFieldSyntacticAccessKind;
 }
 export declare class SecondStageResolver {
     private readonly analyzer;

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

@@ -5,20 +5,21 @@ import { ModifierFlags } from './ModifierFlags.js';
 declare enum PackageMemberDeclarationKind {
     TranslationsDeclaration = 0,
     AliasTypeDeclaration = 1,
-    MemberGroupDeclaration = 2,
-    TypeExtensionDeclaration = 3,
-    ConstructorDeclaration = 4,
-    EntryPointDeclaration = 5,
-    FunctionDeclaration = 6,
-    FunctionTypeDeclaration = 7,
-    ObjectTypeDeclaration = 8,
-    PlainObjectTypeDeclaration = 9,
-    AspectTypeDeclaration = 10,
-    VariableDeclaration = 11,
-    VariableGetterDeclaration = 12,
-    VariableSetterDeclaration = 13,
-    VariantTypeDeclaration = 14,
-    InvalidDeclaration = 15
+    ReducedTypeDeclaration = 2,
+    MemberGroupDeclaration = 3,
+    TypeExtensionDeclaration = 4,
+    ConstructorDeclaration = 5,
+    EntryPointDeclaration = 6,
+    FunctionDeclaration = 7,
+    FunctionTypeDeclaration = 8,
+    ObjectTypeDeclaration = 9,
+    PlainObjectTypeDeclaration = 10,
+    AspectTypeDeclaration = 11,
+    VariableDeclaration = 12,
+    VariableGetterDeclaration = 13,
+    VariableSetterDeclaration = 14,
+    VariantTypeDeclaration = 15,
+    InvalidDeclaration = 16
 }
 type TypeMemberDeclarationKind = tree.TypeMemberDeclaration['kind'];
 export declare enum DeclarationWithTypeMembersKind {
@@ -27,7 +28,8 @@ export declare enum DeclarationWithTypeMembersKind {
     AspectType = 2,
     VariantType = 3,
     AliasType = 4,
-    TypeExtension = 5
+    ReducedType = 5,
+    TypeExtension = 6
 }
 export declare class ModifierValidator {
     private readonly analyzer;

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

@@ -16,14 +16,14 @@ export declare class NodeTypeUtils {
     static isSubprogramDeclarationOrLiteral(node: tree.Node): node is SubprogramDeclarationOrLiteral;
     static isRegularOrBlockFunctionLiteral(node: tree.Node): node is RegularOrBlockFunctionLiteral;
 }
-export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
+export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageReducedTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
 export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;
 export type VariantTypeDeclaration = tree.PackageVariantTypeDeclaration | tree.AnonymousVariantTypeDeclaration;
 export type FunctionTypeDeclaration = tree.PackageFunctionTypeDeclaration | tree.AnonymousFunctionTypeDeclaration;
 export type FunctionDeclaration = tree.PackageFunctionDeclaration | tree.NestedFunctionDeclaration | tree.MethodDeclaration;
 export type TypeDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | FunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
-export type NamedTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.TypeParameterDeclaration;
-export type TypeWithMembersDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | tree.PackageAliasTypeDeclaration;
+export type NamedTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageReducedTypeDeclaration | tree.TypeParameterDeclaration;
+export type TypeWithMembersDeclaration = StructuredTypeDeclaration | VariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageReducedTypeDeclaration;
 export type VariableDeclaration = tree.ForStatementVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.FieldDeclaration | tree.VariantValueDeclaration;
 export type GetterDeclaration = tree.PackageVariableGetterDeclaration | tree.FieldGetterDeclaration | tree.IndexedElementGetterDeclaration | tree.DereferencedVariableGetterDeclaration;
 export type SetterDeclaration = tree.PackageVariableSetterDeclaration | tree.FieldSetterDeclaration | tree.IndexedElementSetterDeclaration | tree.DereferencedVariableSetterDeclaration;

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

@@ -1,9 +1,16 @@
 import { Name } from '../common/index.js';
-import { IEntityHidingMatcher, NamedPackageMemberEntity, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
+import { NamedPackageMemberEntity, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
+import { SourceFile } from '../project/index.js';
 export declare class PackageMemberLookup {
     private readonly package_;
     constructor(package_: PackageEntity);
-    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): readonly NamedPackageMemberEntity[];
-    getNamedMembersByName(name: Name, hidingMatcher?: IEntityHidingMatcher): readonly NamedPackageMemberEntity[];
-    getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];
+    getNamedMembers(context: PackageMemberLookupContext | undefined): readonly NamedPackageMemberEntity[];
+    getNamedMembersByName(name: Name, context: PackageMemberLookupContext | undefined): readonly NamedPackageMemberEntity[];
+    getTypeExtensions(type: TypeEntity, context: PackageMemberLookupContext | undefined): readonly TypeExtensionEntity[];
+}
+export declare class PackageMemberLookupContext {
+    readonly sourceFile: SourceFile | undefined;
+    readonly packageEntity: PackageEntity | undefined;
+    constructor(sourceFile: SourceFile | undefined, packageEntity: PackageEntity | undefined);
+    affectsAccessibility(): boolean;
 }

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

@@ -0,0 +1,27 @@
+import { Analyzer } from './Analyzer.js';
+import * as controlFlow from './control-flow/index.js';
+export declare class ReachabilityChecker {
+    private readonly analyzer;
+    private readonly checkResults;
+    constructor(analyzer: Analyzer);
+    /**
+     * Проверяет, достижим ли узел графа потока управления с учётом семантики.
+     *
+     * Дополнительные проверки необходимы по причине того, что граф потока управления строится на основе синтаксического
+     * дерева и не учитывает семантику.
+     *
+     * Например, следующий код
+     * ```artel
+     * конст а = Объект()
+     * если не(а это Объект)
+     * {
+     *   // ...
+     * }
+     * ```
+     *
+     * достижим с точки зрения синтаксиса, но недостижим с точки зрения семантики, поскольку типом переменной `а`
+     * всегда является `Объект`.
+     */
+    isControlFlowNodeReachable(node: controlFlow.Node): boolean;
+    private isConditionReachable;
+}

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

@@ -0,0 +1,20 @@
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { TypeMemberLookupContext } from './TypeMemberLookup.js';
+export declare class ReductionSourceMemberFinder {
+    private static signatureComparisonOptions_;
+    private static get signatureComparisonOptions();
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
+    findField(member: types.Field, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: tree.Node): types.Field | undefined;
+    findMethod(member: types.Method, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: tree.Node): types.Method | undefined;
+    findOperator(member: types.Operator, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: tree.Node): types.Operator | undefined;
+    findConstructor(member: types.Constructor, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: tree.Node): types.Constructor | undefined;
+    findDestructor(member: types.Destructor, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: tree.Node): types.Destructor | undefined;
+    findIndexer(member: types.Indexer, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: tree.Node): types.Indexer | undefined;
+    findDereferenceOperator(member: types.DereferenceOperator, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, nodeForDiagnostic: tree.Node): types.DereferenceOperator | undefined;
+    private getTypeMemberLookupOptions;
+    private checkMembersHaveSameHiding;
+}

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

@@ -0,0 +1,14 @@
+import { Lazy, Name, PackageLocale } from '../common/index.js';
+export declare const enum ReservedNameKind {
+    Result = 0,
+    Value = 1
+}
+export declare const reservedNamesByLocale: Lazy<{
+    [T in PackageLocale]: {
+        [T in ReservedNameKind]: Name;
+    };
+}>;
+export declare const reservedNameKindByNameKey: Lazy<{
+    0: ReadonlyMap<string, ReservedNameKind>;
+    1: ReadonlyMap<string, ReservedNameKind>;
+}>;

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

@@ -20,6 +20,9 @@ export declare class SourceFileAnalyzer {
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile);
     analyze(taskController: TaskController): Promise<Diagnostic[]>;
     private analyzeNode;
+    private checkErrorStatement;
+    private checkBreakLoopOrContinueLoopStatement;
+    private isStatementUsedInsideLoop;
     private checkTypeParameterList;
     private checkTypeParameterDeclaration;
     private checkFunctionLiteral;

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

@@ -36,6 +36,7 @@ export declare class TypeArgumentInferrer {
     private inferFromTypes;
     private inferToParameterType;
     private inferToStructuredType;
+    private inferToReducedType;
     private inferFromSubstitutions;
     private inferToUnionType;
     private inferFromFunctionTypes;

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

@@ -1,34 +1,33 @@
 import { Name, PackageLocale } from '../common/index.js';
-import { IEntityHidingMatcher, OperatorKind, TypeEntity, TypeExtensionEntity, TypeOrExtensionEntity } from '../entities/index.js';
+import { OperatorKind, PackageEntity, TypeEntity, TypeExtensionEntity, TypeOrExtensionEntity } from '../entities/index.js';
+import { SourceFile } from '../project/SourceFile.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { SemanticContext } from './semantic-context/SemanticContext.js';
 export declare class TypeMemberLookup {
     private readonly analyzer;
     private readonly typeOrExtension;
-    private readonly contextLocale;
     private constructor();
-    static ofType(analyzer: Analyzer, type: types.Type, contextLocale: PackageLocale | undefined): TypeMemberLookup;
-    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, contextLocale: PackageLocale | undefined): TypeMemberLookup;
-    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, contextLocale: PackageLocale | undefined): TypeMemberLookup;
-    static ofTypeOrExtension(analyzer: Analyzer, typeOrExtension: TypeOrExtension, contextLocale: PackageLocale | undefined): TypeMemberLookup;
-    getNamedMembers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.NamedTypeMember[];
-    getNamedMembersByName(name: Name, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.NamedTypeMember[];
-    getOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.Operator[];
-    getOperatorsByKind(kind: OperatorKind, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.Operator[];
-    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.Constructor[];
-    getIndexers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.Indexer[];
-    getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.DereferenceOperator[];
+    static ofType(analyzer: Analyzer, type: types.Type): TypeMemberLookup;
+    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity): TypeMemberLookup;
+    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity): TypeMemberLookup;
+    static ofTypeOrExtension(analyzer: Analyzer, typeOrExtension: TypeOrExtension): TypeMemberLookup;
+    getNamedMembers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
+    getNamedMembersByName(name: Name, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
+    getOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Operator[];
+    getOperatorsByKind(kind: OperatorKind, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Operator[];
+    getConstructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Constructor[];
+    getIndexers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Indexer[];
+    getDereferenceOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.DereferenceOperator[];
 }
 export declare class BoundTypeMemberLookup {
     private readonly lookup;
     private readonly options;
-    private readonly hidingMatcher;
-    private readonly typeExtensionLookup;
+    private readonly context;
     private constructor();
-    static ofType(analyzer: Analyzer, type: types.Type, contextLocale: PackageLocale | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
-    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, contextLocale: PackageLocale | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
-    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, contextLocale: PackageLocale | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
+    static ofType(analyzer: Analyzer, type: types.Type, context: TypeMemberLookupContext | undefined, options: TypeMemberLookupOptions): BoundTypeMemberLookup;
+    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, context: TypeMemberLookupContext | undefined, options: TypeMemberLookupOptions): BoundTypeMemberLookup;
+    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, context: TypeMemberLookupContext | undefined, options: TypeMemberLookupOptions): BoundTypeMemberLookup;
     getNamedMembers(): readonly types.NamedTypeMember[];
     getNamedMembersByName(name: Name): readonly types.NamedTypeMember[];
     getOperators(): readonly types.Operator[];
@@ -37,25 +36,40 @@ export declare class BoundTypeMemberLookup {
     getIndexers(): readonly types.Indexer[];
     getDereferenceOperators(): readonly types.DereferenceOperator[];
 }
+export declare class TypeMemberLookupContext {
+    readonly typeOrExtensionEntity: TypeOrExtensionEntity | undefined;
+    readonly sourceFile: SourceFile | undefined;
+    readonly packageEntity: PackageEntity | undefined;
+    readonly locale: PackageLocale | undefined;
+    readonly typeExtensionLookup: SemanticContext | undefined;
+    constructor(typeOrExtensionEntity: TypeOrExtensionEntity | undefined, sourceFile: SourceFile | undefined, packageEntity: PackageEntity | undefined, locale: PackageLocale | undefined, typeExtensionLookup: SemanticContext | undefined);
+    affectsAccessibility(): boolean;
+}
 export declare enum TypeMemberLookupOptions {
     None = 0,
     OnlyInstanceMembers = 1,
-    OnlyStaticMembers = 2
+    OnlyStaticMembers = 2,
+    NoTypeExtensionMembers = 4,
+    /**
+     * Смотрите метод {@link AccessibilityCheck.isTypeMemberAccessible}.
+     */
+    CheckAccessibilityIgnoringReceiverType = 8,
+    OnlyInstanceOrOnlyStaticMembers = 3
 }
 type TypeOrExtension = TypeOrExtension_type | TypeOrExtension_extension;
 declare class TypeOrExtension_type implements ITypeOrExtension {
     readonly value: types.Type;
     readonly kind = "type";
     constructor(value: types.Type);
-    getEntity(): TypeOrExtensionEntity | undefined;
+    getType(): types.Type | undefined;
 }
 declare class TypeOrExtension_extension implements ITypeOrExtension {
     readonly value: TypeExtensionEntity;
     readonly kind = "extension";
     constructor(value: TypeExtensionEntity);
-    getEntity(): TypeOrExtensionEntity | undefined;
+    getType(): types.Type | undefined;
 }
 interface ITypeOrExtension {
-    getEntity(): TypeOrExtensionEntity | undefined;
+    getType(): types.Type | undefined;
 }
 export {};

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

@@ -11,6 +11,8 @@ export declare function getParentGenericSpecializationExpression(expression: tre
 export declare function getGenericSpecializationExpressionOfCallee(callee: tree.Expression): tree.GenericSpecializationExpression | undefined;
 export declare function unaliasType(type: types.Type): types.Type;
 export declare function unaliasType(type: types.Type | undefined): types.Type | undefined;
+export declare function unaliasTypeAndGetReductionSource(type: types.Type): types.Type;
+export declare function unaliasTypeAndGetReductionSource(type: types.Type | undefined): types.Type | undefined;
 export declare function findTag(tagTypeEntity: TypeEntity, tags: readonly Tag[]): TagType | undefined;
 export declare function findTag(tagFunctionEntity: FunctionEntity, tags: readonly Tag[]): TagFunction | undefined;
 export declare function findTag(tagEntity: TypeEntity | FunctionEntity, tags: readonly Tag[]): TagType | TagFunction | undefined;

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

@@ -1,6 +1,6 @@
 import { PackageLocale } from '../common/PackageLocale.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { AliasTypeEntity, MethodEntity, StructuredTypeEntity } from '../entities/index.js';
+import { AliasTypeEntity, MethodEntity, ReducedTypeEntity, StructuredTypeEntity } from '../entities/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class WellKnownDeclarationsLoadError extends Error {
     readonly diagnostic: Diagnostic;
@@ -20,17 +20,18 @@ export interface WellKnownDeclarations {
     readonly enumerator: StructuredTypeEntity;
     readonly enumeratorMethod: MethodEntity;
     readonly array: StructuredTypeEntity;
-    readonly readonlyArray: StructuredTypeEntity;
+    readonly readonlyArray: ReducedTypeEntity;
     readonly map: StructuredTypeEntity;
-    readonly readonlyMap: StructuredTypeEntity;
+    readonly readonlyMap: ReducedTypeEntity;
     readonly set: StructuredTypeEntity;
-    readonly readonlySet: StructuredTypeEntity;
+    readonly readonlySet: ReducedTypeEntity;
     readonly measure: StructuredTypeEntity;
     readonly reference: StructuredTypeEntity;
     readonly task: StructuredTypeEntity;
     readonly error: StructuredTypeEntity;
     readonly func: StructuredTypeEntity;
     readonly parameterArray: AliasTypeEntity;
+    readonly impossibleCase: StructuredTypeEntity;
     readonly defaultImport: StructuredTypeEntity;
     readonly realName: StructuredTypeEntity;
     readonly builtIntoPlatform: StructuredTypeEntity;
@@ -64,6 +65,7 @@ export declare class LocalizedWellKnownDeclarations implements WellKnownDeclarat
     private error_;
     private func_;
     private parameterArray_;
+    private impossibleCase_;
     private defaultImport_;
     private realName_;
     private builtIntoPlatform_;
@@ -83,23 +85,25 @@ export declare class LocalizedWellKnownDeclarations implements WellKnownDeclarat
     get enumerator(): StructuredTypeEntity;
     get enumeratorMethod(): MethodEntity;
     get array(): StructuredTypeEntity;
-    get readonlyArray(): StructuredTypeEntity;
+    get readonlyArray(): ReducedTypeEntity;
     get map(): StructuredTypeEntity;
-    get readonlyMap(): StructuredTypeEntity;
+    get readonlyMap(): ReducedTypeEntity;
     get set(): StructuredTypeEntity;
-    get readonlySet(): StructuredTypeEntity;
+    get readonlySet(): ReducedTypeEntity;
     get measure(): StructuredTypeEntity;
     get reference(): StructuredTypeEntity;
     get task(): StructuredTypeEntity;
     get error(): StructuredTypeEntity;
     get func(): StructuredTypeEntity;
     get parameterArray(): AliasTypeEntity;
+    get impossibleCase(): StructuredTypeEntity;
     get defaultImport(): StructuredTypeEntity;
     get realName(): StructuredTypeEntity;
     get builtIntoPlatform(): StructuredTypeEntity;
     get fieldProxy(): StructuredTypeEntity;
     get javaScriptDecorator(): StructuredTypeEntity;
     private getLocalizedStructuredType;
+    private getLocalizedReducedType;
     private getLocalizedAliasType;
     private getLocalizedMethod;
     private getLocalizationContext;

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

@@ -1,11 +1,13 @@
 import { Diagnostic } from '../../diagnostic/Diagnostic.js';
 import { SourceFile } from '../../project/SourceFile.js';
+import * as tree from '../../tree/index.js';
 import { SubprogramDeclarationOrLiteral } from '../NodeTypeUtils.js';
 import { NarrowableReferenceExpression } from './NarrowableExpression.js';
 import { Node } from './Nodes.js';
 export declare class GraphBuilder {
     private readonly sourceFile;
     private readonly controlFlowNodeByReference;
+    private readonly controlFlowNodesPrecedingErrorStatement;
     private readonly controlFlowNodesEndingSubprogram;
     private readonly unreachableCodeDiagnostics;
     private isInRebuildingFinallyClauseGraphMode;
@@ -41,7 +43,8 @@ export declare class GraphBuilder {
 }
 export declare class GraphBuildResult {
     readonly controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>;
+    readonly controlFlowNodesPrecedingErrorStatement: ReadonlyMap<tree.ErrorStatement, Node>;
     readonly controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>;
     readonly unreachableCodeDiagnostics: readonly Diagnostic[];
-    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
+    constructor(controlFlowNodeByReference: ReadonlyMap<NarrowableReferenceExpression, Node>, controlFlowNodesPrecedingErrorStatement: ReadonlyMap<tree.ErrorStatement, Node>, controlFlowNodesEndingSubprogram: ReadonlyMap<SubprogramDeclarationOrLiteral, Node>, unreachableCodeDiagnostics: readonly Diagnostic[]);
 }

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

@@ -1,6 +1,7 @@
 import { Name } from '../../common/index.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
+import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
 import { SemanticContext } from './SemanticContext.js';
 import { SemanticContextWithParent } from './SemanticContextWithParent.js';
@@ -13,8 +14,9 @@ export declare class FieldWithInitializerSemanticContext extends SemanticContext
     private readonly node;
     constructor(analyzer: Analyzer, node: tree.FieldDeclaration, outer: SemanticContextContainingTypeMember);
     isStatic(): boolean;
+    getTypeMemberLookupContext(): TypeMemberLookupContext;
     getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
     getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
+    getOwnNamedDeclarations(_initialContext: SemanticContext, _noInstanceMembers: boolean): readonly NamedDeclaration[];
+    getOwnNamedDeclarationsByName(_name: Name, _initialContext: SemanticContext, _noInstanceMembers: boolean): readonly NamedDeclaration[];
 }