@artel/artc 0.6.25281 → 0.6.25283

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

@@ -1,5 +1,5 @@
 import { AccessKind, Name } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -12,9 +12,10 @@ export declare class FirstStageResolver {
     private readonly semanticContext_;
     private readonly analyzer;
     private readonly node;
+    private readonly diagnostics;
     private get semanticContext();
-    constructor(analyzer: Analyzer, node: tree.IdentifierExpression);
-    resolve(): FirstStageResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
     private tryResolveOperatorAccessMeaning;
     private resolveTypeAccess;
     private createNotSubstitutedAccessedFunction;
@@ -23,20 +24,16 @@ export declare class FirstStageResolver {
 export declare class SecondStageResolver {
     private readonly analyzer;
     private readonly node;
-    private readonly firstStageResolutionResult;
+    private readonly firstStageMeaning;
     private readonly analysisOptions;
-    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
-    resolve(): ResolutionResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageMeaning: MeaningStage1, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private resolveTypeAccessAtCalleePosition;
     private resolveFunctionAccess;
     private resolveOperatorAccess;
     private resolveNotCalledFunctionsAccess;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: Diagnostic | readonly Diagnostic[]);
-}
 export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_constructorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: AccessedVariable;
@@ -92,11 +89,6 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export declare class FirstStageResolutionResult {
-    readonly meaning: MeaningStage1;
-    readonly diagnostics: readonly Diagnostic[] | undefined;
-    constructor(meaning: MeaningStage1, diagnostics?: Diagnostic | readonly Diagnostic[]);
-}
 export type MeaningStage1 = Meaning_variableAccess | MeaningStage1_functionAccess | MeaningStage1_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class MeaningStage1_typeAccessAtCalleePosition {
     readonly types: readonly NamedTypeEntity[];

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

@@ -1,23 +1,19 @@
 import { AccessKind } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { IndexedAccessExpression } 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: IndexedAccessExpression);
-    resolve(): ResolutionResult;
+    constructor(analyzer: Analyzer, node: IndexedAccessExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private getArgumentsRangeWithBrackets;
     private convertSyntacticAccessKind;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics?: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-}
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
     readonly candidates: readonly types.Indexer[];

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

@@ -1,5 +1,5 @@
 import { AccessKind } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -11,11 +11,12 @@ export declare class FirstStageResolver {
     private readonly semanticContext_;
     private readonly analyzer;
     private readonly node;
+    private readonly diagnostics;
     private get memberName();
     private get semanticContext();
     private get receiver();
-    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression);
-    resolve(): FirstStageResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
     private resolvePackageAliasMemberAccessMeaning;
     private resolvePackageMemberAccessMeaning;
     private resolveTypeAccess;
@@ -28,10 +29,11 @@ export declare class FirstStageResolver {
 export declare class SecondStageResolver {
     private readonly analyzer;
     private readonly node;
-    private readonly firstStageResolutionResult;
+    private readonly firstStageMeaning;
     private readonly analysisOptions;
-    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | undefined);
-    resolve(): ResolutionResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageMeaning: MeaningStage1, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private resolveTypeAccessAtCalleePosition;
     private resolvePackageFunctionAccess;
     private resolveStaticMethodAccess;
@@ -39,11 +41,6 @@ export declare class SecondStageResolver {
     private resolveNotCalledFunctionsAccess;
     private resolveOperatorAccess;
 }
-export declare class ResolutionResult {
-    readonly meaning: Meaning;
-    readonly diagnostics: readonly Diagnostic[] | undefined;
-    constructor(meaning: Meaning, diagnostics?: Diagnostic | readonly Diagnostic[]);
-}
 export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_constructorAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: PackageVariableEntity;
@@ -126,11 +123,6 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
-export declare class FirstStageResolutionResult {
-    readonly meaning: MeaningStage1;
-    readonly diagnostics: readonly Diagnostic[] | undefined;
-    constructor(meaning: MeaningStage1, diagnostics?: Diagnostic | readonly Diagnostic[]);
-}
 export type MeaningStage1 = Meaning_packageVariableAccess | MeaningStage1_packageFunctionAccess | Meaning_packageTypeAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | MeaningStage1_staticMethodAccess | Meaning_instanceFieldAccess | MeaningStage1_instanceMethodAccess | MeaningStage1_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class MeaningStage1_typeAccessAtCalleePosition {
     readonly types: readonly PackageTypeEntity[];

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { QualifiedName } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -7,9 +7,10 @@ import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeResolver {
     private readonly analyzer;
     private readonly node;
+    private readonly diagnostics;
     private readonly semanticContext_;
     private get semanticContext();
-    constructor(analyzer: Analyzer, node: QualifiedName);
+    constructor(analyzer: Analyzer, node: QualifiedName, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): NamedTypeResolutionResult;
     private lookupTypeOrContainerWithTypes;
     private findTypesOrContainersWithTypesInResolvedQualifier;
@@ -21,9 +22,8 @@ export declare class NamedTypeResolver {
 export declare class NamedTypeResolutionResult {
     readonly types: readonly NamedTypeEntity[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly Diagnostic[];
     readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
+    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
 }
 export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
 export declare class ResolvedQualifier_packageNameSegment {

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -7,13 +7,13 @@ import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
     private readonly analyzer;
     private readonly node;
-    constructor(analyzer: Analyzer, node: NamedTypeSpecifier);
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: NamedTypeSpecifier, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): NamedTypeSpecifierResolutionResult;
 }
 export declare class NamedTypeSpecifierResolutionResult {
     readonly type: types.Type | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly Diagnostic[];
     readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
+    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
 }

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

@@ -24,7 +24,7 @@ export type FunctionDeclaration = tree.PackageFunctionDeclaration | tree.NestedF
 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 VariableDeclaration = tree.ForStatementVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.FieldDeclaration | tree.VariantDeclaration;
+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;
 export type PackageVariableAccessorDeclaration = tree.PackageVariableGetterDeclaration | tree.PackageVariableSetterDeclaration;

package/build/types/analysis/ObjectExpressionMeaning.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 { Analyzer } from './Analyzer.js';
@@ -10,19 +10,14 @@ import { Analyzer } from './Analyzer.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;
-    constructor(analyzer: Analyzer, node: tree.ObjectExpression);
-    resolve(): ResolutionResult;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.ObjectExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
     private resolveOwnConstructorAccess;
     private resolveContextAccess;
     private invalidContextDiagnostic;
     private findContainingConstructor;
 }
-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_ownConstructorAccess | Meaning_objectAccess | Meaning_unresolved;
 declare class Meaning_ownConstructorAccess {
     /**

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

@@ -1,5 +1,5 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { PackageEntityMembers } from '../entities/PackageMembers.js';
+import { PackageEntityMembers } from '../entities/index.js';
 import { ProgramOrTextTranslationPackage } from '../project/SourcePackage.js';
 import { Analyzer } from './Analyzer.js';
 export declare class PackageMemberConflictsValidator {

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

@@ -83,4 +83,5 @@ export declare class SourceFileAnalyzer {
     private addDiagnostic;
     private addDiagnostics;
     private addDiagnosticsLocatedInAnalyzedFile;
+    private sortAndRemoveDuplicateDiagnosticsInPlace;
 }

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

@@ -20,6 +20,7 @@ export declare class SubstitutedFunction_entity implements ISubstitutedFunction
     getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
+    equals(other: SubstitutedFunction, considerLocale?: boolean): boolean;
 }
 export declare class SubstitutedFunction_typeMember implements ISubstitutedFunction {
     readonly method: types.Method;
@@ -37,6 +38,7 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
+    equals(other: SubstitutedFunction, considerLocale?: boolean): boolean;
 }
 interface ISubstitutedFunction {
     getEntity(): NamedFunctionEntity;
@@ -47,5 +49,6 @@ interface ISubstitutedFunction {
     getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
     isAsync(): boolean;
+    equals(other: SubstitutedFunction, considerLocale: boolean): boolean;
 }
 export {};

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

@@ -1,4 +1,4 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -9,9 +9,10 @@ import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;
+    private readonly diagnostics;
     private readonly semanticContext_;
     private get semanticContext();
-    constructor(analyzer: Analyzer, node: Tag);
+    constructor(analyzer: Analyzer, node: Tag, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): ResolutionResult;
     private resolveNameInScope;
     private resolveNameInPackage;
@@ -21,9 +22,8 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics?: readonly Diagnostic[];
     readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[];
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics?: (readonly Diagnostic[]) | Diagnostic, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[]);
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[]);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {

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

@@ -1,4 +1,4 @@
-import { WithDiagnostics } from '../diagnostic/WithDiagnostics.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -26,7 +26,8 @@ export declare class UserDefinableBinaryOperatorResolver {
     private readonly right;
     private readonly operatorKind;
     private readonly operatorNodeForDiagnostic;
-    constructor(analyzer: Analyzer, left: tree.Expression, right: tree.Expression, operatorKind: BinaryOperatorKind, operatorNodeForDiagnostic: tree.Node);
-    resolve(): WithDiagnostics<types.Operator>;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, left: tree.Expression, right: tree.Expression, operatorKind: BinaryOperatorKind, operatorNodeForDiagnostic: tree.Node, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): types.Operator | undefined;
     private chooseSuitableOperators;
 }

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

@@ -1,4 +1,4 @@
-import { WithDiagnostics } from '../diagnostic/WithDiagnostics.js';
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
@@ -16,7 +16,8 @@ import { Analyzer } from './index.js';
 export declare class UserDefinableUnaryOperatorResolver {
     private readonly analyzer;
     private readonly node;
+    private readonly diagnostics;
     private get operatorKind();
-    constructor(analyzer: Analyzer, node: tree.PrefixUnaryExpression);
-    resolve(): WithDiagnostics<types.Operator>;
+    constructor(analyzer: Analyzer, node: tree.PrefixUnaryExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): types.Operator | undefined;
 }

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

@@ -15,6 +15,7 @@ export declare function findTag(tagTypeEntity: TypeEntity, tags: readonly Tag[])
 export declare function findTag(tagFunctionEntity: FunctionEntity, tags: readonly Tag[]): TagFunction | undefined;
 export declare function findTag(tagEntity: TypeEntity | FunctionEntity, tags: readonly Tag[]): TagType | TagFunction | undefined;
 export declare function getRequiredTypeParameterCount(typeParameters: readonly TypeParameterEntity[]): number;
+export declare function flattenPackageImportDirectiveList(list: tree.PackageImportDirectiveList): Iterable<tree.PackageImport>;
 export declare function flattenPackageMemberDeclarationList(list: tree.PackageMemberDeclarationList): Iterable<Exclude<tree.PackageMemberDeclaration, tree.PackageMemberGroupDeclaration>>;
 export declare function flattenTypeMemberDeclarationList(list: tree.TypeMemberDeclarationList): Iterable<Exclude<tree.TypeMemberDeclaration, tree.TypeMemberGroupDeclaration>>;
 export declare function isComputedVariableEntity(entity: VariableEntity): boolean;

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

@@ -1,5 +1,4 @@
 import { Name } from '../../common/index.js';
-import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { NamedDeclaration, TypeOrContainerWithTypes } from './Declarations.js';
@@ -14,8 +13,8 @@ export declare class FieldWithInitializerSemanticContext extends SemanticContext
     private readonly node;
     constructor(analyzer: Analyzer, node: tree.FieldDeclaration, outer: SemanticContextContainingTypeMember);
     isStatic(): boolean;
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(_name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(_name: Name, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    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[];
 }

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

@@ -22,10 +22,10 @@ export declare abstract class SemanticContextBase {
     abstract getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
     abstract getTryStatementContext(): TryStatementContextKind | undefined;
     abstract isStatic(): boolean;
-    abstract getOwnTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    abstract getOwnTypesOrContainersWithTypesByName(name: Name, hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    abstract getOwnNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    abstract getOwnNamedDeclarationsByName(name: Name, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    abstract getOwnTypesOrContainersWithTypes(initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    abstract getOwnTypesOrContainersWithTypesByName(name: Name, initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    abstract getOwnNamedDeclarations(initialContext: SemanticContext, noInstanceMembers?: boolean): readonly NamedDeclaration[];
+    abstract getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, noInstanceMembers?: boolean): readonly NamedDeclaration[];
     getContainingSourceFile(): SourceFile;
     getContainingPackage(): PackageEntity;
     getHidingMatcher(): IEntityHidingMatcher;

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

@@ -1,6 +1,5 @@
 import { Name } from '../../common/index.js';
 import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
-import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
 import { LocalVariableEntity, NestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../../entities/index.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
@@ -28,10 +27,10 @@ export declare abstract class SemanticContextValidatingNameConflictsBase extends
     constructor(analyzer: Analyzer);
     protected abstract createMemberEntities(): readonly MemberOfSemanticContextValidatingNameConflicts[];
     protected abstract createMemberEntitiesForTypeLookup(): readonly MemberOfSemanticContextValidatingNameConflictsForTypeLookup[];
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(name: Name, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    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[];
     validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
     private getMemberEntityDictionary;
     private validateNestedFunctionsConflicts;

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

@@ -1,4 +1,5 @@
 import { Name } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
 import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
 import { PackageEntity, TextTranslationEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
 import { SourceFile } from '../../project/SourceFile.js';
@@ -15,14 +16,16 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     protected asContext: SemanticContext;
     private readonly analyzer;
     private readonly sourceFile;
-    private readonly sourceFileMembers;
     private readonly containingPackageMemberLookup;
     private readonly importedPackageMemberLookups;
+    private readonly packageAliases;
+    private readonly packageAliasesByNameKey_;
     private readonly packageNameSegments;
-    private readonly packageNameSegmentsByKey_;
+    private readonly packageNameSegmentsByNameKey_;
     private readonly diagnosticArgumentFactory;
     private readonly primaryTextTranslationPackage_;
-    private get packageNameSegmentsByKey();
+    private get packageAliasesByNameKey();
+    private get packageNameSegmentsByNameKey();
     private get primaryTextTranslationPackage();
     constructor(analyzer: Analyzer, node: tree.SourceFile);
     getContainingSubprogram(): SubprogramInfo | undefined;
@@ -32,12 +35,13 @@ export declare class SourceFileSemanticContext extends SemanticContextBase {
     getTryStatementContext(): TryStatementContextKind | undefined;
     isStatic(): boolean;
     getDiagnosticArgumentFactory(): DiagnosticArgumentFactory;
-    getOwnTypesOrContainersWithTypes(hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(name: Name, hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): NamedDeclaration[];
-    getOwnNamedDeclarationsByName(name: Name, _noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    getOwnTypesOrContainersWithTypes(initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(name: Name, initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnNamedDeclarations(initialContext: SemanticContext, _noInstanceMembers?: boolean): NamedDeclaration[];
+    getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, _noInstanceMembers?: boolean): readonly NamedDeclaration[];
     getOwnTypeExtensionsByType(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): TypeExtensionEntity[];
     getTextTranslationEntityByTextKey(key: TextKey): readonly TextTranslationEntity[];
+    validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
     private convertPackageMemberToNamedDeclaration;
     private convertPackageAliasToTypeOrContainerWithTypes;
     private convertPackageMemberToTypeOrContainerWithTypes;

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

@@ -1,5 +1,4 @@
 import { Name } from '../../common/index.js';
-import { IEntityHidingMatcher } from '../../entities/EntityHiding.js';
 import * as tree from '../../tree/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral } from '../NodeTypeUtils.js';
@@ -19,10 +18,10 @@ export declare abstract class OutermostSemanticContextOfSubprogram extends Seman
     readonly kind = "outermost-of-subprogram";
     abstract getContainingSubprogram(): SubprogramInfo;
     getTryStatementContext(): TryStatementContextKind | undefined;
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(_name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(_name: Name, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    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[];
 }
 export declare class FunctionSemanticContext extends OutermostSemanticContextOfSubprogram {
     readonly outer: SemanticContext;

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

@@ -28,10 +28,10 @@ export declare class OutermostSemanticContextOfType extends SemanticContextWithP
     getContainingTypeOrTypeExtension(): TypeOrTypeExtension | undefined;
     getContainingSubprogram(): SubprogramInfo | undefined;
     isStatic(): boolean;
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(_name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(_noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
-    getOwnNamedDeclarationsByName(_name: Name, _noInstanceMembers?: boolean, _hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    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[];
     private getContainingType;
 }
 type TypeDeclarationWithTypeParameters = tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration | tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration;
@@ -47,10 +47,10 @@ export declare class TypeParametersOfTypeSemanticContext extends SemanticContext
 }
 declare abstract class TypeOrExtensionBodySemanticContext extends SemanticContextWithParent {
     protected abstract memberLookup: TypeMemberLookup;
-    getOwnTypesOrContainersWithTypes(_hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnTypesOrContainersWithTypesByName(_name: Name, _hidingMatcher?: IEntityHidingMatcher): readonly TypeOrContainerWithTypes[];
-    getOwnNamedDeclarations(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): NamedDeclaration[];
-    getOwnNamedDeclarationsByName(name: Name, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly NamedDeclaration[];
+    getOwnTypesOrContainersWithTypes(_initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnTypesOrContainersWithTypesByName(_name: Name, _initialContext: SemanticContext): readonly TypeOrContainerWithTypes[];
+    getOwnNamedDeclarations(initialContext: SemanticContext, noInstanceMembers?: boolean): NamedDeclaration[];
+    getOwnNamedDeclarationsByName(name: Name, initialContext: SemanticContext, noInstanceMembers?: boolean): readonly NamedDeclaration[];
     getOwnOperators(noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly types.Operator[];
     getOwnOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean, hidingMatcher?: IEntityHidingMatcher): readonly types.Operator[];
     private convertNamedMember;

package/build/types/api/Api.d.ts

@@ -6,21 +6,20 @@ export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/Autot
 export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
 export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
 export type { Meaning as DereferenceExpressionMeaning } from '../analysis/DereferenceExpressionMeaning.js';
-export * from '../analysis/SourceFileAnalyzer.js';
 export * from '../analysis/FindModifier.js';
-export type { Meaning as IdentifierExpressionMeaning, ResolutionResult as IdentifierExpressionResolutionResult } from '../analysis/IdentifierExpressionMeaning.js';
+export type { Meaning as IdentifierExpressionMeaning } from '../analysis/IdentifierExpressionMeaning.js';
 export * from '../analysis/ImportedPackageNameTree.js';
 export type { Meaning as IndexedAccessExpressionMeaning } from '../analysis/IndexedAccessExpressionMeaning.js';
-export type { Meaning as MemberAccessExpressionMeaning, ResolutionResult as MemberAccessExpressionResolutionResult } from '../analysis/MemberAccessExpressionMeaning.js';
+export type { Meaning as MemberAccessExpressionMeaning } from '../analysis/MemberAccessExpressionMeaning.js';
 export * from '../analysis/NodeTypeUtils.js';
 export type { Meaning as ObjectExpressionMeaning } from '../analysis/ObjectExpressionMeaning.js';
 export * from '../analysis/PackageMemberLookup.js';
 export * as semanticContext from '../analysis/semantic-context/index.js';
-export * from '../analysis/SourceFileMembers.js';
+export * from '../analysis/SourceFileAnalyzer.js';
 export * from '../analysis/SourcePackageDependencyGraph.js';
 export * from '../analysis/SubstitutedFunction.js';
-export type { Meaning as TagMeaning } from '../analysis/TagMeaning.js';
 export * from '../analysis/Tag.js';
+export type { Meaning as TagMeaning } from '../analysis/TagMeaning.js';
 export * from '../analysis/Translation.js';
 export * from '../analysis/TypeMemberLookup.js';
 export * from '../analysis/Utils.js';

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

@@ -4,12 +4,14 @@ export declare class ArrayUtils {
      *
      * Работает быстрее, чем `array.splice(index, 1)`, и не выделяет память для массива удалённых элементов.
      */
-    static removeElement<T>(array: T[], index: number): void;
+    static removeElement<T>(array: T[], index: number, count?: number): void;
     static pushElementIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[] | undefined, element: T): boolean;
     static pushElementsIfUniqueComparingWithEquals<T extends WithEqualsMethod<T>>(array: T[] | undefined, elements: readonly T[]): void;
     static count<T>(array: readonly T[], cb: (v: T) => boolean): number;
     static compareWithEqualsIgnoringOrder<T extends WithEqualsMethod<T>>(array1: readonly T[], array2: readonly T[]): boolean;
     static compareWithComparatorIgnoringOrder<T1, T2>(array1: readonly T1[], array2: readonly T2[], comparator: (e1: T1, e2: T2) => boolean): boolean;
+    static compareWithEquals<T extends WithEqualsMethod<T>>(array1: readonly T[], array2: readonly T[]): boolean;
+    static compareWithComparator<T1, T2>(array1: readonly T1[], array2: readonly T2[], comparator: (e1: T1, e2: T2) => boolean): boolean;
 }
 export type WithEqualsMethod<T> = {
     equals(t: T): boolean;