@artel/artc 0.6.26039 → 0.8.26001

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

@@ -1,10 +1,434 @@
-import { Analyzer as AnalyzerA } from '../a/Analyzer.js';
+import { Name, PackageLocale, Query, 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/m/index.js';
+import * as project from '../../project/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
 import { Analyzer as BaseAnalyzer, CommonAnalyzerState } from '../Analyzer.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
+import { ImportedPackageNameTree, PackageImportInfo, PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { Analyzer as AnalyzerA } from '../a/Analyzer.js';
+import { ArgumentToParameterMatchResult, MatchResultParameter } from './ArgumentToParameterMatchResult.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 { ReachabilityChecker } from './ReachabilityChecker.js';
+import { ReductionSourceMemberFinder } from './ReductionSourceMemberFinder.js';
+import { ReservedNameKind } from './ReservedNameDictionary.js';
+import * as staticDeclarationMeaning from './StaticDeclarationMeaning.js';
+import { SyntacticAccessKind } from './SyntacticAccessKind.js';
+import * as tagMeaning from './TagMeaning.js';
+import * as controlFlow from './control-flow/index.js';
+import * as semanticContext from './semantic-context/index.js';
 /**
  * Анализатор диалекта М.
  */
 export declare class Analyzer extends BaseAnalyzer {
     readonly dialectA: AnalyzerA;
+    readonly type: Type;
+    readonly returnType: ReturnType;
+    readonly entity: Entity;
+    readonly semanticContext: semanticContext.SemanticContextBuilder;
+    readonly argumentToParameterMatchResult: ArgumentToParameterMatchResult;
+    readonly tags: Tags;
+    readonly packageImports: PackageImports;
+    readonly reachabilityChecker: ReachabilityChecker;
+    readonly reductionSourceMemberFinder: ReductionSourceMemberFinder;
+    readonly localTypes: LocalTypes;
+    readonly staticDeclarations: StaticDeclarations;
     get dialectM(): Analyzer;
+    private readonly targetType;
+    private readonly memberAccessExpressionResolutionResults;
+    private readonly memberAccessExpressionResolutionResultsFirstStage;
+    private readonly callExpressionResolutionResults;
+    private readonly indexedAccessExpressionResolutionResults;
+    private readonly dereferenceExpressionMeanings;
+    private readonly identifierExpressionResolutionResults;
+    private readonly identifierExpressionResolutionResultsFirstStage;
+    private readonly tagResolutionResults;
+    private readonly objectExpressionResolutionResults;
+    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;
+    private readonly packageTypeMemberConflictsDiagnostics;
+    private readonly valueParameterEntities;
     constructor(state: CommonAnalyzerState, analyzerA: AnalyzerA);
+    getProjectSourceFileM(node: tree.SourceFile): project.SourceFileM;
+    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;
+    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;
+    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 | tree.StaticDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
+    getDeclarationsUsageOfSourceFileM(sourceFile: tree.SourceFile, taskController: TaskController): Promise<DeclarationsUsageMap>;
+    getPackageAndStaticVariablesInitializationDiagnostics(pkg: project.SourcePackageM, taskController: TaskController): Promise<readonly Diagnostic[]>;
+    getPackageTypeMemberConflictsDiagnostics(pkg: project.SourcePackageM): Promise<readonly Diagnostic[]>;
+    createDefaultConstructors(typeEntity: e.StructuredTypeEntity, fields: readonly e.FieldEntity[]): readonly e.MethodEntity[];
+    createBackingPackageVariables(declaredPackageMembers: readonly e.NamedPackageMemberEntity[], pkg: e.PackageEntity): e.PackageVariableEntity[];
+    createBackingFields(declaredMembers: readonly e.NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
+    getDeclaredTypeMemberEntities(node: tree.TypeWithMembersOrExtensionDeclaration): e.TypeMemberEntity[];
+    checkBodyOfBasicAliasTypeMethod(node: tree.MethodDeclaration | tree.StaticMethodDeclaration, diagnostics?: DiagnosticAcceptor): {
+        basicMethodOfOriginalType: e.MethodEntity;
+    } | undefined;
+    getControlFlowGraph(sourceFile: project.SourceFileM): controlFlow.GraphBuildResult;
+    validateSourcePackageMemberConflicts(pkg: project.ProgramOrTextTranslationPackage): readonly Diagnostic[];
+    determineUnderlyingTypeOfSourceVariantType(memberList: tree.TypeMemberDeclarationList): types.Type;
+    getOwnAndBaseConstructorCallsCheckResult(node: tree.TypeWithMembersDeclaration): OwnAndBaseConstructorCallsCheckResult;
+    isCallingOwnConstructorCorrectly(node: tree.MethodDeclaration): boolean;
+    isOwnOrBaseConstructorCalledCorrectly(node: tree.CallExpression): 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.IdentifierExpression | tree.MemberAccessExpression): boolean;
+    checkTypeIsUsedAsValue(typeAccess: tree.IdentifierExpression | tree.MemberAccessExpression): boolean;
+    isPossiblyCastedBaseExpression(node: tree.Expression): boolean;
+    createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], nodeOrLocation: NodeOrDiagnosticLocation): Diagnostic;
+    /**
+     * Является ли член типа именованным с точки зрения диалекта М.
+     */
+    isNamedTypeMemberEntity(entity: e.TypeMemberEntity): entity is e.NamedTypeMemberEntity;
+    getValueParameterOfSetterEntity(entity: e.AccessorEntity): e.ParameterEntity | undefined;
+    getValueParameterNodeOfSetter(node: tree.PackageVariableSetterDeclaration | tree.StaticFieldSetterDeclaration | tree.FieldSetterDeclaration | tree.IndexedElementSetterDeclaration): tree.ParameterDeclaration | undefined;
+    getIndexParametersOfIndexedElementSetter(node: tree.IndexedElementAccessorDeclaration): Query<tree.ParameterDeclaration>;
+}
+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 and: BinaryExpressionOperatorClassificationResult;
+    const or: 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 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 ofAssumptionExpression;
+    private ofBinaryExpression;
+    private ofCallExpression;
+    private ofIndexedAccessExpression;
+    private ofMissingExpression;
+    private ofParenthesizedExpression;
+    private ofPrefixUnaryExpression;
+    private ofMemberAccessExpression;
+    private ofReferenceExpression;
+    private ofDereferenceExpression;
+    private ofConditionalExpression;
+    private ofTextLiteral;
+    private ofLocalizableTextLiteral;
+    /**
+       * По умолчанию литерал шаблона текста имеет тип Текст.
+       *
+       * Литерал шаблона текста имеет тип ШаблонТекста в следующих случаях:
+       * - если он присваивается в переменную, имеющую тип ШаблонТекста;
+       * - если он присваивается в переменную, имеющую союзный тип, содержащий тип ШаблонТекста
+       *   и не содержащий тип Текст.
+       */
+    private ofTextTemplateLiteral;
+    /**
+     * По умолчанию литерал шаблона текста имеет тип Текст.
+     *
+     * Литерал переводимого шаблона текста имеет тип ШаблонТекстаПереводимый в следующих случаях:
+     * - если он присваивается в переменную, имеющую тип ШаблонТекстаПереводимый;
+     * - если он присваивается в переменную, имеющую союзный тип, содержащий тип ШаблонТекстаПереводимый
+     *   и не содержащий тип Текст.
+     */
+    private ofLocalizableTextTemplateLiteral;
+    private ofIdentifierExpression;
+    private ofTokenExpression;
+    private ofKeywordExpression;
+    private ofObjectExpression;
+    private ofBaseExpression;
+    private ofGenericSpecializationExpression;
+    private ofDefaultMatchExpression;
+    private ofLocalTypeSpecifier;
+    private ofNamedTypeSpecifier;
+    private ofParenthesizedTypeSpecifier;
+    private ofNullableTypeSpecifier;
+    private ofUnionTypeSpecifier;
+    private ofInvalidTypeSpecifier;
+    private reportReturnTypeCanNotBeInferredDiagnostic;
+    private getNarrowedTypeIfNarrowableReference;
+}
+declare class ReturnType {
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
+    ofLocalFunctionTypeDeclaration(node: tree.LocalFunctionTypeDeclaration): 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;
+    ofStaticMethodDeclaration(node: tree.StaticMethodDeclaration): types.Type;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): types.Type;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): types.Type;
+    ofStaticFieldGetterDeclaration(node: tree.StaticFieldGetterDeclaration): 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 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 localFunctionTypeEntities;
+    private readonly aliasTypeEntities;
+    private readonly packageFunctionEntities;
+    private readonly methodEntities;
+    private readonly nestedFunctionEntities;
+    private readonly packageAliasEntities;
+    private readonly textTranslationDeclarationEntities;
+    private readonly functionLiteralEntities;
+    private readonly functionBlockLiteralEntities;
+    private readonly localClassEntities;
+    private readonly packageTypeDeclarationEntities;
+    constructor(analyzer: Analyzer);
+    ofPackage(pkg: project.SourcePackageM): e.PackageEntity;
+    ofProgramPackage(pkg: project.ProgramPackageM): e.ProgramPackageEntity;
+    ofTranslationPackage(pkg: project.TranslationPackageM): se.SourceNameTranslationPackageEntity;
+    ofTextTranslationPackage(pkg: project.TextTranslationPackageM): e.TextTranslationPackageEntity;
+    ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): e.PackageVariableEntity;
+    ofComputedPackageVariableDeclaration(node: tree.PackageVariableAccessorDeclaration): e.PackageVariableEntity;
+    ofFieldDeclaration(node: tree.FieldDeclaration): e.FieldEntity;
+    ofStaticFieldDeclaration(node: tree.StaticFieldDeclaration): e.FieldEntity;
+    ofComputedFieldDeclaration(node: tree.FieldAccessorDeclaration): e.FieldEntity;
+    ofComputedStaticFieldDeclaration(node: tree.StaticFieldAccessorDeclaration): 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;
+    ofPackageTypeDeclaration(node: tree.PackageTypeDeclaration): e.PackageStructuredTypeEntity | e.PackageVariantTypeEntity | e.TypeExtensionEntity;
+    ofLocalStructuredTypeDeclaration(node: tree.LocalStructuredTypeDeclaration): e.LocalStructuredTypeEntity;
+    ofLocalFunctionTypeDeclaration(node: tree.LocalFunctionTypeDeclaration): e.AnonymousFunctionTypeEntity;
+    ofPackageAliasTypeDeclaration(node: tree.PackageAliasTypeDeclaration): e.AliasTypeEntity;
+    ofPackageFunctionDeclaration(node: tree.PackageFunctionDeclaration): e.PackageFunctionEntity;
+    ofMethodDeclaration(node: tree.MethodDeclaration): e.MethodEntity;
+    ofStaticMethodDeclaration(node: tree.StaticMethodDeclaration): e.MethodEntity;
+    ofNestedFunctionDeclaration(node: tree.NestedFunctionDeclaration): e.NestedFunctionEntity;
+    ofPackageVariableGetterDeclaration(node: tree.PackageVariableGetterDeclaration): e.PackageFunctionEntity;
+    ofFieldGetterDeclaration(node: tree.FieldGetterDeclaration): e.MethodEntity;
+    ofStaticFieldGetterDeclaration(node: tree.StaticFieldGetterDeclaration): e.MethodEntity;
+    ofIndexedElementGetterDeclaration(node: tree.IndexedElementGetterDeclaration): e.MethodEntity;
+    ofGetterDeclaration(node: tree.GetterDeclaration): e.AccessorEntity;
+    ofPackageVariableSetterDeclaration(node: tree.PackageVariableSetterDeclaration): e.PackageFunctionEntity;
+    ofFieldSetterDeclaration(node: tree.FieldSetterDeclaration): e.MethodEntity;
+    ofStaticFieldSetterDeclaration(node: tree.StaticFieldSetterDeclaration): e.MethodEntity;
+    ofIndexedElementSetterDeclaration(node: tree.IndexedElementSetterDeclaration): e.MethodEntity;
+    ofSetterDeclaration(node: tree.SetterDeclaration): e.AccessorEntity;
+    ofIndexedElementAccessorDeclaration(node: tree.IndexedElementAccessorDeclaration): e.MethodEntity;
+    ofVariantValueDeclaration(node: tree.VariantValueDeclaration): e.FieldEntity;
+    ofPackageImport(node: tree.PackageImport): e.PackageAliasEntity;
+    ofTypeWithMembersOrExtensionDeclaration(node: tree.TypeWithMembersOrExtensionDeclaration): 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;
+}
+declare class Tags {
+    private readonly analyzer;
+    private readonly tagsByNodeWithTags;
+    constructor(analyzer: Analyzer);
+    ofNodeWithTags(node: tree.NodeWithTags): readonly tags.Tag[];
+    createModifierFlagsOfNodeWithTags(node: tree.NodeWithTags): ModifierFlags;
+    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.SourceFileM): ReadonlyMap<tree.PackageImport, ResolvedPackageImport>;
+    getImportedPackage(node: tree.PackageImport): ResolvedPackageImport | undefined;
+    getPackagesAvailableForImport(pkg: project.SourcePackageM): readonly e.PackageEntity[];
+    getUniqueImportedPackages(sourceFile: project.SourceFileM): readonly PackageImportInfo[];
+    getImportedPackageNameTree(node: tree.SourceFile): ImportedPackageNameTree;
+    private getAutomaticallyImportedPackages;
+}
+declare class LocalTypes {
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
+    collectLocalTypesFromPackageMemberList(result: e.LocalStructuredTypeEntity[], nodes: Iterable<tree.PackageMemberDeclaration> | undefined): void;
+    collectLocalTypesFromTypeMemberList(result: e.LocalStructuredTypeEntity[], nodes: Iterable<tree.TypeMemberDeclaration> | undefined): void;
+    collectLocalTypesFromStatementList(result: e.LocalStructuredTypeEntity[], nodes: Iterable<tree.Statement> | undefined): void;
+    collectLocalTypesInPackageMember(result: e.LocalStructuredTypeEntity[], node: tree.PackageMemberDeclaration | undefined): void;
+    collectLocalTypesInTypeMember(result: e.LocalStructuredTypeEntity[], node: tree.TypeMemberDeclaration | undefined): void;
+    collectLocalTypesInStatement(result: e.LocalStructuredTypeEntity[], node: tree.Statement | undefined): void;
+    collectLocalTypesInExpression(result: e.LocalStructuredTypeEntity[], node: tree.Expression | undefined): void;
+    collectLocalTypesInTagOfNodeWithTags(result: e.LocalStructuredTypeEntity[], node: tree.NodeWithTags | undefined): void;
+    collectLocalTypesInParameterClause(result: e.LocalStructuredTypeEntity[], node: tree.ParameterListParent | undefined): void;
+    collectLocalTypesInTypeParameterClause(result: e.LocalStructuredTypeEntity[], node: tree.TypeParameterClause | undefined): void;
+    collectLocalTypesInTypeArgumentClause(result: e.LocalStructuredTypeEntity[], node: tree.TypeArgumentClause | undefined): void;
+    collectLocalTypesInArgumentList(result: e.LocalStructuredTypeEntity[], node: tree.ArgumentList | undefined): void;
+    collectLocalTypesInVariableInitializer(result: e.LocalStructuredTypeEntity[], node: tree.VariableInitializer | undefined): void;
+    collectLocalTypesInTypeSpecifier(result: e.LocalStructuredTypeEntity[], node: tree.TypeSpecifier | undefined): void;
+}
+declare class StaticDeclarations {
+    private readonly analyzer;
+    private readonly staticDeclarationTypes;
+    private readonly staticDeclarationMeanings;
+    private readonly staticDeclarationsOfTypeOrExtension;
+    constructor(analyzer: Analyzer);
+    resolveStaticDeclarationMeaning(node: tree.StaticDeclaration): staticDeclarationMeaning.Meaning;
+    getTypeEntityContainingStaticDeclaration(node: tree.StaticDeclaration): e.TypeEntityWithMembers;
+    getStaticDeclarationsOfTypeOrExtension(node: tree.TypeWithMembersOrExtensionDeclaration): readonly tree.StaticDeclaration[];
+}
+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 {};

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

@@ -0,0 +1,23 @@
+import { ParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class ArgumentToParameterMatchResult {
+    private readonly analyzer;
+    private readonly matchResults;
+    constructor(analyzer: Analyzer);
+    ofCallExpression(node: tree.CallExpression): MatchResult | undefined;
+    ofTag(node: tree.Tag): MatchResult | undefined;
+    ofIndexedAccessExpression(node: tree.IndexedAccessExpression): MatchResult | undefined;
+    private convertMatchResult;
+    private convertParameter;
+}
+export declare class MatchResult {
+    readonly parameterByArgument: ReadonlyMap<tree.Argument, MatchResultParameter>;
+    constructor(parameterByArgument: ReadonlyMap<tree.Argument, MatchResultParameter>);
+}
+export declare class MatchResultParameter {
+    readonly entity: ParameterEntity;
+    readonly type: types.Type;
+    constructor(entity: ParameterEntity, type: types.Type);
+}

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

@@ -0,0 +1,40 @@
+import { Name } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/m/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;
+    private readonly arguments_;
+    private readonly diagnostics;
+    private readonly unmatchedRequiredParametersDiagnosticLocation;
+    constructor(analyzer: Analyzer, signature: TSignature, arguments_: readonly TArgument[], diagnostics: DiagnosticAcceptor | undefined, unmatchedRequiredParametersDiagnosticLocation: NodeOrDiagnosticLocation | undefined);
+    match(): MatchResult<TParameter, TArgument>;
+    private matchArgumentsToParameters;
+    private reportArgumentDiagnostic;
+}
+export declare class MatchResult<TParameter extends ISignatureParameter, TArgument extends IArgument> {
+    readonly mapping: ReadonlyMap<TArgument, TParameter>;
+    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;
+    isOptional(): boolean;
+    isVariadic(): boolean;
+}
+export interface IArgument {
+    readonly name: Name | undefined;
+    getDiagnosticLocation(): NodeOrDiagnosticLocation | undefined;
+}
+export declare class SourceArgument implements IArgument {
+    private readonly analyzer;
+    readonly node: tree.Argument;
+    readonly name: Name | undefined;
+    constructor(analyzer: Analyzer, node: tree.Argument);
+    getDiagnosticLocation(): NodeOrDiagnosticLocation;
+}

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

@@ -0,0 +1,25 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.BaseExpression, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private resolveBaseObjectAccess;
+    private invalidContextDiagnostic;
+    private staticContextDiagnostic;
+    private getBaseOrAliasedType;
+}
+export type Meaning = Meaning_baseObjectAccess | Meaning_unresolved;
+declare class Meaning_baseObjectAccess {
+    readonly type: types.Type;
+    readonly kind = "base-object-access";
+    constructor(type: types.Type);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export {};

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

@@ -0,0 +1,72 @@
+import { AccessKind } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/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;
+    private readonly analysisOptions;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.CallExpression, analysisOptions: ExpressionAnalysisOptions | undefined, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private checkExpressionDenotesType;
+    private checkExpressionDenotesFunction;
+    private resolveFunctionCallExpression;
+    private getBaseTypeEntity;
+    private resolveConstructorCallOrVariantAccessExpression;
+    private resolveObjectFunctionCallExpression;
+}
+export type Meaning = Meaning_functionCall | Meaning_objectFunctionCall | Meaning_constructorCall | Meaning_variantValueAccess | Meaning_unresolved;
+export declare class Meaning_functionCall {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly isOwnConstructorCall: boolean;
+    readonly isBaseConstructorCall: boolean;
+    readonly isAsFunctionCall: boolean;
+    readonly isIsFunctionCall: boolean;
+    readonly kind = "function-call";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined, isOwnConstructorCall: boolean, isBaseConstructorCall: boolean, isAsFunctionCall: boolean, isIsFunctionCall: boolean);
+}
+export declare class Meaning_objectFunctionCall {
+    readonly type: types.FunctionType;
+    readonly kind = "object-function-call";
+    constructor(type: types.FunctionType);
+}
+export declare class Meaning_constructorCall {
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    readonly type: types.Type | undefined;
+    readonly typeEntity: NamedTypeEntity | undefined;
+    readonly candidates: readonly types.Method[];
+    readonly suitableOrSingleConstructor: types.Method | undefined;
+    readonly kind = "constructor-call";
+    constructor(
+    /**
+     * Тип объекта, получаемого в результате вызова конструктора.
+     *
+     * При поиске конструктора в типе-псевдониме конструктор может быть найден в оригинальном типе. В таком случае тип,
+     * создаваемый найденным конструктором, будет отличаться от результирующего типа, хранимого в этом поле, но будет
+     * с ним совместим.
+     */
+    type: types.Type | undefined, typeEntity: NamedTypeEntity | undefined, candidates: readonly types.Method[], suitableOrSingleConstructor: types.Method | undefined);
+}
+export declare class Meaning_variantValueAccess {
+    readonly suitableTypes: readonly types.Type[];
+    readonly type: types.Type;
+    readonly field: types.Field;
+    readonly accessKind: AccessKind;
+    readonly kind = "variant-value-access";
+    constructor(suitableTypes: readonly types.Type[], type: types.Type, field: types.Field, accessKind: AccessKind);
+}
+export declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}

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

@@ -0,0 +1,24 @@
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
+import { Analyzer } from './Analyzer.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+export declare class Resolver {
+    static resolve(analyzer: Analyzer, candidates: readonly types.Method[], argumentList: tree.ArgumentList | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): readonly types.Method[];
+    static resolveByNamedTypes(analyzer: Analyzer, typeEntities: readonly NamedTypeEntity[], argumentList: tree.ArgumentList | undefined, typeArgumentClause: tree.TypeArgumentClause | undefined, analysisOptions: ExpressionAnalysisOptions, typeMemberLookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, diagnosticLocation: NodeOrDiagnosticLocation | undefined): ResolutionResult;
+    private static typeCanBeConstructed;
+}
+export declare class ResolutionResult {
+    readonly candidates: readonly types.Method[];
+    readonly suitableConstructors: readonly types.Method[];
+    readonly typeEntity: NamedTypeEntity | undefined;
+    readonly type: types.Type | undefined;
+    readonly singleNotSuitableSubstitutedCandidate: types.Method | undefined;
+    private static empty_;
+    static get empty(): ResolutionResult;
+    get suitableOrSingleConstructor(): types.Method | undefined;
+    constructor(candidates: readonly types.Method[], suitableConstructors: readonly types.Method[], typeEntity: NamedTypeEntity | undefined, type: types.Type | undefined, singleNotSuitableSubstitutedCandidate: types.Method | undefined);
+}

package/build/types/analysis/m/DeclarationsUsageCounter.d.ts

@@ -0,0 +1,12 @@
+import { TaskController } from '../../common/index.js';
+import * as tree from '../../tree/m/index.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
+import { Analyzer } from './Analyzer.js';
+export declare class DeclarationsUsageCounter {
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly usageInfoByEntity;
+    constructor(analyzer: Analyzer, sourceFile: tree.SourceFile);
+    count(taskController: TaskController): Promise<DeclarationsUsageMap>;
+    private recordUsage;
+}