@artel/artc 0.6.25244 → 0.6.25246

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

@@ -1,19 +1,17 @@
-import { AccessKind, MaybeLazy } from '../common/index.js';
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
-import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer, TargetTypeHint } from './index.js';
-import { WithLocalization } from './Localization.js';
 export declare class Resolver {
     private readonly _semanticContext;
     private readonly _analyzer;
     private readonly _node;
     private readonly _targetTypeHint;
-    private get memberSearchName();
+    private get memberName();
     private get semanticContext();
     private get receiver();
     constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, targetTypeHint: TargetTypeHint | undefined);
@@ -31,12 +29,12 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
+    readonly diagnostic?: Diagnostic | undefined;
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
     readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: MaybeLazy<Diagnostic> | undefined, 
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
     /**
      * Может ли измениться результат, если посчитать его с другим целевым типом?
      */
@@ -44,24 +42,24 @@ export declare class ResolutionResult {
 }
 export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
-    readonly variable: FoundNamedDeclaration<PackageVariableEntity>;
+    readonly variable: PackageVariableEntity;
     readonly accessKind: AccessKind;
     readonly kind = "package-variable-access";
-    constructor(variable: FoundNamedDeclaration<PackageVariableEntity>, accessKind: AccessKind);
+    constructor(variable: PackageVariableEntity, accessKind: AccessKind);
 }
 declare class Meaning_packageFunctionAccess {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "package-function-access";
-    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 declare class Meaning_packageTypeAccess {
-    readonly candidates: readonly FoundNamedDeclaration<PackageTypeEntity>[];
-    readonly suitableTypes: readonly FoundNamedDeclaration<types.Type>[];
+    readonly candidates: readonly PackageTypeEntity[];
+    readonly suitableTypes: readonly types.Type[];
     readonly kind = "package-type-access";
-    get singleSuitableType(): FoundNamedDeclaration<types.Type> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<PackageTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<types.Type>[]);
+    get singleSuitableType(): types.Type | undefined;
+    constructor(candidates: readonly PackageTypeEntity[], suitableTypes: readonly types.Type[]);
 }
 declare class Meaning_packageNameSegmentAccess {
     readonly packageTreeNode: PackageNameTreeNode;
@@ -70,43 +68,43 @@ declare class Meaning_packageNameSegmentAccess {
 }
 declare class Meaning_staticFieldAccess {
     readonly type: types.Type;
-    readonly field: FoundNamedDeclaration<types.Field>;
+    readonly field: types.Field;
     readonly accessKind: AccessKind;
     readonly kind = "static-field-access";
-    constructor(type: types.Type, field: FoundNamedDeclaration<types.Field>, accessKind: AccessKind);
+    constructor(type: types.Type, field: types.Field, accessKind: AccessKind);
 }
 declare class Meaning_staticMethodAccess {
     readonly type: types.Type;
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "static-method-access";
-    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
-    constructor(type: types.Type, candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(type: types.Type, candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 declare class Meaning_instanceFieldAccess {
-    readonly field: FoundNamedDeclaration<types.Field>;
+    readonly field: types.Field;
     readonly accessKind: AccessKind;
     readonly kind = "instance-field-access";
-    constructor(field: FoundNamedDeclaration<types.Field>, accessKind: AccessKind);
+    constructor(field: types.Field, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "instance-method-access";
-    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 declare class Meaning_operatorAccess {
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Operator>[];
-    readonly suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[];
+    readonly candidates: readonly types.Operator[];
+    readonly suitableOperators: readonly types.Operator[];
     readonly kind = "operator-access";
-    get singleSuitableOperator(): FoundAnonymousDeclaration<types.Operator> | undefined;
-    constructor(candidates: readonly FoundAnonymousDeclaration<types.Operator>[], suitableOperators: readonly FoundAnonymousDeclaration<types.Operator>[]);
+    get singleSuitableOperator(): types.Operator | undefined;
+    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
 declare class Meaning_mixedAmbiguousAccess {
-    readonly entities: readonly WithLocalization<Entity>[];
+    readonly entities: readonly Entity[];
     readonly kind = "mixed-ambiguous-access";
-    constructor(entities: readonly WithLocalization<Entity>[]);
+    constructor(entities: readonly Entity[]);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";

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

@@ -1,11 +1,8 @@
-import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { QualifiedName } from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { WithLocalization } from './Localization.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeResolver {
     private readonly _analyzer;
@@ -22,11 +19,11 @@ export declare class NamedTypeResolver {
     private createAmbiguousAccessDiagnostic;
 }
 export declare class NamedTypeResolutionResult {
-    readonly types: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly types: readonly NamedTypeEntity[];
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
-    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(types: readonly FoundNamedDeclaration<NamedTypeEntity>[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    readonly diagnostics: readonly Diagnostic[];
+    readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
 }
 export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
 export declare class ResolvedQualifier_packageNameSegment {
@@ -40,8 +37,8 @@ export declare class ResolvedQualifier_packageAlias {
     constructor(packageAlias: PackageAliasEntity);
 }
 export declare class ResolvedQualifier_type {
-    readonly candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[];
-    readonly suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly NamedTypeEntity[];
     readonly kind = "type";
-    constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[]);
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
 }

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

@@ -1,10 +1,7 @@
-import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeSpecifier } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
-import { WithLocalization } from './Localization.js';
 import { ResolvedQualifier } from './NamedTypeResolver.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
@@ -15,9 +12,9 @@ export declare class NamedTypeSpecifierResolver {
     private resolveTypeOverload;
 }
 export declare class NamedTypeSpecifierResolutionResult {
-    readonly type: FoundNamedDeclaration<types.Type> | undefined;
+    readonly type: types.Type | undefined;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostics: readonly MaybeLazy<Diagnostic>[];
-    readonly ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(type: FoundNamedDeclaration<types.Type> | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly MaybeLazy<Diagnostic>[], ambiguousDeclarations: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    readonly diagnostics: readonly Diagnostic[];
+    readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(type: types.Type | undefined, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics: readonly Diagnostic[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
 }

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

@@ -22,6 +22,7 @@ export type FunctionTypeDeclaration = tree.PackageFunctionTypeDeclaration | tree
 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 VariableDeclaration = tree.EnumerationVariableDeclaration | tree.PackageVariableDeclaration | tree.LocalVariableDeclaration | tree.ParameterDeclaration | tree.FieldDeclaration | tree.VariantDeclaration;
 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/ObjectExpressionMeaning.d.ts

@@ -2,7 +2,6 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 /**
  * "объект" может использоваться только в следующих конструкциях:
  * 1. объект() - в конструкторе для вызова другого собственного конструктора.
@@ -12,12 +11,18 @@ export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
     constructor(analyzer: Analyzer, node: tree.ObjectExpression);
-    resolve(): Meaning;
+    resolve(): ResolutionResult;
     private resolveOwnConstructorAccess;
     private resolveContextAccess;
-    private invalidContextMeaning;
+    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 {
     /**
@@ -28,9 +33,10 @@ declare class Meaning_ownConstructorAccess {
      * с ним совместим.
      */
     readonly type: types.Type;
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
-    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "own-constructor-access";
+    get singleSuitableConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -39,7 +45,7 @@ declare class Meaning_ownConstructorAccess {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_objectAccess {
     readonly type: types.Type;
@@ -47,8 +53,6 @@ declare class Meaning_objectAccess {
     constructor(type: types.Type);
 }
 declare class Meaning_unresolved {
-    readonly diagnostic: Diagnostic | undefined;
     readonly kind = "unresolved";
-    constructor(diagnostic: Diagnostic | undefined);
 }
 export {};

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

@@ -0,0 +1,23 @@
+import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { ConstructorEntity, TypeEntityWithMembers } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { SemanticContext } from './semantic-context/SemanticContext.js';
+export declare class OwnAndBaseConstructorCallsChecker {
+    private readonly _analyzer;
+    private readonly _constructorDeclarations;
+    private readonly _typeEntity;
+    private readonly _semanticContext;
+    constructor(_analyzer: Analyzer, _constructorDeclarations: readonly tree.ConstructorDeclaration[], _typeEntity: TypeEntityWithMembers, _semanticContext: SemanticContext);
+    check(): OwnAndBaseConstructorCallsCheckResult;
+    private addOwnConstructorCallOrReportCycleDiagnostic;
+    private getUnaliasedBaseObjectType;
+    private findAccessibleConstructorWithoutParameters;
+}
+export declare class OwnAndBaseConstructorCallsCheckResult {
+    readonly ownConstructorCalls: ReadonlyMap<ConstructorEntity, ConstructorEntity>;
+    readonly baseConstructorCalls: ReadonlyMap<ConstructorEntity, types.Constructor>;
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(ownConstructorCalls: ReadonlyMap<ConstructorEntity, ConstructorEntity>, baseConstructorCalls: ReadonlyMap<ConstructorEntity, types.Constructor>, diagnostics: readonly Diagnostic[]);
+}

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

@@ -0,0 +1,17 @@
+import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { SourcePackage } from '../project/SourcePackage.js';
+import { Analyzer } from './Analyzer.js';
+import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
+export declare class PackageAndStaticVariablesInitializationValidator {
+    private readonly _analyzer;
+    private readonly _package;
+    private readonly _declarationsUsageCountResults;
+    private readonly _diagnostics;
+    constructor(_analyzer: Analyzer, _package: SourcePackage, _declarationsUsageCountResults: readonly DeclarationsUsageCountResult[], _diagnostics: DiagnosticAcceptor);
+    validate(): void;
+    private getVariablesThatNeedToBeInitializedInConstructor;
+    private collectStaticFieldsThatNeedToBeInitializedInConstructor;
+    private excludeVariablesInitializedInConstructor;
+    private reportNotInitialedVariableDiagnostic;
+    private getVariableDiagnosticLocationWithFallback;
+}

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

@@ -1,14 +1,9 @@
-import { SearchName } from '../common/index.js';
+import { Name } from '../common/index.js';
 import { IEntityHidingMatcher, NamedPackageMemberEntity, PackageEntity, TypeEntity, TypeExtensionEntity } from '../entities/index.js';
-import { FoundNamedDeclaration } from './FoundDeclaration.js';
-import { LocalizationContext } from './LocalizationContext.js';
 export declare class PackageMemberLookup {
     private readonly _package;
-    private readonly _localizationContext;
-    private readonly _translatedMembers;
-    private get translatedMembers();
-    constructor(_package: PackageEntity, _localizationContext: LocalizationContext | undefined);
-    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedPackageMemberEntity>[];
-    getNamedMembersByName(name: SearchName, hidingMatcher?: IEntityHidingMatcher): readonly FoundNamedDeclaration<NamedPackageMemberEntity>[];
+    constructor(_package: PackageEntity);
+    getNamedMembers(hidingMatcher?: IEntityHidingMatcher): readonly NamedPackageMemberEntity[];
+    getNamedMembersByName(name: Name, hidingMatcher?: IEntityHidingMatcher): readonly NamedPackageMemberEntity[];
     getTypeExtensions(type: TypeEntity, hidingMatcher?: IEntityHidingMatcher): readonly TypeExtensionEntity[];
 }

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

@@ -1,12 +1,12 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { OriginalPackageMembers } from '../entities/PackageMembers.js';
+import { PackageEntityMembers } from '../entities/PackageMembers.js';
 import { ProgramPackage } from '../project/SourcePackage.js';
 import { Analyzer } from './Analyzer.js';
 export declare class PackageMemberNameConflictsValidator {
     private readonly _analyzer;
     private readonly _members;
     private readonly _diagnostics;
-    constructor(_analyzer: Analyzer, _members: OriginalPackageMembers);
+    constructor(_analyzer: Analyzer, _members: PackageEntityMembers);
     validate(): readonly Diagnostic[];
     private validateFunctionNameConflicts;
     private validateTypeNameConflicts;

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

@@ -1,4 +1,4 @@
-import { SearchName } from '../common/index.js';
+import { Name } from '../common/index.js';
 import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { PackageAliasEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeExtensionEntity } from '../entities/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -10,9 +10,9 @@ export declare class SourceFileMembers {
     get declarationsByName(): ReadonlyMap<string, readonly NamedSourceFileMemberEntity[]>;
     constructor(analyzer: Analyzer, namedMembers: readonly NamedSourceFileMemberEntity[], typeExtensions: readonly TypeExtensionEntity[]);
     getNamedDeclarations(): readonly NamedSourceFileMemberEntity[];
-    getNamedDeclarationsByName(name: SearchName): readonly NamedSourceFileMemberEntity[];
+    getNamedDeclarationsByName(name: Name): readonly NamedSourceFileMemberEntity[];
     getPackageAliases(): readonly PackageAliasEntity[];
-    getPackageAliasesByName(name: SearchName): readonly PackageAliasEntity[];
+    getPackageAliasesByName(name: Name): readonly PackageAliasEntity[];
     getTypeExtensions(): readonly TypeExtensionEntity[];
     validateNameConflicts(diagnostics: DiagnosticAcceptor): void;
     private getDiagnosticLocation;

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

@@ -1,13 +1,10 @@
-import { MaybeLazy } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { FunctionEntity, NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
-import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer } from './index.js';
-import { WithLocalization } from './Localization.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class Resolver {
     private readonly _analyzer;
@@ -27,25 +24,25 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostic?: MaybeLazy<Diagnostic> | undefined;
-    readonly ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: MaybeLazy<Diagnostic> | undefined, ambiguousDeclarations?: readonly WithLocalization<EntityOrPackageNameTreeNode>[] | undefined);
+    readonly diagnostic?: Diagnostic | undefined;
+    readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {
     readonly type: types.Type;
-    readonly candidates: readonly FoundAnonymousDeclaration<types.Constructor>[];
-    readonly suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[];
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "tag-type";
-    get singleSuitableConstructor(): FoundAnonymousDeclaration<types.Constructor> | undefined;
-    constructor(type: types.Type, candidates: readonly FoundAnonymousDeclaration<types.Constructor>[], suitableConstructors: readonly FoundAnonymousDeclaration<types.Constructor>[]);
+    get singleSuitableConstructor(): types.Constructor | undefined;
+    constructor(type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_tagFunction {
-    readonly candidates: readonly FoundNamedDeclaration<AccessedFunction>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[];
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "tag-function";
-    get singleSuitableFunction(): FoundNamedDeclaration<AccessedFunction> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<AccessedFunction>[], suitableFunctions: readonly FoundNamedDeclaration<AccessedFunction>[]);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
@@ -62,17 +59,17 @@ export declare class ResolvedQualifier_packageAlias {
     constructor(packageAlias: PackageAliasEntity);
 }
 export declare class ResolvedQualifier_type {
-    readonly candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[];
-    readonly suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[];
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly NamedTypeEntity[];
     readonly kind = "type";
-    get singleSuitableType(): FoundNamedDeclaration<NamedTypeEntity> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<NamedTypeEntity>[], suitableTypes: readonly FoundNamedDeclaration<NamedTypeEntity>[]);
+    get singleSuitableType(): NamedTypeEntity | undefined;
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
 }
 export declare class ResolvedQualifier_function {
-    readonly candidates: readonly FoundNamedDeclaration<FunctionEntity>[];
-    readonly suitableFunctions: readonly FoundNamedDeclaration<FunctionEntity>[];
+    readonly candidates: readonly FunctionEntity[];
+    readonly suitableFunctions: readonly FunctionEntity[];
     readonly kind = "function";
-    get singleSuitableFunction(): FoundNamedDeclaration<FunctionEntity> | undefined;
-    constructor(candidates: readonly FoundNamedDeclaration<FunctionEntity>[], suitableFunctions: readonly FoundNamedDeclaration<FunctionEntity>[]);
+    get singleSuitableFunction(): FunctionEntity | undefined;
+    constructor(candidates: readonly FunctionEntity[], suitableFunctions: readonly FunctionEntity[]);
 }
 export {};

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

@@ -5,7 +5,7 @@ export type Tag = TagType | TagFunction;
 declare abstract class TagBase {
     readonly argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>;
     private readonly _argumentByName;
-    get argumentByName(): ReadonlyMap<string, TagArgument>;
+    get argumentByOriginalName(): ReadonlyMap<string, TagArgument>;
     constructor(argumentByParameter: ReadonlyMap<ParameterVariableEntity, TagArgument>);
 }
 export declare class TagType extends TagBase {

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

@@ -1,11 +1,11 @@
 import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { OriginalTypeEntityMembers } from '../entities/TypeEntityMembers.js';
+import { TypeEntityMembers } from '../entities/TypeEntityMembers.js';
 import { Analyzer } from './Analyzer.js';
 export declare class TypeMemberConflictsValidator {
     private readonly _analyzer;
     private readonly _members;
     private readonly _diagnostics;
-    constructor(_analyzer: Analyzer, _members: OriginalTypeEntityMembers, _diagnostics: DiagnosticAcceptor);
+    constructor(_analyzer: Analyzer, _members: TypeEntityMembers, _diagnostics: DiagnosticAcceptor);
     validate(): void;
     private validateNamedMembers;
     private validateNamedMembersWithoutIsStaticCheck;

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

@@ -1,32 +1,24 @@
-import { PackageLocale, SearchName } from '../common/index.js';
+import { Name, PackageLocale } from '../common/index.js';
 import { IEntityHidingMatcher, OperatorKind, TypeEntity, TypeExtensionEntity, TypeOrExtensionEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
-import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
-import { LocalizationContext } from './LocalizationContext.js';
 import { SemanticContext } from './semantic-context/SemanticContext.js';
 export declare class TypeMemberLookup {
     private readonly _analyzer;
     private readonly _typeOrExtension;
-    private readonly _localizationContext;
-    private readonly _searchLocale;
-    /**
-     * Язык, на котором будет осуществляться поиск членов типа.
-     */
-    get searchLocale(): PackageLocale;
+    private readonly _contextLocale;
     private constructor();
-    static ofType(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
-    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
-    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
-    static ofTypeOrExtension(analyzer: Analyzer, typeOrExtension: TypeOrExtension, localizationContext: LocalizationContext | undefined): TypeMemberLookup;
-    getNamedMembers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getNamedMembersByName(name: SearchName, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Constructor>[];
-    getIndexers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.Indexer>[];
-    getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
-    private getLocaleOfTypeEntity;
+    static ofType(analyzer: Analyzer, type: types.Type, contextLocale: PackageLocale | undefined): TypeMemberLookup;
+    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, contextLocale: PackageLocale | undefined): TypeMemberLookup;
+    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, contextLocale: PackageLocale | undefined): TypeMemberLookup;
+    static ofTypeOrExtension(analyzer: Analyzer, typeOrExtension: TypeOrExtension, contextLocale: PackageLocale | undefined): TypeMemberLookup;
+    getNamedMembers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.NamedTypeMember[];
+    getNamedMembersByName(name: Name, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.NamedTypeMember[];
+    getOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.Operator[];
+    getOperatorsByKind(kind: OperatorKind, options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.Operator[];
+    getConstructors(hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.Constructor[];
+    getIndexers(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.Indexer[];
+    getDereferenceOperators(options?: TypeMemberLookupOptions, hidingMatcher?: IEntityHidingMatcher, typeExtensionLookup?: SemanticContext): readonly types.DereferenceOperator[];
 }
 export declare class BoundTypeMemberLookup {
     private readonly _lookup;
@@ -34,16 +26,16 @@ export declare class BoundTypeMemberLookup {
     private readonly _hidingMatcher;
     private readonly _typeExtensionLookup;
     private constructor();
-    static ofType(analyzer: Analyzer, type: types.Type, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
-    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
-    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, localizationContext: LocalizationContext | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
-    getNamedMembers(): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getNamedMembersByName(name: SearchName): readonly FoundNamedDeclaration<types.NamedTypeMember>[];
-    getOperators(): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getOperatorsByKind(kind: OperatorKind): readonly FoundAnonymousDeclaration<types.Operator>[];
-    getConstructors(): readonly FoundAnonymousDeclaration<types.Constructor>[];
-    getIndexers(): readonly FoundAnonymousDeclaration<types.Indexer>[];
-    getDereferenceOperators(): readonly FoundAnonymousDeclaration<types.DereferenceOperator>[];
+    static ofType(analyzer: Analyzer, type: types.Type, contextLocale: PackageLocale | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
+    static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity, contextLocale: PackageLocale | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
+    static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity, contextLocale: PackageLocale | undefined, options: TypeMemberLookupOptions | undefined, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined): BoundTypeMemberLookup;
+    getNamedMembers(): readonly types.NamedTypeMember[];
+    getNamedMembersByName(name: Name): readonly types.NamedTypeMember[];
+    getOperators(): readonly types.Operator[];
+    getOperatorsByKind(kind: OperatorKind): readonly types.Operator[];
+    getConstructors(): readonly types.Constructor[];
+    getIndexers(): readonly types.Indexer[];
+    getDereferenceOperators(): readonly types.DereferenceOperator[];
 }
 export declare enum TypeMemberLookupOptions {
     None = 0,

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

@@ -9,6 +9,7 @@ export declare class TypeNarrower {
     private _reference;
     private readonly _typeByNode;
     private readonly _isVariableAssignedInLoopCheckResults;
+    private get locale();
     constructor(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node);
     getType(): types.Type;
     private getTypeAtControlFlowNode;

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

@@ -2,7 +2,6 @@ import { WithDiagnostics } from '../common/index.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
 import { Expression, Node } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer } from './index.js';
 /**
  * Определяет подходящую двухместную операцию, определённую пользователем (+, *, == и др.).
@@ -32,6 +31,6 @@ export declare class UserDefinableBinaryOperatorResolver {
     private get leftType();
     private get rightType();
     constructor(_analyzer: Analyzer, _left: Expression, _right: Expression, _operatorKind: BinaryOperatorKind, _operatorNodeForDiagnostic: Node);
-    resolve(): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
+    resolve(): WithDiagnostics<types.Operator>;
     private chooseSuitableOperators;
 }

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

@@ -1,7 +1,6 @@
 import { WithDiagnostics } from '../common/index.js';
 import { PrefixUnaryExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer } from './index.js';
 /**
  * Определяет подходящую одноместную операцию, определённую пользователем (+, -, не).
@@ -19,5 +18,5 @@ export declare class UserDefinableUnaryOperatorResolver {
     private readonly _node;
     private get operatorKind();
     constructor(_analyzer: Analyzer, _node: PrefixUnaryExpression);
-    resolve(): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
+    resolve(): WithDiagnostics<types.Operator>;
 }