@artel/artc 0.6.26039 → 0.8.26001

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

@@ -0,0 +1,28 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { DereferenceExpression } from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { ComputedAccess } from '../ComputedAccess.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private readonly semanticContext_;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: DereferenceExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private createComputedAccess;
+    private getAccessibleDereferenceOperatorGetter;
+    private getAccessibleDereferenceOperatorSetter;
+}
+export type Meaning = Meaning_resolved | Meaning_unresolved;
+declare class Meaning_resolved {
+    readonly operator: types.DereferenceOperator;
+    readonly access: ComputedAccess;
+    readonly kind = "resolved";
+    constructor(operator: types.DereferenceOperator, access: ComputedAccess);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export {};

package/build/types/analysis/m/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/m/FunctionAccessResolver.d.ts

@@ -0,0 +1,19 @@
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/m/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;
+    static resolveByTargetType(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): ResolutionResult;
+    private static convertProcessedSignature;
+    private static reportAmbiguousAccessDiagnostic;
+}
+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/m/IdentifierExpressionMeaning.d.ts

@@ -0,0 +1,137 @@
+import { 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/m/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { ComputedAccess } from '../ComputedAccess.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
+import * as callExpressionMeaning from './CallExpressionMeaning.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+import { NamedDeclaration } from './semantic-context/index.js';
+export declare class FirstStageResolver {
+    private readonly semanticContext_;
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
+    private resolveVariableAccess;
+    private resolveVariableEntityAccess;
+    private resolvePackageVariableAccess;
+    private getAccessiblePackageVariableGetter;
+    private getAccessiblePackageVariableSetter;
+    private resolveFieldAccess;
+    private getAccessibleFieldGetter;
+    private getAccessibleFieldSetter;
+    private resolveAccessOfVariableWithoutExplicitAccessors;
+    private checkExpressionDenotesType;
+    private resolveTypeAccess;
+    private tryResolveVariantValueAccess;
+    private createNotSubstitutedAccessedFunction;
+    private createComputedAccessForVariableWithoutExplicitAccessors;
+}
+export declare class SecondStageResolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly firstStageMeaning;
+    private readonly analysisOptions;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageMeaning: MeaningStage1, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private resolveTypeAccessAtCalleePosition;
+    private resolveFunctionAccess;
+    private resolveNotCalledFunctionsAccess;
+}
+export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_variantValueAccess | Meaning_typeAccessAtConstructorCall | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class Meaning_variableAccess {
+    readonly variable: AccessedVariable;
+    readonly access: ComputedAccess;
+    readonly objectParameterContainingVariable: ParameterEntity | undefined;
+    readonly kind = "variable-access";
+    constructor(variable: AccessedVariable, access: ComputedAccess, objectParameterContainingVariable: ParameterEntity | undefined);
+}
+declare class Meaning_variantValueAccess {
+    readonly suitableTypes: readonly types.Type[];
+    readonly type: types.Type;
+    readonly field: types.Field;
+    readonly access: ComputedAccess;
+    readonly kind = "variant-value-access";
+    constructor(suitableTypes: readonly types.Type[], type: types.Type, field: types.Field, access: ComputedAccess);
+}
+declare class Meaning_functionAccess {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly objectParameterContainingFunctions: ParameterEntity | undefined;
+    readonly kind = "function-access";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined, objectParameterContainingFunctions: ParameterEntity | undefined);
+}
+declare class Meaning_packageAliasAccess {
+    readonly packageAlias: PackageAliasEntity;
+    readonly kind = "package-alias-access";
+    constructor(packageAlias: PackageAliasEntity);
+}
+declare class Meaning_packageNameSegmentAccess {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment-access";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+declare class Meaning_typeAccess {
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly types.Type[];
+    readonly isUsedAsValue: boolean;
+    readonly kind = "type-access";
+    get singleSuitableType(): types.Type | undefined;
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly types.Type[], isUsedAsValue: boolean);
+}
+declare class Meaning_typeAccessAtConstructorCall {
+    readonly typeCandidates: readonly NamedTypeEntity[];
+    readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
+    readonly kind = "type-access-at-constructor-call";
+    constructor(typeCandidates: readonly NamedTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
+}
+declare class Meaning_mixedAmbiguousAccess {
+    readonly declarations: readonly NamedDeclaration[];
+    readonly kind = "mixed-ambiguous-access";
+    constructor(declarations: readonly NamedDeclaration[]);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export type MeaningStage1 = Meaning_variableAccess | MeaningStage1_functionAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_typeAccess | Meaning_variantValueAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class MeaningStage1_typeAccessAtCalleePosition {
+    readonly types: readonly NamedTypeEntity[];
+    readonly kind = "type-access-at-callee-position";
+    constructor(types: readonly NamedTypeEntity[]);
+}
+declare class MeaningStage1_functionAccess {
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly objectParameterContainingFunctions: ParameterEntity | undefined;
+    readonly kind = "function-access";
+    constructor(functions: readonly NotSubstitutedAccessedFunction[], objectParameterContainingFunctions: ParameterEntity | undefined);
+}
+export type AccessedVariable = AccessedVariable_entity | AccessedVariable_typeMember;
+export declare class AccessedVariable_entity implements IAccessedVariable {
+    readonly value: VariableEntity;
+    readonly kind = "entity";
+    constructor(value: VariableEntity);
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+export declare class AccessedVariable_typeMember implements IAccessedVariable {
+    readonly value: types.Field;
+    readonly kind = "type-member";
+    constructor(value: types.Field);
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+interface IAccessedVariable {
+    getEntity(): VariableEntity;
+    getName(): Name;
+    getType(): types.Type;
+}
+export {};

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

@@ -0,0 +1,32 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { IndexedAccessExpression } from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { ComputedAccess } from '../ComputedAccess.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private readonly semanticContext_;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: IndexedAccessExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private createComputedAccess;
+    private getAccessibleIndexerGetter;
+    private getAccessibleIndexerSetter;
+    private getDiagnosticLocation;
+}
+export type Meaning = Meaning_resolved | Meaning_unresolved;
+declare class Meaning_resolved {
+    readonly candidates: readonly types.Indexer[];
+    readonly suitableIndexers: readonly types.Indexer[];
+    readonly access: ComputedAccess;
+    readonly kind = "resolved";
+    get singleSuitableIndexer(): types.Indexer | undefined;
+    get singleIndexer(): types.Indexer | undefined;
+    constructor(candidates: readonly types.Indexer[], suitableIndexers: readonly types.Indexer[], access: ComputedAccess);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export {};

package/build/types/analysis/m/InstanceFieldsInitializationValidator.d.ts

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

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

@@ -0,0 +1,137 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { Entity, PackageTypeEntity, PackageVariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { ComputedAccess } from '../ComputedAccess.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
+import * as callExpressionMeaning from './CallExpressionMeaning.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+export declare class FirstStageResolver {
+    private readonly semanticContext_;
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private get memberName();
+    private get semanticContext();
+    private get receiver();
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): MeaningStage1;
+    private resolvePackageAliasMemberAccessMeaning;
+    private resolvePackageMemberAccessMeaning;
+    private resolvePackageTypeAccess;
+    private resolvePackageNameSegmentAccessMeaning;
+    private resolveStaticMemberOrVariantAccessMeaning;
+    private resolveInstanceMemberAccessMeaning;
+    private resolveFieldAccess;
+    private getAccessibleFieldGetter;
+    private getAccessibleFieldSetter;
+    private resolvePackageVariableAccess;
+    private getAccessiblePackageVariableGetter;
+    private getAccessiblePackageVariableSetter;
+    private createComputedAccessForVariableWithoutExplicitAccessors;
+}
+export declare class SecondStageResolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly firstStageMeaning;
+    private readonly analysisOptions;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageMeaning: MeaningStage1, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private resolveTypeAccessAtCalleePosition;
+    private resolvePackageFunctionAccess;
+    private resolveStaticMethodAccess;
+    private resolveInstanceMethodAccess;
+    private resolveNotCalledFunctionsAccess;
+}
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_typeAccessAtConstructorCall | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class Meaning_packageVariableAccess {
+    readonly variable: PackageVariableEntity;
+    readonly access: ComputedAccess;
+    readonly kind = "package-variable-access";
+    constructor(variable: PackageVariableEntity, access: ComputedAccess);
+}
+declare class Meaning_packageFunctionAccess {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly kind = "package-function-access";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+declare class Meaning_packageTypeAccess {
+    readonly candidates: readonly PackageTypeEntity[];
+    readonly suitableTypes: readonly types.Type[];
+    readonly isUsedAsValue: boolean;
+    readonly kind = "package-type-access";
+    get singleSuitableType(): types.Type | undefined;
+    constructor(candidates: readonly PackageTypeEntity[], suitableTypes: readonly types.Type[], isUsedAsValue: boolean);
+}
+declare class Meaning_typeAccessAtConstructorCall {
+    readonly typeCandidates: readonly PackageTypeEntity[];
+    readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
+    readonly kind = "type-access-at-constructor-call";
+    constructor(typeCandidates: readonly PackageTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
+}
+declare class Meaning_packageNameSegmentAccess {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment-access";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+declare class Meaning_staticFieldAccess {
+    readonly type: types.Type;
+    readonly field: types.Field;
+    readonly access: ComputedAccess;
+    readonly kind = "static-field-access";
+    constructor(type: types.Type, field: types.Field, access: ComputedAccess);
+}
+declare class Meaning_staticMethodAccess {
+    readonly type: types.Type;
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly kind = "static-method-access";
+    constructor(type: types.Type, candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+declare class Meaning_instanceFieldAccess {
+    readonly field: types.Field;
+    readonly access: ComputedAccess;
+    readonly kind = "instance-field-access";
+    constructor(field: types.Field, access: ComputedAccess);
+}
+declare class Meaning_instanceMethodAccess {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly kind = "instance-method-access";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+declare class Meaning_mixedAmbiguousAccess {
+    readonly entities: readonly Entity[];
+    readonly kind = "mixed-ambiguous-access";
+    constructor(entities: readonly Entity[]);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export type MeaningStage1 = Meaning_packageVariableAccess | MeaningStage1_packageFunctionAccess | Meaning_packageTypeAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | MeaningStage1_staticMethodAccess | Meaning_instanceFieldAccess | MeaningStage1_instanceMethodAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+declare class MeaningStage1_typeAccessAtCalleePosition {
+    readonly types: readonly PackageTypeEntity[];
+    readonly kind = "type-access-at-callee-position";
+    constructor(types: readonly PackageTypeEntity[]);
+}
+declare class MeaningStage1_packageFunctionAccess {
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly kind = "package-function-access";
+    constructor(functions: readonly NotSubstitutedAccessedFunction[]);
+}
+declare class MeaningStage1_staticMethodAccess {
+    readonly type: types.Type;
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly kind = "static-method-access";
+    constructor(type: types.Type, functions: readonly NotSubstitutedAccessedFunction[]);
+}
+declare class MeaningStage1_instanceMethodAccess {
+    readonly functions: readonly NotSubstitutedAccessedFunction[];
+    readonly kind = "instance-method-access";
+    constructor(functions: readonly NotSubstitutedAccessedFunction[]);
+}
+export {};

package/build/types/analysis/m/ModifierFlags.d.ts

@@ -0,0 +1,20 @@
+export declare enum ModifierFlags {
+    None = 0,
+    HiddenWithoutLevel = 1,
+    HiddenInType = 2,
+    HiddenInHierarchy = 4,
+    HiddenInFile = 8,
+    HiddenInPackage = 16,
+    Static = 32,
+    Abstract = 64,
+    Basic = 128,
+    Override = 256,
+    Async = 512,
+    Const = 1024,
+    First = 1,
+    Last = 1024,
+    NotComputed = 2048,
+    AnyHiddenModifier = 31,
+    HiddenInPackageOrWithoutLevel = 17,
+    HiddenInTypeOrWithoutLevel = 3
+}

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

@@ -0,0 +1,44 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity, PackageAliasEntity } from '../../entities/index.js';
+import { QualifiedName } from '../../tree/m/index.js';
+import { EntityOrPackageNameTreeNode } from '../EntityOrPackageNameTreeNode.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
+export declare class NamedTypeResolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private readonly semanticContext_;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: QualifiedName, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): NamedTypeResolutionResult;
+    private lookupTypeOrContainerWithTypes;
+    private findTypesOrContainersWithTypesInResolvedQualifier;
+    private findTypesOrContainersWithTypesInPackageAccessedViaAlias;
+    private findTypesOrContainersWithTypesInPackageNameSegment;
+    private convertPackageMember;
+    private createAmbiguousAccessDiagnostic;
+}
+export declare class NamedTypeResolutionResult {
+    readonly types: readonly NamedTypeEntity[];
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined;
+    constructor(types: readonly NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations: readonly EntityOrPackageNameTreeNode[] | undefined);
+}
+export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type;
+export declare class ResolvedQualifier_packageNameSegment {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+export declare class ResolvedQualifier_packageAlias {
+    readonly packageAlias: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(packageAlias: PackageAliasEntity);
+}
+export declare class ResolvedQualifier_type {
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly NamedTypeEntity[];
+    readonly kind = "type";
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
+}

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

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

package/build/types/analysis/m/ObjectExpressionMeaning.d.ts

@@ -0,0 +1,29 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { ParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.ObjectExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private invalidContextDiagnostic;
+    private staticContextDiagnostic;
+}
+export type Meaning = Meaning_objectAccess | Meaning_objectParameterAccess | Meaning_unresolved;
+declare class Meaning_objectAccess {
+    readonly type: types.Type;
+    readonly kind = "object-access";
+    constructor(type: types.Type);
+}
+declare class Meaning_objectParameterAccess {
+    readonly parameter: ParameterEntity;
+    readonly kind = "object-parameter-access";
+    constructor(parameter: ParameterEntity);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export {};

package/build/types/analysis/m/OverloadResolver.d.ts

@@ -0,0 +1,104 @@
+import { Displayable, Name } from '../../common/index.js';
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import { TypeParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/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 { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+import * as inferrer from './TypeArgumentInferrer.js';
+export declare class OverloadResolver<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends Argument> {
+    private readonly analyzer;
+    private readonly mode;
+    private readonly signatures;
+    private readonly arguments_;
+    private readonly analysisOptions;
+    private readonly dataForTypeArgumentInference;
+    private readonly diagnostics;
+    private readonly nodesForDiagnostic;
+    constructor(analyzer: Analyzer, mode: ResolutionMode, signatures: readonly TSignature[], arguments_: readonly TArgument[], analysisOptions: ExpressionAnalysisOptions, dataForTypeArgumentInference: DataForTypeArgumentInference | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodesForDiagnostic: DiagnosticLocations | undefined);
+    resolveOverload(): ProcessedSignature<TSignature, TParameter, TArgument>[];
+    private areArgumentTypesAssignableToParameterTypes;
+    private tryChooseBestSignature;
+    private tryChooseBetterSignatureBasedOnParameterTypes;
+    private chooseBetterTargetType;
+    private tryChooseBetterSignatureBasedOnVariadicParameters;
+    private tryChooseBetterSignatureBasedOnPresenceOfTypeParameters;
+    private tryChooseBetterSignatureBasedOnParameterCount;
+    private functionLiteralCouldBeAssignableToType;
+    private reportAmbiguousAccessDiagnostic;
+}
+export interface ISignature<TParameter extends ISignatureParameter> extends matcher.ISignature<TParameter> {
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly TParameter[];
+    getReturnType(): types.Type | undefined;
+    getOuterSubstitutions(): types.Substitutions | undefined;
+    toDisplayable(factory: DiagnosticArgumentFactory): Displayable;
+}
+export interface ISignatureParameter extends matcher.ISignatureParameter {
+    getType(): types.Type;
+    getIndex(): number;
+}
+export type ResolutionMode = ResolutionByExplicitArguments | ResolutionByTargetType;
+export declare class ResolutionByExplicitArguments {
+    readonly kind = "by-explicit-arguments";
+}
+export declare class ResolutionByTargetType {
+    readonly targetType: types.FunctionType;
+    readonly kind = "by-target-type";
+    constructor(targetType: types.FunctionType);
+}
+export type Argument = SourceArgument | IntrinsicArgument;
+export interface SourceArgument extends matcher.IArgument, inferrer.SourceArgument, IArgument {
+    readonly kind: 'source';
+    readonly expression: tree.Expression;
+}
+export declare class IntrinsicArgument implements matcher.IArgument, inferrer.IntrinsicArgument, IArgument {
+    readonly kind = "intrinsic";
+    readonly type: types.Type;
+    get name(): Name | undefined;
+    constructor(type: types.Type);
+    getDiagnosticLocation(): NodeOrDiagnosticLocation | undefined;
+    getType(analysisOptions_: ExpressionAnalysisOptions | undefined): types.Type;
+}
+interface IArgument {
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
+}
+export declare class SourceNodeArgument implements SourceArgument {
+    readonly kind = "source";
+    readonly node: tree.Argument;
+    readonly name: Name | undefined;
+    private readonly analyzer;
+    get expression(): tree.Expression;
+    constructor(analyzer: Analyzer, node: tree.Argument);
+    getDiagnosticLocation(): NodeOrDiagnosticLocation;
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
+}
+export declare class SourceExpressionArgument implements SourceArgument {
+    private readonly analyzer;
+    readonly expression: tree.Expression;
+    readonly kind = "source";
+    get name(): Name | undefined;
+    constructor(analyzer: Analyzer, expression: tree.Expression);
+    getDiagnosticLocation(): NodeOrDiagnosticLocation;
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
+}
+export declare class DataForTypeArgumentInference {
+    readonly specifiedTypeArguments: readonly types.Type[];
+    readonly targetType: types.Type | undefined;
+    constructor(specifiedTypeArguments: readonly types.Type[], targetType: types.Type | undefined);
+}
+export interface DiagnosticLocations {
+    readonly access: NodeOrDiagnosticLocation | undefined;
+    readonly typeArgumentClause: NodeOrDiagnosticLocation | undefined;
+    readonly argumentList: NodeOrDiagnosticLocation | undefined;
+}
+export interface ProcessedSignature<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends matcher.IArgument> {
+    readonly value: TSignature;
+    readonly matchResult: matcher.MatchResult<TParameter, TArgument>;
+    readonly typeArguments: readonly types.Type[] | undefined;
+    readonly isMatching: boolean;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { Diagnostic } from '../../diagnostic/Diagnostic.js';
+import { MethodEntity, TypeWithMembersOrExtensionEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { SemanticContext } from './semantic-context/SemanticContext.js';
+export declare class OwnAndBaseConstructorCallsChecker {
+    private readonly analyzer;
+    private readonly constructorDeclarations;
+    private readonly typeEntity;
+    private readonly semanticContext;
+    constructor(analyzer: Analyzer, constructorDeclarations: readonly tree.MethodDeclaration[], typeEntity: TypeWithMembersOrExtensionEntity, semanticContext: SemanticContext);
+    check(): OwnAndBaseConstructorCallsCheckResult;
+    private addOwnConstructorCallOrReportCycleDiagnostic;
+    private getUnaliasedBaseObjectType;
+    private findAccessibleConstructorWithoutParameters;
+}
+export declare class OwnAndBaseConstructorCallsCheckResult {
+    readonly typeRequiresExplicitOwnOrBaseConstructorCalls: boolean;
+    readonly ownOrBaseConstructorCallInfos: ReadonlyMap<MethodEntity, OwnOrBaseConstructorCallInfo>;
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(typeRequiresExplicitOwnOrBaseConstructorCalls: boolean, ownOrBaseConstructorCallInfos: ReadonlyMap<MethodEntity, OwnOrBaseConstructorCallInfo>, diagnostics: readonly Diagnostic[]);
+}
+export declare class OwnOrBaseConstructorCallInfo {
+    readonly isOwnConstructorCall: boolean;
+    readonly constructor_: types.Method;
+    /**
+     * Отсутствие узла означает, что базовый конструктор без параметров не был вызван явно.
+     */
+    readonly node: tree.CallExpression | undefined;
+    constructor(isOwnConstructorCall: boolean, constructor_: types.Method, 
+    /**
+     * Отсутствие узла означает, что базовый конструктор без параметров не был вызван явно.
+     */
+    node: tree.CallExpression | undefined);
+}