@artel/artc 0.6.25254 → 0.6.25256

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, ExpressionAnalysisOptions } 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 _analysisOptions;
+    constructor(analyzer: Analyzer, node: tree.MemberAccessExpression, firstStageResolutionResult: FirstStageResolutionResult, analysisOptions: ExpressionAnalysisOptions | 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, ExpressionAnalysisOptions } 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 _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: 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(_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(): DiagnosticLocation;
+    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(): DiagnosticLocation;
+    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 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 {};

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

@@ -0,0 +1,13 @@
+import { Analyzer } from './Analyzer.js';
+import * as tree from '../tree/index.js';
+import { LocalVariableEntity } from '../entities/VariableEntity.js';
+import * as types from '../types/index.js';
+export declare class ReturnTypeInferrer {
+    private readonly _analyzer;
+    private readonly _block;
+    private readonly _resultVariable;
+    constructor(_analyzer: Analyzer, _block: tree.FunctionBlock, _resultVariable: LocalVariableEntity);
+    infer(): types.Type;
+    private checkResultVariableIsUsedAndCollectReturnedTypes;
+    private getTypeOfResultVariableAtTheEndOfSubprogram;
+}

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

@@ -3,6 +3,8 @@ import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { PackageAliasEntity, PackageFunctionEntity, PackageTypeEntity, PackageVariableEntity, TypeExtensionEntity } from '../entities/index.js';
 import { Analyzer } from './Analyzer.js';
 export declare class SourceFileMembers {
+    private static readonly _emptyNamedMembers;
+    private static readonly _emptyPackageAliases;
     private readonly _analyzer;
     private readonly _namedMembers;
     private readonly _typeExtensions;

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

@@ -1,22 +1,24 @@
 import { Name } from '../common/index.js';
-import { FunctionEntity, ParameterVariableEntity } from '../entities/index.js';
+import { FunctionEntity, PackageOrNestedFunctionEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
+import { AccessedFunctionValueParameter } from './AccessedFunction.js';
+import { Analyzer } from './Analyzer.js';
 export type SubstitutedFunction = SubstitutedFunction_entity | SubstitutedFunction_typeMember;
 export declare class SubstitutedFunction_entity implements ISubstitutedFunction {
-    readonly entity: FunctionEntity;
-    readonly entitySignatureType: types.FunctionType;
+    readonly entity: PackageOrNestedFunctionEntity;
     readonly substitutions: types.Substitutions;
     readonly kind = "entity";
     private readonly _signatureType;
-    constructor(entity: FunctionEntity, entitySignatureType: types.FunctionType, substitutions: types.Substitutions);
-    getEntity(): FunctionEntity;
+    private readonly _valueParameters;
+    get debuggerDisplay(): string;
+    constructor(entity: PackageOrNestedFunctionEntity, substitutions: types.Substitutions);
+    getEntity(): PackageOrNestedFunctionEntity;
     getName(): Name;
-    getSignatureType(): types.FunctionType;
+    getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
-    getValueParameters(): readonly {
-        entity: ParameterVariableEntity;
-        type: types.Type;
-    }[];
+    getOuterSubstitutions(): types.Substitutions | undefined;
+    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getReturnType(): types.Type;
     isAsync(): boolean;
 }
 export declare class SubstitutedFunction_typeMember implements ISubstitutedFunction {
@@ -24,26 +26,26 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     readonly substitutions: types.Substitutions;
     readonly kind = "type-member";
     private readonly _signatureType;
+    private readonly _valueParameters;
+    get debuggerDisplay(): string;
     constructor(method: types.Method, substitutions: types.Substitutions);
     getEntity(): FunctionEntity;
     getName(): Name;
-    getSignatureType(): types.FunctionType;
+    getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
-    getValueParameters(): readonly {
-        entity: ParameterVariableEntity;
-        type: types.Type;
-    }[];
+    getOuterSubstitutions(): types.Substitutions | undefined;
+    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getReturnType(): types.Type;
     isAsync(): boolean;
 }
 interface ISubstitutedFunction {
     getEntity(): FunctionEntity;
     getName(): Name;
-    getSignatureType(): types.FunctionType;
+    getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
-    getValueParameters(): readonly {
-        entity: ParameterVariableEntity;
-        type: types.Type;
-    }[];
+    getOuterSubstitutions(): types.Substitutions | undefined;
+    getValueParameters(): readonly AccessedFunctionValueParameter[];
+    getReturnType(): types.Type;
     isAsync(): boolean;
 }
 export {};

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

@@ -1,8 +1,8 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
-import { FunctionEntity, NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
+import { NamedTypeEntity, PackageAliasEntity } from '../entities/index.js';
 import { Tag } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { AccessedFunction } from './AccessedFunction.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
 import { PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import { Analyzer } from './index.js';
 import { EntityOrPackageNameTreeNode } from './Utils.js';
@@ -15,34 +15,35 @@ export declare class Resolver {
     resolve(): ResolutionResult;
     private resolveNameInScope;
     private resolveNameInPackage;
-    private resolveTypeOverload;
     private resolveTagType;
     private resolveTagFunction;
-    private createAccessedFunction;
-    private resolveFunctionOverload;
 }
 export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly resolvedQualifiers: readonly ResolvedQualifier[];
-    readonly diagnostic?: Diagnostic | undefined;
-    readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined;
-    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostic?: Diagnostic | undefined, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[] | undefined);
+    readonly diagnostics?: readonly Diagnostic[];
+    readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[];
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], diagnostics?: (readonly Diagnostic[]) | Diagnostic, ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[]);
 }
 export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
 declare class Meaning_tagType {
     readonly type: types.Type;
     readonly candidates: readonly types.Constructor[];
     readonly suitableConstructors: readonly types.Constructor[];
+    readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
     readonly kind = "tag-type";
     get singleSuitableConstructor(): types.Constructor | undefined;
-    constructor(type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
+    get singleConstructor(): types.Constructor | undefined;
+    constructor(type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
 }
 declare class Meaning_tagFunction {
-    readonly candidates: readonly AccessedFunction[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     readonly kind = "tag-function";
     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_unresolved {
     readonly kind = "unresolved";
@@ -66,10 +67,10 @@ export declare class ResolvedQualifier_type {
     constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
 }
 export declare class ResolvedQualifier_function {
-    readonly candidates: readonly FunctionEntity[];
-    readonly suitableFunctions: readonly FunctionEntity[];
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableFunctions: readonly AccessedFunction[];
     readonly kind = "function";
-    get singleSuitableFunction(): FunctionEntity | undefined;
-    constructor(candidates: readonly FunctionEntity[], suitableFunctions: readonly FunctionEntity[]);
+    get singleSuitableFunction(): AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 export {};

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

@@ -0,0 +1,49 @@
+import { TypeParameterEntity } from '../entities/index.js';
+import * as tree from '../tree/index.js';
+import * as types from '../types/index.js';
+import { Analyzer, ExpressionAnalysisOptions } from './Analyzer.js';
+export type Argument = SourceArgument | IntrinsicArgument;
+export interface SourceArgument {
+    readonly kind: 'source';
+    readonly expression: tree.Expression;
+}
+export interface IntrinsicArgument {
+    readonly kind: 'intrinsic';
+    readonly type: types.Type;
+}
+export declare class ArgumentWithTargetParameterInfo {
+    readonly value: Argument;
+    readonly parameterType: types.Type;
+    constructor(value: Argument, parameterType: types.Type);
+}
+export declare class TypeArgumentInferrer {
+    private readonly _analyzer;
+    private readonly _typeParameters;
+    private readonly _arguments;
+    private readonly _analysisOptions;
+    private readonly _returnType;
+    private readonly _outerSubstitutions;
+    private readonly _inferenceStates;
+    /**
+     * Специальный экземпляр типа, который используется как признак того, что вывод аргументов типа не удался.
+     */
+    private readonly _unresolvedType;
+    private _inferenceHasFailed;
+    constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], args: readonly ArgumentWithTargetParameterInfo[], analysisOptions: ExpressionAnalysisOptions, returnType: types.Type | undefined, outerTypeSubstitutions: types.Substitutions | undefined);
+    infer(): readonly types.Type[] | undefined;
+    private inferFirstStage;
+    private inferSecondStage;
+    private inferFromTypes;
+    private inferToParameterType;
+    private inferToStructuredType;
+    private inferFromSubstitutions;
+    private inferToUnionType;
+    private inferFromFunctionTypes;
+    private createSubstitutions;
+    private inferFromTargetTypeDependentExpression;
+    private tryGetInferredType;
+    private tryFixTypeParametersContainedByTypesOfFunctionParameters;
+    private typeContainsTypeParameter;
+    private substitutionsContainTypeParameter;
+    private isDefinitelyTargetTypeDependentExpression;
+}

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

@@ -1,16 +1,18 @@
+import { PackageLocale } from '../common/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import * as controlFlow from './control-flow/index.js';
+import { NarrowableReference } from './control-flow/index.js';
 export declare class TypeNarrower {
     private readonly _analyzer;
-    private readonly _referenceExpression;
+    private readonly _reference;
     private readonly _initialType;
+    private readonly _locale;
     private readonly _controlFlowNode;
-    private _reference;
     private readonly _typeByNode;
     private readonly _isVariableAssignedInLoopCheckResults;
-    private get locale();
-    constructor(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node);
+    constructor(analyzer: Analyzer, reference: NarrowableReference, locale: PackageLocale, initialType: types.Type, controlFlowNode: controlFlow.Node);
+    static getTypeOfExpression(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node): types.Type;
     getType(): types.Type;
     private getTypeAtControlFlowNode;
     private getTypeAtCondition;

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

@@ -1,5 +1,7 @@
-export declare class Resolver<TCandidate extends ICandidate> {
-    resolveByArgumentCount(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
+import { NamedTypeEntity } from '../entities/index.js';
+export declare class Resolver {
+    static resolve<TCandidate extends ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
+    static resolveByNamedTypeEntities<T extends NamedTypeEntity>(candidates: readonly T[], argumentCount: number): readonly T[];
 }
 export interface ICandidate {
     getParameterCount(): number;

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

@@ -1,6 +1,6 @@
 import { WithDiagnostics } from '../common/index.js';
 import { BinaryOperatorKind } from '../entities/OperatorKind.js';
-import { Expression, Node } from '../tree/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
 /**
@@ -26,11 +26,7 @@ export declare class UserDefinableBinaryOperatorResolver {
     private readonly _right;
     private readonly _operatorKind;
     private readonly _operatorNodeForDiagnostic;
-    private readonly _leftType;
-    private readonly _rightType;
-    private get leftType();
-    private get rightType();
-    constructor(_analyzer: Analyzer, _left: Expression, _right: Expression, _operatorKind: BinaryOperatorKind, _operatorNodeForDiagnostic: Node);
+    constructor(_analyzer: Analyzer, _left: tree.Expression, _right: tree.Expression, _operatorKind: BinaryOperatorKind, _operatorNodeForDiagnostic: tree.Node);
     resolve(): WithDiagnostics<types.Operator>;
     private chooseSuitableOperators;
 }

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

@@ -1,5 +1,5 @@
 import { WithDiagnostics } from '../common/index.js';
-import { PrefixUnaryExpression } from '../tree/index.js';
+import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
 /**
@@ -17,6 +17,6 @@ export declare class UserDefinableUnaryOperatorResolver {
     private readonly _analyzer;
     private readonly _node;
     private get operatorKind();
-    constructor(_analyzer: Analyzer, _node: PrefixUnaryExpression);
+    constructor(_analyzer: Analyzer, _node: tree.PrefixUnaryExpression);
     resolve(): WithDiagnostics<types.Operator>;
 }

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

@@ -7,6 +7,8 @@ type TextToken = tree.Token<tree.TokenKind.TextLiteral> | tree.Token<tree.TokenK
 export declare function getUnescapedTextFromTextToken(token: TextToken): string;
 export declare function unwrapParenthesizedExpressions(expression: tree.Expression): tree.Expression;
 export declare function getParentSkippingParenthesizedExpressions(expression: tree.Expression): tree.ExpressionParent;
+export declare function getParentGenericSpecializationExpression(expression: tree.Expression): tree.GenericSpecializationExpression | undefined;
+export declare function getGenericSpecializationExpressionOfCallee(callee: tree.Expression): tree.GenericSpecializationExpression | undefined;
 export declare function unaliasType(type: types.Type): types.Type;
 export declare function unaliasType(type: types.Type | undefined): types.Type | undefined;
 export declare function getPackageContainingEntity(entity: Entity): PackageEntity;

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

@@ -2,6 +2,6 @@ import { Node, SourceFile } from '../tree/index.js';
 type ChildNodeVisitor = (syntaxNode: VisitedChildNode) => void;
 export type VisitedNode = Node;
 export type VisitedChildNode = Exclude<Node, SourceFile>;
-export declare function visitChildren(node: VisitedNode, visitChildCb: ChildNodeVisitor): void;
-export declare function visitChildrenRecursively(node: VisitedNode, visitChildCb: ChildNodeVisitor): void;
+export declare function visitChildren(node: VisitedNode, visitTokens: boolean, visitChildCb: ChildNodeVisitor): void;
+export declare function visitChildrenRecursively(node: VisitedNode, visitTokens: boolean, visitChildCb: ChildNodeVisitor): void;
 export {};

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

@@ -3,8 +3,6 @@ export * from './ArgumentsToParametersMatcher.js';
 export * from './DeclarationsUsageCounter.js';
 export * from './DiagnosticCollector.js';
 export * from './FindModifier.js';
-export * from './OverloadResolver.js';
 export * from './SourcePackageDependencyGraph.js';
-export * from './TargetTypeHint.js';
 export * from './Visitor.js';
 export * from './WellKnownDeclarations.js';