@artel/artc 0.6.25281 → 0.6.25283

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

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-NVHCHE3R.js";
+} from "./chunk-MJ2ZVHII.js";
 import {
   ArtelVersion,
   Cached,
@@ -15,7 +15,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-TIWNEKIS.js";
+} from "./chunk-2Q4QKW7T.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -217,7 +217,7 @@ var NodeCompiler = class {
       const standardLibraryUri = yield this.findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath);
       if (standardLibraryUri === void 0) {
         const diagnostic = new Diagnostic(DiagnosticData.withCode(
-          401 /* CannotFindTsLibDirectoryBaseSearchPaths0 */,
+          3e3 /* CannotFindTsLibDirectoryBaseSearchPaths0 */,
           [nodeModulesSearchPaths.map((p) => `'${p}'`).join(", ")]
         ), void 0);
         diagnostics?.addDiagnostic(diagnostic);

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

@@ -10,7 +10,7 @@ import {
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-TIWNEKIS.js";
+} from "./chunk-2Q4QKW7T.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {
@@ -71,7 +71,7 @@ var Compiler = class {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
-          403 /* ProgramWithoutMainPackageCannotBeCompiled */
+          3002 /* ProgramWithoutMainPackageCannotBeCompiled */
         ), void 0));
         return void 0;
       }
@@ -85,7 +85,7 @@ var Compiler = class {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
-          403 /* ProgramWithoutMainPackageCannotBeCompiled */
+          3002 /* ProgramWithoutMainPackageCannotBeCompiled */
         ), void 0));
         return "";
       }

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

@@ -20,6 +20,7 @@ export declare class AccessedFunction_entity implements IAccessedFunction {
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     applySubstitutions(substitutions: types.Substitutions): AccessedFunction;
     getOuterSubstitutions(): types.Substitutions | undefined;
+    equals(other: AccessedFunction, considerLocale?: boolean): boolean;
 }
 export declare class AccessedFunction_typeMember implements IAccessedFunction {
     readonly value: types.Method;
@@ -35,6 +36,7 @@ export declare class AccessedFunction_typeMember implements IAccessedFunction {
     getSignatureType(_analyzer: Analyzer): types.FunctionType;
     applySubstitutions(substitutions: types.Substitutions): AccessedFunction;
     getOuterSubstitutions(): types.Substitutions | undefined;
+    equals(other: AccessedFunction, considerLocale?: boolean): boolean;
 }
 export declare class AccessedFunction_substitutedFunction implements IAccessedFunction {
     readonly value: SubstitutedFunction;
@@ -48,6 +50,7 @@ export declare class AccessedFunction_substitutedFunction implements IAccessedFu
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getOuterSubstitutions(): types.Substitutions | undefined;
+    equals(other: AccessedFunction, considerLocale?: boolean): boolean;
 }
 export declare class AccessedFunctionParameter {
     readonly entity: ParameterEntity;
@@ -62,5 +65,6 @@ interface IAccessedFunction {
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getOuterSubstitutions(): types.Substitutions | undefined;
+    equals(other: AccessedFunction, considerLocale: boolean): boolean;
 }
 export {};

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

@@ -3,6 +3,7 @@ import { DisplayableOrPrimitive, Name, PackageLocale, Query, Range, TaskControll
 import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 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';
@@ -13,7 +14,6 @@ import { TsInteropContext, TsProgramState } from '../ts-interop/TsInteropContext
 import * as types from '../types/index.js';
 import { TypeFactory } from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
-import { ResolvedTextTranslationPackage } from './ResolvedTextTranslationPackage.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
 import { ArgumentToParameterMatchResult, MatchResultParameter } from './ArgumentToParameterMatchResult.js';
 import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
@@ -28,18 +28,18 @@ 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 { SourceFileMembers } from './SourceFileMembers.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 * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
 import * as semanticContext from './semantic-context/index.js';
-import { TypeWithMembersOrTypeExtensionDeclaration } from './TreeQuery.js';
-import { WithDiagnostics } from '../diagnostic/WithDiagnostics.js';
 export declare class Analyzer {
     readonly compilation: project.Compilation;
     /**
@@ -66,7 +66,7 @@ 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;
@@ -78,7 +78,6 @@ export declare class Analyzer {
     private readonly tsInterop_;
     private readonly memberAccessExpressionResolutionResults;
     private readonly memberAccessExpressionResolutionResultsFirstStage;
-    private readonly sourceFileMembers;
     private readonly callExpressionResolutionResults;
     private readonly indexedAccessExpressionResolutionResults;
     private readonly dereferenceExpressionMeanings;
@@ -98,13 +97,14 @@ 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;
     private readonly controlFlowGraphs;
-    private readonly diagnosticsComputedLazily;
-    private readonly diagnosticsComputedLazilyAcceptor;
+    private sideDiagnosticAcceptor;
+    private readonly sideDiagnosticsByFile;
+    private readonly sideDiagnosticsWithoutFile;
     private readonly sourcePackageMemberConflictsDiagnostics;
     private readonly notExplicitlyImplementedAbstractTypeMembers;
     private readonly typeMemberImplementationCheckResults;
@@ -135,21 +135,19 @@ export declare class Analyzer {
     getUnambiguousTargetFunctionType(targetType: types.Type | undefined): types.FunctionType | undefined;
     getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
     getUnambiguousTargetReferenceType(targetType: types.Type | undefined): types.Type | undefined;
-    resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.FirstStageResolutionResult;
-    resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.ResolutionResult;
-    getPackageImportsOfDirective(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
-    getSourceFileMembers(node: tree.SourceFile): SourceFileMembers;
-    resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.ResolutionResult;
+    resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.MeaningStage1;
+    resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.Meaning;
+    resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.Meaning;
     getRespectiveParameter(node: tree.Argument): MatchResultParameter | undefined;
-    resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.ResolutionResult;
+    resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.Meaning;
     getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
     resolveAutotypeCallExpression(node: tree.AutotypeCallExpression, analysisOptions?: ExpressionAnalysisOptions): autotypeCallExpressionMeaning.ResolutionResult;
-    resolveIdentifierExpressionFirstStage(node: tree.IdentifierExpression): identifierExpressionResolution.FirstStageResolutionResult;
-    resolveIdentifierExpression(node: tree.IdentifierExpression, analysisOptions?: ExpressionAnalysisOptions): identifierExpressionResolution.ResolutionResult;
+    resolveIdentifierExpressionFirstStage(node: tree.IdentifierExpression): identifierExpressionResolution.MeaningStage1;
+    resolveIdentifierExpression(node: tree.IdentifierExpression, analysisOptions?: ExpressionAnalysisOptions): identifierExpressionResolution.Meaning;
     resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
-    resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.ResolutionResult;
-    resolveBaseExpressionFirstStage(node: tree.BaseExpression): baseExpressionMeaning.FirstStageResolutionsResult;
-    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.ResolutionResult;
+    resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
+    resolveBaseExpressionFirstStage(node: tree.BaseExpression): baseExpressionMeaning.MeaningStage1;
+    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
     /**
      * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
      * `пусто`.
@@ -205,9 +203,9 @@ export declare class Analyzer {
     isFunctionGenerator(node: FunctionDeclaration): boolean;
     allAspectsOfType(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
-    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<types.Operator>;
-    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<types.Operator>;
-    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): WithDiagnostics<types.Operator>;
+    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): types.Operator | undefined;
+    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): types.Operator | undefined;
+    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): types.Operator | undefined;
     classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
     getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
     getOriginalPackageEntities(): readonly e.PackageEntity[];
@@ -265,12 +263,13 @@ 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;
-    resolveLocalizableTextOrTextTemplate(node: tree.LocalizableTextLiteral | tree.LocalizableTextTemplateLiteral): WithDiagnostics<e.TextTranslationEntity>;
+    resolveLocalizableTextOrTextTemplate(node: tree.LocalizableTextLiteral | tree.LocalizableTextTemplateLiteral): e.TextTranslationEntity | undefined;
     instantiateType(entity: e.TypeEntity, typeArguments: readonly types.Type[] | undefined): types.Type;
     instantiateTypeWithSubstitutions(entity: e.TypeEntity, substitutions: types.Substitutions): types.Type;
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;
@@ -286,7 +285,7 @@ export declare class Analyzer {
     getDeclarationsUsageOfSourceFile(sourceFile: tree.SourceFile, taskController: TaskController): Promise<DeclarationsUsageMap>;
     getPackageAndStaticVariablesInitializationDiagnostics(pkg: SourcePackage, taskController: TaskController): Promise<readonly Diagnostic[]>;
     createDefaultConstructors(typeEntity: e.StructuredTypeEntity, fields: readonly e.FieldEntity[]): readonly e.ConstructorEntity[];
-    createBackingPackageVariables(declaredMembers: readonly (e.NamedPackageMemberEntity | e.PackageAliasEntity)[], pkg: e.PackageEntity): e.PackageVariableEntity[];
+    createBackingPackageVariables(declaredPackageMembers: readonly e.NamedPackageMemberEntity[], pkg: e.PackageEntity): e.PackageVariableEntity[];
     createBackingFields(declaredMembers: readonly e.NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
     createNodeDiagnostic(code: DiagnosticCode, node: tree.Node, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createSourceFileRangeDiagnostic(code: DiagnosticCode, range: Range, nodeOrSourceFile: tree.Node | project.SourceFile, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
@@ -302,13 +301,12 @@ export declare class Analyzer {
     createAmbiguousFunctionAccessDiagnostic(functions: readonly AccessedFunction[], node: tree.Node): Diagnostic;
     createAmbiguousTypeMemberAccessDiagnostic(members: readonly types.TypeMember[], node: tree.Node): Diagnostic;
     createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], node: tree.Node): Diagnostic;
-    addDiagnosticComputedLazily(diagnostic: Diagnostic): void;
-    getAcceptorForDiagnosticsComputedLazily(): DiagnosticAcceptor;
-    accumulateSourceFileDiagnosticsComputedLazily(sourceFile: project.SourceFile, diagnostics: DiagnosticAcceptor): void;
+    addSideDiagnostic(diagnostic: Diagnostic): void;
+    getSideDiagnosticAcceptor(): DiagnosticAcceptor;
+    accumulateSideDiagnosticForSourceFile(sourceFile: project.SourceFile, diagnostics: DiagnosticAcceptor): void;
     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;
@@ -322,6 +320,10 @@ 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;
+    };
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -355,6 +357,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;
@@ -379,10 +384,12 @@ 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;
@@ -517,7 +524,7 @@ declare class Entity {
     ofSetterDeclaration(node: SetterDeclaration): e.SetterEntity;
     ofConstructorDeclaration(node: tree.ConstructorDeclaration): e.ConstructorEntity;
     ofDestructorDeclaration(node: tree.DestructorDeclaration): e.DestructorEntity;
-    ofVariantDeclaration(node: tree.VariantDeclaration): e.FieldEntity;
+    ofVariantValueDeclaration(node: tree.VariantValueDeclaration): e.FieldEntity;
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
     ofTypeWithMembersDeclaration(node: TypeWithMembersDeclaration): e.TypeEntityWithMembers;
@@ -565,8 +572,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;
@@ -589,7 +618,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;
@@ -633,10 +661,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;
@@ -646,49 +674,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;
@@ -740,27 +731,22 @@ export declare enum TypeAssignabilityFlags {
 declare class PackageImports {
     private readonly analyzer;
     private readonly packagesAvailableForImport;
-    private readonly analyzedPackageImports;
+    private readonly resolvedPackageImports;
     private readonly importedPackages;
     private readonly automaticallyImportedPackages;
     private readonly importedPackageNameTrees;
     constructor(analyzer: Analyzer);
-    analyzeExplicitPackageImports(sourceFile: project.SourceFile): AnalyzedPackageImports;
+    resolvePackageImports(sourceFile: project.SourceFile): ReadonlyMap<tree.PackageImport, ResolvedPackageImport>;
     getPackagesAvailableForImport(pkg: project.SourcePackage): readonly e.PackageEntity[];
     getUniqueImportedPackages(sourceFile: project.SourceFile): readonly PackageImportInfo[];
     getImportedPackageNameTree(node: tree.SourceFile): ImportedPackageNameTree;
     private getAutomaticallyImportedPackages;
 }
-export declare class AnalyzedPackageImport {
+export declare class ResolvedPackageImport {
     readonly entity: e.PackageEntity | undefined;
     readonly isAliasedImport: e.PackageAliasEntity | undefined;
     constructor(entity: e.PackageEntity | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
 }
-export declare class AnalyzedPackageImports {
-    readonly packageImportInfos: Map<tree.PackageImport, AnalyzedPackageImport>;
-    readonly diagnostics: readonly Diagnostic[];
-    constructor(packageImportInfos: Map<tree.PackageImport, AnalyzedPackageImport>, diagnostics: readonly Diagnostic[]);
-}
 export declare class PackageImportInfo {
     readonly entity: e.PackageEntity;
     readonly aliasEntity: e.PackageAliasEntity | undefined;
@@ -785,33 +771,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/AutotypeCallExpressionMeaning.d.ts

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { AutotypeCallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer, ExpressionAnalysisOptions } from './index.js';
@@ -6,16 +6,16 @@ export declare class Resolver {
     private readonly analyzer;
     private readonly node;
     private readonly analysisOptions;
-    constructor(analyzer: Analyzer, node: AutotypeCallExpression, analysisOptions: ExpressionAnalysisOptions | undefined);
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: AutotypeCallExpression, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): ResolutionResult;
     private isAutotypeExpressionInValidPosition;
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined, dependsOnTargetType?: boolean);
-    static unresolved(diagnostics: readonly Diagnostic[] | undefined, dependsOnTargetType?: boolean): ResolutionResult;
+    constructor(meaning: Meaning, dependsOnTargetType?: boolean);
+    static unresolved(dependsOnTargetType?: boolean): ResolutionResult;
 }
 export type Meaning = Meaning_constructorCall | Meaning_unresolved;
 declare class Meaning_constructorCall {

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
@@ -6,8 +6,9 @@ import { Analyzer } from './Analyzer.js';
 export declare class FirstStageResolver {
     private readonly analyzer;
     private readonly node;
-    constructor(analyzer: Analyzer, node: tree.BaseExpression);
-    resolve(): FirstStageResolutionsResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.BaseExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
     private resolveBaseConstructorOrMethodAccess;
     private resolveBaseConstructorAccess;
     private resolveBaseMethodAccess;
@@ -29,18 +30,13 @@ export declare class FirstStageResolver {
 export declare class SecondStageResolver {
     private readonly analyzer;
     private readonly node;
-    private readonly firstStageResolutionResult;
-    constructor(analyzer: Analyzer, node: tree.BaseExpression, firstStageResolutionResult: FirstStageResolutionsResult);
-    resolve(): ResolutionResult;
+    private readonly firstStageMeaning;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.BaseExpression, firstStageMeaning: MeaningStage1, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private resolveOverriddenMethodAccess;
     private resolveOverriddenOperatorAccess;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionResult;
-}
 export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_overriddenOperatorAccess | Meaning_unresolved;
 declare class Meaning_baseObjectAccess {
     readonly type: types.Type;
@@ -84,12 +80,6 @@ declare class Meaning_overriddenOperatorAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export declare class FirstStageResolutionsResult {
-    readonly meaning: MeaningStage1;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: MeaningStage1, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics?: readonly Diagnostic[]): FirstStageResolutionsResult;
-}
 export type MeaningStage1 = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | MeaningStage1_overriddenMethodAccess | MeaningStage1_overriddenOperatorAccess | Meaning_unresolved;
 declare class MeaningStage1_overriddenMethodAccess {
     readonly method: types.Method;

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -8,8 +8,9 @@ export declare class Resolver {
     private readonly analyzer;
     private readonly node;
     private readonly analysisOptions;
-    constructor(analyzer: Analyzer, node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions | undefined);
-    resolve(): ResolutionResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private checkExpressionDenotesType;
     private checkExpressionDenotesFunction;
     private checkExpressionDenotesOperator;
@@ -18,12 +19,6 @@ export declare class Resolver {
     private resolveConstructorCallExpression;
     private resolveObjectFunctionCallExpression;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics: readonly Diagnostic[] | undefined): ResolutionResult;
-}
 export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
 export declare class Meaning_functionCall {
     readonly candidates: readonly NotSubstitutedAccessedFunction[];

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

@@ -1,14 +1,15 @@
 import { AccessKind } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { DereferenceExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;
+    private readonly diagnostics;
     private readonly semanticContext_;
     private get semanticContext();
-    constructor(analyzer: Analyzer, node: DereferenceExpression);
+    constructor(analyzer: Analyzer, node: DereferenceExpression, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): Meaning;
     private convertSyntacticAccessKind;
 }
@@ -20,8 +21,6 @@ declare class Meaning_resolved {
     constructor(operator: types.DereferenceOperator, accessKind: AccessKind);
 }
 declare class Meaning_unresolved {
-    readonly diagnostic: Diagnostic | undefined;
     readonly kind = "unresolved";
-    constructor(diagnostic: Diagnostic | undefined);
 }
 export {};