@artel/artc 0.6.25254 → 0.6.25255

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

@@ -1,36 +1,55 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { CallExpression } from '../tree/index.js';
+import { NamedTypeEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedFunction } from './AccessedFunction.js';
-import { Analyzer } from './index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import { Analyzer, InferenceOptions } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
     private readonly _node;
-    constructor(_analyzer: Analyzer, _node: CallExpression);
+    private readonly _inferenceOptions;
+    constructor(_analyzer: Analyzer, _node: tree.CallExpression, _inferenceOptions: InferenceOptions | undefined);
     private get callee();
-    resolve(): Meaning;
-    resolveType(meaning: Meaning | undefined): types.Type;
-    private resolveConstructorCallExpressionMeaning;
+    resolve(): ResolutionResult;
+    private checkExpressionDenotesType;
+    private checkExpressionDenotesFunction;
+    private checkExpressionDenotesOperator;
+    private resolveFunctionCallExpression;
+    private resolveOperatorCallExpression;
+    private resolveConstructorCallExpression;
+    private resolveObjectFunctionCallExpression;
     private getNodeForDiagnostics;
-    private getTypeFromMeaning;
+}
+export declare class ResolutionResult {
+    readonly meaning: Meaning;
+    readonly diagnostics?: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
+    static unresolved(diagnostics: readonly Diagnostic[] | undefined): ResolutionResult;
 }
 export type Meaning = Meaning_functionCall | Meaning_operatorCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
-declare class Meaning_functionCall {
-    readonly func: AccessedFunction;
+export declare class Meaning_functionCall {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "function-call";
-    constructor(func: AccessedFunction);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    get singleFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
-declare class Meaning_operatorCall {
-    readonly operator: types.Operator;
+export declare class Meaning_operatorCall {
+    readonly candidates: readonly types.Operator[];
+    readonly suitableOperators: readonly types.Operator[];
     readonly kind = "operator-call";
-    constructor(operator: types.Operator);
+    get singleSuitableOperator(): types.Operator | undefined;
+    get singleOperator(): types.Operator | undefined;
+    constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
-declare class Meaning_objectFunctionCall {
+export declare class Meaning_objectFunctionCall {
     readonly type: types.FunctionType;
     readonly kind = "object-function-call";
     constructor(type: types.FunctionType);
 }
-declare class Meaning_constructorCall {
+export declare class Meaning_constructorCall {
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
      *
@@ -38,11 +57,14 @@ declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    readonly type: types.Type;
+    readonly type: types.Type | undefined;
+    readonly typeEntity: NamedTypeEntity | undefined;
     readonly candidates: readonly types.Constructor[];
     readonly suitableConstructors: readonly types.Constructor[];
+    readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
     readonly kind = "constructor-call";
     get singleSuitableConstructor(): types.Constructor | undefined;
+    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -51,11 +73,8 @@ declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
+    type: types.Type | undefined, typeEntity: NamedTypeEntity | undefined, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
 }
-declare class Meaning_unresolved {
-    readonly diagnostics: readonly Diagnostic[];
+export declare class Meaning_unresolved {
     readonly kind = "unresolved";
-    constructor(diagnostics: readonly Diagnostic[]);
 }
-export {};

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

@@ -0,0 +1,22 @@
+import { PackageLocale } from '../common/index.js';
+import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
+import { IEntityHidingMatcher, NamedTypeEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer, InferenceOptions } from './Analyzer.js';
+import { SemanticContext } from './semantic-context/SemanticContext.js';
+export declare class Resolver {
+    static resolve(analyzer: Analyzer, candidates: readonly types.Constructor[], argumentList: tree.ArgumentList | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): readonly types.Constructor[];
+    static resolveByNamedTypes(analyzer: Analyzer, typeEntities: readonly NamedTypeEntity[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, inferenceOptions: InferenceOptions, locale: PackageLocale, hidingMatcher: IEntityHidingMatcher | undefined, typeExtensionLookup: SemanticContext | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    private static typeCanBeConstructed;
+}
+export declare class ResolutionResult {
+    readonly candidates: readonly types.Constructor[];
+    readonly suitableConstructors: readonly types.Constructor[];
+    readonly typeEntity: NamedTypeEntity | undefined;
+    readonly type: types.Type | undefined;
+    readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
+    private static _empty;
+    static get empty(): ResolutionResult;
+    constructor(candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], typeEntity: NamedTypeEntity | undefined, type: types.Type | undefined, singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
+}

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

@@ -12,8 +12,10 @@ export declare class DiagnosticCollector {
     private readonly _diagnosticAcceptor;
     private _namedDeclarationsUsageMap;
     private readonly _modifierValidator;
+    private readonly _standardTypes;
     private get translationPackage();
     private get isInterfacePackageFile();
+    private get standardTypes();
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile);
     collect(cancellationToken?: CancellationToken | undefined): Promise<Diagnostic[]>;
     private collectNodeDiagnostics;
@@ -29,6 +31,7 @@ export declare class DiagnosticCollector {
     private isNotTranslatedEntity;
     private createNotTranslatedEntitiesDiagnostic;
     private checkAllDefaultConstructorArgumentsAreNamed;
+    private checkPackageVariableDeclaration;
     private checkPackageFunctionDeclaration;
     private checkPackageVariableGetterDeclaration;
     private checkPackageVariableSetterDeclaration;
@@ -52,8 +55,7 @@ export declare class DiagnosticCollector {
     private checkLocalVariableUsedBeforeDeclaration;
     private checkLocalVariableIsUsedBeforeBeingAssigned;
     private checkMemberAccessExpression;
-    private addDiagnosticsFromMatchResult;
-    private checkExpressionTypeAssignableToTargetType;
+    private checkExpressionTypeIsAssignableToTargetType;
     private addTypeAssignabilityDiagnosticIfBothTypesResolved;
     private checkAssignmentIsValid;
     private checkAssignmentToIdentifierExpression;
@@ -66,13 +68,7 @@ export declare class DiagnosticCollector {
     private checkAssignmentToIndexedAccessExpression;
     private checkOptionalChainingIsUsedOnTheLeftSideOfAssignment;
     private checkGenericSpecializationExpression;
-    private checkFunctionSpecialization;
-    private checkTypeSpecialization;
-    private checkSpecializationOfDeclarationWithParameters;
-    /**
-     * @returns `true` если не было ошибки, иначе `false`.
-     */
-    private checkTypeArgumentCount;
+    private checkTypeArgumentTypesAreAssignableToConstraints;
     private checkParameterDeclaration;
     private checkIfVariableIsUnused;
     private checkIfNestedFunctionIsUnused;

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

@@ -0,0 +1,15 @@
+import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
+import * as tree from '../tree/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import { Analyzer, InferenceOptions } from './Analyzer.js';
+export declare class Resolver {
+    static resolveByCallExpression(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], node: tree.CallExpression, inferenceOptions: InferenceOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined): ResolutionResult;
+    static resolveByCallExpressionParts(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, inferenceOptions: InferenceOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    static resolveByTargetType(analyzer: Analyzer, candidates: readonly NotSubstitutedAccessedFunction[], typeArgumentClause: tree.TypeArgumentClause | undefined, inferenceOptions: InferenceOptions, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): ResolutionResult;
+    private static convertProcessedSignature;
+    private static reportAmbiguousAccessDiagnostic;
+}
+export interface ResolutionResult {
+    suitableFunctions: readonly AccessedFunction[];
+    singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+}

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

@@ -3,37 +3,41 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { NamedTypeEntity, PackageAliasEntity, VariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedFunction } from './AccessedFunction.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { Analyzer, TargetTypeHint } from './index.js';
+import { Analyzer, InferenceOptions } from './index.js';
 import { NamedDeclaration } from './semantic-context/index.js';
-export declare class Resolver {
+export declare class FirstStageResolver {
     private readonly _semanticContext;
     private readonly _analyzer;
     private readonly _node;
-    private readonly _targetTypeHint;
     private get semanticContext();
-    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, targetTypeHint: TargetTypeHint | undefined);
-    resolve(): ResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression);
+    resolve(): FirstStageResolutionResult;
     private tryResolveOperatorAccessMeaning;
-    private resolveFunctionOverload;
-    private createAccessedFunction;
+    private resolveTypeAccess;
+    private createNotSubstitutedAccessedFunction;
     private convertSyntacticAccessKind;
 }
+export declare class SecondStageResolver {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _firstStageResolutionResult;
+    private readonly _inferenceOptions;
+    constructor(analyzer: Analyzer, node: tree.IdentifierExpression, firstStageResolutionResult: FirstStageResolutionResult, inferenceOptions: InferenceOptions | undefined);
+    resolve(): ResolutionResult;
+    private resolveTypeAccessAtCalleePosition;
+    private resolveFunctionAccess;
+    private resolveOperatorAccess;
+    private resolveNotCalledFunctionsAccess;
+}
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
-    /**
-     * Может ли измениться результат, если посчитать его с другим целевым типом?
-     */
-    readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
-    /**
-     * Может ли измениться результат, если посчитать его с другим целевым типом?
-     */
-    dependsOnTargetType?: boolean);
-}
-export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+    readonly diagnostics: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: Diagnostic | readonly Diagnostic[]);
+}
+export type Meaning = Meaning_variableAccess | Meaning_functionAccess | Meaning_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | Meaning_typeAccess | Meaning_constructorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_variableAccess {
     readonly variable: AccessedVariable;
     readonly accessKind: AccessKind;
@@ -41,17 +45,20 @@ declare class Meaning_variableAccess {
     constructor(variable: AccessedVariable, accessKind: AccessKind);
 }
 declare class Meaning_functionAccess {
-    readonly candidates: readonly AccessedFunction[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "function-access";
     get singleSuitableFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
+    get singleFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
 declare class Meaning_operatorAccess {
     readonly candidates: readonly types.Operator[];
     readonly suitableOperators: readonly types.Operator[];
     readonly kind = "operator-access";
     get singleSuitableOperator(): types.Operator | undefined;
+    get singleOperator(): types.Operator | undefined;
     constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
 declare class Meaning_packageAliasAccess {
@@ -71,6 +78,12 @@ declare class Meaning_typeAccess {
     get singleSuitableType(): types.Type | undefined;
     constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly types.Type[]);
 }
+declare class Meaning_constructorAccess {
+    readonly typeCandidates: readonly NamedTypeEntity[];
+    readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
+    readonly kind = "constructor-access";
+    constructor(typeCandidates: readonly NamedTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
+}
 declare class Meaning_mixedAmbiguousAccess {
     readonly declarations: readonly NamedDeclaration[];
     readonly kind = "mixed-ambiguous-access";
@@ -79,6 +92,27 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
+export declare class FirstStageResolutionResult {
+    readonly meaning: MeaningStage1;
+    readonly diagnostics: readonly Diagnostic[] | undefined;
+    constructor(meaning: MeaningStage1, diagnostics?: Diagnostic | readonly Diagnostic[]);
+}
+export type MeaningStage1 = Meaning_variableAccess | MeaningStage1_functionAccess | MeaningStage1_operatorAccess | Meaning_packageNameSegmentAccess | Meaning_packageAliasAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_typeAccess | 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 kind = "function-access";
+    constructor(functions: readonly NotSubstitutedAccessedFunction[]);
+}
+declare class MeaningStage1_operatorAccess {
+    readonly operators: readonly types.Operator[];
+    readonly kind = "operator-access";
+    constructor(operators: readonly types.Operator[]);
+}
 export type AccessedVariable = AccessedVariable_entity | AccessedVariable_typeMember;
 export declare class AccessedVariable_entity implements IAccessedVariable {
     readonly value: VariableEntity;

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

@@ -15,8 +15,8 @@ export declare class Resolver {
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined);
+    readonly diagnostics?: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
 }
 export type Meaning = Meaning_resolved | Meaning_unresolved;
 declare class Meaning_resolved {
@@ -25,6 +25,7 @@ declare class Meaning_resolved {
     readonly accessKind: AccessKind;
     readonly kind = "resolved";
     get singleSuitableIndexer(): types.Indexer | undefined;
+    get singleIndexer(): types.Indexer | undefined;
     constructor(candidates: readonly types.Indexer[], suitableIndexers: readonly types.Indexer[], accessKind: AccessKind);
 }
 declare class Meaning_unresolved {

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

@@ -3,44 +3,48 @@ import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { Entity, PackageTypeEntity, PackageVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedFunction } from './AccessedFunction.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
+import * as callExpressionMeaning from './CallExpressionMeaning.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
-import { Analyzer, TargetTypeHint } from './index.js';
-export declare class Resolver {
+import { Analyzer, InferenceOptions } from './index.js';
+export declare class FirstStageResolver {
     private readonly _semanticContext;
     private readonly _analyzer;
     private readonly _node;
-    private readonly _targetTypeHint;
     private get memberName();
     private get semanticContext();
     private get receiver();
-    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, targetTypeHint: TargetTypeHint | undefined);
-    resolve(): ResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression);
+    resolve(): FirstStageResolutionResult;
     private resolvePackageAliasMemberAccessMeaning;
     private resolvePackageMemberAccessMeaning;
+    private resolveTypeAccess;
     private resolvePackageNameSegmentAccessMeaning;
-    private createAccessedFunctionFromPackageMember;
     private resolveStaticMemberOrVariantAccessMeaning;
-    private createAccessedFunctionFromTypeMember;
     private resolveInstanceMemberAccessMeaning;
     private tryResolveInstanceOperatorAccessMeaning;
-    private resolveFunctionOverload;
     private convertSyntacticAccessKind;
 }
+export declare class SecondStageResolver {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _firstStageResolutionResult;
+    private readonly _inferenceOptions;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageResolutionResult: FirstStageResolutionResult, inferenceOptions: InferenceOptions | undefined);
+    resolve(): ResolutionResult;
+    private resolveTypeAccessAtCalleePosition;
+    private resolvePackageFunctionAccess;
+    private resolveStaticMethodAccess;
+    private resolveInstanceMethodAccess;
+    private resolveNotCalledFunctionsAccess;
+    private resolveOperatorAccess;
+}
 export declare class ResolutionResult {
     readonly meaning: Meaning;
-    readonly diagnostic?: Diagnostic | undefined;
-    /**
-     * Может ли измениться результат, если посчитать его с другим целевым типом?
-     */
-    readonly dependsOnTargetType: boolean;
-    constructor(meaning: Meaning, diagnostic?: Diagnostic | undefined, 
-    /**
-     * Может ли измениться результат, если посчитать его с другим целевым типом?
-     */
-    dependsOnTargetType?: boolean);
-}
-export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
+    readonly diagnostics: readonly Diagnostic[] | undefined;
+    constructor(meaning: Meaning, diagnostics?: Diagnostic | readonly Diagnostic[]);
+}
+export type Meaning = Meaning_packageVariableAccess | Meaning_packageFunctionAccess | Meaning_packageTypeAccess | Meaning_constructorAccess | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | Meaning_staticMethodAccess | Meaning_instanceFieldAccess | Meaning_instanceMethodAccess | Meaning_operatorAccess | Meaning_mixedAmbiguousAccess | Meaning_unresolved;
 declare class Meaning_packageVariableAccess {
     readonly variable: PackageVariableEntity;
     readonly accessKind: AccessKind;
@@ -48,11 +52,13 @@ declare class Meaning_packageVariableAccess {
     constructor(variable: PackageVariableEntity, accessKind: AccessKind);
 }
 declare class Meaning_packageFunctionAccess {
-    readonly candidates: readonly AccessedFunction[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "package-function-access";
     get singleSuitableFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
+    get singleFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
 declare class Meaning_packageTypeAccess {
     readonly candidates: readonly PackageTypeEntity[];
@@ -61,6 +67,12 @@ declare class Meaning_packageTypeAccess {
     get singleSuitableType(): types.Type | undefined;
     constructor(candidates: readonly PackageTypeEntity[], suitableTypes: readonly types.Type[]);
 }
+declare class Meaning_constructorAccess {
+    readonly typeCandidates: readonly PackageTypeEntity[];
+    readonly callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall;
+    readonly kind = "constructor-access";
+    constructor(typeCandidates: readonly PackageTypeEntity[], callExpressionMeaning: callExpressionMeaning.Meaning_constructorCall);
+}
 declare class Meaning_packageNameSegmentAccess {
     readonly packageTreeNode: PackageNameTreeNode;
     readonly kind = "package-name-segment-access";
@@ -75,11 +87,13 @@ declare class Meaning_staticFieldAccess {
 }
 declare class Meaning_staticMethodAccess {
     readonly type: types.Type;
-    readonly candidates: readonly AccessedFunction[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "static-method-access";
     get singleSuitableFunction(): AccessedFunction | undefined;
-    constructor(type: types.Type, candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
+    get singleFunction(): AccessedFunction | undefined;
+    constructor(type: types.Type, candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
 declare class Meaning_instanceFieldAccess {
     readonly field: types.Field;
@@ -88,17 +102,20 @@ declare class Meaning_instanceFieldAccess {
     constructor(field: types.Field, accessKind: AccessKind);
 }
 declare class Meaning_instanceMethodAccess {
-    readonly candidates: readonly AccessedFunction[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "instance-method-access";
     get singleSuitableFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
+    get singleFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
 declare class Meaning_operatorAccess {
     readonly candidates: readonly types.Operator[];
     readonly suitableOperators: readonly types.Operator[];
     readonly kind = "operator-access";
     get singleSuitableOperator(): types.Operator | undefined;
+    get singleOperator(): types.Operator | undefined;
     constructor(candidates: readonly types.Operator[], suitableOperators: readonly types.Operator[]);
 }
 declare class Meaning_mixedAmbiguousAccess {
@@ -109,4 +126,36 @@ declare class Meaning_mixedAmbiguousAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
+export declare class FirstStageResolutionResult {
+    readonly meaning: MeaningStage1;
+    readonly diagnostics: readonly Diagnostic[] | undefined;
+    constructor(meaning: MeaningStage1, diagnostics?: Diagnostic | readonly Diagnostic[]);
+}
+export type MeaningStage1 = Meaning_packageVariableAccess | MeaningStage1_packageFunctionAccess | Meaning_packageTypeAccess | MeaningStage1_typeAccessAtCalleePosition | Meaning_packageNameSegmentAccess | Meaning_staticFieldAccess | MeaningStage1_staticMethodAccess | Meaning_instanceFieldAccess | MeaningStage1_instanceMethodAccess | MeaningStage1_operatorAccess | 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[]);
+}
+declare class MeaningStage1_operatorAccess {
+    readonly operators: readonly types.Operator[];
+    readonly kind = "operator-access";
+    constructor(operators: readonly types.Operator[]);
+}
 export {};

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

@@ -9,7 +9,6 @@ export declare class NamedTypeSpecifierResolver {
     private readonly _node;
     constructor(_analyzer: Analyzer, _node: NamedTypeSpecifier);
     resolve(): NamedTypeSpecifierResolutionResult;
-    private resolveTypeOverload;
 }
 export declare class NamedTypeSpecifierResolutionResult {
     readonly type: types.Type | undefined;

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

@@ -14,6 +14,7 @@ export declare class NodeTypeUtils {
     static isVariantTypeDeclaration(node: tree.Node): node is VariantTypeDeclaration;
     static isNullLiteral(node: tree.Node): boolean;
     static isSubprogramDeclarationOrLiteral(node: tree.Node): node is SubprogramDeclarationOrLiteral;
+    static isRegularOrBlockFunctionLiteral(node: tree.Node): node is RegularOrBlockFunctionLiteral;
 }
 export type PackageTypeDeclaration = tree.PackageAliasTypeDeclaration | tree.PackageFunctionTypeDeclaration | tree.PackageStructuredTypeDeclaration | tree.PackageVariantTypeDeclaration;
 export type StructuredTypeDeclaration = tree.PackageStructuredTypeDeclaration | tree.AnonymousStructuredTypeDeclaration;

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

@@ -37,6 +37,7 @@ declare class Meaning_ownConstructorAccess {
     readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "own-constructor-access";
     get singleSuitableConstructor(): types.Constructor | undefined;
+    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.

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

@@ -0,0 +1,9 @@
+import { DiagnosticAcceptorWithArgumentFactory } from '../diagnostic/Diagnostic.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    static resolveByCallExpression(analyzer: Analyzer, candidates: readonly types.Operator[], node: tree.CallExpression, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined): readonly types.Operator[];
+    static resolveByTargetType(analyzer: Analyzer, candidates: readonly types.Operator[], targetType: types.Type | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodeForDiagnostic: tree.Node | undefined): readonly types.Operator[];
+    private static reportAmbiguousAccessDiagnostic;
+}

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

@@ -1,12 +1,98 @@
-import { Analyzer } from '../analysis/index.js';
+import { Analyzer, InferenceOptions } from '../analysis/index.js';
+import { Displayable, Name } from '../common/index.js';
+import { DiagnosticAcceptorWithArgumentFactory, DiagnosticLocation } 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 * as matcher from './ArgumentsToParametersMatcher.js';
-export declare class OverloadResolver<TSignature extends matcher.ISignature<TParameter>, TParameter extends matcher.ISignatureParameter, TArgument extends matcher.IArgument> {
+import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.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;
-    constructor(_analyzer: Analyzer, _signatures: readonly TSignature[], _arguments: readonly TArgument[]);
-    resolveOverload(): TSignature[];
+    private readonly _inferenceOptions;
+    private readonly _dataForTypeArgumentInference;
+    private readonly _diagnostics;
+    private readonly _nodesForDiagnostic;
+    constructor(_analyzer: Analyzer, _mode: ResolutionMode, _signatures: readonly TSignature[], _arguments: readonly TArgument[], _inferenceOptions: InferenceOptions, _dataForTypeArgumentInference: DataForTypeArgumentInference | undefined, _diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, _nodesForDiagnostic: NodesForDiagnostic | undefined);
+    resolveOverload(): ProcessedSignature<TSignature, TParameter, TArgument>[];
+    private areArgumentTypesAssignableToParameterTypes;
     private tryChooseBestSignature;
     private chooseBetterTargetType;
-    private getDistanceBetweenTypesInHierarchy;
+    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(): DiagnosticLocation | undefined;
+    getType(_inferenceOptions: InferenceOptions | undefined): types.Type;
+}
+interface IArgument {
+    getType(inferenceOptions: InferenceOptions | 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(): DiagnosticLocation;
+    getType(inferenceOptions: InferenceOptions | 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(): DiagnosticLocation;
+    getType(inferenceOptions: InferenceOptions | 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 NodesForDiagnostic {
+    readonly accessNode: tree.Node | undefined;
+    readonly typeArgumentClause: tree.Node | undefined;
+    readonly argumentList: tree.Node | 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 {};