@artel/artc 0.6.26017 → 0.6.26019

package/build/types/analysis/{ConstructorCallResolver.d.ts → a/ConstructorCallResolver.d.ts}

@@ -1,10 +1,11 @@
-import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
-import { NamedTypeEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
-import { TypeMemberLookupContext } from './TypeMemberLookup.js';
-import { NodeOrDiagnosticLocation } from './Utils.js';
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
 export declare class Resolver {
     static resolve(analyzer: Analyzer, candidates: readonly types.Constructor[], argumentList: tree.ArgumentList | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): readonly types.Constructor[];
     static resolveByNamedTypes(analyzer: Analyzer, typeEntities: readonly NamedTypeEntity[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, typeMemberLookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): ResolutionResult;
@@ -18,5 +19,6 @@ export declare class ResolutionResult {
     readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
     private static empty_;
     static get empty(): ResolutionResult;
+    get suitableOrSingleConstructor(): types.Constructor | undefined;
     constructor(candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], typeEntity: NamedTypeEntity | undefined, type: types.Type | undefined, singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
 }

package/build/types/analysis/a/DeclarationsUsageCounter.d.ts

@@ -0,0 +1,12 @@
+import { TaskController } from '../../common/index.js';
+import * as tree from '../../tree/a/index.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
+import { Analyzer } from './Analyzer.js';
+export declare class DeclarationsUsageCounter {
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly usageInfoByEntity;
+    constructor(analyzer: Analyzer, sourceFile: tree.SourceFile);
+    count(taskController: TaskController): Promise<DeclarationsUsageMap>;
+    private recordUsage;
+}

package/build/types/analysis/{DereferenceExpressionMeaning.d.ts → a/DereferenceExpressionMeaning.d.ts}

@@ -1,8 +1,8 @@
-import { AccessKind } from '../common/index.js';
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { DereferenceExpression } from '../tree/index.js';
-import * as types from '../types/index.js';
-import { Analyzer } from './index.js';
+import { AccessKind } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { DereferenceExpression } from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;

package/build/types/analysis/a/ExpressionAnalysisOptions.d.ts

@@ -0,0 +1,21 @@
+import * as types from '../../types/index.js';
+export declare class ExpressionAnalysisOptions {
+    readonly targetType: types.Type | undefined;
+    /**
+     * Определяет, можно ли кэшировать результат анализа выражений, если результат зависит от целевого типа. Результат
+     * анализа, который не зависит от целевого типа, можно кэшировать всегда.
+     */
+    readonly allowCaching: boolean;
+    readonly isResolvingOverload: boolean;
+    constructor(targetType: types.Type | undefined, 
+    /**
+     * Определяет, можно ли кэшировать результат анализа выражений, если результат зависит от целевого типа. Результат
+     * анализа, который не зависит от целевого типа, можно кэшировать всегда.
+     */
+    allowCaching: boolean, isResolvingOverload: boolean);
+    static withTargetType(options: ExpressionAnalysisOptions | undefined, targetType: types.Type | undefined): ExpressionAnalysisOptions;
+    withTargetType(targetType: types.Type | undefined): ExpressionAnalysisOptions;
+    withAllowCaching(allowCaching: boolean): ExpressionAnalysisOptions;
+    withIsResolvingOverload(isResolvingOverload: boolean): ExpressionAnalysisOptions;
+    withTargetTypeAndAllowCaching(targetType: types.Type | undefined, allowCaching: boolean): ExpressionAnalysisOptions;
+}

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

@@ -0,0 +1,5 @@
+import * as tree from '../../tree/a/index.js';
+import { ModifierFlags } from './ModifierFlags.js';
+export declare function findModifier(node: tree.NodeWithModifiers, modifierKeywordKind: tree.ModifierKeywordKind): tree.Modifier | undefined;
+export declare function createDeclaredModifierFlags(node: tree.NodeWithModifiers): ModifierFlags;
+export declare function modifierToModifierFlag(modifier: tree.Modifier): ModifierFlags;

package/build/types/analysis/{FunctionAccessResolver.d.ts → a/FunctionAccessResolver.d.ts}

@@ -1,8 +1,9 @@
-import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
-import * as tree from '../tree/index.js';
-import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
-import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
-import { NodeOrDiagnosticLocation } from './Utils.js';
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/a/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
 export declare class Resolver {
     static resolveByCallExpression(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined): ResolutionResult;
     static resolveByCallExpressionParts(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): ResolutionResult;
@@ -10,7 +11,9 @@ export declare class Resolver {
     private static convertProcessedSignature;
     private static reportAmbiguousAccessDiagnostic;
 }
-export interface ResolutionResult {
-    suitableFunctions: readonly AccessedFunction[];
-    singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+export declare class ResolutionResult {
+    readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+    get suitableOrSingleFunction(): AccessedFunction | undefined;
+    constructor(suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }

package/build/types/analysis/{IdentifierExpressionMeaning.d.ts → a/IdentifierExpressionMeaning.d.ts}

@@ -1,12 +1,13 @@
-import { AccessKind, Name } from '../common/index.js';
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { NamedTypeEntity, PackageAliasEntity, ParameterEntity, VariableEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import { AccessKind, Name } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity, PackageAliasEntity, ParameterEntity, VariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
-import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { Analyzer, ExpressionAnalysisOptions } from './index.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
 import { NamedDeclaration } from './semantic-context/index.js';
 export declare class FirstStageResolver {
     private readonly semanticContext_;
@@ -42,13 +43,10 @@ declare class Meaning_variableAccess {
 }
 declare class Meaning_functionAccess {
     readonly candidates: readonly NotSubstitutedAccessedFunction[];
-    readonly suitableFunctions: readonly AccessedFunction[];
-    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
     readonly objectParameterContainingFunctions: ParameterEntity | undefined;
     readonly kind = "function-access";
-    get singleSuitableFunction(): AccessedFunction | undefined;
-    get singleFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined, objectParameterContainingFunctions: ParameterEntity | undefined);
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined, objectParameterContainingFunctions: ParameterEntity | undefined);
 }
 declare class Meaning_packageAliasAccess {
     readonly packageAlias: PackageAliasEntity;

package/build/types/analysis/{IndexedAccessExpressionMeaning.d.ts → a/IndexedAccessExpressionMeaning.d.ts}

@@ -1,8 +1,8 @@
-import { AccessKind } from '../common/index.js';
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { IndexedAccessExpression } from '../tree/index.js';
-import * as types from '../types/index.js';
-import { Analyzer } from './index.js';
+import { AccessKind } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { IndexedAccessExpression } from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;

package/build/types/analysis/{InstanceFieldsInitializationValidator.d.ts → a/InstanceFieldsInitializationValidator.d.ts}

@@ -1,7 +1,7 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/a/index.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
 import { Analyzer } from './Analyzer.js';
-import { DeclarationsUsageMap } from './DeclarationsUsageCounter.js';
-import { TypeWithMembersDeclaration } from './NodeTypeUtils.js';
 export declare class InstanceFieldsInitializationValidator {
     private readonly analyzer;
     private readonly typeDeclaration;
@@ -9,7 +9,7 @@ export declare class InstanceFieldsInitializationValidator {
     private readonly diagnostics;
     private readonly semanticContext_;
     private get semanticContext();
-    constructor(analyzer: Analyzer, typeDeclaration: TypeWithMembersDeclaration, declarationsUsageCountResult: DeclarationsUsageMap, diagnostics: DiagnosticAcceptor);
+    constructor(analyzer: Analyzer, typeDeclaration: tree.TypeWithMembersDeclaration, declarationsUsageCountResult: DeclarationsUsageMap, diagnostics: DiagnosticAcceptor);
     validate(): void;
     private getFieldsThatNeedToBeInitializedInConstructor;
     private checkDefaultConstructorInitializesAllFields;

package/build/types/analysis/{MemberAccessExpressionMeaning.d.ts → a/MemberAccessExpressionMeaning.d.ts}

@@ -1,12 +1,13 @@
-import { AccessKind } from '../common/index.js';
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import { AccessKind } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { Entity, PackageTypeEntity, PackageVariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
-import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { Analyzer, ExpressionAnalysisOptions } from './index.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
 export declare class FirstStageResolver {
     private readonly semanticContext_;
     private readonly analyzer;
@@ -49,12 +50,9 @@ declare class Meaning_packageVariableAccess {
 }
 declare class Meaning_packageFunctionAccess {
     readonly candidates: readonly NotSubstitutedAccessedFunction[];
-    readonly suitableFunctions: readonly AccessedFunction[];
-    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
     readonly kind = "package-function-access";
-    get singleSuitableFunction(): AccessedFunction | undefined;
-    get singleFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
 }
 declare class Meaning_packageTypeAccess {
     readonly candidates: readonly PackageTypeEntity[];
@@ -84,12 +82,9 @@ declare class Meaning_staticFieldAccess {
 declare class Meaning_staticMethodAccess {
     readonly type: types.Type;
     readonly candidates: readonly NotSubstitutedAccessedFunction[];
-    readonly suitableFunctions: readonly AccessedFunction[];
-    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
     readonly kind = "static-method-access";
-    get singleSuitableFunction(): AccessedFunction | undefined;
-    get singleFunction(): AccessedFunction | undefined;
-    constructor(type: types.Type, candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
+    constructor(type: types.Type, candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
 }
 declare class Meaning_instanceFieldAccess {
     readonly field: types.Field;
@@ -99,12 +94,9 @@ declare class Meaning_instanceFieldAccess {
 }
 declare class Meaning_instanceMethodAccess {
     readonly candidates: readonly NotSubstitutedAccessedFunction[];
-    readonly suitableFunctions: readonly AccessedFunction[];
-    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
     readonly kind = "instance-method-access";
-    get singleSuitableFunction(): AccessedFunction | undefined;
-    get singleFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
 }
 declare class Meaning_mixedAmbiguousAccess {
     readonly entities: readonly Entity[];

package/build/types/analysis/{ModifierValidator.d.ts → a/ModifierValidator.d.ts}

@@ -1,8 +1,8 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import * as tree from '../tree/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/a/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
 import { Analyzer } from './Analyzer.js';
 import { ModifierFlags } from './ModifierFlags.js';
-import { NodeOrDiagnosticLocation } from './Utils.js';
 declare enum PackageMemberDeclarationKind {
     TranslationsDeclaration = 0,
     AliasTypeDeclaration = 1,

package/build/types/analysis/{NamedTypeResolver.d.ts → a/NamedTypeResolver.d.ts}

@@ -1,9 +1,9 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
-import { QualifiedName } from '../tree/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity, PackageAliasEntity } from '../../entities/index.js';
+import { QualifiedName } from '../../tree/a/index.js';
+import { EntityOrPackageNameTreeNode } from '../EntityOrPackageNameTreeNode.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
 import { Analyzer } from './Analyzer.js';
-import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeResolver {
     private readonly analyzer;
     private readonly node;

package/build/types/analysis/{NamedTypeSpecifierResolver.d.ts → a/NamedTypeSpecifierResolver.d.ts}

@@ -1,9 +1,9 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { NamedTypeSpecifier } from '../tree/index.js';
-import * as types from '../types/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeSpecifier } from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { EntityOrPackageNameTreeNode } from '../EntityOrPackageNameTreeNode.js';
 import { Analyzer } from './Analyzer.js';
 import { ResolvedQualifier } from './NamedTypeResolver.js';
-import { EntityOrPackageNameTreeNode } from './Utils.js';
 export declare class NamedTypeSpecifierResolver {
     private readonly analyzer;
     private readonly node;

package/build/types/analysis/{NodeTypeUtils.d.ts → a/NodeTypeUtils.d.ts}

@@ -1,4 +1,4 @@
-import * as tree from '../tree/index.js';
+import * as tree from '../../tree/a/index.js';
 export declare class NodeTypeUtils {
     static isTypeDeclaration(node: tree.Node): node is TypeDeclaration;
     static isNamedTypeDeclaration(node: tree.Node): node is NamedTypeDeclaration;

package/build/types/analysis/{ObjectExpressionMeaning.d.ts → a/ObjectExpressionMeaning.d.ts}

@@ -1,7 +1,7 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { ParameterEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { ParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class Resolver {
     private readonly analyzer;
@@ -9,7 +9,6 @@ export declare class Resolver {
     private readonly diagnostics;
     constructor(analyzer: Analyzer, node: tree.ObjectExpression, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): Meaning;
-    private invalidContextDiagnostic;
 }
 export type Meaning = Meaning_objectAccess | Meaning_objectParameterAccess | Meaning_unresolved;
 declare class Meaning_objectAccess {

package/build/types/analysis/{OverloadResolver.d.ts → a/OverloadResolver.d.ts}

@@ -1,13 +1,14 @@
-import { Analyzer, ExpressionAnalysisOptions } from '../analysis/index.js';
-import { Displayable, Name } from '../common/index.js';
-import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
-import { TypeParameterEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
+import { Displayable, Name } from '../../common/index.js';
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import { TypeParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { DiagnosticArgumentFactory } from '../DiagnosticArgumentFactory.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { Analyzer } from './Analyzer.js';
 import * as matcher from './ArgumentsToParametersMatcher.js';
-import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
 import * as inferrer from './TypeArgumentInferrer.js';
-import { NodeOrDiagnosticLocation } from './Utils.js';
 export declare class OverloadResolver<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends Argument> {
     private readonly analyzer;
     private readonly mode;

package/build/types/analysis/{OwnAndBaseConstructorCallsChecker.d.ts → a/OwnAndBaseConstructorCallsChecker.d.ts}

@@ -1,7 +1,7 @@
-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 { Diagnostic } from '../../diagnostic/Diagnostic.js';
+import { ConstructorEntity, TypeEntityWithMembers } from '../../entities/index.js';
+import * as tree from '../../tree/a/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 {

package/build/types/analysis/{OwnConstructorCallExpressionMeaning.d.ts → a/OwnConstructorCallExpressionMeaning.d.ts}

@@ -1,7 +1,7 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { Analyzer } from './index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;
@@ -27,10 +27,8 @@ declare class Meaning_ownConstructorCall {
      */
     readonly type: types.Type;
     readonly candidates: readonly types.Constructor[];
-    readonly suitableConstructors: readonly types.Constructor[];
+    readonly suitableOrSingleConstructor: types.Constructor | undefined;
     readonly kind = "constructor-call";
-    get singleSuitableConstructor(): types.Constructor | undefined;
-    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -39,7 +37,7 @@ declare class Meaning_ownConstructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableOrSingleConstructor: types.Constructor | undefined);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";

package/build/types/analysis/{PackageAndStaticVariablesInitializationValidator.d.ts → a/PackageAndStaticVariablesInitializationValidator.d.ts}

@@ -1,13 +1,13 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { SourcePackage } from '../project/SourcePackage.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { SourcePackageA } from '../../project/SourcePackage.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
 import { Analyzer } from './Analyzer.js';
-import { DeclarationsUsageMap } from './DeclarationsUsageCounter.js';
 export declare class PackageAndStaticVariablesInitializationValidator {
     private readonly analyzer;
     private readonly package_;
     private readonly declarationsUsageMapList;
     private readonly diagnostics;
-    constructor(analyzer: Analyzer, package_: SourcePackage, declarationsUsageMapList: readonly DeclarationsUsageMap[], diagnostics: DiagnosticAcceptor);
+    constructor(analyzer: Analyzer, package_: SourcePackageA, declarationsUsageMapList: readonly DeclarationsUsageMap[], diagnostics: DiagnosticAcceptor);
     validate(): void;
     private getVariablesThatNeedToBeInitializedInConstructor;
     private collectStaticFieldsThatNeedToBeInitializedInConstructor;

package/build/types/analysis/{ReductionSourceMemberFinder.d.ts → a/ReductionSourceMemberFinder.d.ts}

@@ -1,11 +1,10 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import * as types from '../types/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as types from '../../types/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
 import { Analyzer } from './Analyzer.js';
-import { TypeMemberLookupContext } from './TypeMemberLookup.js';
-import { NodeOrDiagnosticLocation } from './Utils.js';
 export declare class ReductionSourceMemberFinder {
-    private static signatureComparisonOptions_;
-    private static get signatureComparisonOptions();
+    private static readonly signatureComparisonOptions;
     private readonly analyzer;
     constructor(analyzer: Analyzer);
     findField(member: types.Field, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Field | undefined;

package/build/types/analysis/{ReservedNameDictionary.d.ts → a/ReservedNameDictionary.d.ts}

@@ -1,4 +1,6 @@
-import { Lazy, Name, PackageLocale } from '../common/index.js';
+import { Lazy } from '../../common/Lazy.js';
+import { Name } from '../../common/Name.js';
+import { PackageLocale } from '../../common/PackageLocale.js';
 export declare const enum ReservedNameKind {
     Result = 0,
     Value = 1

package/build/types/analysis/{AnalyzedTranslationPackage.d.ts → a/ResolvedTranslationPackage.d.ts}

@@ -1,30 +1,29 @@
-import { PackageLocale } from '../common/index.js';
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { EntityLocalizationContext, LocalizablePackageMemberEntity } from '../entities/EntityLocalizationContext.js';
-import { AnonymousTypeEntity, Entity, EntityContainingParameter, EntityContainingTypeParameter, PackageEntity, PackageEntityMembers, PackageMemberEntity, ParameterEntity, TypeEntityMembers, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../entities/index.js';
-import { PackageName, SourceFile, TranslationPackage } from '../project/index.js';
-import * as tree from '../tree/index.js';
+import { PackageLocale } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { EntityLocalizationContext, LocalizablePackageMemberEntity } from '../../entities/EntityLocalizationContext.js';
+import { AnonymousTypeEntity, Entity, EntityContainingParameter, EntityContainingTypeParameter, PackageEntity, PackageEntityMembers, PackageMemberEntity, ParameterEntity, TypeEntityMembers, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity } from '../../entities/index.js';
+import { PackageName, SourceFile, TranslationPackageA } from '../../project/index.js';
+import * as tree from '../../tree/a/index.js';
 import { Analyzer } from './Analyzer.js';
-export declare class AnalyzedTranslationPackage {
+export declare class ResolvedTranslationPackage {
     private static readonly maxDisplayedNotTranslatedEntitiesCount;
     readonly localizationContext: EntityLocalizationContext;
     readonly translatedTargetPackage: PackageEntity;
     private readonly analyzer;
     private readonly package_;
+    private readonly packageEntity;
     private readonly targetPackage;
     private readonly entityNameConflictsValidator;
-    private readonly localizedPackageByOriginalReferencedPackage;
     private readonly translatedEntityByOriginal;
     private readonly packageMemberTranslationTargetsByNode;
     private readonly typeMemberTranslationTargetsByNode;
     private readonly translatedPackageMembers;
     private readonly translatedTypeMembersByTypeOrExtensionEntity;
-    constructor(analyzer: Analyzer, package_: TranslationPackage, targetPackage: PackageEntity);
+    constructor(analyzer: Analyzer, package_: TranslationPackageA, targetPackage: PackageEntity);
     getTargetPackage(): PackageEntity;
-    getDefinition(): TranslationPackage;
+    getDefinition(): TranslationPackageA;
     getTranslatedName(): PackageName;
     getTranslationLocale(): PackageLocale;
-    getLocalizedPackageByOriginalReferencedPackage(): ReadonlyMap<PackageEntity, PackageEntity>;
     getTranslatedPackageMembers(): PackageEntityMembers;
     ensureAllLazyDiagnosticsReportedForSourceFile(sourceFile: SourceFile): void;
     accumulateDiagnosticForSourceFile(sourceFile: SourceFile, diagnostics: DiagnosticAcceptor): void;
@@ -59,7 +58,6 @@ export declare class AnalyzedTranslationPackage {
     private areTypeParameterEntitiesEqualToTranslationTypeParameters;
     private areParameterEntitiesEqualToTranslationParameters;
     private createNotTranslatedEntitiesDiagnostic;
-    private createLocalizedPackageByOriginalReferencedPackage;
     private createTranslatedDefaultConstructorEntity;
     private tryCreateAutomaticTranslationOfDerivedTypeMember;
     private translationsDeclarations;

package/build/types/analysis/{ReturnTypeInferrer.d.ts → a/ReturnTypeInferrer.d.ts}

@@ -1,6 +1,6 @@
-import { LocalVariableEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
+import { LocalVariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class ReturnTypeInferrer {
     private readonly analyzer;

package/build/types/analysis/{SourceFileAnalyzer.d.ts → a/SourceFileAnalyzer.d.ts}

@@ -1,7 +1,7 @@
-import { TaskController } from '../common/index.js';
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import * as project from '../project/index.js';
-import { Analyzer } from './index.js';
+import { TaskController } from '../../common/index.js';
+import { Diagnostic } from '../../diagnostic/Diagnostic.js';
+import * as project from '../../project/index.js';
+import { Analyzer } from './Analyzer.js';
 export declare class SourceFileAnalyzer {
     private readonly analyzer;
     private readonly sourceFile;
@@ -13,11 +13,11 @@ export declare class SourceFileAnalyzer {
     private namedDeclarationsUsageMap;
     private readonly modifierValidator;
     private readonly standardTypes_;
-    private get translationPackage();
+    private get resolvedTranslationPackage();
     private get textTranslationPackage();
     private get isInterfacePackageFile();
     private get standardTypes();
-    constructor(analyzer: Analyzer, sourceFile: project.SourceFile);
+    constructor(analyzer: Analyzer, sourceFile: project.SourceFileA);
     analyze(taskController: TaskController): Promise<Diagnostic[]>;
     private analyzeNode;
     private checkPackageVariantDeclaration;

package/build/types/analysis/{SourcePackageMembersCreator.d.ts → a/SourcePackageMembersCreator.d.ts}

@@ -1,6 +1,6 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { PackageVariableEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { PackageVariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class SourcePackageMembersCreator {
     static createMembersWithCompoundDeclarations(analyzer: Analyzer, memberList: tree.PackageMemberDeclarationList, resultingComputedVariables: Map<tree.Node, PackageVariableEntity>, diagnostics: DiagnosticAcceptor | undefined): void;

package/build/types/analysis/a/SyntacticAccessKind.d.ts

@@ -0,0 +1,6 @@
+export declare const enum SyntacticAccessKind {
+    Get = 0,
+    Set = 1,
+    GetSet = 2,
+    ReferencedValue = 3
+}