@artel/artc 0.6.25244 → 0.6.25246

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

@@ -1,18 +1,19 @@
 import { Name, PackageLocale } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
+import { EntityLocalizationContext } from '../entities/EntityLocalizationContext.js';
 import { PackageEntity } from '../entities/PackageEntity.js';
-import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
-import { PackageVariableEntity, ParameterVariableEntity, FieldEntity } from '../entities/VariableEntity.js';
-import { AliasTypeEntity, ConstructorEntity, DestructorEntity, IndexerEntity, FunctionEntity, FunctionTypeEntity, NamedPackageMemberEntity, OperatorEntity, PackageFunctionEntity, PackageFunctionTypeEntity, PackageTypeEntity, StructuredTypeEntity, MethodEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
+import { FieldEntity, PackageVariableEntity, ParameterVariableEntity } from '../entities/VariableEntity.js';
+import { AliasTypeEntity, ConstructorEntity, DestructorEntity, FunctionEntity, FunctionTypeEntity, IndexerEntity, MethodEntity, NamedEntity, NamedPackageMemberEntity, NamedTypeMemberEntity, OperatorEntity, PackageFunctionEntity, PackageFunctionTypeEntity, PackageTypeEntity, StructuredTypeEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
 import { PackageName, TranslationPackage } from '../project/index.js';
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
-import { LocalizedName } from './Localization.js';
-import { NamedEntity } from './LocalizationContext.js';
+import { Translation } from './Localization.js';
 export declare class AnalyzedTranslationPackage {
     private readonly _analyzer;
     private readonly _package;
-    private readonly _translatedPackage;
+    private readonly _targetTarget;
+    readonly entityLocalizationContext: EntityLocalizationContext;
+    private readonly _localizedPackageByOriginalReferencedPackage;
     private readonly _members;
     private readonly _translatedTypeEntityMembers;
     private readonly _functionSignatureTranslations;
@@ -21,11 +22,13 @@ export declare class AnalyzedTranslationPackage {
     private readonly _constructorSignatureTranslations;
     private readonly _indexerSignatureTranslations;
     private readonly _translatedTypeHeaders;
-    constructor(_analyzer: Analyzer, _package: TranslationPackage, _translatedPackage: PackageEntity);
-    getTranslatedPackage(): PackageEntity;
+    constructor(_analyzer: Analyzer, _package: TranslationPackage, _targetTarget: PackageEntity);
+    getTargetPackage(): PackageEntity;
+    getPackageInTranslatedLanguage(): PackageEntity;
     getDefinition(): TranslationPackage;
     getTranslatedName(): PackageName;
     getTranslationLocale(): PackageLocale;
+    getLocalizedPackageByOriginalReferencedPackage(): ReadonlyMap<PackageEntity, PackageEntity>;
     getMembers(): TranslatedPackageMembers;
     getTypeEntityMembers(typeEntity: PackageTypeEntity): TranslatedTypeEntityMembers | undefined;
     getPackageVariableTranslationTarget(node: tree.PackageVariableTranslation): GetSingleTranslationTargetResult<PackageVariableEntity>;
@@ -39,16 +42,17 @@ export declare class AnalyzedTranslationPackage {
     getMethodTranslationTargets(node: tree.MethodTranslation): GetMultipleTranslationTargetsResult<MethodEntity>;
     getConstructorTranslationTargets(node: tree.ConstructorTranslation): GetMultipleTranslationTargetsResult<ConstructorEntity>;
     getIndexerTranslationTargets(node: tree.IndexerTranslation): GetMultipleTranslationTargetsResult<IndexerEntity>;
-    getFunctionSignature(entity: FunctionEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getOperatorSignature(entity: OperatorEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getPackageFunctionSignature(entity: PackageFunctionEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getMethodSignature(entity: MethodEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getFunctionTypeSignature(entity: FunctionTypeEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getConstructorSignature(entity: ConstructorEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getDestructorSignature(entity: DestructorEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getIndexerSignature(entity: IndexerEntity): LocalizedSubprogramSignature.Translated | undefined;
-    getTypeHeader(entity: TypeEntityWithHeaderLocalization): LocalizedTypeHeader.Translated | undefined;
-    getEntityName(entity: NamedEntity): Name | undefined;
+    getFunctionSignature(entity: FunctionEntity): TranslatedSubprogramSignature | undefined;
+    getOperatorSignature(entity: OperatorEntity): TranslatedSubprogramSignature | undefined;
+    getPackageFunctionSignature(entity: PackageFunctionEntity): TranslatedSubprogramSignature | undefined;
+    getMethodSignature(entity: MethodEntity): TranslatedSubprogramSignature | undefined;
+    getFunctionTypeSignature(entity: FunctionTypeEntity): TranslatedSubprogramSignature | undefined;
+    getConstructorSignature(entity: ConstructorEntity): TranslatedSubprogramSignature | undefined;
+    getDestructorSignature(entity: DestructorEntity): TranslatedSubprogramSignature | undefined;
+    getIndexerSignature(entity: IndexerEntity): TranslatedSubprogramSignature | undefined;
+    getTypeHeader(entity: TypeEntityWithHeaderLocalization): TranslatedTypeHeader | undefined;
+    getEntityName(entity: NamedEntity): TranslatedName | undefined;
+    private createLocalizedPackageByOriginalReferencedPackage;
     private createPackageMembers;
     private createTypeEntityMembers;
     private createTranslatedSubprogramSignatureFromPackageFunctionTranslation;
@@ -60,98 +64,57 @@ export declare class AnalyzedTranslationPackage {
     private createTranslatedTypeSignature;
     private enumerateTranslationsDeclarations;
     private findTypeTranslation;
-    private createAmbiguousAccessDiagnostic;
 }
 export declare class TranslatedPackageMembers {
     private readonly _namedMembers;
-    private readonly _membersByNameKey;
     private readonly _nameByEntity;
-    private get membersByNameKey();
     private get nameByEntity();
     constructor(_namedMembers: readonly TranslatedNamedPackageMember[]);
     getNamedMembers(): readonly TranslatedNamedPackageMember[];
-    getNamedMembersByName(name: Name): readonly TranslatedNamedPackageMember[];
-    getMemberName(entity: NamedPackageMemberEntity): Name | undefined;
+    getMemberName(entity: NamedPackageMemberEntity): TranslatedName | undefined;
 }
 export declare class TranslatedNamedPackageMember {
     readonly value: NamedPackageMemberEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: NamedPackageMemberEntity, name: LocalizedName.Translated);
+    readonly name: TranslatedName;
+    constructor(value: NamedPackageMemberEntity, name: TranslatedName);
 }
 export declare class TranslatedTypeEntityMembers {
     private readonly _namedMembers;
     readonly translationPackage: AnalyzedTranslationPackage;
-    private readonly _membersByNameKey;
     private readonly _nameByEntity;
-    private get membersByNameKey();
     private get nameByEntity();
     constructor(_namedMembers: readonly TranslatedNamedTypeEntityMember[], translationPackage: AnalyzedTranslationPackage);
     getNamedMembers(): readonly TranslatedNamedTypeEntityMember[];
-    getNamedMembersByName(name: Name): readonly TranslatedNamedTypeEntityMember[];
-    getMemberName(entity: NamedTypeMemberEntity): Name | undefined;
+    getMemberName(entity: NamedTypeMemberEntity): TranslatedName | undefined;
 }
 export declare class TranslatedNamedTypeEntityMember {
     readonly value: NamedTypeMemberEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: NamedTypeMemberEntity, name: LocalizedName.Translated);
+    readonly name: TranslatedName;
+    constructor(value: NamedTypeMemberEntity, name: TranslatedName);
 }
-export type LocalizedSubprogramSignature = LocalizedSubprogramSignature.Original | LocalizedSubprogramSignature.Translated;
-export declare namespace LocalizedSubprogramSignature {
-    export class Original implements ILocalizedSubprogramSignature {
-        readonly typeParameters: readonly Name[];
-        readonly valueParameters: readonly Name[];
-        readonly locale: PackageLocale;
-        readonly kind = "original";
-        constructor(typeParameters: readonly Name[], valueParameters: readonly Name[], locale: PackageLocale);
-        getTypeParameterNames(): readonly LocalizedName[];
-        getValueParameterNames(): readonly LocalizedName[];
-    }
-    export class Translated implements ILocalizedSubprogramSignature {
-        readonly typeParameters: readonly TranslatedTypeParameter[];
-        readonly valueParameters: readonly TranslatedValueParameter[];
-        readonly kind = "translated";
-        constructor(typeParameters: readonly TranslatedTypeParameter[], valueParameters: readonly TranslatedValueParameter[]);
-        getTypeParameterNames(): readonly LocalizedName[];
-        getValueParameterNames(): readonly LocalizedName[];
-        getTypeParameterName(entity: TypeParameterEntity): Name | undefined;
-        getValueParameterName(entity: ParameterVariableEntity): Name | undefined;
-    }
-    interface ILocalizedSubprogramSignature {
-        getTypeParameterNames(): readonly LocalizedName[];
-        getValueParameterNames(): readonly LocalizedName[];
-    }
-    export {};
+export declare class TranslatedSubprogramSignature {
+    readonly translation: Translation;
+    readonly typeParameters: readonly TranslatedTypeParameter[];
+    readonly valueParameters: readonly TranslatedValueParameter[];
+    constructor(translation: Translation, typeParameters: readonly TranslatedTypeParameter[], valueParameters: readonly TranslatedValueParameter[]);
+    getTypeParameterName(entity: TypeParameterEntity): TranslatedName | undefined;
+    getValueParameterName(entity: ParameterVariableEntity): TranslatedName | undefined;
 }
 export declare class TranslatedTypeParameter {
     readonly value: TypeParameterEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: TypeParameterEntity, name: LocalizedName.Translated);
+    readonly name: TranslatedName;
+    constructor(value: TypeParameterEntity, name: TranslatedName);
 }
 export declare class TranslatedValueParameter {
     readonly value: ParameterVariableEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: ParameterVariableEntity, name: LocalizedName.Translated);
+    readonly name: TranslatedName;
+    constructor(value: ParameterVariableEntity, name: TranslatedName);
 }
-export type LocalizedTypeHeader = LocalizedTypeHeader.Original | LocalizedTypeHeader.Translated;
-export declare namespace LocalizedTypeHeader {
-    export class Original implements ILocalizedTypeHeader {
-        readonly typeParameters: readonly Name[];
-        readonly locale: PackageLocale;
-        readonly kind = "original";
-        constructor(typeParameters: readonly Name[], locale: PackageLocale);
-        getTypeParameterNames(): readonly LocalizedName[];
-    }
-    export class Translated implements ILocalizedTypeHeader {
-        readonly typeParameters: readonly TranslatedTypeParameter[];
-        readonly kind = "translated";
-        constructor(typeParameters: readonly TranslatedTypeParameter[]);
-        getTypeParameterNames(): readonly LocalizedName[];
-        getTypeParameterName(entity: TypeParameterEntity): Name | undefined;
-    }
-    interface ILocalizedTypeHeader {
-        getTypeParameterNames(): readonly LocalizedName[];
-    }
-    export {};
+export declare class TranslatedTypeHeader {
+    readonly translation: Translation;
+    readonly typeParameters: readonly TranslatedTypeParameter[];
+    constructor(translation: Translation, typeParameters: readonly TranslatedTypeParameter[]);
+    getTypeParameterName(entity: TypeParameterEntity): TranslatedName | undefined;
 }
 export type TypeEntityWithHeaderLocalization = StructuredTypeEntity | VariantTypeEntity | AliasTypeEntity;
 export declare class GetSingleTranslationTargetResult<T> {
@@ -174,3 +137,8 @@ export declare class GetMultipleTranslationTargetsResult<T> {
     static invalid<T>(diagnostics: readonly Diagnostic[]): GetMultipleTranslationTargetsResult<T>;
     static invalid<T>(diagnostics: readonly Diagnostic[], targets: readonly T[], isAmbiguous: boolean): GetMultipleTranslationTargetsResult<T>;
 }
+export declare class TranslatedName {
+    readonly value: Name;
+    readonly translation: Translation;
+    constructor(value: Name, translation: Translation);
+}

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

@@ -1,11 +1,10 @@
 import ts from 'typescript';
-import { CancellationToken, Lazy, Name, PackageLocale, Range, SearchName, WithDiagnostics } from '../common/index.js';
+import { CancellationToken, DisplayableOrPrimitive, Name, PackageLocale, Range, WithDiagnostics } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
-import { OriginalPackageMembers } from '../entities/PackageMembers.js';
-import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
+import { PackageEntityMembers } from '../entities/PackageMembers.js';
 import * as e from '../entities/index.js';
 import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
 import * as project from '../project/index.js';
@@ -23,18 +22,17 @@ import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
-import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
+import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
 import * as functionOverloadResolver from './FunctionOverloadResolver.js';
 import * as identifierExpressionResolution from './IdentifierExpressionMeaning.js';
 import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
-import { WithLocalization } from './Localization.js';
-import { LocalizationContext } from './LocalizationContext.js';
 import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
 import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
-import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
+import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
 import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
 import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
@@ -52,8 +50,16 @@ export declare class Analyzer {
      * Пакет с именем 'Артель', содержащий стандартные типы.
      */
     readonly systemPackage: e.PackageEntity;
-    readonly wellKnownDeclarations: WellKnownDeclarations;
-    readonly standardTypes: types.StandardTypes;
+    /**
+     * Стандартные объявления на языке оригинала. Для получения стандартных объявлений на желаемом языке используйте
+     * {@link getLocalizedWellKnownDeclarations}.
+     */
+    readonly originalWellKnownDeclarations: WellKnownDeclarations;
+    /**
+     * Стандартные типы на языке оригинала. Для получения стандартных типов на желаемом языке используйте
+     * {@link getLocalizedStandardTypes}.
+     */
+    readonly originalStandardTypes: types.StandardTypes;
     readonly typeFactory: TypeFactory;
     readonly type: Type;
     readonly returnType: ReturnType;
@@ -62,7 +68,6 @@ export declare class Analyzer {
     readonly valueLocalVariableEntity: ValueLocalVariableEntity;
     readonly semanticContext: semanticContext.SemanticContextBuilder;
     readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
-    readonly defaultConstructors: DefaultConstructors;
     readonly overriddenMember: OverriddenMember;
     readonly tags: Tags;
     readonly linkedEntity: LinkedEntity;
@@ -82,8 +87,8 @@ export declare class Analyzer {
     private readonly _autotypeCallExpressionMeanings;
     private readonly _identifierExpressionResolutionResults;
     private readonly _tagResolutionResults;
-    private readonly _objectExpressionMeanings;
-    private readonly _baseExpressionMeanings;
+    private readonly _objectExpressionResolutionResults;
+    private readonly _baseExpressionResolutionResults;
     private readonly _namedTypeSpecifierResolutionResults;
     private readonly _prefixUnaryExpressionOperatorResolutionResults;
     private readonly _binaryExpressionUserDefinableOperatorResolutionResults;
@@ -95,15 +100,23 @@ export declare class Analyzer {
     private readonly _linkedMultiPlatformPackagesByPlatform;
     private readonly _functionBlockWithYieldStatementCheckResults;
     private readonly _namedDeclarationsUsageCountResults;
+    private readonly _packageAndStaticVariablesInitializationDiagnostics;
     private readonly _controlFlowGraphs;
     private readonly _diagnosticsComputedLazily;
     private readonly _diagnosticsComputedLazilyAcceptor;
     private readonly _sourcePackageMemberConflictsDiagnostics;
     private readonly _notExplicitlyImplementedAbstractTypeMembers;
     private readonly _typeMemberImplementationCheckResults;
+    private _originalPackageEntitiesByNameKey;
+    private _packageEntitiesByNameKey;
+    private readonly _localizedWellKnownDeclarations;
+    private readonly _localizedStandardTypes;
+    private readonly _ownAndBaseConstructorCallsCheckResults;
+    private readonly _expressionCanBeUsedInForLoopCheckResults;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
+    checkExpressionCanBeUsedInForLoop(node: tree.Expression): WithDiagnostics<ExpressionCanBeUsedInForLoopCheckResult>;
     ifTypeEnumerableThenItemType(type: types.Type): types.Type | undefined;
     ifTypeEnumeratorThenItemType(type: types.Type): types.Type | undefined;
     isTypeArrayOrReadonlyArray(type: types.Type): {
@@ -136,8 +149,8 @@ export declare class Analyzer {
     getAutotypeCallExpressionMeaning(node: tree.AutotypeCallExpression, targetTypeHint?: TargetTypeHint): autotypeCallExpressionMeaning.Meaning;
     resolveIdentifierExpression(node: tree.IdentifierExpression, targetTypeHint?: TargetTypeHint): identifierExpressionResolution.ResolutionResult;
     resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
-    getObjectExpressionMeaning(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
-    getBaseExpressionMeaning(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
+    resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.ResolutionResult;
+    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.ResolutionsResult;
     /**
      * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
      * `пусто`.
@@ -172,11 +185,9 @@ export declare class Analyzer {
     checkIdentifierNameIsReserved(name: string, locale: PackageLocale): ReservedIdentifierKind | undefined;
     getReservedIdentifierName(reservedIdentifierKind: ReservedIdentifierKind, locale: PackageLocale): string;
     createNameFromIdentifier(node: tree.Identifier): Name;
-    createSearchNameFromIdentifier(identifier: tree.Identifier): SearchName;
-    createLocalizationContext(sourceFile: project.SourceFile): LocalizationContext;
     getImplicitBaseTypeForStructuredType(entity: e.StructuredTypeEntity): types.StructuredType | undefined;
-    getImplicitBaseTypeForVariantType(): types.StructuredType;
-    getImplicitBaseTypeForFunctionType(): types.StructuredType;
+    getImplicitBaseTypeForVariantType(locale: PackageLocale): types.StructuredType;
+    getImplicitBaseTypeForFunctionType(locale: PackageLocale): types.StructuredType;
     resolveNamedTypeSpecifier(node: tree.NamedTypeSpecifier): NamedTypeSpecifierResolutionResult;
     checkExpressionDenotesType(expression: tree.Expression): {
         type: types.Type | undefined;
@@ -192,13 +203,16 @@ export declare class Analyzer {
     checkFunctionBlockWithYieldStatement(node: tree.FunctionBlock): boolean;
     enumerateAspects(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
-    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
-    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
-    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): WithDiagnostics<FoundAnonymousDeclaration<types.Operator>>;
+    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>;
     classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
     getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
+    getOriginalPackageEntities(): readonly e.PackageEntity[];
     getPackageEntities(): readonly e.PackageEntity[];
-    getPackageEntity(name: PackageName): e.PackageEntity | undefined;
+    getOriginalPackageEntityByName(name: PackageName): e.PackageEntity | undefined;
+    getPackageEntityByName(name: PackageName): e.PackageEntity | undefined;
+    getAnalyzedTranslationPackages(): readonly AnalyzedTranslationPackage[];
     createFunctionTypeInvokeMethod(entity: e.FunctionTypeEntity): e.MethodEntity;
     /**
      * Преобразует тип таким образом, чтобы он не мог содержать значение `пусто`.
@@ -222,13 +236,16 @@ export declare class Analyzer {
     canTypeParameterBeNone(type: types.ParameterType): boolean;
     /**
      * Делает тип `Пусто` совместимым с данным типом.
+     *
+     * @param locale Язык для типа Пусто.
+     *
      * @example
      * - Число         -> Число | Пусто
      * - Число | Пусто -> Число | Пусто
      * - Т: Объект?    -> (Т: Объект?) | Пусто (см. метод isNoneAssignableToType)
      * - Т: Объект     -> (Т: Объект) | Пусто
      */
-    includeNoneToType(type: types.Type): types.Type;
+    includeNoneToType(type: types.Type, locale: PackageLocale): types.Type;
     /**
      * Отвечает на вопрос "Совместим ли тип `Пусто` с данным типом?" (Можно ли присвоить `пусто` в переменную с данным типом?).
      * @example Для следующих типов метод вернёт:
@@ -239,16 +256,17 @@ export declare class Analyzer {
     isNoneAssignableToType(type: types.Type): boolean;
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isValueParameterVariadic(entity: e.VariableEntity): boolean;
-    getDefaultTypeParameterConstraint(): types.Type;
-    getOriginalSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
+    getDefaultTypeParameterConstraint(locale: PackageLocale): types.Type;
+    getSignatureTypeOfFunctionEntity(entity: e.FunctionEntity): types.FunctionType;
     getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterVariableEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
-    getAnalyzedTranslationPackageForPackage(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
+    findAnalyzedTranslationPackageForLocale(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
+    getLocalizedPackageWithLocale(originalPackageEntity: e.PackageEntity, locale: PackageLocale): e.PackageEntity | undefined;
     enumerateAnalyzedTranslationPackages(): Iterable<AnalyzedTranslationPackage>;
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
-    createPackageMembers(pkg: SourcePackage): OriginalPackageMembers;
+    createPackageMembers(pkg: SourcePackage): PackageEntityMembers;
     instantiateType(entity: e.TypeEntity, typeArguments?: readonly types.Type[]): types.Type;
     instantiateType(entity: e.TypeEntity, substitutions?: types.Substitutions): types.Type;
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;
@@ -261,11 +279,13 @@ export declare class Analyzer {
     createPackageMemberHiding(node: tree.PackageMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     getDeclarationsUsageCount(sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined): Promise<DeclarationsUsageCountResult>;
+    getPackageAndStaticVariablesInitializationDiagnostics(pkg: SourcePackage, cancellationToken: CancellationToken | undefined): 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[];
-    createBackingFields(declaredMembers: readonly NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
-    createNodeDiagnostic(code: DiagnosticCode, node: tree.Node, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
-    createSourceFileRangeDiagnostic(code: DiagnosticCode, range: Range, nodeOrSourceFile: tree.Node | project.SourceFile, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
-    createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly string[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
+    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;
+    createDiagnostic(code: DiagnosticCode, location: DiagnosticLocation | undefined, formatArguments?: readonly DisplayableOrPrimitive[], kind?: DiagnosticKind, flags?: DiagnosticFlags): Diagnostic;
     createNodeDiagnosticLocation(node: tree.Node): DiagnosticLocation;
     getDeclaredTypeMemberEntities(node: tree.TypeMemberDeclarationBlock): DeclaredTypeMemberEntities;
     getBasicMethodOfOriginalTypeForBasicMethodOfAliasType(entity: e.MethodEntity): e.MethodEntity | undefined;
@@ -273,14 +293,10 @@ export declare class Analyzer {
         basicMethodOfOriginalType: e.MethodEntity;
     } | undefined;
     getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
-    createAmbiguousEntityAccessDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousEntityAccessLazyDiagnostic(entities: readonly WithLocalization<e.Entity>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
-    createAmbiguousFunctionAccessDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousFunctionAccessLazyDiagnostic(functions: readonly WithLocalization<AccessedFunction>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
-    createAmbiguousTypeMemberAccessDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousTypeMemberAccessLazyDiagnostic(members: readonly WithLocalization<types.TypeMember>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
-    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Diagnostic;
-    createAmbiguousNamedScopeDeclarationAccessLazyDiagnostic(declarations: readonly WithLocalization<semanticContext.NamedDeclaration>[], lctx: LocalizationContext, node: tree.Node): Lazy<Diagnostic>;
+    createAmbiguousEntityAccessDiagnostic(entities: readonly e.Entity[], node: tree.Node): Diagnostic;
+    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;
     getSourceFileDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
@@ -290,6 +306,13 @@ export declare class Analyzer {
     getTypeMemberImplementationCheckResult(typeEntity: e.TypeEntityWithMembers): TypeMemberImplementationCheckResult;
     createEntityContextForTypeDeclaration(node: TypeDeclaration): e.EntityContext;
     isFunctionBlockWithImplicitlyReturnedExpression(node: tree.FunctionBlock): boolean;
+    getLocalizedWellKnownDeclarations(locale: PackageLocale): WellKnownDeclarations;
+    getLocalizedStandardTypes(locale: PackageLocale): types.StandardTypes;
+    determineUnderlyingTypeOfSourceVariantType(memberList: tree.TypeMemberDeclarationList): types.Type;
+    getOwnAndBaseConstructorCallsCheckResult(node: TypeWithMembersDeclaration): OwnAndBaseConstructorCallsCheckResult;
+    isConstructorCallingOwnConstructor(node: tree.ConstructorDeclaration): boolean;
+    createDiagnosticArgumentFactoryWithinPackage(entity: e.PackageEntity): DiagnosticArgumentFactory;
+    createDiagnosticArgumentFactoryWithinEntityContext(context: e.EntityContext): DiagnosticArgumentFactory;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -315,6 +338,11 @@ export declare const enum SyntacticAccessKind {
     GetSet = 2,
     ReferencedValue = 3
 }
+export declare class ExpressionCanBeUsedInForLoopCheckResult {
+    readonly elementType: types.Type;
+    readonly ifTypeDoesNotImplementEnumerableThenEnumeratorMethod: types.Method | undefined;
+    constructor(elementType: types.Type, ifTypeDoesNotImplementEnumerableThenEnumeratorMethod: types.Method | undefined);
+}
 declare class Type {
     private readonly _analyzer;
     private readonly _unionTypeSpecifierTypes;
@@ -324,8 +352,8 @@ declare class Type {
     constructor(_analyzer: Analyzer);
     ofExpression(node: tree.Expression, targetTypeHint?: TargetTypeHint): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
-    ofAccessedFunction(accessedFunction: WithLocalization<AccessedFunction>): types.Type;
-    ofAccessedOperator(operator: WithLocalization<types.Operator>): types.Type;
+    ofAccessedFunction(accessedFunction: AccessedFunction): types.Type;
+    ofAccessedOperator(operator: types.Operator): types.Type;
     ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral, targetTypeHint?: TargetTypeHint): types.FunctionType;
     ofFunctionLiteral(node: tree.FunctionLiteral, targetTypeHint?: TargetTypeHint): types.FunctionType;
     private ofArrayLiteral;
@@ -449,6 +477,7 @@ declare class Entity {
     ofVariantDeclaration(node: tree.VariantDeclaration): e.FieldEntity;
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
+    ofTypeWithMembersDeclaration(node: TypeWithMembersDeclaration): e.TypeEntityWithMembers;
     private getContainingPackageLoadedFromDts;
     private createComputedFieldEntities;
     private createDereferenceOperatorEntities;
@@ -483,14 +512,6 @@ declare class ValueLocalVariableEntity {
     ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.LocalVariableEntity;
     ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
 }
-declare class DefaultConstructors {
-    private readonly _analyzer;
-    private readonly _defaultConstructorEntities;
-    constructor(_analyzer: Analyzer);
-    ofStructuredType(type: StructuredTypeDeclaration): readonly e.ConstructorEntity[];
-    private createDefaultConstructors;
-    private getPublicInstanceStoredVariables;
-}
 declare class OverriddenMember {
     private readonly _analyzer;
     private readonly _namedMemberFinder;
@@ -646,16 +667,15 @@ declare class PackageImports {
     private readonly _importedPackageNameTrees;
     constructor(_analyzer: Analyzer);
     analyzeExplicitPackageImports(sourceFile: project.SourceFile): AnalyzedPackageImports;
-    getPackagesAvailableForImport(pkg: project.SourcePackage): readonly AvailablePackage[];
+    getPackagesAvailableForImport(pkg: project.SourcePackage): readonly e.PackageEntity[];
     getUniqueImportedPackages(sourceFile: project.SourceFile): readonly PackageImportInfo[];
     getImportedPackageNameTree(node: tree.SourceFile): ImportedPackageNameTree;
     private getAutomaticallyImportedPackages;
 }
 export declare class AnalyzedPackageImport {
     readonly entity: e.PackageEntity | undefined;
-    readonly translationPackage: AnalyzedTranslationPackage | undefined;
     readonly isAliasedImport: e.PackageAliasEntity | undefined;
-    constructor(entity: e.PackageEntity | undefined, translationPackage: AnalyzedTranslationPackage | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
+    constructor(entity: e.PackageEntity | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
 }
 export declare class AnalyzedPackageImports {
     readonly packageImportInfos: Map<tree.PackageImport, AnalyzedPackageImport>;
@@ -664,9 +684,8 @@ export declare class AnalyzedPackageImports {
 }
 export declare class PackageImportInfo {
     readonly entity: e.PackageEntity;
-    readonly translationPackage: AnalyzedTranslationPackage | undefined;
     readonly isAliasedImport: e.PackageAliasEntity | undefined;
-    constructor(entity: e.PackageEntity, translationPackage: AnalyzedTranslationPackage | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
+    constructor(entity: e.PackageEntity, isAliasedImport: e.PackageAliasEntity | undefined);
 }
 declare class TypeUtils {
     private readonly _analyzer;
@@ -732,44 +751,16 @@ declare class ConflictsCheck {
 export type EntityWithoutTypeParametersInSignature = e.ConstructorEntity | e.DestructorEntity | e.OperatorEntity | e.IndexerEntity;
 export type TypeMemberWithoutTypeParametersInSignature = types.Constructor | types.Destructor | types.Operator | types.Indexer;
 export declare class ExpressionDenotesFunctionCheckResult {
-    readonly candidates: readonly WithLocalization<AccessedFunction>[];
-    readonly suitableFunctions: readonly WithLocalization<AccessedFunction>[];
-    get singleSuitableFunction(): WithLocalization<AccessedFunction> | undefined;
-    constructor(candidates: readonly WithLocalization<AccessedFunction>[], suitableFunctions: readonly WithLocalization<AccessedFunction>[]);
+    readonly candidates: readonly AccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 export declare class ExpressionDenotesOperatorCheckResult {
-    readonly candidates: readonly WithLocalization<types.Operator>[];
-    readonly suitableOperators: readonly WithLocalization<types.Operator>[];
-    get singleSuitableOperator(): WithLocalization<types.Operator> | undefined;
-    constructor(candidates: readonly WithLocalization<types.Operator>[], suitableOperators: readonly WithLocalization<types.Operator>[]);
-}
-type AvailablePackage = AvailablePackage.Original | AvailablePackage.Translated;
-declare namespace AvailablePackage {
-    export class Original implements IAvailablePackage {
-        readonly value: e.PackageEntity;
-        readonly kind = "original";
-        constructor(value: e.PackageEntity);
-        getImportName(): PackageName;
-        getLocale(): PackageLocale;
-        getEntity(): e.PackageEntity;
-        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
-    }
-    export class Translated implements IAvailablePackage {
-        readonly value: AnalyzedTranslationPackage;
-        readonly kind = "translated";
-        constructor(value: AnalyzedTranslationPackage);
-        getImportName(): PackageName;
-        getLocale(): PackageLocale;
-        getEntity(): e.PackageEntity;
-        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
-    }
-    interface IAvailablePackage {
-        getImportName(): PackageName;
-        getLocale(): PackageLocale;
-        getEntity(): e.PackageEntity;
-        getTranslationPackage(): AnalyzedTranslationPackage | undefined;
-    }
-    export {};
+    readonly candidates: readonly types.Operator[];
+    readonly suitableOperators: readonly types.Operator[];
+    get singleSuitableOperator(): types.Operator | undefined;
+    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
 export declare class DeclaredTypeMemberEntities {
     readonly variables: readonly e.FieldEntity[];
@@ -779,7 +770,7 @@ export declare class DeclaredTypeMemberEntities {
     readonly destructors: readonly e.DestructorEntity[];
     readonly indexers: readonly e.SourceIndexerEntity[];
     readonly dereferenceOperators: readonly e.DereferenceOperatorEntity[];
-    get namedMembers(): NamedTypeMemberEntity[];
+    get namedMembers(): e.NamedTypeMemberEntity[];
     constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], operators: readonly e.OperatorEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.SourceIndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
 }
 export {};

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

@@ -1,29 +1,27 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { ParameterVariableEntity } from '../entities/index.js';
-import { Argument, AutotypeCallExpression, CallExpression, IndexedAccessExpression, Tag } from '../tree/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { LocalizedName } from './Localization.js';
 import { Analyzer } from './index.js';
 export declare class ArgumentToParameterMatchResult {
     private readonly _analyzer;
     private readonly _matchResults;
     constructor(_analyzer: Analyzer);
-    ofCallExpression(node: CallExpression): MatchResult | undefined;
-    ofAutotypeCallExpression(node: AutotypeCallExpression): MatchResult | undefined;
-    ofTag(node: Tag): MatchResult | undefined;
-    ofIndexedAccessExpression(node: IndexedAccessExpression): MatchResult | undefined;
+    ofCallExpression(node: tree.CallExpression): MatchResult | undefined;
+    ofAutotypeCallExpression(node: tree.AutotypeCallExpression): MatchResult | undefined;
+    ofTag(node: tree.Tag): MatchResult | undefined;
+    ofIndexedAccessExpression(node: tree.IndexedAccessExpression): MatchResult | undefined;
     private convertMatchResult;
     private convertParameter;
 }
 export declare class MatchResult {
-    readonly parameterByArgument: ReadonlyMap<Argument, MatchResultValueParameter>;
+    readonly parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>;
     readonly unmatchedParameters: readonly MatchResultValueParameter[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(parameterByArgument: ReadonlyMap<Argument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
+    constructor(parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
 }
 export declare class MatchResultValueParameter {
     readonly entity: ParameterVariableEntity;
     readonly type: types.Type;
-    readonly name: LocalizedName;
-    constructor(entity: ParameterVariableEntity, type: types.Type, name: LocalizedName);
+    constructor(entity: ParameterVariableEntity, type: types.Type);
 }