@artel/artc 0.6.26017 → 0.6.26019

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

@@ -0,0 +1,466 @@
+import { Name, PackageLocale, TaskController } from '../../common/index.js';
+import { Diagnostic, DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { WithDiagnostics } from '../../diagnostic/WithDiagnostics.js';
+import { BinaryOperatorKind } from '../../entities/OperatorKind.js';
+import * as tags from '../../entities/Tag.js';
+import * as e from '../../entities/index.js';
+import * as se from '../../entities/source/a/index.js';
+import * as project from '../../project/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { Analyzer as BaseAnalyzer } from '../Analyzer.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
+import { ImportedPackageNameTree, PackageImportInfo, PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { TsInteropInputs } from '../TsInteropInputs.js';
+import { Analyzer as AnalyzerM } from '../m/Analyzer.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';
+import * as dereferenceExpressionMeaning from './DereferenceExpressionMeaning.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+import * as identifierExpressionResolution from './IdentifierExpressionMeaning.js';
+import * as indexedAccessExpressionMeaning from './IndexedAccessExpressionMeaning.js';
+import * as memberAccessExpressionResolution from './MemberAccessExpressionMeaning.js';
+import { ModifierFlags } from './ModifierFlags.js';
+import { NamedTypeSpecifierResolutionResult } from './NamedTypeSpecifierResolver.js';
+import * as objectExpressionMeaning from './ObjectExpressionMeaning.js';
+import { OwnAndBaseConstructorCallsCheckResult } from './OwnAndBaseConstructorCallsChecker.js';
+import * as ownConstructorCallExpressionMeaning from './OwnConstructorCallExpressionMeaning.js';
+import { ReachabilityChecker } from './ReachabilityChecker.js';
+import { ReductionSourceMemberFinder } from './ReductionSourceMemberFinder.js';
+import { ReservedNameKind } from './ReservedNameDictionary.js';
+import { SyntacticAccessKind } from './SyntacticAccessKind.js';
+import * as tagMeaning from './TagMeaning.js';
+import { TypeWithMembersOrTypeExtensionDeclaration } from './TreeQuery.js';
+import * as controlFlow from './control-flow/index.js';
+import * as semanticContext from './semantic-context/index.js';
+/**
+ * Анализатор диалекта А. Является основным анализатором, и имеет ссылку на анализатор диалекта М.
+ */
+export declare class Analyzer extends BaseAnalyzer {
+    readonly dialectM: AnalyzerM;
+    readonly type: Type;
+    readonly returnType: ReturnType;
+    readonly entity: Entity;
+    readonly resultLocalVariableEntity: ResultLocalVariableEntity;
+    readonly valueLocalVariableEntity: ValueLocalVariableEntity;
+    readonly semanticContext: semanticContext.SemanticContextBuilder;
+    readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
+    readonly tags: Tags;
+    readonly packageImports: PackageImports;
+    readonly reachabilityChecker: ReachabilityChecker;
+    readonly reductionSourceMemberFinder: ReductionSourceMemberFinder;
+    get dialectA(): Analyzer;
+    private readonly targetType;
+    private readonly memberAccessExpressionResolutionResults;
+    private readonly memberAccessExpressionResolutionResultsFirstStage;
+    private readonly callExpressionResolutionResults;
+    private readonly indexedAccessExpressionResolutionResults;
+    private readonly dereferenceExpressionMeanings;
+    private readonly ownConstructorCallExpressionMeanings;
+    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 resolvedLocalizableTexts;
+    private readonly isFunctionGeneratorCheckResults;
+    private readonly namedDeclarationsUsageCountResults;
+    private readonly packageAndStaticVariablesInitializationDiagnostics;
+    private readonly controlFlowGraphs;
+    private readonly sourcePackageMemberConflictsDiagnostics;
+    private readonly ownAndBaseConstructorCallsCheckResults;
+    private readonly expressionCanBeUsedInForLoopCheckResults;
+    private readonly nameByIdentifierText;
+    constructor(compilation: project.Compilation, tsInteropInputs: TsInteropInputs);
+    getProjectSourceFileA(node: tree.SourceFile): project.SourceFileA;
+    checkExpressionCanBeUsedInForLoop(node: tree.Expression): WithDiagnostics<ExpressionCanBeUsedInForLoopCheckResult>;
+    expressionCanBeReferenced(node: tree.Expression): boolean;
+    checkBlockCallsAsyncMethods(node: tree.StatementBlock | tree.FunctionBlock): boolean;
+    getSyntacticAccessKind(node: tree.Expression): SyntacticAccessKind;
+    getEntityContainingTypeMemberDeclaration(node: tree.TypeMemberDeclaration): e.TypeWithMembersOrExtensionEntity;
+    getTargetTypeOfExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type | undefined;
+    resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.MeaningStage1;
+    resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.Meaning;
+    resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.Meaning;
+    getRespectiveParameter(node: tree.Argument): MatchResultParameter | undefined;
+    resolveIndexedAccessExpression(node: tree.IndexedAccessExpression): indexedAccessExpressionMeaning.Meaning;
+    resolveDereferenceExpression(node: tree.DereferenceExpression): dereferenceExpressionMeaning.Meaning;
+    resolveAutotypeCallExpression(node: tree.AutotypeCallExpression, analysisOptions?: ExpressionAnalysisOptions): autotypeCallExpressionMeaning.ResolutionResult;
+    resolveOwnConstructorCallExpression(node: tree.OwnConstructorCallExpression): ownConstructorCallExpressionMeaning.Meaning;
+    resolveIdentifierExpressionFirstStage(node: tree.IdentifierExpression): identifierExpressionResolution.MeaningStage1;
+    resolveIdentifierExpression(node: tree.IdentifierExpression, analysisOptions?: ExpressionAnalysisOptions): identifierExpressionResolution.Meaning;
+    resolveTag(node: tree.Tag): tagMeaning.ResolutionResult;
+    resolveObjectExpression(node: tree.ObjectExpression): objectExpressionMeaning.Meaning;
+    resolveBaseExpressionFirstStage(node: tree.BaseExpression): baseExpressionMeaning.MeaningStage1;
+    resolveBaseExpression(node: tree.BaseExpression): baseExpressionMeaning.Meaning;
+    /**
+     * Проверяет, является ли выражение цепочкой доступов через `?`, заканчивающейся выражением, тип которого допускает
+     * `пусто`.
+     *
+     * Пример:
+     * ```artel
+     * а?.б
+     * а?[1]
+     * а?^
+     * а?()
+     * (а)?.б
+     * ```
+     *
+     * где тип переменной `а` допускает `пусто`.
+     */
+    isExpressionValidOptionalChaining(node: tree.Expression): boolean;
+    /**
+     * Проверяет, является ли выражение цепочкой доступов через `?`.
+     *
+     * Пример:
+     * ```artel
+     * а?.б
+     * а?[1]
+     * а?^
+     * а?()
+     * (а?.б)
+     * ```
+     */
+    isExpressionOptionalChainingSyntactically(node: tree.Expression): boolean;
+    isExpressionValidOutermostOptionalChaining(node: tree.Expression): boolean;
+    includeNullToTypeIfExpressionValidOutermostOptionalChaining(type: types.Type, node: tree.Expression): types.Type;
+    checkIdentifierNameIsReserved(name: Name, locale: PackageLocale): ReservedNameKind | undefined;
+    getReservedName(reservedNameKind: ReservedNameKind, locale: PackageLocale): Name;
+    createNameFromIdentifier(node: tree.Identifier): Name;
+    resolveNamedTypeSpecifier(node: tree.NamedTypeSpecifier): NamedTypeSpecifierResolutionResult;
+    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;
+    getDenotedPackageNameTreeNode(expression: tree.Expression): PackageNameTreeNode | undefined;
+    /**
+     * Функция считается генератором, если:
+     * - Использует команду `выдать`.
+     * - Не использует команду `выдать`, но её возвращаемым типом является `Перебираемый` или `Перебор`, она не
+     *   возвращает значение и не использует переменную `результат` (использование команды `вернуть` без указания
+     *   возвращаемого значения допустимо). В таком случае это генератор, не возвращающий ни одного элемента.
+     */
+    isFunctionGenerator(node: tree.FunctionDeclaration): boolean;
+    resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): types.Method | undefined;
+    resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): types.Method | undefined;
+    resolveCompoundAssignmentStatementOperator(node: tree.AssignmentStatement, operatorKind: BinaryOperatorKind): types.Method | undefined;
+    classifyBinaryExpressionOperator(operator: tree.BinaryExpressionOperator): BinaryExpressionOperatorClassificationResult;
+    getBinaryOperatorKindIfCompoundAssignmentOperator(operator: tree.AssignmentStatementOperator): BinaryOperatorKind | undefined;
+    resolveLocalizableTextOrTextTemplate(node: tree.LocalizableTextLiteral | tree.LocalizableTextTemplateLiteral): e.TextTranslationEntity | undefined;
+    createPackageMemberHiding(node: tree.PackageMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
+    createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
+    getDeclarationsUsageOfSourceFileA(sourceFile: tree.SourceFile, taskController: TaskController): Promise<DeclarationsUsageMap>;
+    getPackageAndStaticVariablesInitializationDiagnostics(pkg: project.SourcePackageA, taskController: TaskController): Promise<readonly Diagnostic[]>;
+    createDefaultConstructors(typeEntity: e.StructuredTypeEntity, fields: readonly e.FieldEntity[]): readonly e.ConstructorEntity[];
+    createBackingPackageVariables(declaredPackageMembers: readonly e.NamedPackageMemberEntity[], pkg: e.PackageEntity): e.PackageVariableEntity[];
+    createBackingFields(declaredMembers: readonly e.NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
+    getDeclaredTypeMemberEntities(node: tree.TypeMemberDeclarationBlock): DeclaredTypeMemberEntities;
+    checkBodyOfBasicAliasTypeMethod(node: tree.MethodDeclaration, diagnostics?: DiagnosticAcceptor): {
+        basicMethodOfOriginalType: e.MethodEntity;
+    } | undefined;
+    getControlFlowGraph(sourceFile: project.SourceFileA): controlFlow.GraphBuildResult;
+    validateSourcePackageMemberConflicts(pkg: project.ProgramOrTextTranslationPackage): readonly Diagnostic[];
+    determineUnderlyingTypeOfSourceVariantType(memberList: tree.TypeMemberDeclarationList): types.Type;
+    getOwnAndBaseConstructorCallsCheckResult(node: tree.TypeWithMembersDeclaration): OwnAndBaseConstructorCallsCheckResult;
+    isConstructorCallingOwnConstructor(node: tree.ConstructorDeclaration): boolean;
+    ifCalleeThenCallExpression(node: tree.Expression): tree.CallExpression | undefined;
+    getNodeForAmbiguousAccessDiagnostic(access: tree.Expression): tree.Node;
+    isPossibleWrappedTargetTypeDependentFunctionLiteral(node: tree.Expression): boolean;
+    isTargetTypeDependentFunctionLiteral(node: tree.Expression): node is tree.RegularOrBlockFunctionLiteral;
+    checkTypeArgumentCount(typeArgumentCount: number, typeParameters: readonly e.TypeParameterEntity[], diagnostics?: DiagnosticAcceptor, diagnosticLocation?: NodeOrDiagnosticLocation): boolean;
+    checkTypeCanBeUsedAsValue(typeAccess: tree.Expression): boolean;
+    isPossiblyCastedBaseExpression(node: tree.Expression): boolean;
+    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], nodeOrLocation: NodeOrDiagnosticLocation): Diagnostic;
+}
+export type BinaryExpressionOperatorClassificationResult = {
+    kind: 'user-definable';
+    operatorKind: BinaryOperatorKind;
+} | {
+    kind: 'question-question';
+} | {
+    kind: 'equals';
+} | {
+    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 modulo: BinaryExpressionOperatorClassificationResult;
+    const bitwiseAnd: BinaryExpressionOperatorClassificationResult;
+    const bitwiseOr: BinaryExpressionOperatorClassificationResult;
+    const bitwiseXor: BinaryExpressionOperatorClassificationResult;
+    const leftShift: BinaryExpressionOperatorClassificationResult;
+    const signedRightShift: BinaryExpressionOperatorClassificationResult;
+    const unsignedRightShift: BinaryExpressionOperatorClassificationResult;
+    const and: BinaryExpressionOperatorClassificationResult;
+    const or: BinaryExpressionOperatorClassificationResult;
+    const xor: BinaryExpressionOperatorClassificationResult;
+    const equals: BinaryExpressionOperatorClassificationResult;
+    const notEquals: BinaryExpressionOperatorClassificationResult;
+    const questionQuestion: BinaryExpressionOperatorClassificationResult;
+}
+export declare class ExpressionCanBeUsedInForLoopCheckResult {
+    readonly elementType: types.Type;
+    readonly ifTypeDoesNotImplementEnumerableThenEnumeratorMethod: types.Method | undefined;
+    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;
+    private recursionDepth;
+    constructor(analyzer: Analyzer);
+    ofExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type;
+    ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
+    private ofExpressionWithoutGuard;
+    private ofFunctionBlockLiteral;
+    private ofFunctionLiteral;
+    private ofRegularOrBlockFunctionLiteral;
+    private createFunctionTypeOfFunctionEntity;
+    private ofArrayLiteral;
+    private ofAssertionExpression;
+    private ofAssumptionExpression;
+    private ofAsExpression;
+    private ofBinaryExpression;
+    private ofCallExpression;
+    private ofAutotypeCallExpression;
+    private ofIndexedAccessExpression;
+    private ofMissingExpression;
+    private ofIsExpression;
+    private ofParenthesizedExpression;
+    private ofPrefixUnaryExpression;
+    private ofMemberAccessExpression;
+    private ofReferenceExpression;
+    private ofDereferenceExpression;
+    private ofConditionalExpression;
+    private ofTextLiteral;
+    /**
+     * По умолчанию литерал шаблона текста имеет тип Текст.
+     *
+     * Литерал шаблона текста имеет тип ШаблонТекста в следующих случаях:
+     * - если он присваивается в переменную, имеющую тип ШаблонТекста;
+     * - если он присваивается в переменную, имеющую союзный тип, содержащий тип ШаблонТекста
+     *   и не содержащий тип Текст.
+     */
+    private ofTextTemplateLiteral;
+    private ofIdentifierExpression;
+    private ofTokenExpression;
+    private ofKeywordExpression;
+    private ofObjectExpression;
+    private ofBaseExpression;
+    private ofGenericSpecializationExpression;
+    private ofDefaultMatchExpression;
+    private ofOwnConstructorCallExpression;
+    private ofAnonymousTypeSpecifier;
+    private ofNamedTypeSpecifier;
+    private ofParenthesizedTypeSpecifier;
+    private ofNullableTypeSpecifier;
+    private ofUnionTypeSpecifier;
+    private ofIntersectionTypeSpecifier;
+    private ofInvalidTypeSpecifier;
+    private reportReturnTypeCanNotBeInferredDiagnostic;
+    private getNarrowedTypeIfNarrowableReference;
+}
+declare class ReturnType {
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
+    ofAnonymousFunctionTypeDeclaration(node: tree.AnonymousFunctionTypeDeclaration): types.Type;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): types.Type;
+    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): types.Type;
+    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): types.Type;
+    ofFunctionLiteral(node: tree.FunctionLiteral): types.Type;
+    ofMethodDeclaration(node: tree.MethodDeclaration): types.Type;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): types.Type;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): types.Type;
+    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): types.Type;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): types.Type;
+    ofFunctionDeclaration(node: tree.FunctionDeclaration): types.Type;
+    ofTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): types.Type;
+}
+declare class Entity {
+    private readonly analyzer;
+    private readonly packageEntities;
+    private readonly programPackageEntities;
+    private readonly nameTranslationPackageEntities;
+    private readonly textTranslationPackageEntities;
+    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 anonymousFunctionTypeEntities;
+    private readonly aliasTypeEntities;
+    private readonly reducedTypeEntities;
+    private readonly packageFunctionEntities;
+    private readonly methodEntities;
+    private readonly nestedFunctionEntities;
+    private readonly constructorEntities;
+    private readonly destructorEntities;
+    private readonly getterEntities;
+    private readonly setterEntities;
+    private readonly typeExtensionEntities;
+    private readonly packageAliasEntities;
+    private readonly textTranslationDeclarationEntities;
+    private readonly functionLiteralEntities;
+    private readonly functionBlockLiteralEntities;
+    constructor(analyzer: Analyzer);
+    ofPackage(pkg: project.SourcePackageA): e.PackageEntity;
+    ofProgramPackage(pkg: project.ProgramPackageA): e.ProgramPackageEntity;
+    ofTranslationPackage(pkg: project.TranslationPackageA): se.SourceNameTranslationPackageEntity;
+    ofTextTranslationPackage(pkg: project.TextTranslationPackageA): e.TextTranslationPackageEntity;
+    ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): e.PackageVariableEntity;
+    ofComputedPackageVariableDeclaration(node: tree.PackageVariableAccessorDeclaration): e.PackageVariableEntity;
+    ofFieldDeclaration(node: tree.FieldDeclaration): e.FieldEntity;
+    ofComputedFieldDeclaration(node: tree.FieldAccessorDeclaration): e.FieldEntity;
+    ofLocalVariableDeclaration(node: tree.LocalVariableDeclaration): e.LocalVariableEntity;
+    ofForStatementVariableDeclaration(node: tree.ForStatementVariableDeclaration): e.LocalVariableEntity;
+    ofErrorVariableDeclaration(node: tree.ErrorVariableDeclaration): e.LocalVariableEntity;
+    ofParameterDeclaration(node: tree.ParameterDeclaration): e.ParameterEntity;
+    ofTypeParameterDeclaration(node: tree.TypeParameterDeclaration): e.TypeParameterEntity;
+    ofIndexerDeclaration(node: tree.IndexedElementAccessorDeclaration): e.IndexerEntity;
+    ofDereferenceOperatorDeclaration(node: tree.DereferencedVariableAccessorDeclaration): e.DereferenceOperatorEntity;
+    ofPackageStructuredTypeDeclaration(node: tree.PackageStructuredTypeDeclaration): e.PackageStructuredTypeEntity;
+    ofPackageClassDeclaration(node: tree.PackageClassDeclaration): e.PackageStructuredTypeEntity;
+    ofPackageStructureDeclaration(node: tree.PackageStructureDeclaration): e.PackageStructuredTypeEntity;
+    ofPackageAspectDeclaration(node: tree.PackageAspectDeclaration): e.PackageStructuredTypeEntity;
+    ofAnonymousStructuredTypeDeclaration(node: tree.AnonymousStructuredTypeDeclaration): e.AnonymousStructuredTypeEntity;
+    ofAnonymousClassDeclaration(node: tree.AnonymousClassDeclaration): e.AnonymousStructuredTypeEntity;
+    ofStructuredTypeDeclaration(node: tree.StructuredTypeDeclaration): e.StructuredTypeEntity;
+    ofAnonymousFunctionTypeDeclaration(node: tree.AnonymousFunctionTypeDeclaration): e.AnonymousFunctionTypeEntity;
+    ofFunctionTypeDeclaration(node: tree.FunctionTypeDeclaration): e.FunctionTypeEntity;
+    ofPackageVariantDeclaration(node: tree.PackageVariantDeclaration): e.PackageVariantTypeEntity;
+    ofPackageAliasTypeDeclaration(node: tree.PackageAliasTypeDeclaration): e.AliasTypeEntity;
+    ofPackageReducedTypeDeclaration(node: tree.PackageReducedTypeDeclaration): e.ReducedTypeEntity;
+    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.PackageFunctionEntity;
+    ofMethodDeclaration(node: tree.MethodDeclaration): e.MethodEntity;
+    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.NestedFunctionEntity;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.GetterEntity;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.GetterEntity;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.GetterEntity;
+    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): e.GetterEntity;
+    ofGetterDeclaration(node: tree.GetterDeclaration): e.GetterEntity;
+    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.SetterEntity;
+    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.SetterEntity;
+    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.SetterEntity;
+    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.SetterEntity;
+    ofSetterDeclaration(node: tree.SetterDeclaration): e.SetterEntity;
+    ofConstructorDeclaration(node: tree.ConstructorDeclaration): e.ConstructorEntity;
+    ofDestructorDeclaration(node: tree.DestructorDeclaration): e.DestructorEntity;
+    ofVariantValueDeclaration(node: tree.VariantValueDeclaration): e.FieldEntity;
+    ofTypeExtensionDeclaration(node: tree.TypeExtensionDeclaration): e.TypeExtensionEntity;
+    ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
+    ofTypeWithMembersDeclaration(node: tree.TypeWithMembersDeclaration): e.TypeEntityWithMembers;
+    ofTypeWithMembersOrExtensionDeclaration(node: TypeWithMembersOrTypeExtensionDeclaration): e.TypeWithMembersOrExtensionEntity;
+    ofTranslationTextTemplateParameter(node: tree.TranslationTextTemplateParameter): e.ParameterEntity;
+    ofTextTranslationDeclaration(node: tree.TextTranslationSource): e.TextTranslationEntity;
+    ofFunctionLiteral(node: tree.FunctionLiteral): e.AnonymousFunctionEntity;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): e.AnonymousFunctionEntity;
+    ofRegularOrBlockFunctionLiteral(node: tree.RegularOrBlockFunctionLiteral): e.AnonymousFunctionEntity;
+    ofFunctionLiteralInternal(node: tree.FunctionLiteral): se.FunctionLiteralEntity;
+    ofFunctionBlockLiteralInternal(node: tree.FunctionBlockLiteral): se.FunctionBlockLiteralEntity;
+    ofFunctionLiteralParameterDeclarationInternal(node: tree.ParameterDeclaration, literal: tree.FunctionLiteral): se.FunctionLiteralParameterDeclarationEntity;
+    private getContainingPackageLoadedFromDts;
+    private createComputedFieldEntities;
+    private createComputedFieldEntitiesWithoutIsStaticCheck;
+    private createDereferenceOperatorEntities;
+    private createDereferenceOperatorEntitiesWithoutIsStaticCheck;
+    private createIndexerAndParameterEntities;
+    private createIndexerAndParameterEntitiesWithoutIsStaticCheck;
+    private createAndCacheIndexerEntityAndParameters;
+    private areIndexedElementAccessorDeclarationsEqual;
+}
+declare class ResultLocalVariableEntity {
+    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;
+    ofFunctionLiteral(node: tree.FunctionLiteral): e.LocalVariableEntity;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): e.LocalVariableEntity;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.LocalVariableEntity;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.LocalVariableEntity;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.LocalVariableEntity;
+    ofDereferencedVariableGetterDeclaration(node: tree.DereferencedVariableGetterDeclaration): e.LocalVariableEntity;
+    ofFunctionDeclaration(node: tree.FunctionDeclaration): e.LocalVariableEntity;
+    ofTextTranslationFunctionDeclaration(node: tree.TextTranslationFunctionDeclaration): e.LocalVariableEntity;
+    private createResultLocalVariableEntity;
+}
+declare class ValueLocalVariableEntity {
+    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;
+    ofDereferencedVariableSetterDeclaration(node: tree.DereferencedVariableSetterDeclaration): e.LocalVariableEntity;
+    private createValueLocalVariableEntity;
+}
+declare class Tags {
+    private readonly analyzer;
+    private readonly tagsByNodeWithTags;
+    constructor(analyzer: Analyzer);
+    ofNodeWithTags(node: tree.NodeWithTags): readonly tags.Tag[];
+    private createTagsOfNodeWithTags;
+    private createTagFromNode;
+    private argumentToTagArgument;
+}
+declare class PackageImports {
+    private readonly analyzer;
+    private readonly packagesAvailableForImport;
+    private readonly resolvedPackageImports;
+    private readonly importedPackages;
+    private readonly automaticallyImportedPackages;
+    private readonly importedPackageNameTrees;
+    constructor(analyzer: Analyzer);
+    resolvePackageImports(sourceFile: project.SourceFileA): ReadonlyMap<tree.PackageImport, ResolvedPackageImport>;
+    getPackagesAvailableForImport(pkg: project.SourcePackageA): readonly e.PackageEntity[];
+    getUniqueImportedPackages(sourceFile: project.SourceFileA): readonly PackageImportInfo[];
+    getImportedPackageNameTree(node: tree.SourceFile): ImportedPackageNameTree;
+    private getAutomaticallyImportedPackages;
+}
+export declare class ResolvedPackageImport {
+    readonly entity: e.PackageEntity | undefined;
+    readonly isAliasedImport: e.PackageAliasEntity | undefined;
+    constructor(entity: e.PackageEntity | undefined, isAliasedImport: e.PackageAliasEntity | undefined);
+}
+export declare class ExpressionDenotesFunctionCheckResult {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+export declare class DeclaredTypeMemberEntities {
+    readonly variables: readonly e.FieldEntity[];
+    readonly methods: readonly e.MethodEntity[];
+    readonly constructors: readonly e.ConstructorEntity[];
+    readonly destructors: readonly e.DestructorEntity[];
+    readonly indexers: readonly e.IndexerEntity[];
+    readonly dereferenceOperators: readonly e.DereferenceOperatorEntity[];
+    get namedMembers(): e.NamedTypeMemberEntity[];
+    constructor(variables: readonly e.FieldEntity[], methods: readonly e.MethodEntity[], constructors: readonly e.ConstructorEntity[], destructors: readonly e.DestructorEntity[], indexers: readonly e.IndexerEntity[], dereferenceOperators: readonly e.DereferenceOperatorEntity[]);
+}
+export {};

package/build/types/analysis/{ArgumentToParameterMatchResult.d.ts → a/ArgumentToParameterMatchResult.d.ts}

@@ -1,7 +1,7 @@
-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';
+import { ParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
 export declare class ArgumentToParameterMatchResult {
     private readonly analyzer;
     private readonly matchResults;

package/build/types/analysis/{ArgumentsToParametersMatcher.d.ts → a/ArgumentsToParametersMatcher.d.ts}

@@ -1,8 +1,8 @@
-import { Name } from '../common/index.js';
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import * as tree from '../tree/index.js';
-import { Analyzer } from './index.js';
-import { NodeOrDiagnosticLocation } from './Utils.js';
+import { Name } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/a/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { Analyzer } from './Analyzer.js';
 export declare class ArgumentToParameterMatcher<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends IArgument> {
     private readonly analyzer;
     private readonly signature;

package/build/types/analysis/{AutotypeCallExpressionMeaning.d.ts → a/AutotypeCallExpressionMeaning.d.ts}

@@ -1,13 +1,14 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { AutotypeCallExpression } from '../tree/index.js';
-import * as types from '../types/index.js';
-import { Analyzer, ExpressionAnalysisOptions } from './index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;
     private readonly analysisOptions;
     private readonly diagnostics;
-    constructor(analyzer: Analyzer, node: AutotypeCallExpression, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    constructor(analyzer: Analyzer, node: tree.AutotypeCallExpression, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
     resolve(): ResolutionResult;
     private isAutotypeExpressionInValidPosition;
 }
@@ -28,10 +29,8 @@ declare class Meaning_constructorCall {
      */
     readonly type: types.Type;
     readonly candidates: readonly types.Constructor[];
-    readonly suitableConstructors: readonly types.Constructor[];
+    readonly suitableOrSingleConstructor: types.Constructor | undefined;
     readonly kind = "constructor-call";
-    get singleSuitableConstructor(): types.Constructor | undefined;
-    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -40,7 +39,7 @@ declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableOrSingleConstructor: types.Constructor | undefined);
 }
 declare class Meaning_unresolved {
     readonly kind = "unresolved";

package/build/types/analysis/{BaseExpressionMeaning.d.ts → a/BaseExpressionMeaning.d.ts}

@@ -1,7 +1,7 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { AccessedFunction } from './AccessedFunction.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction } from '../AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
 export declare class FirstStageResolver {
     private readonly analyzer;
@@ -14,6 +14,7 @@ export declare class FirstStageResolver {
     private resolveBaseMethodAccess;
     private resolveBaseObjectAccess;
     private invalidContextDiagnostic;
+    private staticContextDiagnostic;
     private getBaseOrAliasedType;
     private getContainingTypeMemberDeclaration;
 }
@@ -51,10 +52,8 @@ declare class Meaning_baseConstructorAccess {
      */
     readonly type: types.Type;
     readonly candidates: readonly types.Constructor[];
-    readonly suitableConstructors: readonly types.Constructor[];
+    readonly suitableOrSingleConstructor: types.Constructor | undefined;
     readonly kind = "base-constructor-access";
-    get singleSuitableConstructor(): types.Constructor | undefined;
-    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -63,7 +62,7 @@ declare class Meaning_baseConstructorAccess {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[]);
+    type: types.Type, candidates: readonly types.Constructor[], suitableOrSingleConstructor: types.Constructor | undefined);
 }
 declare class Meaning_overriddenMethodAccess {
     readonly method: AccessedFunction;

package/build/types/analysis/{CallExpressionMeaning.d.ts → a/CallExpressionMeaning.d.ts}

@@ -1,9 +1,10 @@
-import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
-import { NamedTypeEntity } from '../entities/index.js';
-import * as tree from '../tree/index.js';
-import * as types from '../types/index.js';
-import { AccessedFunction, NotSubstitutedAccessedFunction } from './AccessedFunction.js';
-import { Analyzer, ExpressionAnalysisOptions } from './index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity } from '../../entities/index.js';
+import * as tree from '../../tree/a/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
 export declare class Resolver {
     private readonly analyzer;
     private readonly node;
@@ -20,12 +21,9 @@ export declare class Resolver {
 export type Meaning = Meaning_functionCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_unresolved;
 export declare class Meaning_functionCall {
     readonly candidates: readonly NotSubstitutedAccessedFunction[];
-    readonly suitableFunctions: readonly AccessedFunction[];
-    readonly singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined;
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
     readonly kind = "function-call";
-    get singleSuitableFunction(): AccessedFunction | undefined;
-    get singleFunction(): AccessedFunction | undefined;
-    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableFunctions: readonly AccessedFunction[], singleNotSuitableSubstitutedCandidate: AccessedFunction | undefined);
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
 }
 export declare class Meaning_objectFunctionCall {
     readonly type: types.FunctionType;
@@ -43,11 +41,8 @@ export declare class Meaning_constructorCall {
     readonly type: types.Type | undefined;
     readonly typeEntity: NamedTypeEntity | undefined;
     readonly candidates: readonly types.Constructor[];
-    readonly suitableConstructors: readonly types.Constructor[];
-    readonly singleNotSuitableSubstitutedCandidate: types.Constructor | undefined;
+    readonly suitableOrSingleConstructor: types.Constructor | undefined;
     readonly kind = "constructor-call";
-    get singleSuitableConstructor(): types.Constructor | undefined;
-    get singleConstructor(): types.Constructor | undefined;
     constructor(
     /**
      * Тип объекта, получаемого в результате вызова конструктора.
@@ -56,7 +51,7 @@ export declare class Meaning_constructorCall {
      * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
      * с ним совместим.
      */
-    type: types.Type | undefined, typeEntity: NamedTypeEntity | undefined, candidates: readonly types.Constructor[], suitableConstructors: readonly types.Constructor[], singleNotSuitableSubstitutedCandidate: types.Constructor | undefined);
+    type: types.Type | undefined, typeEntity: NamedTypeEntity | undefined, candidates: readonly types.Constructor[], suitableOrSingleConstructor: types.Constructor | undefined);
 }
 export declare class Meaning_unresolved {
     readonly kind = "unresolved";