@artel/artc 0.6.25258 → 0.6.25260

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { CancellationToken, DisplayableOrPrimitive, Name, PackageLocale, Range, WithDiagnostics } from '../common/index.js';
+import { CancellationToken, DisplayableOrPrimitive, Name, PackageLocale, Query, Range, TypeWithMembersOrTypeExtensionDeclaration, WithDiagnostics } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
@@ -15,7 +15,7 @@ import * as types from '../types/index.js';
 import { TypeFactory } from '../types/index.js';
 import { AccessedFunction } from './AccessedFunction.js';
 import { AnalyzedTranslationPackage } from './AnalyzedTranslationPackage.js';
-import { ArgumentToParameterMatchResult, MatchResultValueParameter } from './ArgumentToParameterMatchResult.js';
+import { ArgumentToParameterMatchResult, MatchResultParameter } from './ArgumentToParameterMatchResult.js';
 import * as autotypeCallExpressionMeaning from './AutotypeCallExpressionMeaning.js';
 import * as baseExpressionMeaning from './BaseExpressionMeaning.js';
 import * as callExpressionMeaning from './CallExpressionMeaning.js';
@@ -71,75 +71,71 @@ export declare class Analyzer {
     readonly signatureComparer: SignatureComparer;
     readonly conflictsCheck: ConflictsCheck;
     readonly typeAssignabilityCheck: TypeAssignabilityCheck;
-    private readonly _tsInteropInputs;
-    private readonly _targetType;
-    private readonly _tsInterop;
-    private readonly _memberAccessExpressionResolutionResults;
-    private readonly _memberAccessExpressionResolutionResultsFirstStage;
-    private readonly _sourceFileMembers;
-    private readonly _callExpressionResolutionResults;
-    private readonly _indexedAccessExpressionResolutionResults;
-    private readonly _dereferenceExpressionMeanings;
-    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;
-    private readonly _binaryExpressionUserDefinableOperatorResolutionResults;
-    private readonly _assignmentStatementOperatorResolutionResults;
-    private readonly _valueParametersOfFunctionBlockLiterals;
-    private readonly _extendedTypes;
-    private readonly _analyzedTranslationPackages;
-    private readonly _linkedMultiPlatformPackagesByPlatform;
-    private readonly _isFunctionGeneratorCheckResults;
-    private readonly _namedDeclarationsUsageCountResults;
-    private readonly _packageAndStaticVariablesInitializationDiagnostics;
-    private readonly _controlFlowGraphs;
-    private readonly _diagnosticsComputedLazily;
-    private readonly _diagnosticsComputedLazilyAcceptor;
-    private readonly _sourcePackageMemberConflictsDiagnostics;
-    private readonly _notExplicitlyImplementedAbstractTypeMembers;
-    private readonly _typeMemberImplementationCheckResults;
-    private _originalPackageEntitiesByNameKey;
-    private _packageEntitiesByNameKey;
-    private readonly _localizedWellKnownDeclarations;
-    private readonly _localizedStandardTypes;
-    private readonly _ownAndBaseConstructorCallsCheckResults;
-    private readonly _expressionCanBeUsedInForLoopCheckResults;
-    private readonly _nameByIdentifierText;
+    private readonly tsInteropInputs;
+    private readonly targetType;
+    private readonly tsInterop_;
+    private readonly memberAccessExpressionResolutionResults;
+    private readonly memberAccessExpressionResolutionResultsFirstStage;
+    private readonly sourceFileMembers;
+    private readonly callExpressionResolutionResults;
+    private readonly indexedAccessExpressionResolutionResults;
+    private readonly dereferenceExpressionMeanings;
+    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;
+    private readonly binaryExpressionUserDefinableOperatorResolutionResults;
+    private readonly assignmentStatementOperatorResolutionResults;
+    private readonly parametersOfFunctionBlockLiterals;
+    private readonly extendedTypes;
+    private readonly analyzedTranslationPackages;
+    private readonly linkedMultiPlatformPackagesByPlatform;
+    private readonly isFunctionGeneratorCheckResults;
+    private readonly namedDeclarationsUsageCountResults;
+    private readonly packageAndStaticVariablesInitializationDiagnostics;
+    private readonly controlFlowGraphs;
+    private readonly diagnosticsComputedLazily;
+    private readonly diagnosticsComputedLazilyAcceptor;
+    private readonly sourcePackageMemberConflictsDiagnostics;
+    private readonly notExplicitlyImplementedAbstractTypeMembers;
+    private readonly typeMemberImplementationCheckResults;
+    private originalPackageEntitiesByNameKey;
+    private packageEntitiesByNameKey;
+    private readonly localizedWellKnownDeclarations;
+    private readonly localizedStandardTypes;
+    private readonly ownAndBaseConstructorCallsCheckResults;
+    private readonly expressionCanBeUsedInForLoopCheckResults;
+    private readonly nameByIdentifierText;
     get tsInterop(): TsInteropContext;
     constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
     getProjectSourceFile(node: tree.SourceFile): project.SourceFile;
     checkExpressionCanBeUsedInForLoop(node: tree.Expression): WithDiagnostics<ExpressionCanBeUsedInForLoopCheckResult>;
     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;
-    isTypeReference(type: types.Type): {
-        referencedType: types.Type;
-    } | undefined;
+    ifTypeEnumerableThenElementType(type: types.Type): types.Type | undefined;
+    ifTypeEnumeratorThenElementType(type: types.Type): types.Type | undefined;
+    ifTypeEnumerableOrEnumeratorThenElementType(type: types.Type): types.Type | undefined;
+    ifTypeArrayOrReadonlyArrayThenElementType(type: types.Type): types.Type | undefined;
+    ifTypeReferenceThenReferencedType(type: types.Type): types.Type | undefined;
     isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
     getTypeAssignabilityFlags(source: types.Type, target: types.Type): TypeAssignabilityFlags;
-    checkBlockInvokesAsyncMethods(node: tree.StatementBlock | tree.FunctionBlock): boolean;
+    checkBlockCallsAsyncMethods(node: tree.StatementBlock | tree.FunctionBlock): boolean;
     getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
-    getTypeMemberEntityContainer(node: tree.TypeMemberDeclaration): e.TypeMemberEntityContainer;
+    getEntityContainingTypeMemberDeclaration(node: tree.TypeMemberDeclaration): e.TypeWithMembersOrExtensionEntity;
     getTargetTypeOfExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): 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;
+    getUnambiguousTargetReferenceType(targetType: types.Type | undefined): types.Type | undefined;
     resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.FirstStageResolutionResult;
     resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.ResolutionResult;
     enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
     getSourceFileMembers(node: tree.SourceFile): ActualSourceFileMembers;
     resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.ResolutionResult;
-    getRespectiveParameter(node: tree.Argument): MatchResultValueParameter | undefined;
+    getRespectiveParameter(node: tree.Argument): MatchResultParameter | undefined;
     resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.ResolutionResult;
     getDereferenceExpressionMeaning(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
     resolveAutotypeCallExpression(node: tree.AutotypeCallExpression, analysisOptions?: ExpressionAnalysisOptions): autotypeCallExpressionMeaning.ResolutionResult;
@@ -187,17 +183,13 @@ export declare class Analyzer {
     getImplicitBaseTypeForVariantType(locale: PackageLocale): types.StructuredType;
     getImplicitBaseTypeForFunctionType(locale: PackageLocale): types.StructuredType;
     resolveNamedTypeSpecifier(node: tree.NamedTypeSpecifier): NamedTypeSpecifierResolutionResult;
-    checkExpressionDenotesType(expression: tree.Expression): {
-        type: types.Type | undefined;
-    } | undefined;
-    checkExpressionDenotesPackageAlias(expression: tree.Expression): {
-        packageAlias: e.PackageAliasEntity;
-    } | undefined;
-    checkExpressionDenotesFunction(expression: tree.Expression): ExpressionDenotesFunctionCheckResult | undefined;
-    checkExpressionDenotesOperator(expression: tree.Expression): ExpressionDenotesOperatorCheckResult | undefined;
-    checkExpressionDenotesPackageNameSegment(expression: tree.Expression): {
-        packageTreeNode: PackageNameTreeNode;
-    } | undefined;
+    getDenotedType(expression: tree.Expression): types.Type | undefined;
+    isExpressionDenotingType(expression: tree.Expression): boolean;
+    getDenotedPackageAlias(expression: tree.Expression): e.PackageAliasEntity | undefined;
+    getDenotedFunction(expression: tree.Expression): ExpressionDenotesFunctionCheckResult | undefined;
+    isExpressionDenotingFunction(expression: tree.Expression): boolean;
+    getDenotedOperator(expression: tree.Expression): ExpressionDenotesOperatorCheckResult | undefined;
+    getDenotedPackageNameTreeNode(expression: tree.Expression): PackageNameTreeNode | undefined;
     /**
      * Функция считается генератором, если:
      * - Использует команду `выдать`.
@@ -260,19 +252,19 @@ export declare class Analyzer {
      */
     isNullAssignableToType(type: types.Type): boolean;
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
-    isValueParameterVariadic(entity: e.VariableEntity): boolean;
+    isParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(locale: PackageLocale): types.Type;
-    getFunctionBlockLiteralValueParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterVariableEntity[];
+    getFunctionBlockLiteralParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
     findAnalyzedTranslationPackageForLocale(entity: e.PackageEntity, locale: PackageLocale): AnalyzedTranslationPackage | undefined;
     getLocalizedPackageWithLocale(originalPackageEntity: e.PackageEntity, locale: PackageLocale): e.PackageEntity | undefined;
-    enumerateAnalyzedTranslationPackages(): Iterable<AnalyzedTranslationPackage>;
+    enumerateAnalyzedTranslationPackages(): Query<AnalyzedTranslationPackage>;
     getLinkedMultiPlatformPackagesByPlatform(entity: e.PackageEntity): ReadonlyMap<PlatformKind, LinkedMultiPlatformPackage> | undefined;
     getLinkedMultiPlatformPackage(entity: e.PackageEntity, platform: PlatformKind): LinkedMultiPlatformPackage | undefined;
     createPackageMembers(pkg: SourcePackage): PackageEntityMembers;
-    instantiateType(entity: e.TypeEntity, typeArguments?: readonly types.Type[]): types.Type;
-    instantiateType(entity: e.TypeEntity, substitutions?: types.Substitutions): types.Type;
+    instantiateType(entity: e.TypeEntity, typeArguments: readonly types.Type[] | undefined): types.Type;
+    instantiateTypeWithSubstitutions(entity: e.TypeEntity, substitutions: types.Substitutions): types.Type;
     instantiateTypeByIdentitySubstitution(entity: e.TypeEntity): types.Type;
     instantiateTypeMemberByIdentitySubstitution(entity: e.FieldEntity): types.Field;
     instantiateTypeMemberByIdentitySubstitution(entity: e.MethodEntity): types.Method;
@@ -341,6 +333,27 @@ export type BinaryExpressionOperatorClassificationResult = {
 } | {
     kind: 'not-equals';
 };
+export declare namespace BinaryExpressionOperatorClassificationResult {
+    const multiply: BinaryExpressionOperatorClassificationResult;
+    const greaterThan: BinaryExpressionOperatorClassificationResult;
+    const greaterThanOrEqual: BinaryExpressionOperatorClassificationResult;
+    const lessThan: BinaryExpressionOperatorClassificationResult;
+    const lessThanOrEqual: BinaryExpressionOperatorClassificationResult;
+    const subtract: BinaryExpressionOperatorClassificationResult;
+    const add: BinaryExpressionOperatorClassificationResult;
+    const divide: BinaryExpressionOperatorClassificationResult;
+    const integerDivide: BinaryExpressionOperatorClassificationResult;
+    const modulo: BinaryExpressionOperatorClassificationResult;
+    const bitwiseAnd: BinaryExpressionOperatorClassificationResult;
+    const bitwiseOr: BinaryExpressionOperatorClassificationResult;
+    const bitwiseXor: BinaryExpressionOperatorClassificationResult;
+    const and: BinaryExpressionOperatorClassificationResult;
+    const or: BinaryExpressionOperatorClassificationResult;
+    const xor: BinaryExpressionOperatorClassificationResult;
+    const equals: BinaryExpressionOperatorClassificationResult;
+    const notEquals: BinaryExpressionOperatorClassificationResult;
+    const questionQuestion: BinaryExpressionOperatorClassificationResult;
+}
 export declare const enum SyntacticAccessKind {
     Get = 0,
     Set = 1,
@@ -353,12 +366,12 @@ export declare class ExpressionCanBeUsedInForLoopCheckResult {
     constructor(elementType: types.Type, ifTypeDoesNotImplementEnumerableThenEnumeratorMethod: types.Method | undefined);
 }
 declare class Type {
-    private readonly _analyzer;
-    private readonly _unionTypeSpecifierTypes;
-    private readonly _intersectionTypeSpecifierTypes;
-    private readonly _functionLiteralTypes;
-    private readonly _nodesForWhichReturnTypeInferenceDiagnosticHasBeenReported;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly unionTypeSpecifierTypes;
+    private readonly intersectionTypeSpecifierTypes;
+    private readonly functionLiteralTypes;
+    private readonly nodesForWhichReturnTypeInferenceDiagnosticHasBeenReported;
+    constructor(analyzer: Analyzer);
     ofExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
     ofAccessedOperator(operator: types.Operator): types.Type;
@@ -413,8 +426,8 @@ declare class Type {
     private getNarrowedTypeIfNarrowableReference;
 }
 declare class ReturnType {
-    private readonly _analyzer;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
     ofAnonymousFunctionTypeDeclaration(node: tree.AnonymousFunctionTypeDeclaration): types.Type;
     ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): types.Type;
     ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): types.Type;
@@ -430,48 +443,48 @@ declare class ReturnType {
     ofFunctionDeclaration(node: FunctionDeclaration): types.Type;
 }
 declare class Entity {
-    private readonly _analyzer;
-    private readonly _packageEntities;
-    private readonly _packageVariableEntities;
-    private readonly _fieldEntities;
-    private readonly _parameterVariableEntities;
-    private readonly _localVariableEntities;
-    private readonly _typeParameterEntities;
-    private readonly _indexerEntities;
-    private readonly _referenceOperatorEntities;
-    private readonly _packageStructuredTypeEntities;
-    private readonly _anonymousStructuredTypeEntities;
-    private readonly _packageVariantTypeEntities;
-    private readonly _anonymousVariantTypeEntities;
-    private readonly _packageFunctionTypeEntities;
-    private readonly _anonymousFunctionTypeEntities;
-    private readonly _aliasTypeEntities;
-    private readonly _packageFunctionEntities;
-    private readonly _methodEntities;
-    private readonly _nestedFunctionEntities;
-    private readonly _constructorEntities;
-    private readonly _operatorEntities;
-    private readonly _destructorEntities;
-    private readonly _getterEntities;
-    private readonly _setterEntities;
-    private readonly _typeExtensionEntities;
-    private readonly _packageAliasEntities;
-    private readonly _translationTextTemplateParameterEntities;
-    private readonly _localizableSimpleTextEntities;
-    private readonly _localizableTextTemplateEntities;
-    private readonly _localizableTextEntitiesByPackage;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly packageEntities;
+    private readonly packageVariableEntities;
+    private readonly fieldEntities;
+    private readonly parameterEntities;
+    private readonly localVariableEntities;
+    private readonly typeParameterEntities;
+    private readonly indexerEntities;
+    private readonly referenceOperatorEntities;
+    private readonly packageStructuredTypeEntities;
+    private readonly anonymousStructuredTypeEntities;
+    private readonly packageVariantTypeEntities;
+    private readonly anonymousVariantTypeEntities;
+    private readonly packageFunctionTypeEntities;
+    private readonly anonymousFunctionTypeEntities;
+    private readonly aliasTypeEntities;
+    private readonly packageFunctionEntities;
+    private readonly methodEntities;
+    private readonly nestedFunctionEntities;
+    private readonly constructorEntities;
+    private readonly operatorEntities;
+    private readonly destructorEntities;
+    private readonly getterEntities;
+    private readonly setterEntities;
+    private readonly typeExtensionEntities;
+    private readonly packageAliasEntities;
+    private readonly translationTextTemplateParameterEntities;
+    private readonly localizableSimpleTextEntities;
+    private readonly localizableTextTemplateEntities;
+    private readonly localizableTextEntitiesByPackage;
+    constructor(analyzer: Analyzer);
     ofPackage(pkg: SourcePackage): e.PackageEntity;
     ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): e.PackageVariableEntity;
     ofComputedPackageVariableDeclaration(node: PackageVariableAccessorDeclaration): e.PackageVariableEntity;
     ofFieldDeclaration(node: tree.FieldDeclaration): e.FieldEntity;
     ofComputedFieldDeclaration(node: FieldAccessorDeclaration): e.FieldEntity;
     ofLocalVariableDeclaration(node: tree.LocalVariableDeclaration): e.LocalVariableEntity;
-    ofEnumerationVariableDeclaration(node: tree.EnumerationVariableDeclaration): e.LocalVariableEntity;
+    ofForStatementVariableDeclaration(node: tree.ForStatementVariableDeclaration): e.LocalVariableEntity;
     ofErrorVariableDeclaration(node: tree.ErrorVariableDeclaration): e.LocalVariableEntity;
-    ofParameterDeclaration(node: tree.ParameterDeclaration): e.ParameterVariableEntity;
+    ofParameterDeclaration(node: tree.ParameterDeclaration): e.ParameterEntity;
     ofTypeParameterDeclaration(node: tree.TypeParameterDeclaration): e.TypeParameterEntity;
-    ofIndexerDeclaration(node: IndexedElementAccessorDeclaration): e.SourceIndexerEntity;
+    ofIndexerDeclaration(node: IndexedElementAccessorDeclaration): e.IndexerEntity;
     ofDereferenceOperatorDeclaration(node: DereferencedVariableAccessorDeclaration): e.DereferenceOperatorEntity;
     ofPackageStructuredTypeDeclaration(node: tree.PackageStructuredTypeDeclaration): e.PackageStructuredTypeEntity;
     ofAnonymousStructuredTypeDeclaration(node: tree.AnonymousStructuredTypeDeclaration): e.AnonymousStructuredTypeEntity;
@@ -503,17 +516,19 @@ declare class Entity {
     ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
     ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
     ofTypeWithMembersDeclaration(node: TypeWithMembersDeclaration): e.TypeEntityWithMembers;
+    ofTypeWithMembersOrExtensionDeclaration(node: TypeWithMembersOrTypeExtensionDeclaration): e.TypeWithMembersOrExtensionEntity;
     ofTranslationTextTemplateParameter(node: tree.TranslationTextTemplateParameter): e.TranslationTextTemplateParameterEntity;
     private getContainingPackageLoadedFromDts;
     private createComputedFieldEntities;
     private createDereferenceOperatorEntities;
-    private createIndexerEntities;
+    private createIndexerAndParameterEntities;
+    private createAndCacheIndexerEntityAndParameters;
     private areIndexedElementAccessorDeclarationsEqual;
 }
 declare class ResultLocalVariableEntity {
-    private readonly _analyzer;
-    private readonly _entities;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly entities;
+    constructor(analyzer: Analyzer);
     ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.LocalVariableEntity;
     ofMethodDeclaration(node: tree.MethodDeclaration): e.LocalVariableEntity;
     ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.LocalVariableEntity;
@@ -528,9 +543,9 @@ declare class ResultLocalVariableEntity {
     private createResultLocalVariableEntity;
 }
 declare class ValueLocalVariableEntity {
-    private readonly _analyzer;
-    private readonly _entities;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly entities;
+    constructor(analyzer: Analyzer);
     ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.LocalVariableEntity;
     ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.LocalVariableEntity;
     ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.LocalVariableEntity;
@@ -538,22 +553,22 @@ declare class ValueLocalVariableEntity {
     private createValueLocalVariableEntity;
 }
 declare class OverriddenMember {
-    private readonly _analyzer;
-    private readonly _namedMemberFinder;
-    private readonly _operatorFinder;
-    private readonly _indexerFinder;
-    private readonly _dereferenceOperatorFinder;
-    private readonly _isField;
-    private readonly _isMethod;
-    private readonly _isOperator;
-    private readonly _isIndexer;
-    private readonly _isDereferenceOperator;
-    private readonly _overriddenAndShadowedFields;
-    private readonly _overriddenAndShadowedMethods;
-    private readonly _overriddenAndShadowedOperators;
-    private readonly _overriddenAndShadowedIndexers;
-    private readonly _overriddenAndShadowedDereferenceOperators;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly namedMemberFinder;
+    private readonly operatorFinder;
+    private readonly indexerFinder;
+    private readonly dereferenceOperatorFinder;
+    private readonly isField;
+    private readonly isMethod;
+    private readonly isOperator;
+    private readonly isIndexer;
+    private readonly isDereferenceOperator;
+    private readonly overriddenAndShadowedFields;
+    private readonly overriddenAndShadowedMethods;
+    private readonly overriddenAndShadowedOperators;
+    private readonly overriddenAndShadowedIndexers;
+    private readonly overriddenAndShadowedDereferenceOperators;
+    constructor(analyzer: Analyzer);
     getOverriddenAndShadowedFields(node: tree.FieldDeclaration | FieldAccessorDeclaration): OverriddenAndShadowedMembers<types.Field, types.NamedTypeMember>;
     getOverriddenAndShadowedMethods(node: tree.MethodDeclaration): OverriddenAndShadowedMembers<types.Method, types.NamedTypeMember>;
     getOverriddenAndShadowedOperators(node: tree.OperatorDeclaration): OverriddenAndShadowedMembers<types.Operator>;
@@ -597,17 +612,17 @@ export type OverridableTypeMember = types.Field | types.Method | types.Operator
 export declare function isOverridableTypeMember(entity: types.TypeMember): entity is OverridableTypeMember;
 export type NodeWithTags = tree.PackageMemberDeclaration | tree.TypeMemberDeclaration | tree.ParameterDeclaration;
 declare class Tags {
-    private readonly _analyzer;
-    private readonly _tagsByNodeWithTags;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly tagsByNodeWithTags;
+    constructor(analyzer: Analyzer);
     ofNodeWithTags(node: NodeWithTags): readonly tags.Tag[];
     private createTagsOfNodeWithTags;
     private createTagFromNode;
     private argumentToTagArgument;
 }
 declare class LinkedEntity {
-    private readonly _analyzer;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
     entityCanBeLinked(entity: e.Entity): boolean;
     ofType(entity: e.TypeEntity, platform: PlatformKind): e.TypeEntity | undefined;
     ofTypeWithMembers(entity: e.TypeEntityWithMembers, platform: PlatformKind): e.TypeEntityWithMembers | undefined;
@@ -628,9 +643,9 @@ export declare class LinkedMultiPlatformPackage {
     readonly pkg: e.PackageEntity;
     readonly implementationPackage: e.PackageEntity;
     readonly targetPlatform: PlatformKind;
-    private readonly _memberLookup;
-    private readonly _linkedTypesWithMembers;
-    private readonly _linkedParameterTypes;
+    private readonly memberLookup_;
+    private readonly linkedTypesWithMembers;
+    private readonly linkedParameterTypes;
     private get memberLookup();
     constructor(analyzer: Analyzer, pkg: e.PackageEntity, implementationPackage: e.PackageEntity, targetPlatform: PlatformKind);
     getLinkedVariable(entity: e.PackageVariableEntity): e.PackageVariableEntity | undefined;
@@ -651,7 +666,7 @@ export declare class LinkedTypeWithMembers {
     readonly externalType: e.TypeEntityWithMembers;
     readonly targetType: e.TypeEntityWithMembers;
     readonly linkedPackage: LinkedMultiPlatformPackage;
-    private readonly _memberLookup;
+    private readonly memberLookup_;
     private get memberLookup();
     constructor(analyzer: Analyzer, externalType: e.TypeEntityWithMembers, targetType: e.TypeEntityWithMembers, linkedPackage: LinkedMultiPlatformPackage);
     getLinkedField(entity: e.FieldEntity): e.FieldEntity | undefined;
@@ -662,17 +677,17 @@ export declare class LinkedTypeWithMembers {
     getLinkedDereferenceOperator(entity: e.DereferenceOperatorEntity): e.DereferenceOperatorEntity | undefined;
 }
 declare class OwningPlainObjectModificationCheck {
-    private _analyzer;
-    private readonly _owningPlainObjectModificationCheckResult;
-    constructor(_analyzer: Analyzer);
+    private analyzer;
+    private readonly owningPlainObjectModificationCheckResult;
+    constructor(analyzer: Analyzer);
     ofDeclarationBody(node: tree.FunctionBlock): boolean;
     private checkMethodBodyModifiesPlainObject;
     private checkReceiverModifiesPlainObjectRecursively;
     private nodeBelongsToPlainObjectDeclaration;
 }
 declare class TypeAssignabilityCheck {
-    private readonly _analyzer;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
     isTypeAssignableTo(source: types.Type, target: types.Type): boolean;
     getAssignabilityFlags(source: types.Type, target: types.Type): TypeAssignabilityFlags;
     /**
@@ -710,13 +725,13 @@ export declare enum TypeAssignabilityFlags {
     Last = 16
 }
 declare class PackageImports {
-    private readonly _analyzer;
-    private readonly _packagesAvailableForImport;
-    private readonly _analyzedPackageImports;
-    private readonly _importedPackages;
-    private readonly _automaticallyImportedPackages;
-    private readonly _importedPackageNameTrees;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly packagesAvailableForImport;
+    private readonly analyzedPackageImports;
+    private readonly importedPackages;
+    private readonly automaticallyImportedPackages;
+    private readonly importedPackageNameTrees;
+    constructor(analyzer: Analyzer);
     analyzeExplicitPackageImports(sourceFile: project.SourceFile): AnalyzedPackageImports;
     getPackagesAvailableForImport(pkg: project.SourcePackage): readonly e.PackageEntity[];
     getUniqueImportedPackages(sourceFile: project.SourceFile): readonly PackageImportInfo[];
@@ -739,8 +754,8 @@ export declare class PackageImportInfo {
     constructor(entity: e.PackageEntity, aliasEntity: e.PackageAliasEntity | undefined);
 }
 declare class TypeUtils {
-    private readonly _analyzer;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
     getCommonObjectAndAspectTypesOfUnion(unionType: types.UnionType): readonly types.StructuredType[];
     removeBaseTypesInPlace(types: types.Type[]): void;
     removeDerivedTypesInPlace(types: types.Type[]): void;
@@ -758,9 +773,9 @@ declare class TypeUtils {
     private flattenTypeParameterConstraint;
 }
 declare class SignatureComparer {
-    private readonly _analyzer;
-    private _stubParameterTypes;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly stubParameterTypes;
+    constructor(analyzer: Analyzer);
     areEqualFunctionEntities(function1: e.FunctionEntity, function2: e.FunctionEntity, options: SignatureComparisonOptions): boolean;
     /**
      * Метод аналогичен методу {@link areEqualFunctionEntities}.
@@ -785,9 +800,9 @@ export declare enum SignatureComparisonOptions {
     CheckTypeParameterCountIntersection = 4
 }
 declare class ConflictsCheck {
-    private readonly _analyzer;
-    private static readonly _signatureComparisonOptions;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private static readonly signatureComparisonOptions;
+    constructor(analyzer: Analyzer);
     /**
      * Проверяет, конфликтуют ли две функции, т.е. могут ли такие функции находиться в одной области видимости.
      * Метод не сравнивает имена.
@@ -830,9 +845,10 @@ export type TypeMemberWithoutTypeParametersInSignature = types.Constructor | typ
 export declare class ExpressionDenotesFunctionCheckResult {
     readonly candidates: readonly AccessedFunction[];
     readonly suitableFunctions: readonly AccessedFunction[];
+    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
     get singleSuitableFunction(): AccessedFunction | undefined;
     get singleFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[]);
+    constructor(candidates: readonly AccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
 }
 export declare class ExpressionDenotesOperatorCheckResult {
     readonly candidates: readonly types.Operator[];
@@ -846,10 +862,10 @@ export declare class DeclaredTypeMemberEntities {
     readonly operators: readonly e.OperatorEntity[];
     readonly constructors: readonly e.ConstructorEntity[];
     readonly destructors: readonly e.DestructorEntity[];
-    readonly indexers: readonly e.SourceIndexerEntity[];
+    readonly indexers: readonly e.IndexerEntity[];
     readonly dereferenceOperators: readonly e.DereferenceOperatorEntity[];
     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[]);
+    constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], operators: readonly e.OperatorEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.IndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
 }
 export declare class ExpressionAnalysisOptions {
     readonly targetType: types.Type | undefined;

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

@@ -1,11 +1,11 @@
-import { ParameterVariableEntity } from '../entities/index.js';
+import { ParameterEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './index.js';
 export declare class ArgumentToParameterMatchResult {
-    private readonly _analyzer;
-    private readonly _matchResults;
-    constructor(_analyzer: Analyzer);
+    private readonly analyzer;
+    private readonly matchResults;
+    constructor(analyzer: Analyzer);
     ofCallExpression(node: tree.CallExpression): MatchResult | undefined;
     ofAutotypeCallExpression(node: tree.AutotypeCallExpression): MatchResult | undefined;
     ofTag(node: tree.Tag): MatchResult | undefined;
@@ -14,11 +14,11 @@ export declare class ArgumentToParameterMatchResult {
     private convertParameter;
 }
 export declare class MatchResult {
-    readonly parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>;
-    constructor(parameterByArgument: ReadonlyMap<tree.Argument, MatchResultValueParameter>);
+    readonly parameterByArgument: ReadonlyMap<tree.Argument, MatchResultParameter>;
+    constructor(parameterByArgument: ReadonlyMap<tree.Argument, MatchResultParameter>);
 }
-export declare class MatchResultValueParameter {
-    readonly entity: ParameterVariableEntity;
+export declare class MatchResultParameter {
+    readonly entity: ParameterEntity;
     readonly type: types.Type;
-    constructor(entity: ParameterVariableEntity, type: types.Type);
+    constructor(entity: ParameterEntity, type: types.Type);
 }

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

@@ -3,12 +3,12 @@ import { DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic
 import * as tree from '../tree/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;
-    private readonly _diagnostics;
-    private readonly _nodeForUnmatchedRequiredParametersDiagnostic;
-    constructor(_analyzer: Analyzer, _signature: TSignature, _arguments: readonly TArgument[], _diagnostics: DiagnosticAcceptor | undefined, _nodeForUnmatchedRequiredParametersDiagnostic: tree.Node | undefined);
+    private readonly analyzer;
+    private readonly signature;
+    private readonly arguments_;
+    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 reportArgumentDiagnostic;
@@ -30,9 +30,9 @@ export interface IArgument {
     getDiagnosticLocation(): DiagnosticLocation | undefined;
 }
 export declare class SourceArgument implements IArgument {
-    private readonly _analyzer;
+    private readonly analyzer;
     readonly node: tree.Argument;
     readonly name: Name | undefined;
-    constructor(_analyzer: Analyzer, node: tree.Argument);
+    constructor(analyzer: Analyzer, node: tree.Argument);
     getDiagnosticLocation(): DiagnosticLocation;
 }

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

@@ -1,10 +1,10 @@
 import { Analyzer } from './Analyzer.js';
 import * as controlFlow from './control-flow/index.js';
 export declare class AssignmentChecker {
-    private readonly _analyzer;
-    private readonly _variableReference;
-    private readonly _controlFlowNode;
-    private readonly _checkResults;
+    private readonly analyzer;
+    private readonly variableReference;
+    private readonly controlFlowNode;
+    private readonly checkResults;
     constructor(analyzer: Analyzer, variableReference: controlFlow.NarrowableReference, controlFlowNode: controlFlow.Node);
     checkVariableIsAssigned(): boolean;
     private checkVariableIsAssignedAtNode;