@artel/artc 0.6.25254 → 0.6.25255

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

@@ -1,34 +1,40 @@
 import { Name } from '../common/index.js';
-import { FunctionEntity, ParameterVariableEntity, TypeParameterEntity } from '../entities/index.js';
+import { FunctionEntity, MethodEntity, PackageOrNestedFunctionEntity, ParameterVariableEntity, TypeParameterEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { SubstitutedFunction } from './SubstitutedFunction.js';
 export type AccessedFunction = AccessedFunction_entity | AccessedFunction_typeMember | AccessedFunction_substitutedFunction;
+export type NotSubstitutedAccessedFunction = AccessedFunction_entity | AccessedFunction_typeMember;
 export declare class AccessedFunction_entity implements IAccessedFunction {
-    readonly value: FunctionEntity;
+    readonly value: PackageOrNestedFunctionEntity;
     readonly kind = "entity";
-    constructor(value: FunctionEntity);
+    get debuggerDisplay(): string;
+    constructor(value: PackageOrNestedFunctionEntity);
     getTypeParameters(): readonly TypeParameterEntity[];
     getValueParameters(): readonly AccessedFunctionValueParameter[];
     getReturnType(): types.Type;
-    getEntity(): FunctionEntity;
+    getEntity(): PackageOrNestedFunctionEntity;
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
+    applySubstitutions(analyzer: Analyzer, map: types.Substitutions): AccessedFunction;
 }
 export declare class AccessedFunction_typeMember implements IAccessedFunction {
     readonly value: types.Method;
     readonly kind = "type-member";
+    get debuggerDisplay(): string;
     constructor(value: types.Method);
     getTypeParameters(): readonly TypeParameterEntity[];
     getValueParameters(): readonly AccessedFunctionValueParameter[];
     getReturnType(): types.Type;
-    getEntity(): FunctionEntity;
+    getEntity(): MethodEntity;
     getName(): Name;
     getSignatureType(_analyzer: Analyzer): types.FunctionType;
+    applySubstitutions(_analyzer: Analyzer, substitutions: types.Substitutions): AccessedFunction;
 }
 export declare class AccessedFunction_substitutedFunction implements IAccessedFunction {
     readonly value: SubstitutedFunction;
     readonly kind = "substituted-function";
+    get debuggerDisplay(): string;
     constructor(value: SubstitutedFunction);
     getTypeParameters(): readonly TypeParameterEntity[];
     getValueParameters(): readonly AccessedFunctionValueParameter[];

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

@@ -22,6 +22,7 @@ export declare class AnalyzedTranslationPackage {
     private readonly _constructorSignatureTranslations;
     private readonly _indexerSignatureTranslations;
     private readonly _translatedTypeHeaders;
+    private readonly _typeTranslationByEntity;
     constructor(_analyzer: Analyzer, _package: TranslationPackage, _targetTarget: PackageEntity);
     getTargetPackage(): PackageEntity;
     getPackageInTranslatedLanguage(): PackageEntity;
@@ -63,7 +64,7 @@ export declare class AnalyzedTranslationPackage {
     private createTranslatedSubprogramSignatureForDefaultConstructor;
     private createTranslatedTypeSignature;
     private enumerateTranslationsDeclarations;
-    private findTypeTranslation;
+    private getTypeEntityTranslationNode;
 }
 export declare class TranslatedPackageMembers {
     private readonly _namedMembers;

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

@@ -19,26 +19,22 @@ import { ArgumentToParameterMatchResult, MatchResultValueParameter } from './Arg
 import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
-import * as constructorOverloadResolver from './ConstructorOverloadResolver.js';
 import { DeclarationsUsageMap } from './DeclarationsUsageCounter.js';
 import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
 import { DiagnosticArgumentFactory } from './DiagnosticArgumentFactory.js';
-import * as functionOverloadResolver from './FunctionOverloadResolver.js';
 import * as identifierExpressionResolution from './IdentifierExpressionMeaning.js';
 import { ImportedPackageNameTree, PackageNameTreeNode } from './ImportedPackageNameTree.js';
 import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
 import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
 import { ModifierFlags } from './ModifierFlags.js';
 import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
-import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
+import { DereferencedVariableAccessorDeclaration, FieldAccessorDeclaration, FunctionDeclaration, FunctionTypeDeclaration, GetterDeclaration, IndexedElementAccessorDeclaration, PackageVariableAccessorDeclaration, RegularOrBlockFunctionLiteral, SetterDeclaration, StructuredTypeDeclaration, TypeDeclaration, TypeWithMembersDeclaration, VariantTypeDeclaration } from './NodeTypeUtils.js';
 import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
 import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
 import { SourceFileMembers as ActualSourceFileMembers } from './SourceFileMembers.js';
 import * as tagMeaning from './TagMeaning.js';
 import * as tags from './Tags.js';
-import { TargetTypeHint } from './TargetTypeHint.js';
 import { TypeMemberImplementationCheckResult } from './TypeMemberImplementationChecker.js';
-import * as typeOverloadResolver from './TypeOverloadResolver.js';
 import * as controlFlow from './control-flow/index.js';
 import { WellKnownDeclarations } from './index.js';
 import * as semanticContext from './semantic-context/index.js';
@@ -72,20 +68,24 @@ export declare class Analyzer {
     readonly owningPlainObjectModificationCheck: OwningPlainObjectModificationCheck;
     readonly packageImports: PackageImports;
     readonly typeUtils: TypeUtils;
+    readonly signatureComparer: SignatureComparer;
     readonly conflictsCheck: ConflictsCheck;
+    readonly typeAssignabilityCheck: TypeAssignabilityCheck;
     private readonly _tsInteropInputs;
     private readonly _targetType;
-    private readonly _typeAssignabilityCheck;
     private readonly _tsInterop;
     private readonly _memberAccessExpressionResolutionResults;
+    private readonly _memberAccessExpressionResolutionResultsFirstStage;
     private readonly _sourceFileMembers;
-    private readonly _callExpressionMeanings;
+    private readonly _callExpressionResolutionResults;
     private readonly _indexedAccessExpressionResolutionResults;
     private readonly _dereferenceExpressionMeanings;
-    private readonly _autotypeCallExpressionMeanings;
+    private readonly _autotypeCallExpressionResolutionResults;
     private readonly _identifierExpressionResolutionResults;
+    private readonly _identifierExpressionResolutionResultsFirstStage;
     private readonly _tagResolutionResults;
     private readonly _objectExpressionResolutionResults;
+    private readonly _baseExpressionResolutionResultsFirstStage;
     private readonly _baseExpressionResolutionResults;
     private readonly _namedTypeSpecifierResolutionResults;
     private readonly _prefixUnaryExpressionOperatorResolutionResults;
@@ -96,7 +96,7 @@ export declare class Analyzer {
     private readonly _extendedTypes;
     private readonly _analyzedTranslationPackages;
     private readonly _linkedMultiPlatformPackagesByPlatform;
-    private readonly _functionBlockWithYieldStatementCheckResults;
+    private readonly _isFunctionGeneratorCheckResults;
     private readonly _namedDeclarationsUsageCountResults;
     private readonly _packageAndStaticVariablesInitializationDiagnostics;
     private readonly _controlFlowGraphs;
@@ -118,6 +118,7 @@ export declare class Analyzer {
     isEnumeratorMethodSignature(entity: e.MethodEntity): boolean;
     ifTypeEnumerableThenItemType(type: types.Type): types.Type | undefined;
     ifTypeEnumeratorThenItemType(type: types.Type): types.Type | undefined;
+    ifTypeEnumerableOrEnumeratorThenItemType(type: types.Type): types.Type | undefined;
     isTypeArrayOrReadonlyArray(type: types.Type): {
         elementType: types.Type;
     } | undefined;
@@ -129,27 +130,25 @@ export declare class Analyzer {
     checkBlockInvokesAsyncMethods(node: tree.StatementBlock | tree.FunctionBlock): boolean;
     getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
     getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): e.TypeMemberEntityContainer;
-    getTargetTypeOfExpression(node: tree.Expression, hint?: TargetTypeHint): types.Type | undefined;
+    getTargetTypeOfExpression(node: tree.Expression, inferenceOptions?: InferenceOptions): types.Type | undefined;
     getUnambiguousTargetFunctionType(targetType: types.Type | undefined): types.FunctionType | undefined;
     getUnambiguousTargetArrayType(targetType: types.Type | undefined): types.Type | undefined;
     getEnumeratorElementType(node: tree.Node): types.Type | undefined;
-    resolveFunctionOverloadByCallExpression<TCandidate extends functionOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends functionOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], node: tree.CallExpression): readonly TCandidate[];
-    resolveFunctionOverloadByTargetType<TCandidate extends functionOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends functionOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], targetType: types.FunctionType): readonly TCandidate[];
-    resolveConstructorOverload<TCandidate extends constructorOverloadResolver.ICandidate<TValueParameter>, TValueParameter extends constructorOverloadResolver.IValueParameter>(candidates: readonly TCandidate[], args: readonly tree.Argument[]): readonly TCandidate[];
-    resolveTypeOverloadByArgumentCount<TCandidate extends typeOverloadResolver.ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
-    resolveMemberAccessExpression(node: tree.MemberAccessExpression, targetTypeHint?: TargetTypeHint): memberAccessExpressionResolution.ResolutionResult;
+    resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.FirstStageResolutionResult;
+    resolveMemberAccessExpression(node: tree.MemberAccessExpression, inferenceOptions?: InferenceOptions): memberAccessExpressionResolution.ResolutionResult;
     enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
     getSourceFileMembers(node: tree.SourceFile): ActualSourceFileMembers;
-    getCallExpressionMeaning(node: tree.CallExpression): callExpressionMeaning.Meaning;
-    getCallExpressionType(node: tree.CallExpression): types.Type;
+    resolveCallExpression(node: tree.CallExpression, inferenceOptions?: InferenceOptions): callExpressionMeaning.ResolutionResult;
     getRespectiveParameter(node: tree.Argument): MatchResultValueParameter | undefined;
     resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.ResolutionResult;
     getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
-    getAutotypeCallExpressionMeaning(node: tree.AutotypeCallExpression, targetTypeHint?: TargetTypeHint): autotypeCallExpressionMeaning.Meaning;
-    resolveIdentifierExpression(node: tree.IdentifierExpression, targetTypeHint?: TargetTypeHint): identifierExpressionResolution.ResolutionResult;
+    resolveAutotypeCallExpression(node: tree.AutotypeCallExpression, inferenceOptions?: InferenceOptions): autotypeCallExpressionMeaning.ResolutionResult;
+    resolveIdentifierExpressionFirstStage(node: tree.IdentifierExpression): identifierExpressionResolution.FirstStageResolutionResult;
+    resolveIdentifierExpression(node: tree.IdentifierExpression, inferenceOptions?: InferenceOptions): identifierExpressionResolution.ResolutionResult;
     resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
     resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.ResolutionResult;
-    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.ResolutionsResult;
+    resolveBaseExpressionFirstStage(node: tree.BaseExpression): baseExpressionMeaning.FirstStageResolutionsResult;
+    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.ResolutionResult;
     /**
      * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
      * `пусто`.
@@ -199,7 +198,14 @@ export declare class Analyzer {
     checkExpressionDenotesPackageNameSegment(expression: tree.Expression): {
         packageTreeNode: PackageNameTreeNode;
     } | undefined;
-    checkFunctionBlockWithYieldStatement(node: tree.FunctionBlock): boolean;
+    /**
+     * Функция считается генератором, если:
+     * - Использует команду `выдать`.
+     * - Не использует команду `выдать`, но её возвращаемым типом является `Перебираемый` или `Перебор`, она не
+     *   возвращает значение и не использует переменную `результат` (использование команды `вернуть` без указания
+     *   возвращаемого значения допустимо). В таком случае это генератор, не возвращающий ни одного элемента.
+     */
+    isFunctionGenerator(node: FunctionDeclaration): boolean;
     enumerateAspects(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
     resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<types.Operator>;
@@ -293,7 +299,7 @@ export declare class Analyzer {
         basicMethodOfOriginalType: e.MethodEntity;
     } | undefined;
     getControlFlowGraph(sourceFile: project.SourceFile): controlFlow.GraphBuildResult;
-    createAmbiguousEntityAccessDiagnostic(entities: readonly e.Entity[], node: tree.Node): Diagnostic;
+    createAmbiguousEntityAccessDiagnostic(entities: readonly e.Entity[], node: tree.Node, diagnosticArgumentFactory?: DiagnosticArgumentFactory): Diagnostic;
     createAmbiguousFunctionAccessDiagnostic(functions: readonly AccessedFunction[], node: tree.Node): Diagnostic;
     createAmbiguousTypeMemberAccessDiagnostic(members: readonly types.TypeMember[], node: tree.Node): Diagnostic;
     createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], node: tree.Node): Diagnostic;
@@ -313,6 +319,12 @@ export declare class Analyzer {
     isConstructorCallingOwnConstructor(node: tree.ConstructorDeclaration): boolean;
     createDiagnosticArgumentFactoryWithinPackage(entity: e.PackageEntity): DiagnosticArgumentFactory;
     createDiagnosticArgumentFactoryWithinEntityContext(context: e.EntityContext): DiagnosticArgumentFactory;
+    ifCalleeThenCallExpression(node: tree.Expression): tree.CallExpression | undefined;
+    getNodeForAmbiguousAccessDiagnostic(access: tree.Expression): tree.Node;
+    isPossibleWrappedTargetTypeDependentFunctionLiteral(node: tree.Expression): boolean;
+    isTargetTypeDependentFunctionLiteral(node: tree.Expression): node is RegularOrBlockFunctionLiteral;
+    checkTypeArgumentCount(typeArgumentCount: number, typeParameters: readonly e.TypeParameterEntity[], diagnostics?: DiagnosticAcceptor, nodeForDiagnostic?: tree.Node): boolean;
+    checkTypeCanBeUsedAsValue(typeAccess: tree.Expression): boolean;
     private createTsInterop;
 }
 export declare class TsInteropInputs {
@@ -348,14 +360,15 @@ declare class Type {
     private readonly _unionTypeSpecifierTypes;
     private readonly _intersectionTypeSpecifierTypes;
     private readonly _functionLiteralTypes;
-    private readonly _functionBlockLiteralTypes;
+    private readonly _nodesForWhichReturnTypeInferenceDiagnosticHasBeenReported;
     constructor(_analyzer: Analyzer);
-    ofExpression(node: tree.Expression, targetTypeHint?: TargetTypeHint): types.Type;
+    ofExpression(node: tree.Expression, inferenceOptions?: InferenceOptions): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
     ofAccessedFunction(accessedFunction: AccessedFunction): types.Type;
     ofAccessedOperator(operator: types.Operator): types.Type;
-    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral, targetTypeHint?: TargetTypeHint): types.FunctionType;
-    ofFunctionLiteral(node: tree.FunctionLiteral, targetTypeHint?: TargetTypeHint): types.FunctionType;
+    ofRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral, inferenceOptions?: InferenceOptions): types.FunctionType;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral, inferenceOptions?: InferenceOptions): types.FunctionType;
+    ofFunctionLiteral(node: tree.FunctionLiteral, inferenceOptions?: InferenceOptions): types.FunctionType;
     private ofArrayLiteral;
     private ofAssertionExpression;
     private ofAssumptionExpression;
@@ -396,9 +409,11 @@ declare class Type {
     private ofUnionTypeSpecifier;
     private ofIntersectionTypeSpecifier;
     private ofInvalidTypeSpecifier;
-    private getTargetlessFunctionBlockLiteralType;
-    private inferFunctionLiteralTypeFromNodeWithFallbackToTargetType;
-    private inferFunctionLiteralTypeFromNode;
+    private createFunctionLiteralType;
+    private createFunctionBlockLiteralType;
+    private inferAndCacheReturnTypeOfRegularOrBlockFunctionLiteral;
+    private replaceReturnTypeOfFunctionType;
+    private reportReturnTypeCanNotBeInferredDiagnostic;
     private getNarrowedTypeIfNarrowableReference;
 }
 declare class ReturnType {
@@ -416,6 +431,7 @@ declare class ReturnType {
     ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): types.Type;
     ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): types.Type;
     ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): types.Type;
+    ofFunctionDeclaration(node: FunctionDeclaration): types.Type;
 }
 declare class Entity {
     private readonly _analyzer;
@@ -492,18 +508,12 @@ declare class Entity {
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
     ofTypeWithMembersDeclaration(node: TypeWithMembersDeclaration): e.TypeEntityWithMembers;
     ofTranslationTextTemplateParameter(node: tree.TranslationTextTemplateParameter): e.TranslationTextTemplateParameterEntity;
-    ofTextLiteral(node: tree.TextLiteral): e.LocalizableSimpleTextEntity;
-    ofTextTemplateLiteral(node: tree.TextTemplateLiteral): e.LocalizableTextTemplateEntity;
-    private ensureLocalizableTextEntitiesCreated;
     private getContainingPackageLoadedFromDts;
     private createComputedFieldEntities;
     private createDereferenceOperatorEntities;
     private createIndexerEntities;
     private areIndexedElementAccessorDeclarationsEqual;
 }
-type EntityClassMembers = Entity[keyof Entity];
-type GetNodesFromMethodsParameter<T> = T extends (node: infer TNode) => e.Entity ? (TNode extends tree.Node ? TNode : never) : never;
-export type NodeCorrespondingToEntity = GetNodesFromMethodsParameter<EntityClassMembers>;
 declare class ResultLocalVariableEntity {
     private readonly _analyzer;
     private readonly _entities;
@@ -518,6 +528,7 @@ declare class ResultLocalVariableEntity {
     ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.LocalVariableEntity;
     ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.LocalVariableEntity;
     ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): e.LocalVariableEntity;
+    ofFunctionDeclaration(node: FunctionDeclaration): e.LocalVariableEntity;
     private createResultLocalVariableEntity;
 }
 declare class ValueLocalVariableEntity {
@@ -528,6 +539,7 @@ declare class ValueLocalVariableEntity {
     ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.LocalVariableEntity;
     ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.LocalVariableEntity;
     ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
+    private createValueLocalVariableEntity;
 }
 declare class OverriddenMember {
     private readonly _analyzer;
@@ -662,6 +674,32 @@ declare class OwningPlainObjectModificationCheck {
     private checkReceiverModifiesPlainObjectRecursively;
     private nodeBelongsToPlainObjectDeclaration;
 }
+declare class TypeAssignabilityCheck {
+    private readonly _analyzer;
+    constructor(_analyzer: Analyzer);
+    isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
+    getAssignabilityFlags(source: types.Type, target: types.Type): TypeAssignabilityFlags;
+    /**
+     * Определяет, насколько данный вид совместимости типов более предпочтителен при определении совместимости союзного
+     * тип с другим, а также при определении наиболее подходящей перегрузки. Чем выше счёт - тем вид более предпочтителен.
+     */
+    getSingleFlagScore(flag: TypeAssignabilityFlags): number;
+    getLowestFlagsScore(flags: TypeAssignabilityFlags): number;
+    private getAssignabilityFlagsForStructuredTypes;
+    /**
+     * @example
+     * ```artel
+     * пусть а = операция(п: Текст): Объект { }
+     * пусть б = операция(п: Объект): Текст { }
+     *
+     * а = б // Корректно
+     * б = а // Ошибка
+     * ```
+     */
+    private getAssignabilityFlagsForFunctionTypes;
+    private areNewFlagsBetter;
+    private getFlagCount;
+}
 export declare enum TypeAssignabilityFlags {
     None = 0,
     /**
@@ -712,7 +750,10 @@ declare class TypeUtils {
     removeDerivedTypesInPlace(types: types.Type[]): void;
     getBaseOrAliasedTypes(type: types.Type): readonly types.Type[];
     getPossiblyAliasedBaseObjectType(type: types.Type): types.Type | undefined;
+    getPossiblyAliasedBaseAspectTypes(type: types.Type): readonly types.Type[] | undefined;
+    getBaseObjectTypeOrAliasedType(type: types.Type): types.Type | undefined;
     getBaseAndAliasedTypesRecursively(type: types.Type): readonly types.Type[];
+    isTypeDerivedFromOrEqualsTo(source: types.Type, target: types.Type, considerTypeArguments?: boolean): boolean;
     private collectBaseAndAliasedTypesRecursively;
     private getBaseTypesForCommonTypesSearch;
     private addTypeAndCollectAllBaseTypes;
@@ -720,10 +761,37 @@ declare class TypeUtils {
     private getFlattenedConstituentTypesForCommonTypesSearch;
     private flattenTypeParameterConstraint;
 }
-declare class ConflictsCheck {
+declare class SignatureComparer {
     private readonly _analyzer;
     private _stubParameterTypes;
     constructor(_analyzer: Analyzer);
+    areEqualFunctionEntities(function1: e.FunctionEntity, function2: e.FunctionEntity, options: SignatureComparisonOptions): boolean;
+    /**
+     * Метод аналогичен методу {@link areEqualFunctionEntities}.
+     */
+    areEqualMethods(method1: types.Method, method2: types.Method, options: SignatureComparisonOptions): boolean;
+    /**
+     * Проверяет, конфликтуют две сущности, имеющие параметры, но не имеющие параметры типа.
+     *
+     * Отношение "сущности, имеющие только параметры, конфликтуют" является транзитивным.
+     */
+    areEqualSignaturesWithoutTypeParameters(entity1: EntityWithoutTypeParametersInSignature, entity2: EntityWithoutTypeParametersInSignature): boolean;
+    areEqualTypeMemberSignaturesWithoutTypeParameters(member1: TypeMemberWithoutTypeParametersInSignature, member2: TypeMemberWithoutTypeParametersInSignature): boolean;
+    doTypeParameterCountsIntersect(typeParameters1: readonly e.TypeParameterEntity[], typeParameters2: readonly e.TypeParameterEntity[]): boolean;
+    private areEqualParameters;
+    private areEqualTypeMemberParameters;
+    private createSubstitutionsWithStubTypes;
+}
+export declare enum SignatureComparisonOptions {
+    None = 0,
+    CompareNames = 1,
+    CompareReturnTypes = 2,
+    CheckTypeParameterCountIntersection = 4
+}
+declare class ConflictsCheck {
+    private readonly _analyzer;
+    private static readonly _signatureComparisonOptions;
+    constructor(_analyzer: Analyzer);
     /**
      * Проверяет, конфликтуют ли две функции, т.е. могут ли такие функции находиться в одной области видимости.
      * Метод не сравнивает имена.
@@ -760,10 +828,6 @@ declare class ConflictsCheck {
      * {@link doFunctionSignaturesConflict}).
      */
     doPackageTypesConflict(type1: e.PackageTypeEntity, type2: e.PackageTypeEntity): boolean;
-    doTypeArgumentCountsIntersect(typeParameters1: readonly e.TypeParameterEntity[], typeParameters2: readonly e.TypeParameterEntity[]): boolean;
-    private doParametersConflict;
-    private doTypeMemberParametersConflict;
-    private createSubstitutionMapWithStubTypes;
 }
 export type EntityWithoutTypeParametersInSignature = e.ConstructorEntity | e.DestructorEntity | e.OperatorEntity | e.IndexerEntity;
 export type TypeMemberWithoutTypeParametersInSignature = types.Constructor | types.Destructor | types.Operator | types.Indexer;
@@ -771,6 +835,7 @@ export declare class ExpressionDenotesFunctionCheckResult {
     readonly candidates: readonly AccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
     get singleSuitableFunction(): AccessedFunction | undefined;
+    get singleFunction(): AccessedFunction | undefined;
     constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
 }
 export declare class ExpressionDenotesOperatorCheckResult {
@@ -790,4 +855,15 @@ export declare class DeclaredTypeMemberEntities {
     get namedMembers(): e.NamedTypeMemberEntity[];
     constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], operators: readonly e.OperatorEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.SourceIndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
 }
+export declare class InferenceOptions {
+    readonly targetType: types.Type | undefined;
+    readonly allowCaching: boolean;
+    readonly allowReportingDiagnostics: boolean;
+    constructor(targetType: types.Type | undefined, allowCaching: boolean, allowReportingDiagnostics: boolean);
+    static withTargetType(options: InferenceOptions | undefined, targetType: types.Type | undefined): InferenceOptions;
+    withTargetType(targetType: types.Type | undefined): InferenceOptions;
+    withAllowCaching(allowCaching: boolean): InferenceOptions;
+    withAllowReportingDiagnostics(allowReportingDiagnostics: boolean): InferenceOptions;
+    withTargetTypeAndAllowCaching(targetType: types.Type | undefined, allowCaching: boolean): InferenceOptions;
+}
 export {};

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

@@ -1,4 +1,3 @@
-import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { ParameterVariableEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
@@ -16,9 +15,7 @@ export declare class ArgumentToParameterMatchResult {
 }
 export declare class MatchResult {
     readonly parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>;
-    readonly unmatchedParameters: readonly MatchResultValueParameter[];
-    readonly diagnostics: readonly Diagnostic[];
-    constructor(parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>, unmatchedParameters: readonly MatchResultValueParameter[], diagnostics: readonly Diagnostic[]);
+    constructor(parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>);
 }
 export declare class MatchResultValueParameter {
     readonly entity: ParameterVariableEntity;

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

@@ -1,44 +1,38 @@
 import { Name } from '../common/index.js';
-import { Diagnostic, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
+import { DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
 export declare class ArgumentToParameterMatcher<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends IArgument> {
     private readonly _analyzer;
     private readonly _signature;
     private readonly _arguments;
-    constructor(_analyzer: Analyzer, _signature: TSignature, _arguments: readonly TArgument[]);
+    private readonly _diagnostics;
+    private readonly _nodeForUnmatchedRequiredParametersDiagnostic;
+    constructor(_analyzer: Analyzer, _signature: TSignature, _arguments: readonly TArgument[], _diagnostics: DiagnosticAcceptor | undefined, _nodeForUnmatchedRequiredParametersDiagnostic: tree.Node | undefined);
     match(): MatchResult<TParameter, TArgument>;
     private matchArgumentsToParameters;
-    private addArgumentDiagnostic;
-    private getArgumentType;
+    private reportArgumentDiagnostic;
 }
 export declare class MatchResult<TParameter extends ISignatureParameter, TArgument extends IArgument> {
     readonly mapping: ReadonlyMap<TArgument, TParameter>;
-    readonly unmatchedRequiredParameters: readonly TParameter[];
-    readonly argumentArrangementDiagnostics: readonly Diagnostic[];
-    readonly hasTypeAssignabilityErrors: boolean;
-    get isMatching(): boolean;
-    constructor(mapping: ReadonlyMap<TArgument, TParameter>, unmatchedRequiredParameters: readonly TParameter[], argumentArrangementDiagnostics: readonly Diagnostic[], hasTypeAssignabilityErrors: boolean);
+    readonly isMatching: boolean;
+    constructor(mapping: ReadonlyMap<TArgument, TParameter>, isMatching: boolean);
 }
 export interface ISignature<TParameter extends ISignatureParameter> {
     getParameters(): readonly TParameter[];
 }
 export interface ISignatureParameter {
     getName(): Name | undefined;
-    getType(): types.Type;
     isOptional(): boolean;
 }
 export interface IArgument {
-    getExpression(): tree.Expression;
-    getName(): Name | undefined;
+    readonly name: Name | undefined;
     getDiagnosticLocation(): DiagnosticLocation | undefined;
 }
 export declare class SourceArgument implements IArgument {
     private readonly _analyzer;
     readonly node: tree.Argument;
+    readonly name: Name | undefined;
     constructor(_analyzer: Analyzer, node: tree.Argument);
-    getExpression(): tree.Expression;
-    getName(): Name | undefined;
     getDiagnosticLocation(): DiagnosticLocation;
 }

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

@@ -1,13 +1,19 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import { AutotypeCallExpression } from '../tree/index.js';
 import * as types from '../types/index.js';
-import { Analyzer, TargetTypeHint } from './index.js';
+import { Analyzer, InferenceOptions } from './index.js';
 export declare class Resolver {
     private readonly _analyzer;
     readonly _node: AutotypeCallExpression;
-    readonly _targetTypeHint: TargetTypeHint | undefined;
-    constructor(_analyzer: Analyzer, _node: AutotypeCallExpression, _targetTypeHint: TargetTypeHint | undefined);
-    resolve(): Meaning;
+    readonly _inferenceOptions: InferenceOptions | undefined;
+    constructor(_analyzer: Analyzer, _node: AutotypeCallExpression, _inferenceOptions: InferenceOptions | undefined);
+    resolve(): ResolutionResult;
+}
+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_constructorCall | Meaning_unresolved;
 declare class Meaning_constructorCall {
@@ -22,6 +28,8 @@ declare class Meaning_constructorCall {
     readonly candidates: readonly types.Constructor[];
     readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "constructor-call";
+    get singleSuitableConstructor(): types.Constructor | undefined;
+    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -33,8 +41,6 @@ declare class Meaning_constructorCall {
     type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_unresolved {
-    readonly diagnostics: readonly Diagnostic[];
     readonly kind = "unresolved";
-    constructor(diagnostics: readonly Diagnostic[]);
 }
 export {};

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

@@ -1,21 +1,13 @@
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
+import { AccessedFunction } from './AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
-/**
- * "основа" не является самостоятельным выражением и может использоваться только в следующих конструкциях:
- * 1. `основа()` - в конструкторе для вызова базового конструктора или в методе для вызова базового метода.
- * 2. `основа.поле` (`основа.метод`) - в любом выражении в контексте типа, имеющего базовый тип.
- * 3. `основа[]` - аналогично п. 2.
- * 4. `основа^` - аналогично п. 2.
- * 5. `(основа как БазовыйАспект).поле`, `(основа как БазовыйАспект)[]`, `(основа как БазовыйАспект)^` - для доступа к
- *    реализации по умолчанию члена базового аспекта.
- */
-export declare class Resolver {
+export declare class FirstStageResolver {
     private readonly _analyzer;
     private readonly _node;
     constructor(analyzer: Analyzer, node: tree.BaseExpression);
-    resolve(): ResolutionsResult;
+    resolve(): FirstStageResolutionsResult;
     private resolveBaseConstructorOrMethodAccess;
     private resolveBaseConstructorAccess;
     private resolveBaseMethodAccess;
@@ -25,11 +17,29 @@ export declare class Resolver {
     private getBaseOrAliasedType;
     private getContainingTypeMemberDeclaration;
 }
-export declare class ResolutionsResult {
+/**
+ * "основа" не является самостоятельным выражением и может использоваться только в следующих конструкциях:
+ * 1. `основа()` - в конструкторе для вызова базового конструктора или в методе для вызова базового метода.
+ * 2. `основа.поле` (`основа.метод`) - в любом выражении в контексте типа, имеющего базовый тип.
+ * 3. `основа[]` - аналогично п. 2.
+ * 4. `основа^` - аналогично п. 2.
+ * 5. `(основа как БазовыйАспект).поле`, `(основа как БазовыйАспект)[]`, `(основа как БазовыйАспект)^` - для доступа к
+ *    реализации по умолчанию члена базового аспекта.
+ */
+export declare class SecondStageResolver {
+    private readonly _analyzer;
+    private readonly _node;
+    private readonly _firstStageResolutionResult;
+    constructor(analyzer: Analyzer, node: tree.BaseExpression, firstStageResolutionResult: FirstStageResolutionsResult);
+    resolve(): ResolutionResult;
+    private resolveOverriddenMethodAccess;
+    private resolveOverriddenOperatorAccess;
+}
+export declare class ResolutionResult {
     readonly meaning: Meaning;
     readonly diagnostics?: readonly Diagnostic[] | undefined;
     constructor(meaning: Meaning, diagnostics?: readonly Diagnostic[] | undefined);
-    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionsResult;
+    static unresolved(diagnostics?: readonly Diagnostic[]): ResolutionResult;
 }
 export type Meaning = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | Meaning_overriddenMethodAccess | Meaning_overriddenOperatorAccess | Meaning_unresolved;
 declare class Meaning_baseObjectAccess {
@@ -50,6 +60,7 @@ declare class Meaning_baseConstructorAccess {
     readonly suitableConstructors: readonly types.Constructor[];
     readonly kind = "base-constructor-access";
     get singleSuitableConstructor(): types.Constructor | undefined;
+    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -61,9 +72,9 @@ declare class Meaning_baseConstructorAccess {
     type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
 }
 declare class Meaning_overriddenMethodAccess {
-    readonly method: types.Method;
+    readonly method: AccessedFunction;
     readonly kind = "overridden-method-access";
-    constructor(method: types.Method);
+    constructor(method: AccessedFunction);
 }
 declare class Meaning_overriddenOperatorAccess {
     readonly operator: types.Operator;
@@ -73,4 +84,21 @@ declare class Meaning_overriddenOperatorAccess {
 declare class Meaning_unresolved {
     readonly kind = "unresolved";
 }
+export declare class FirstStageResolutionsResult {
+    readonly meaning: MeaningStage1;
+    readonly diagnostics?: readonly Diagnostic[] | undefined;
+    constructor(meaning: MeaningStage1, diagnostics?: readonly Diagnostic[] | undefined);
+    static unresolved(diagnostics?: readonly Diagnostic[]): FirstStageResolutionsResult;
+}
+export type MeaningStage1 = Meaning_baseObjectAccess | Meaning_baseConstructorAccess | MeaningStage1_overriddenMethodAccess | MeaningStage1_overriddenOperatorAccess | Meaning_unresolved;
+declare class MeaningStage1_overriddenMethodAccess {
+    readonly method: types.Method;
+    readonly kind = "overridden-method-access";
+    constructor(method: types.Method);
+}
+declare class MeaningStage1_overriddenOperatorAccess {
+    readonly operator: types.Operator;
+    readonly kind = "overridden-operator-access";
+    constructor(operator: types.Operator);
+}
 export {};