@artel/artc 0.6.25282 → 0.6.25284

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

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

package/build/{chunk-3DN3M64Y.js → chunk-ZV3UW5X6.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-DURHSZYF.js";
+} from "./chunk-OBX375YX.js";
 import {
   ArtelVersion,
   Cached,
@@ -15,7 +15,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-VVFLEWSA.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';
@@ -28,14 +27,19 @@ import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeanin
 import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
 import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
-import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+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';
@@ -65,13 +69,15 @@ export declare class Analyzer {
     readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
     readonly overriddenMember: OverriddenMember;
     readonly tags: Tags;
-    readonly linkedEntity: LinkedEntity;
+    readonly implementation: ImplementationEntity;
     readonly owningPlainObjectModificationCheck: OwningPlainObjectModificationCheck;
     readonly packageImports: PackageImports;
     readonly typeUtils: TypeUtils;
     readonly signatureComparer: SignatureComparer;
     readonly conflictsCheck: ConflictsCheck;
     readonly typeAssignabilityCheck: TypeAssignabilityCheck;
+    readonly reachabilityChecker: ReachabilityChecker;
+    readonly reductionSourceMemberFinder: ReductionSourceMemberFinder;
     private readonly tsInteropInputs;
     private readonly targetType;
     private readonly tsInterop_;
@@ -96,7 +102,7 @@ export declare class Analyzer {
     private textTranslationPackagesByTargetPackage;
     private primaryTextTranslationPackageByTargetPackage;
     private resolvedLocalizableTexts;
-    private readonly linkedMultiPlatformPackagesByPlatform;
+    private readonly resolvedImplementationPackagesByPlatform;
     private readonly isFunctionGeneratorCheckResults;
     private readonly namedDeclarationsUsageCountResults;
     private readonly packageAndStaticVariablesInitializationDiagnostics;
@@ -178,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;
@@ -262,8 +269,9 @@ export declare class Analyzer {
     getLocalizedPackageWithLocale(originalPackageEntity: e.PackageEntity, locale: PackageLocale): e.PackageEntity | undefined;
     enumerateAnalyzedTranslationPackages(): Query<AnalyzedTranslationPackage>;
     enumerateResolvedTextTranslationPackages(): Query<ResolvedTextTranslationPackage>;
-    getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
-    getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
+    getResolvedImplementationPackagesByPlatform(interfacePackage: e.PackageEntity): ReadonlyMap<PlatformKind, ResolvedImplementationPackage> | undefined;
+    getResolvedImplementationPackageForInterfacePackage(interfacePackage: e.PackageEntity, platform: PlatformKind): ResolvedImplementationPackage | undefined;
+    getResolvedImplementationPackage(implementationPackage: e.PackageEntity): ResolvedImplementationPackage | undefined;
     getTextTranslationPackagesMap(): ReadonlyMap<e.PackageEntity, ResolvedTextTranslationPackage[]>;
     getTextTranslationPackagesOfTargetPackage(targetPackage: e.PackageEntity): ResolvedTextTranslationPackage[] | undefined;
     getPrimaryTextTranslationPackageOfTargetPackage(targetPackage: e.PackageEntity): ResolvedTextTranslationPackage | undefined;
@@ -276,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;
@@ -305,7 +315,6 @@ export declare class Analyzer {
     validateSourcePackageMemberConflicts(pkg: project.ProgramOrTextTranslationPackage): readonly Diagnostic[];
     getNotExplicitlyImplementedAbstractMembers(typeEntity: e.TypeEntityWithMembers): readonly types.TypeMember[];
     getTypeMemberImplementationCheckResult(typeEntity: e.TypeEntityWithMembers): TypeMemberImplementationCheckResult;
-    createEntityContextForTypeDeclaration(node: TypeDeclaration): e.EntityContext;
     isFunctionBlockWithImplicitlyReturnedExpression(node: tree.FunctionBlock): boolean;
     getLocalizedWellKnownDeclarations(locale: PackageLocale): WellKnownDeclarations;
     getLocalizedStandardTypes(locale: PackageLocale): types.StandardTypes;
@@ -319,6 +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): TypeMemberLookupContext;
+    isPossiblyCastedBaseExpression(node: tree.Expression): boolean;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -352,6 +363,9 @@ export declare namespace BinaryExpressionOperatorClassificationResult {
     const bitwiseAnd: BinaryExpressionOperatorClassificationResult;
     const bitwiseOr: BinaryExpressionOperatorClassificationResult;
     const bitwiseXor: BinaryExpressionOperatorClassificationResult;
+    const leftShift: BinaryExpressionOperatorClassificationResult;
+    const signedRightShift: BinaryExpressionOperatorClassificationResult;
+    const unsignedRightShift: BinaryExpressionOperatorClassificationResult;
     const and: BinaryExpressionOperatorClassificationResult;
     const or: BinaryExpressionOperatorClassificationResult;
     const xor: BinaryExpressionOperatorClassificationResult;
@@ -376,10 +390,11 @@ declare class Type {
     private readonly intersectionTypeSpecifierTypes;
     private readonly functionLiteralTypes;
     private readonly nodesForWhichReturnTypeInferenceDiagnosticHasBeenReported;
+    private recursionDepth;
     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;
     private ofRegularOrBlockFunctionLiteral;
@@ -462,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;
@@ -498,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;
@@ -562,8 +579,30 @@ declare class ValueLocalVariableEntity {
     ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
     private createValueLocalVariableEntity;
 }
+export declare enum SignatureComparisonOptions {
+    None = 0,
+    CompareNames = 1,
+    CompareReturnTypes = 2,
+    CheckTypeParameterCountIntersection = 4
+}
+type TypeComparer = (t1: types.Type, t2: types.Type) => boolean;
+declare class SignatureComparer {
+    private readonly analyzer;
+    private readonly substitutionStubTypes;
+    constructor(analyzer: Analyzer);
+    areEqualFunctionEntities(function1: e.FunctionEntity, function2: e.FunctionEntity, options: SignatureComparisonOptions, typeComparer?: TypeComparer): boolean;
+    areEqualMethods(method1: types.Method, method2: types.Method, options: SignatureComparisonOptions, typeComparer?: TypeComparer): boolean;
+    areEqualSignaturesWithoutTypeParameters(entity1: EntityWithoutTypeParametersInSignature, entity2: EntityWithoutTypeParametersInSignature, options: SignatureComparisonOptions, typeComparer?: TypeComparer): boolean;
+    areEqualTypeMemberSignaturesWithoutTypeParameters(member1: TypeMemberWithoutTypeParametersInSignature, member2: TypeMemberWithoutTypeParametersInSignature, options: SignatureComparisonOptions, typeComparer?: TypeComparer): boolean;
+    doTypeParameterCountsIntersect(typeParameters1: readonly e.TypeParameterEntity[], typeParameters2: readonly e.TypeParameterEntity[]): boolean;
+    private areEqualParameters;
+    private areEqualTypeMemberParameters;
+    private areEqualTypes;
+    private createSubstitutionsWithStubTypes;
+}
 declare class OverriddenMember {
     private readonly analyzer;
+    static readonly signatureComparisonOptions = SignatureComparisonOptions.None;
     private readonly namedMemberFinder;
     private readonly operatorFinder;
     private readonly indexerFinder;
@@ -586,7 +625,6 @@ declare class OverriddenMember {
     getOverriddenAndShadowedDereferenceOperators(node: DereferencedVariableAccessorDeclaration): OverriddenAndShadowedMembers<types.DereferenceOperator>;
     entityCanBeOverridden(entity: OverridableTypeMemberEntity): boolean;
     getMemberTypeOrReturnType(member: types.TypeMember): types.Type;
-    findMatchingMembersInType(member: types.TypeMember, type: types.Type): readonly types.TypeMember[];
     private findOverriddenMembers;
     private findOverriddenOrShadowedNamedMembersInType;
     private findOverriddenOrShadowedOperatorsInType;
@@ -630,10 +668,10 @@ declare class Tags {
     private createTagFromNode;
     private argumentToTagArgument;
 }
-declare class LinkedEntity {
+declare class ImplementationEntity {
     private readonly analyzer;
     constructor(analyzer: Analyzer);
-    entityCanBeLinked(entity: e.Entity): boolean;
+    entityCanHaveImplementation(entity: e.Entity): boolean;
     ofType(entity: e.TypeEntity, platform: PlatformKind): e.TypeEntity | undefined;
     ofTypeWithMembers(entity: e.TypeEntityWithMembers, platform: PlatformKind): e.TypeEntityWithMembers | undefined;
     ofParameterType(entity: e.TypeParameterEntity, platform: PlatformKind): e.TypeParameterEntity | undefined;
@@ -643,49 +681,12 @@ declare class LinkedEntity {
     ofMethod(entity: e.MethodEntity, platform: PlatformKind): e.MethodEntity | undefined;
     ofOperator(entity: e.OperatorEntity, platform: PlatformKind): e.OperatorEntity | undefined;
     ofConstructor(entity: e.ConstructorEntity, platform: PlatformKind): e.ConstructorEntity | undefined;
+    ofDestructor(entity: e.DestructorEntity, platform: PlatformKind): e.DestructorEntity | undefined;
     ofIndexer(entity: e.IndexerEntity, platform: PlatformKind): e.IndexerEntity | undefined;
     ofDereferenceOperator(entity: e.DereferenceOperatorEntity, platform: PlatformKind): e.DereferenceOperatorEntity | undefined;
     ofGetter(entity: e.GetterEntity, platform: PlatformKind): e.GetterEntity | undefined;
     ofSetter(entity: e.SetterEntity, platform: PlatformKind): e.SetterEntity | undefined;
 }
-export declare class LinkedMultiPlatformPackage {
-    readonly analyzer: Analyzer;
-    readonly pkg: e.PackageEntity;
-    readonly implementationPackage: e.PackageEntity;
-    readonly targetPlatform: PlatformKind;
-    private readonly memberLookup_;
-    private readonly linkedTypesWithMembers;
-    private readonly linkedParameterTypes;
-    private get memberLookup();
-    constructor(analyzer: Analyzer, pkg: e.PackageEntity, implementationPackage: e.PackageEntity, targetPlatform: PlatformKind);
-    getLinkedVariable(entity: e.PackageVariableEntity): e.PackageVariableEntity | undefined;
-    getLinkedMethod(entity: e.PackageFunctionEntity): e.PackageFunctionEntity | undefined;
-    getLinkedTypeWithMembers(entity: e.TypeEntityWithMembers): LinkedTypeWithMembers | undefined;
-    getLinkedParameterType(entity: e.TypeParameterEntity): e.TypeParameterEntity | undefined;
-    /**
-     * Используется для сравнения типов при связывании объявления из многоплатформенного пакета с объявлением из
-     * реализационного пакета. В частности, при сравнении типов параметров для выбора правильной перегрузки
-     * метода (конструктора, индексатора).
-     */
-    compareTypesDuringLinking(type1: types.Type, type2: types.Type): boolean;
-    private findPackageType;
-    private compareSubstitutionsDuringLinking;
-}
-export declare class LinkedTypeWithMembers {
-    readonly analyzer: Analyzer;
-    readonly externalType: e.TypeEntityWithMembers;
-    readonly targetType: e.TypeEntityWithMembers;
-    readonly linkedPackage: LinkedMultiPlatformPackage;
-    private readonly memberLookup_;
-    private get memberLookup();
-    constructor(analyzer: Analyzer, externalType: e.TypeEntityWithMembers, targetType: e.TypeEntityWithMembers, linkedPackage: LinkedMultiPlatformPackage);
-    getLinkedField(entity: e.FieldEntity): e.FieldEntity | undefined;
-    getLinkedMethod(entity: e.MethodEntity): e.MethodEntity | undefined;
-    getLinkedOperator(entity: e.OperatorEntity): e.OperatorEntity | undefined;
-    getLinkedConstructor(entity: e.ConstructorEntity): e.ConstructorEntity | undefined;
-    getLinkedIndexer(entity: e.IndexerEntity): e.IndexerEntity | undefined;
-    getLinkedDereferenceOperator(entity: e.DereferenceOperatorEntity): e.DereferenceOperatorEntity | undefined;
-}
 declare class OwningPlainObjectModificationCheck {
     private analyzer;
     private readonly owningPlainObjectModificationCheckResult;
@@ -707,6 +708,7 @@ declare class TypeAssignabilityCheck {
     getSingleFlagScore(flag: TypeAssignabilityFlags): number;
     getLowestFlagsScore(flags: TypeAssignabilityFlags): number;
     private getAssignabilityFlagsForStructuredTypes;
+    private isStructuredTypeDerivedFromOrEqualsTo;
     /**
      * @example
      * ```artel
@@ -777,33 +779,6 @@ declare class TypeUtils {
     private getFlattenedConstituentTypesForCommonTypesSearch;
     private flattenTypeParameterConstraint;
 }
-declare class SignatureComparer {
-    private readonly analyzer;
-    private readonly stubParameterTypes;
-    constructor(analyzer: Analyzer);
-    areEqualFunctionEntities(function1: e.FunctionEntity, function2: e.FunctionEntity, options: SignatureComparisonOptions): boolean;
-    /**
-     * Метод аналогичен методу {@link areEqualFunctionEntities}.
-     */
-    areEqualMethods(method1: types.Method, method2: types.Method, options: SignatureComparisonOptions): boolean;
-    /**
-     * Проверяет, конфликтуют две сущности, имеющие параметры, но не имеющие параметры типа.
-     *
-     * Отношение "сущности, имеющие только параметры, конфликтуют" является транзитивным.
-     */
-    areEqualSignaturesWithoutTypeParameters(entity1: EntityWithoutTypeParametersInSignature, entity2: EntityWithoutTypeParametersInSignature): boolean;
-    areEqualTypeMemberSignaturesWithoutTypeParameters(member1: TypeMemberWithoutTypeParametersInSignature, member2: TypeMemberWithoutTypeParametersInSignature): boolean;
-    doTypeParameterCountsIntersect(typeParameters1: readonly e.TypeParameterEntity[], typeParameters2: readonly e.TypeParameterEntity[]): boolean;
-    private areEqualParameters;
-    private areEqualTypeMemberParameters;
-    private createSubstitutionsWithStubTypes;
-}
-export declare enum SignatureComparisonOptions {
-    None = 0,
-    CompareNames = 1,
-    CompareReturnTypes = 2,
-    CheckTypeParameterCountIntersection = 4
-}
 declare class ConflictsCheck {
     private readonly analyzer;
     private static readonly signatureComparisonOptions;

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/ResolvedImplementationPackage.d.ts

@@ -0,0 +1,48 @@
+import { ConstructorEntity, DereferenceOperatorEntity, DestructorEntity, FieldEntity, IndexerEntity, MethodEntity, OperatorEntity, PackageEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeEntity } from '../entities/index.js';
+import { PlatformKind } from '../project/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class ResolvedImplementationPackage {
+    private readonly analyzer;
+    readonly interfacePackage: PackageEntity;
+    readonly implementationPackage: PackageEntity;
+    readonly targetPlatform: PlatformKind;
+    private static signatureComparisonOptions_;
+    private static get signatureComparisonOptions();
+    private implementationPackageMembers_;
+    private readonly diagnostics;
+    private readonly variableImplementations;
+    private readonly functionImplementations;
+    private readonly typeImplementations;
+    private readonly typeMemberImplementations;
+    private hasReportedAllDiagnostics;
+    private get implementationPackageMembers();
+    constructor(analyzer: Analyzer, interfacePackage: PackageEntity, implementationPackage: PackageEntity, targetPlatform: PlatformKind);
+    ensureAllDiagnosticReported(): void;
+    getPackageVariableImplementation(entity: PackageVariableEntity): PackageVariableEntity | undefined;
+    getPackageFunctionImplementation(entity: PackageFunctionEntity): PackageFunctionEntity | undefined;
+    getPackageTypeImplementation(entity: PackageTypeEntity): PackageTypeEntity | undefined;
+    getFieldImplementation(entity: FieldEntity): FieldEntity | undefined;
+    getMethodImplementation(entity: MethodEntity): MethodEntity | undefined;
+    getOperatorImplementation(entity: OperatorEntity): OperatorEntity | undefined;
+    getConstructorImplementation(entity: ConstructorEntity): ConstructorEntity | undefined;
+    getDestructorImplementation(entity: DestructorEntity): DestructorEntity | undefined;
+    getIndexerImplementation(entity: IndexerEntity): IndexerEntity | undefined;
+    getDereferenceOperatorImplementation(entity: DereferenceOperatorEntity): DereferenceOperatorEntity | undefined;
+    static isTypeThatDoesNotRequireImplementation(entity: TypeEntity): boolean;
+    private getTypeMemberImplementations;
+    private findFieldImplementation;
+    private findMethodImplementation;
+    private findOperatorImplementation;
+    private findConstructorImplementation;
+    private findDestructorImplementation;
+    private findIndexerImplementation;
+    private findDereferenceOperatorImplementation;
+    private checkImplementationTypeMemberBasicModifier;
+    private checkImplementationTypeMemberAbstractModifier;
+    private areEqualFunctions;
+    private areEqualTypeMembersWithoutTypeParameters;
+    private areEqualTypes;
+    private areEqualSubstitutions;
+    private reportPackageDoesNotContainImplementationDiagnostic;
+    private reportTypeDoesNotContainImplementationDiagnostic;
+}

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;