@artel/artc 0.6.25217 → 0.6.25219

package/build/{chunk-CMPXXHBQ.js → chunk-QLTGS2V2.js}

@@ -1,6 +1,6 @@
 import {
   Compiler
-} from "./chunk-HN3XZZQX.js";
+} from "./chunk-AIY75NR5.js";
 import {
   ArtelVersion,
   Cached,
@@ -14,7 +14,7 @@ import {
   __async,
   performanceMeasurementStageNames,
   performanceMeasurementStages
-} from "./chunk-TXAEJ2GI.js";
+} from "./chunk-IYSH7MAQ.js";
 
 // source/executor/FileSystemUri.ts
 import { platform } from "os";
@@ -216,7 +216,7 @@ var NodeCompiler = class {
       const standardLibraryUri = yield this.findStandardTypeScriptLibrary(nodeModulesSearchPaths, defaultTsLibraryPath);
       if (standardLibraryUri === void 0) {
         const diagnostic = new Diagnostic(DiagnosticData.withCode(
-          113 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
+          117 /* CanNotFindTsLibDirectoryBaseSearchPaths0 */,
           [nodeModulesSearchPaths.map((p) => `'${p}'`).join(", ")]
         ), void 0);
         diagnostics?.addDiagnostic(diagnostic);
@@ -231,7 +231,8 @@ var NodeCompiler = class {
       const loadCompilationOptions = {
         workspaceUri: options?.workspacePath !== void 0 ? FileSystemUri.pathToUri(options.workspacePath) : void 0,
         builtInsStandardPackagesUri: options?.builtInsStandardPackagesPath !== void 0 ? FileSystemUri.pathToUri(options.builtInsStandardPackagesPath) : void 0,
-        userStandardPackagesUri: options?.userStandardPackagesPath !== void 0 ? FileSystemUri.pathToUri(options.userStandardPackagesPath) : void 0
+        userStandardPackagesUri: options?.userStandardPackagesPath !== void 0 ? FileSystemUri.pathToUri(options.userStandardPackagesPath) : void 0,
+        enableLogging: options?.enableLogging
       };
       return yield Compiler.loadCompilation(
         projectUri,
@@ -391,7 +392,8 @@ var CommandLineCompiler = class {
           loadCompilationOptions: {
             workspacePath: parsedArguments.workspacePath,
             userStandardPackagesPath: parsedArguments.standardPackagesPath,
-            builtInsStandardPackagesPath: parsedArguments.builtInStandardPackagesPath
+            builtInsStandardPackagesPath: parsedArguments.builtInStandardPackagesPath,
+            enableLogging: parsedArguments.enableLogging
           },
           outputPath: parsedArguments.outputPath,
           diagnostics,
@@ -466,6 +468,7 @@ var ArgumentsParser = class {
       projectPath: void 0,
       outputPath: void 0,
       noWarnings: false,
+      enableLogging: false,
       measurePerformance: false,
       defaultTsLibraryPath: void 0,
       workspacePath: void 0,
@@ -582,6 +585,11 @@ var ArgumentsParser = class {
           result.noWarnings = true;
           break;
         }
+        case "--\u0432\u043A\u043B\u044E\u0447\u0438\u0442\u044C-\u0436\u0443\u0440\u043D\u0430\u043B\u0438\u0437\u0430\u0446\u0438\u044E":
+        case "--enable-logging": {
+          result.enableLogging = true;
+          break;
+        }
         case "--\u0437\u0430\u043C\u0435\u0440\u0438\u0442\u044C-\u043F\u0440\u043E\u0438\u0437\u0432\u043E\u0434\u0438\u0442\u0435\u043B\u044C\u043D\u043E\u0441\u0442\u044C":
         case "--measure-performance": {
           result.measurePerformance = true;

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

@@ -1,11 +1,9 @@
 import { Name, PackageLocale } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { PackageEntity } from '../entities/PackageEntity.js';
-import { NamedMember, NamedPackageMemberEntity } from '../entities/PackageMembers.js';
 import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
 import { PackageVariableEntity, ParameterVariableEntity, TypeVariableEntity } from '../entities/VariableEntity.js';
-import { VariantEntity } from '../entities/VariantEntity.js';
-import { AliasTypeEntity, ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity, OperatorEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageTypeEntity, PackageVariantTypeEntity, StructuredTypeEntity, TypeMethodEntity, TypeParameterEntity, VariantTypeEntity } from '../entities/index.js';
+import { AliasTypeEntity, ConstructorEntity, DestructorEntity, IndexerEntity, MethodEntity, MethodTypeEntity, NamedPackageMemberEntity, OperatorEntity, PackageMethodEntity, PackageMethodTypeEntity, PackageTypeEntity, StructuredTypeEntity, TypeMethodEntity, 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';
@@ -17,7 +15,6 @@ export declare class AnalyzedTranslationPackage {
     private readonly _translatedPackage;
     private readonly _members;
     private readonly _translatedTypeEntityMembers;
-    private readonly _translatedVariants;
     private readonly _methodSignatureTranslations;
     private readonly _operatorSignatureTranslations;
     private readonly _methodTypeSignatureTranslations;
@@ -31,7 +28,6 @@ export declare class AnalyzedTranslationPackage {
     getTranslationLocale(): PackageLocale;
     getMembers(): TranslatedPackageMembers;
     getTypeEntityMembers(typeEntity: PackageTypeEntity): TranslatedTypeEntityMembers | undefined;
-    getVariants(typeEntity: PackageVariantTypeEntity): TranslatedVariants | undefined;
     getPackageVariableTranslationTarget(node: tree.PackageVariableTranslation): GetSingleTranslationTargetResult<PackageVariableEntity>;
     getPackageMethodTranslationTargets(node: tree.PackageMethodTranslation): GetMultipleTranslationTargetsResult<PackageMethodEntity>;
     getMethodTypeTranslationTarget(node: tree.MethodTypeTranslation): GetSingleTranslationTargetResult<PackageMethodTypeEntity>;
@@ -39,7 +35,7 @@ export declare class AnalyzedTranslationPackage {
     /**
      * В случае, когда имя переменной экземпляра совпадает с именем статической переменной, перевод будет иметь две цели.
      */
-    getTypeVariableOrVariantTranslationTargets(node: tree.TypeVariableOrVariantTranslation): GetMultipleTranslationTargetsResult<TypeVariableEntity | VariantEntity>;
+    getTypeVariableOrVariantTranslationTargets(node: tree.TypeVariableOrVariantTranslation): GetMultipleTranslationTargetsResult<TypeVariableEntity>;
     getTypeMethodTranslationTargets(node: tree.TypeMethodTranslation): GetMultipleTranslationTargetsResult<TypeMethodEntity>;
     getConstructorTranslationTargets(node: tree.ConstructorTranslation): GetMultipleTranslationTargetsResult<ConstructorEntity>;
     getIndexerTranslationTargets(node: tree.IndexerTranslation): GetMultipleTranslationTargetsResult<IndexerEntity>;
@@ -55,7 +51,6 @@ export declare class AnalyzedTranslationPackage {
     getEntityName(entity: NamedEntity): Name | undefined;
     private createPackageMembers;
     private createTypeEntityMembers;
-    private createVariants;
     private createTranslatedSubprogramSignatureFromPackageMethodTranslation;
     private createTranslatedSubprogramSignatureFromTypeMethodTranslation;
     private createTranslatedSubprogramSignatureFromMethodTypeTranslation;
@@ -78,9 +73,9 @@ export declare class TranslatedPackageMembers {
     getMemberName(entity: NamedPackageMemberEntity): Name | undefined;
 }
 export declare class TranslatedNamedPackageMember {
-    readonly value: NamedMember;
+    readonly value: NamedPackageMemberEntity;
     readonly name: LocalizedName.Translated;
-    constructor(value: NamedMember, name: LocalizedName.Translated);
+    constructor(value: NamedPackageMemberEntity, name: LocalizedName.Translated);
 }
 export declare class TranslatedTypeEntityMembers {
     private readonly _namedMembers;
@@ -99,23 +94,6 @@ export declare class TranslatedNamedTypeEntityMember {
     readonly name: LocalizedName.Translated;
     constructor(value: NamedTypeMemberEntity, name: LocalizedName.Translated);
 }
-export declare class TranslatedVariants {
-    private readonly _variants;
-    readonly translationPackage: AnalyzedTranslationPackage;
-    private readonly _variantsByNameKey;
-    private readonly _nameByEntity;
-    private get variantsByNameKey();
-    private get nameByEntity();
-    constructor(_variants: readonly TranslatedVariant[], translationPackage: AnalyzedTranslationPackage);
-    get(): readonly TranslatedVariant[];
-    getByName(name: Name): readonly TranslatedVariant[];
-    getName(entity: VariantEntity): Name | undefined;
-}
-export declare class TranslatedVariant {
-    readonly value: VariantEntity;
-    readonly name: LocalizedName.Translated;
-    constructor(value: VariantEntity, name: LocalizedName.Translated);
-}
 export type LocalizedSubprogramSignature = LocalizedSubprogramSignature.Original | LocalizedSubprogramSignature.Translated;
 export declare namespace LocalizedSubprogramSignature {
     export class Original implements ILocalizedSubprogramSignature {

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

@@ -4,7 +4,7 @@ import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnosti
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
-import * as packageMembers from '../entities/PackageMembers.js';
+import { OriginalPackageMembers } from '../entities/PackageMembers.js';
 import { NamedTypeMemberEntity } from '../entities/TypeEntityMembers.js';
 import * as e from '../entities/index.js';
 import { ReservedIdentifierKind } from '../parser/ReservedIdentifierDictionary.js';
@@ -16,9 +16,9 @@ import * as types from '../types/index.js';
 import { TypeFactory } from '../types/index.js';
 import { AccessedMethod } from './AccessedMethod.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
+import { ArgumentToParameterMatchResult, MatchResultValueParameter } from './ArgumentToParameterMatchResult.js';
 import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
-import { CallArgumentToParameterMatchResult, MatchResultValueParameter } from './CallArgumentToParameterMatchResult.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
 import { DeclarationsUsageCountResult } from './DeclarationsUsageCounter.js';
@@ -29,6 +29,7 @@ import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageN
 import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
 import { WithLocalization } from './Localization.js';
 import { LocalizationContext } from './LocalizationContext.js';
+import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
 import { GetterDeclaration, MethodTypeDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, TypeDereferencedVariableAccessorDeclaration, TypeIndexedAccessorDeclaration, TypeVariableAccessorDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
@@ -36,7 +37,7 @@ import * as operationOverloadResolver from './OperationOverloadResolver.js';
 import * as propertyAccessExpressionResolution from './PropertyAccessExpressionMeaning.js';
 import * as scope from './Scope.js';
 import { SemanticContextBuilder } from './SemanticContextBuilder.js';
-import * as sourceFileMembers from './SourceFileMembers.js';
+import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
 import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
 import { TargetTypeHint } from './TargetTypeHint.js';
@@ -57,12 +58,10 @@ export declare class Analyzer {
     readonly returnType: ReturnType;
     readonly entity: Entity;
     readonly resultLocalVariableEntity: ResultLocalVariableEntity;
-    readonly paramLocalVariableEntity: ParamLocalVariableEntity;
     readonly valueLocalVariableEntity: ValueLocalVariableEntity;
-    readonly destructuredParameterLocalVariableEntities: DestructuredParameterLocalVariableEntities;
     readonly scope: Scope;
     readonly semanticContext: SemanticContextBuilder;
-    readonly callArgumentToParameterMatchResult: CallArgumentToParameterMatchResult;
+    readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
     readonly defaultConstructors: DefaultConstructors;
     readonly overriddenMember: OverriddenMember;
     readonly tags: Tags;
@@ -80,7 +79,7 @@ export declare class Analyzer {
     private readonly _dereferenceExpressionMeanings;
     private readonly _autotypeCallExpressionMeanings;
     private readonly _identifierExpressionResolutionResults;
-    private readonly _tagMeanings;
+    private readonly _tagResolutionResults;
     private readonly _objectExpressionMeanings;
     private readonly _baseExpressionMeanings;
     private readonly _namedTypeSpecifierResolutionResults;
@@ -111,23 +110,22 @@ export declare class Analyzer {
     getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): e.TypeMemberEntityContainer;
     getTargetTypeOfExpression(node: tree.Expression, hint?: TargetTypeHint): types.Type | undefined;
     getUnambiguousTargetMethodType(targetType: types.Type | undefined): types.MethodType | undefined;
-    getUnambiguousTargetVariantType(targetType: types.Type | undefined): types.VariantType | undefined;
     getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
     getEnumeratorElementType(node: tree.Node): types.Type | undefined;
-    resolveMethodOverloadByCallExpression<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: Iterable<TCandidate>, node: tree.CallExpression): Iterable<TCandidate>;
-    resolveMethodOverloadByTargetType<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: Iterable<TCandidate>, targetType: types.MethodType): Iterable<TCandidate>;
-    resolveConstructorOverload<TCandidate extends constructorOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends constructorOverloadResolver.IValueParameter>(candidates: Iterable<TCandidate>, callArguments: Iterable<tree.CallArgument>): Iterable<TCandidate>;
-    resolveTypeOverloadByArgumentCount<TCandidate extends typeOverloadResolver.ICandidate>(candidates: Iterable<TCandidate>, argumentCount: number): Iterable<TCandidate>;
+    resolveMethodOverloadByCallExpression<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], node: tree.CallExpression): readonly TCandidate[];
+    resolveMethodOverloadByTargetType<TCandidate extends operationOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends operationOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], targetType: types.MethodType): readonly TCandidate[];
+    resolveConstructorOverload<TCandidate extends constructorOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends constructorOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], args: readonly tree.Argument[]): readonly TCandidate[];
+    resolveTypeOverloadByArgumentCount<TCandidate extends typeOverloadResolver.ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
     resolvePropertyAccessExpression(node: tree.PropertyAccessExpression, targetTypeHint?: TargetTypeHint): propertyAccessExpressionResolution.ResolutionResult;
     enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
-    getSourceFileMembers(node: tree.SourceFile): sourceFileMembers.SourceFileMembers;
+    getSourceFileMembers(node: tree.SourceFile): ActualSourceFileMembers;
     getCallExpressionMeaning(node: tree.CallExpression): callExpressionMeaning.Meaning;
-    getRespectiveParameter(node: tree.CallArgument): MatchResultValueParameter | undefined;
+    getRespectiveParameter(node: tree.Argument): MatchResultValueParameter | undefined;
     resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.ResolutionResult;
     getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
     getAutotypeCallExpressionMeaning(node: tree.AutotypeCallExpression, targetTypeHint?: TargetTypeHint): autotypeCallExpressionMeaning.Meaning;
     resolveIdentifierExpression(node: tree.IdentifierExpression, targetTypeHint?: TargetTypeHint): identifierExpressionResolution.ResolutionResult;
-    getTagMeaning(node: tree.Tag): tagMeaning.Meaning;
+    resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
     getObjectExpressionMeaning(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
     getBaseExpressionMeaning(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
     checkExpressionOptionalChaining(node: tree.Expression): boolean;
@@ -213,11 +211,11 @@ export declare class Analyzer {
     getCommonObjectAndAspectTypesOfUnion(_unionType: types.UnionType): readonly types.StructuredType[];
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
-    createPackageMembers(pkg: SourcePackage): packageMembers.OriginalPackageMembers;
+    createPackageMembers(pkg: SourcePackage): OriginalPackageMembers;
     instantiateType(entity: e.TypeEntity, typeArguments?: readonly types.Type[]): types.Type;
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;
-    createPackageMemberHiding(node: tree.PackageMemberDeclaration): e.EntityHidingLevel | undefined;
-    createTypeMemberHiding(node: tree.TypeMemberDeclaration): e.EntityHidingLevel | undefined;
+    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>;
     isExpressionImplicitlyReturnedFromSubprogram(node: tree.ExpressionStatement): boolean;
     createBackingPackageVariables(declaredMembers: readonly (e.NamedPackageMemberEntity | e.PackageAliasEntity)[], pkg: e.PackageEntity): e.PackageVariableEntity[];
@@ -339,7 +337,6 @@ declare class Entity {
     private readonly _destructorEntities;
     private readonly _getterEntities;
     private readonly _setterEntities;
-    private readonly _variantEntities;
     private readonly _typeExtensionEntities;
     private readonly _packageAliasEntities;
     constructor(_analyzer: Analyzer);
@@ -352,7 +349,6 @@ declare class Entity {
     ofEnumerationVariableDeclaration(node: tree.EnumerationVariableDeclaration): e.LocalVariableEntity;
     ofErrorVariableDeclaration(node: tree.ErrorVariableDeclaration): e.LocalVariableEntity;
     ofParameterDeclaration(node: tree.ParameterDeclaration): e.ParameterVariableEntity;
-    ofSetterParameterDeclaration(node: tree.SetterParameterDeclaration): e.ParameterVariableEntity;
     ofTypeParameterDeclaration(node: tree.TypeParameterDeclaration): e.TypeParameterEntity;
     ofTypeIndexerDeclaration(node: TypeIndexedAccessorDeclaration): e.SourceIndexerEntity;
     ofTypeDereferenceOperatorDeclaration(node: TypeDereferencedVariableAccessorDeclaration): e.DereferenceOperatorEntity;
@@ -382,7 +378,7 @@ declare class Entity {
     ofSetterDeclaration(node: SetterDeclaration): e.SetterEntity;
     ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): e.ConstructorEntity;
     ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): e.DestructorEntity;
-    ofVariantDeclaration(node: tree.VariantDeclaration): e.VariantEntity;
+    ofVariantDeclaration(node: tree.VariantDeclaration): e.TypeVariableEntity;
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
     private getContainingPackageLoadedFromDts;
@@ -407,47 +403,14 @@ declare class ResultLocalVariableEntity {
     ofTypeDereferencedVariableGetterDeclaration(node: tree.TypeDereferencedVariableGetterDeclaration): e.LocalVariableEntity;
     private createResultLocalVariableEntity;
 }
-declare class ParamLocalVariableEntity {
+declare class ValueLocalVariableEntity {
     private readonly _analyzer;
-    private readonly _optionalEntities;
     private readonly _entities;
     constructor(_analyzer: Analyzer);
-    ofTypeIndexedGetterDeclaration(node: tree.TypeIndexedGetterDeclaration): e.VariableEntity;
     ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.VariableEntity;
     ofTypeVariableSetterDeclaration(node: tree.TypeVariableSetterDeclaration): e.VariableEntity;
     ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration): e.VariableEntity;
     ofTypeDereferencedVariableSetterDeclaration(node: tree.TypeDereferencedVariableSetterDeclaration): e.VariableEntity;
-    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): e.VariableEntity | undefined;
-    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): e.VariableEntity | undefined;
-    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): e.VariableEntity | undefined;
-    ofMethodLiteral(node: tree.MethodLiteral): e.VariableEntity | undefined;
-    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): e.VariableEntity | undefined;
-    ofOperatorDeclaration(node: tree.OperatorDeclaration): e.VariableEntity | undefined;
-    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): e.VariableEntity | undefined;
-    private createParamLocalVariableEntity;
-    private createAccessorParamLocalVariableEntity;
-}
-declare class ValueLocalVariableEntity {
-    private readonly _analyzer;
-    private readonly _entities;
-    constructor(_analyzer: Analyzer);
-    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.VariableEntity | undefined;
-    ofTypeVariableSetterDeclaration(node: tree.TypeVariableSetterDeclaration): e.VariableEntity | undefined;
-    ofTypeIndexedSetterDeclaration(node: tree.TypeIndexedSetterDeclaration): e.VariableEntity | undefined;
-    ofTypeDereferencedVariableSetterDeclaration(node: tree.TypeDereferencedVariableSetterDeclaration): e.VariableEntity | undefined;
-}
-declare class DestructuredParameterLocalVariableEntities {
-    private readonly _analyzer;
-    private readonly _entities;
-    constructor(_analyzer: Analyzer);
-    ofMethodBlockLiteral(node: tree.MethodBlockLiteral): readonly e.VariableEntity[];
-    ofPackageMethodDeclaration(node: tree.PackageMethodDeclaration): readonly e.VariableEntity[];
-    ofTypeMethodDeclaration(node: tree.TypeMethodDeclaration): readonly e.VariableEntity[];
-    ofOperatorDeclaration(node: tree.OperatorDeclaration): readonly e.VariableEntity[];
-    ofMethodLiteral(node: tree.MethodLiteral): readonly e.VariableEntity[];
-    ofNestedMethodDeclaration(node: tree.NestedMethodDeclaration): readonly e.VariableEntity[];
-    ofTypeConstructorDeclaration(node: tree.TypeConstructorDeclaration): readonly e.VariableEntity[];
-    private createVariableEntitiesBasedOnValueParameters;
 }
 declare class Scope {
     private readonly _analyzer;
@@ -462,7 +425,7 @@ declare class Scope {
     private readonly _methodLiteralScopes;
     private readonly _statementBlockScopes;
     private readonly _forEachStatementScopes;
-    private readonly _onErrorClauseScopes;
+    private readonly _catchClauseScopes;
     private readonly _packageStructuredTypeDeclarationTypeParametersScopes;
     private readonly _structuredTypeDeclarationBodyScopes;
     private readonly _packageMethodTypeDeclarationTypeParametersScopes;
@@ -476,7 +439,6 @@ declare class Scope {
     private readonly _structuredTypeDestructorDeclarationScopes;
     private readonly _typeIndexedAccessorDeclarationParametersScopes;
     private readonly _typeExtensionDeclarationScopes;
-    private readonly _setterParameterClauseScopes;
     constructor(_analyzer: Analyzer);
     ofSourceFile(node: tree.SourceFile): scope.IScope;
     ofMethodBlockLiteral(node: tree.MethodBlockLiteral): scope.IScope;
@@ -489,7 +451,7 @@ declare class Scope {
     ofMethodLiteral(node: tree.MethodLiteral): scope.IScope;
     ofStatementBlock(node: tree.StatementBlock): scope.IScope;
     ofForStatement(node: tree.ForStatement): scope.IScope;
-    ofOnErrorClause(node: tree.OnErrorClause): scope.IScope;
+    ofCatchClause(node: tree.CatchClause): scope.IScope;
     ofPackageStructuredTypeDeclarationTypeParameters(node: tree.PackageStructuredTypeDeclaration): scope.IScope;
     ofStructuredTypeDeclarationBody(node: tree.StructuredTypeDeclarationBody): scope.IScope;
     ofPackageMethodTypeDeclarationTypeParameters(node: tree.PackageMethodTypeDeclaration): scope.IScope;
@@ -503,7 +465,6 @@ declare class Scope {
     ofTypeDestructorDeclaration(node: tree.TypeDestructorDeclaration): scope.IScope;
     ofTypeIndexedAccessorDeclarationParameters(node: TypeIndexedAccessorDeclaration): scope.IScope;
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): scope.IScope;
-    ofSetterParameterClause(node: tree.SetterParameterClause): scope.IScope;
 }
 declare class DefaultConstructors {
     private readonly _analyzer;
@@ -516,11 +477,11 @@ declare class DefaultConstructors {
 declare class OverriddenMember {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
-    getOverriddenVariable(node: tree.TypeVariableDeclaration | TypeVariableAccessorDeclaration): types.Variable | undefined;
-    getOverriddenMethod(node: tree.TypeMethodDeclaration): types.Method | undefined;
-    getOverriddenOperator(node: tree.OperatorDeclaration): types.Operator | undefined;
-    getOverriddenIndexer(node: TypeIndexedAccessorDeclaration): types.Indexer | undefined;
-    getOverriddenDereferenceOperator(node: TypeDereferencedVariableAccessorDeclaration): types.DereferenceOperator | undefined;
+    getOverriddenVariables(node: tree.TypeVariableDeclaration | TypeVariableAccessorDeclaration): types.Variable[];
+    getOverriddenMethods(node: tree.TypeMethodDeclaration): types.Method[];
+    getOverriddenOperators(node: tree.OperatorDeclaration): types.Operator[];
+    getOverriddenIndexers(node: TypeIndexedAccessorDeclaration): types.Indexer[];
+    getOverriddenDereferenceOperators(node: TypeDereferencedVariableAccessorDeclaration): types.DereferenceOperator[];
     private findOverriddenVariableInType;
     private findOverriddenMethodInType;
     private findOverriddenOperatorInType;
@@ -535,6 +496,7 @@ declare class OverriddenMember {
     private enumerateTypesForOverriddenMemberLookup;
     private entityCanOverride;
     private entityCanBeOverridden;
+    private addTypeMemberIfUnique;
 }
 declare class Tags {
     readonly _analyzer: Analyzer;
@@ -542,7 +504,7 @@ declare class Tags {
     constructor(_analyzer: Analyzer);
     ofTagList(tagList: tree.TagList): readonly tags.Tag[];
     private createTags;
-    private callArgumentToTagArgument;
+    private argumentToTagArgument;
 }
 declare class LinkedEntity {
     private readonly _analyzer;
@@ -559,7 +521,6 @@ declare class LinkedEntity {
     ofConstructor(entity: e.ConstructorEntity, platform: PlatformKind): e.ConstructorEntity | undefined;
     ofIndexer(entity: e.IndexerEntity, platform: PlatformKind): e.IndexerEntity | undefined;
     ofDereferenceOperator(entity: e.DereferenceOperatorEntity, platform: PlatformKind): e.DereferenceOperatorEntity | undefined;
-    ofVariant(entity: e.VariantEntity, platform: PlatformKind): e.VariantEntity | undefined;
     ofGetter(entity: e.GetterEntity, platform: PlatformKind): e.GetterEntity | undefined;
     ofSetter(entity: e.SetterEntity, platform: PlatformKind): e.SetterEntity | undefined;
 }
@@ -592,9 +553,7 @@ export declare class LinkedTypeWithMembers {
     readonly targetType: e.TypeEntityWithMembers;
     readonly linkedPackage: LinkedMultiPlatformPackage;
     private readonly _memberLookup;
-    private readonly _variantLookup;
     private get memberLookup();
-    private get variantLookup();
     constructor(analyzer: Analyzer, externalType: e.TypeEntityWithMembers, targetType: e.TypeEntityWithMembers, linkedPackage: LinkedMultiPlatformPackage);
     getLinkedVariable(entity: e.TypeVariableEntity): e.TypeVariableEntity | undefined;
     getLinkedMethod(entity: e.TypeMethodEntity): e.TypeMethodEntity | undefined;
@@ -602,7 +561,6 @@ export declare class LinkedTypeWithMembers {
     getLinkedConstructor(entity: e.ConstructorEntity): e.ConstructorEntity | undefined;
     getLinkedIndexer(entity: e.IndexerEntity): e.IndexerEntity | undefined;
     getLinkedDereferenceOperator(entity: e.DereferenceOperatorEntity): e.DereferenceOperatorEntity | undefined;
-    getLinkedVariant(entity: e.VariantEntity): e.VariantEntity | undefined;
 }
 declare class OwningPlainObjectModificationCheck {
     private _analyzer;

package/build/types/analysis/{CallArgumentToParameterMatchResult.d.ts → ArgumentToParameterMatchResult.d.ts}

@@ -1,10 +1,10 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { VariableEntity } from '../entities/index.js';
-import { AutotypeCallExpression, CallArgument, CallExpression, IndexedAccessExpression, Tag } from '../tree/index.js';
+import { ParameterVariableEntity } from '../entities/index.js';
+import { Argument, AutotypeCallExpression, CallExpression, IndexedAccessExpression, Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
 import { LocalizedName } from './Localization.js';
 import { Analyzer } from './index.js';
-export declare class CallArgumentToParameterMatchResult {
+export declare class ArgumentToParameterMatchResult {
     private readonly _analyzer;
     private readonly _matchResults;
     constructor(_analyzer: Analyzer);
@@ -16,14 +16,14 @@ export declare class CallArgumentToParameterMatchResult {
     private convertParameter;
 }
 export declare class MatchResult {
-    readonly parameterByCallArgument: ReadonlyMap<CallArgument, MatchResultValueParameter>;
+    readonly parameterByArgument: ReadonlyMap<Argument, MatchResultValueParameter>;
     readonly unmatchedParameters: readonly MatchResultValueParameter[];
     readonly diagnostics: readonly Diagnostic[];
-    constructor(parameterByCallArgument: ReadonlyMap<CallArgument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
+    constructor(parameterByArgument: ReadonlyMap<Argument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
 }
 export declare class MatchResultValueParameter {
-    readonly entity: VariableEntity;
+    readonly entity: ParameterVariableEntity;
     readonly type: types.Type;
     readonly name: LocalizedName;
-    constructor(entity: VariableEntity, type: types.Type, name: LocalizedName);
+    constructor(entity: ParameterVariableEntity, type: types.Type, name: LocalizedName);
 }

package/build/types/analysis/{CallArgumentsToParametersMatcher.d.ts → ArgumentsToParametersMatcher.d.ts}

@@ -3,23 +3,23 @@ import { Diagnostic, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
-export declare class CallArgumentToParameterMatcher<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TCallArgument extends ICallArgument> {
+export declare class ArgumentToParameterMatcher<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends IArgument> {
     private readonly _analyzer;
     private readonly _signature;
-    private readonly _callArguments;
-    constructor(_analyzer: Analyzer, _signature: TSignature, _callArguments: readonly TCallArgument[]);
-    match(): MatchResult<TParameter, TCallArgument>;
-    private matchCallArgumentsToParameters;
-    private addCallArgumentDiagnostic;
-    private getCallArgumentType;
+    private readonly _arguments;
+    constructor(_analyzer: Analyzer, _signature: TSignature, _arguments: readonly TArgument[]);
+    match(): MatchResult<TParameter, TArgument>;
+    private matchArgumentsToParameters;
+    private addArgumentDiagnostic;
+    private getArgumentType;
 }
-export declare class MatchResult<TParameter extends ISignatureParameter, TCallArgument extends ICallArgument> {
-    readonly mapping: ReadonlyMap<TCallArgument, TParameter>;
+export declare class MatchResult<TParameter extends ISignatureParameter, TArgument extends IArgument> {
+    readonly mapping: ReadonlyMap<TArgument, TParameter>;
     readonly unmatchedRequiredParameters: readonly TParameter[];
     readonly argumentArrangementDiagnostics: readonly Diagnostic[];
     readonly hasTypeAssignabilityErrors: boolean;
     get isMatching(): boolean;
-    constructor(mapping: ReadonlyMap<TCallArgument, TParameter>, unmatchedRequiredParameters: readonly TParameter[], argumentArrangementDiagnostics: readonly Diagnostic[], hasTypeAssignabilityErrors: boolean);
+    constructor(mapping: ReadonlyMap<TArgument, TParameter>, unmatchedRequiredParameters: readonly TParameter[], argumentArrangementDiagnostics: readonly Diagnostic[], hasTypeAssignabilityErrors: boolean);
 }
 export interface ISignature<TParameter extends ISignatureParameter> {
     getParameters(): readonly TParameter[];
@@ -29,15 +29,15 @@ export interface ISignatureParameter {
     getType(): types.Type;
     isOptional(): boolean;
 }
-export interface ICallArgument {
+export interface IArgument {
     getExpression(): tree.Expression;
     getName(): Name | undefined;
     getDiagnosticLocation(): DiagnosticLocation | undefined;
 }
-export declare class CallArgument implements ICallArgument {
+export declare class SourceArgument implements IArgument {
     private readonly _analyzer;
-    readonly node: tree.CallArgument;
-    constructor(_analyzer: Analyzer, node: tree.CallArgument);
+    readonly node: tree.Argument;
+    constructor(_analyzer: Analyzer, node: tree.Argument);
     getExpression(): tree.Expression;
     getName(): Name | undefined;
     getDiagnosticLocation(): DiagnosticLocation;

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

@@ -7,7 +7,7 @@ import { LocalizedName } from './Localization.js';
 export declare class Resolver<TCandidate extends ICandidate<TValueParameter>, TValueParameter extends IValueParameter> {
     private readonly _analyzer;
     constructor(_analyzer: Analyzer);
-    resolve(candidates: Iterable<TCandidate>, callArguments: Iterable<tree.CallArgument>): Iterable<TCandidate>;
+    resolve(candidates: readonly TCandidate[], args: readonly tree.Argument[]): readonly TCandidate[];
 }
 export interface ICandidate<TValueParameter extends IValueParameter> {
     getValueParameters(): readonly TValueParameter[];

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

@@ -1,7 +1,7 @@
+import { AccessKind } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { DereferenceExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import * as dereferencedVariableAccess from './DereferencedVariableAccess.js';
 import { FoundAnonymousDeclaration } from './FoundDeclaration.js';
 import { Analyzer } from './index.js';
 export declare class Resolver {
@@ -16,9 +16,9 @@ export declare class Resolver {
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
     readonly operator: FoundAnonymousDeclaration<types.DereferenceOperator>;
-    readonly access: dereferencedVariableAccess.DereferencedVariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "resolved";
-    constructor(operator: FoundAnonymousDeclaration<types.DereferenceOperator>, access: dereferencedVariableAccess.DereferencedVariableAccess);
+    constructor(operator: FoundAnonymousDeclaration<types.DereferenceOperator>, accessKind: AccessKind);
 }
 declare class Meaning_unresolved {
     readonly diagnostic: Diagnostic | undefined;

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

@@ -18,6 +18,7 @@ export declare class DiagnosticCollector {
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile, cancellationToken: CancellationToken | undefined);
     collect(): Promise<Diagnostic[]>;
     private collectNodeDiagnostics;
+    private checkCallExpression;
     private addNotTranslatedPackageMembersDiagnostics;
     private collectNotTranslatedPackageMembers;
     private addNotTranslatedTypeMembersDiagnostics;
@@ -30,6 +31,7 @@ export declare class DiagnosticCollector {
     private checkTypeConstructorDeclaration;
     private checkTypeMethodDeclaration;
     private checkOperatorDeclaration;
+    private checkTypeVariableDeclaration;
     private checkTypeVariableGetterDeclaration;
     private checkTypeVariableSetterDeclaration;
     private checkTypeIndexedGetterDeclaration;

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

@@ -1,4 +1,6 @@
 import * as tree from '../tree/index.js';
+import { ModifierFlags } from './ModifierFlags.js';
 type NodeWithModifiers = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration;
 export declare function findModifier(node: NodeWithModifiers, modifierKeywordKind: tree.ModifierKeywordKind): tree.Modifier | undefined;
+export declare function createDeclaredModifierFlags(node: NodeWithModifiers): ModifierFlags;
 export {};

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

@@ -1,13 +1,12 @@
-import { Name } from '../common/index.js';
+import { AccessKind, Name } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { NamedTypeEntity, PackageAliasEntity, VariableEntity, VariantEntity } from '../entities/index.js';
+import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { AccessedMethod } from './AccessedMethod.js';
 import { FoundAnonymousDeclaration, FoundNamedDeclaration } from './FoundDeclaration.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as scope from './Scope.js';
-import * as variableAccess from './VariableAccess.js';
 import { Analyzer, TargetTypeHint } from './index.js';
 export declare class Resolver {
     private readonly _semanticContext;
@@ -25,19 +24,22 @@ export declare class Resolver {
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
-}
-export type Meaning = Meaning_variantAccess | Meaning_variableAccess | Meaning_methodAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
-declare class Meaning_variantAccess {
-    readonly variant: FoundNamedDeclaration<VariantEntity>;
-    readonly kind = "variant-access";
-    constructor(variant: FoundNamedDeclaration<VariantEntity>);
+    /**
+     * Может ли измениться результат, если посчитать его с другим целевым типом?
+     */
+    readonly dependsOnTargetType: boolean;
+    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
+    /**
+     * Может ли измениться результат, если посчитать его с другим целевым типом?
+     */
+    dependsOnTargetType?: boolean);
 }
+export type Meaning = Meaning_variableAccess | Meaning_methodAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: FoundNamedDeclaration<AccessedVariable>;
-    readonly access: variableAccess.VariableAccess;
+    readonly accessKind: AccessKind;
     readonly kind = "variable-access";
-    constructor(variable: FoundNamedDeclaration<AccessedVariable>, access: variableAccess.VariableAccess);
+    constructor(variable: FoundNamedDeclaration<AccessedVariable>, accessKind: AccessKind);
 }
 declare class Meaning_methodAccess {
     readonly candidates: readonly FoundNamedDeclaration<AccessedMethod>[];

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

@@ -1,6 +1,6 @@
-import { PackageLocale, Name } from '../common/index.js';
-import { AliasTypeEntity, MethodEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeParameterEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
-import { AnalyzedTranslationPackage, TranslatedTypeEntityMembers, TranslatedVariants } from './AnalyzedTranslationPackage.js';
+import { Name, PackageLocale } from '../common/index.js';
+import { AliasTypeEntity, MethodEntity, PackageAliasEntity, PackageEntity, PackageMethodTypeEntity, PackageStructuredTypeEntity, PackageVariantTypeEntity, TypeEntity, TypeParameterEntity, VariableEntity } from '../entities/index.js';
+import { AnalyzedTranslationPackage, TranslatedTypeEntityMembers } from './AnalyzedTranslationPackage.js';
 export declare class LocalizationContext {
     readonly originalLocale: PackageLocale;
     private readonly _translationPackageByTranslated;
@@ -9,7 +9,6 @@ export declare class LocalizationContext {
     getTranslationPackage(packageEntity: PackageEntity): AnalyzedTranslationPackage | undefined;
     getTranslationLocale(packageEntity: PackageEntity): PackageLocale;
     getTranslatedTypeEntityMembers(typeEntity: TypeEntity): TranslatedTypeEntityMembers | undefined;
-    getTranslatedVariants(typeEntity: VariantTypeEntity): TranslatedVariants | undefined;
     getEntityName(entity: NamedEntity): Name;
 }
-export type NamedEntity = VariableEntity | VariantEntity | PackageVariantTypeEntity | MethodEntity | TypeParameterEntity | PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
+export type NamedEntity = VariableEntity | PackageVariantTypeEntity | MethodEntity | TypeParameterEntity | PackageMethodTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;