@artel/artc 0.6.26039 → 0.9.26001

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

@@ -0,0 +1,104 @@
+import { Displayable, Name } from '../../common/index.js';
+import { DiagnosticAcceptorWithArgumentFactory } from '../../diagnostic/Diagnostic.js';
+import { TypeParameterEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { DiagnosticArgumentFactory } from '../DiagnosticArgumentFactory.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { Analyzer } from './Analyzer.js';
+import * as matcher from './ArgumentsToParametersMatcher.js';
+import { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+import * as inferrer from './TypeArgumentInferrer.js';
+export declare class OverloadResolver<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends Argument> {
+    private readonly analyzer;
+    private readonly mode;
+    private readonly signatures;
+    private readonly arguments_;
+    private readonly analysisOptions;
+    private readonly dataForTypeArgumentInference;
+    private readonly diagnostics;
+    private readonly nodesForDiagnostic;
+    constructor(analyzer: Analyzer, mode: ResolutionMode, signatures: readonly TSignature[], arguments_: readonly TArgument[], analysisOptions: ExpressionAnalysisOptions, dataForTypeArgumentInference: DataForTypeArgumentInference | undefined, diagnostics: DiagnosticAcceptorWithArgumentFactory | undefined, nodesForDiagnostic: DiagnosticLocations | undefined);
+    resolveOverload(): ProcessedSignature<TSignature, TParameter, TArgument>[];
+    private areArgumentTypesAssignableToParameterTypes;
+    private tryChooseBestSignature;
+    private tryChooseBetterSignatureBasedOnParameterTypes;
+    private chooseBetterTargetType;
+    private tryChooseBetterSignatureBasedOnVariadicParameters;
+    private tryChooseBetterSignatureBasedOnPresenceOfTypeParameters;
+    private tryChooseBetterSignatureBasedOnParameterCount;
+    private functionLiteralCouldBeAssignableToType;
+    private reportAmbiguousAccessDiagnostic;
+}
+export interface ISignature<TParameter extends ISignatureParameter> extends matcher.ISignature<TParameter> {
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly TParameter[];
+    getReturnType(): types.Type | undefined;
+    getOuterSubstitutions(): types.Substitutions | undefined;
+    toDisplayable(factory: DiagnosticArgumentFactory): Displayable;
+}
+export interface ISignatureParameter extends matcher.ISignatureParameter {
+    getType(): types.Type;
+    getIndex(): number;
+}
+export type ResolutionMode = ResolutionByExplicitArguments | ResolutionByTargetType;
+export declare class ResolutionByExplicitArguments {
+    readonly kind = "by-explicit-arguments";
+}
+export declare class ResolutionByTargetType {
+    readonly targetType: types.FunctionType;
+    readonly kind = "by-target-type";
+    constructor(targetType: types.FunctionType);
+}
+export type Argument = SourceArgument | IntrinsicArgument;
+export interface SourceArgument extends matcher.IArgument, inferrer.SourceArgument, IArgument {
+    readonly kind: 'source';
+    readonly expression: tree.Expression;
+}
+export declare class IntrinsicArgument implements matcher.IArgument, inferrer.IntrinsicArgument, IArgument {
+    readonly kind = "intrinsic";
+    readonly type: types.Type;
+    get name(): Name | undefined;
+    constructor(type: types.Type);
+    getDiagnosticLocation(): NodeOrDiagnosticLocation | undefined;
+    getType(analysisOptions_: ExpressionAnalysisOptions | undefined): types.Type;
+}
+interface IArgument {
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
+}
+export declare class SourceNodeArgument implements SourceArgument {
+    readonly kind = "source";
+    readonly node: tree.Argument;
+    readonly name: Name | undefined;
+    private readonly analyzer;
+    get expression(): tree.Expression;
+    constructor(analyzer: Analyzer, node: tree.Argument);
+    getDiagnosticLocation(): NodeOrDiagnosticLocation;
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
+}
+export declare class SourceExpressionArgument implements SourceArgument {
+    private readonly analyzer;
+    readonly expression: tree.Expression;
+    readonly kind = "source";
+    get name(): Name | undefined;
+    constructor(analyzer: Analyzer, expression: tree.Expression);
+    getDiagnosticLocation(): NodeOrDiagnosticLocation;
+    getType(analysisOptions: ExpressionAnalysisOptions | undefined): types.Type;
+}
+export declare class DataForTypeArgumentInference {
+    readonly specifiedTypeArguments: readonly types.Type[];
+    readonly targetType: types.Type | undefined;
+    constructor(specifiedTypeArguments: readonly types.Type[], targetType: types.Type | undefined);
+}
+export interface DiagnosticLocations {
+    readonly access: NodeOrDiagnosticLocation | undefined;
+    readonly typeArgumentClause: NodeOrDiagnosticLocation | undefined;
+    readonly argumentList: NodeOrDiagnosticLocation | undefined;
+}
+export interface ProcessedSignature<TSignature extends ISignature<TParameter>, TParameter extends ISignatureParameter, TArgument extends matcher.IArgument> {
+    readonly value: TSignature;
+    readonly matchResult: matcher.MatchResult<TParameter, TArgument>;
+    readonly typeArguments: readonly types.Type[] | undefined;
+    readonly isMatching: boolean;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { Diagnostic } from '../../diagnostic/Diagnostic.js';
+import { MethodEntity, TypeWithMembersOrExtensionEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import { SemanticContext } from './semantic-context/SemanticContext.js';
+export declare class OwnAndBaseConstructorCallsChecker {
+    private readonly analyzer;
+    private readonly constructorDeclarations;
+    private readonly typeEntity;
+    private readonly semanticContext;
+    constructor(analyzer: Analyzer, constructorDeclarations: readonly tree.MethodDeclaration[], typeEntity: TypeWithMembersOrExtensionEntity, semanticContext: SemanticContext);
+    check(): OwnAndBaseConstructorCallsCheckResult;
+    private addOwnConstructorCallOrReportCycleDiagnostic;
+    private getUnaliasedBaseObjectType;
+    private findAccessibleConstructorWithoutParameters;
+}
+export declare class OwnAndBaseConstructorCallsCheckResult {
+    readonly typeRequiresExplicitOwnOrBaseConstructorCalls: boolean;
+    readonly ownOrBaseConstructorCallInfos: ReadonlyMap<MethodEntity, OwnOrBaseConstructorCallInfo>;
+    readonly diagnostics: readonly Diagnostic[];
+    constructor(typeRequiresExplicitOwnOrBaseConstructorCalls: boolean, ownOrBaseConstructorCallInfos: ReadonlyMap<MethodEntity, OwnOrBaseConstructorCallInfo>, diagnostics: readonly Diagnostic[]);
+}
+export declare class OwnOrBaseConstructorCallInfo {
+    readonly isOwnConstructorCall: boolean;
+    readonly constructor_: types.Method;
+    /**
+     * Отсутствие узла означает, что базовый конструктор без параметров не был вызван явно.
+     */
+    readonly node: tree.CallExpression | undefined;
+    constructor(isOwnConstructorCall: boolean, constructor_: types.Method, 
+    /**
+     * Отсутствие узла означает, что базовый конструктор без параметров не был вызван явно.
+     */
+    node: tree.CallExpression | undefined);
+}

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

@@ -0,0 +1,17 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { SourcePackageM } from '../../project/SourcePackage.js';
+import { DeclarationsUsageMap } from '../DeclarationsUsageMap.js';
+import { Analyzer } from './Analyzer.js';
+export declare class PackageAndStaticVariablesInitializationValidator {
+    private readonly analyzer;
+    private readonly package_;
+    private readonly declarationsUsageMapList;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, package_: SourcePackageM, declarationsUsageMapList: readonly DeclarationsUsageMap[], diagnostics: DiagnosticAcceptor);
+    validate(): void;
+    private getVariablesThatNeedToBeInitializedInSourceFile;
+    private collectStaticFieldsThatNeedToBeInitializedInConstructor;
+    private excludeVariablesInitializedInSourceFile;
+    private reportNotInitialedVariableDiagnostic;
+    private getVariableDiagnosticLocationWithFallback;
+}

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

@@ -0,0 +1,27 @@
+import { Analyzer } from './Analyzer.js';
+import * as controlFlow from './control-flow/index.js';
+export declare class ReachabilityChecker {
+    private readonly analyzer;
+    private readonly checkResults;
+    constructor(analyzer: Analyzer);
+    /**
+     * Проверяет, достижим ли узел графа потока управления с учётом семантики.
+     *
+     * Дополнительные проверки необходимы по причине того, что граф потока управления строится на основе синтаксического
+     * дерева и не учитывает семантику.
+     *
+     * Например, следующий код
+     * ```artel
+     * пусть а = Объект()
+     * если не(а это Объект)
+     * {
+     *   // ...
+     * }
+     * ```
+     *
+     * достижим с точки зрения синтаксиса, но недостижим с точки зрения семантики, поскольку типом переменной `а`
+     * всегда является `Объект`.
+     */
+    isControlFlowNodeReachable(node: controlFlow.Node): boolean;
+    private isConditionReachable;
+}

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

@@ -0,0 +1,17 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import * as types from '../../types/index.js';
+import { NodeOrDiagnosticLocation } from '../NodeOrDiagnosticLocation.js';
+import { TypeMemberLookupContext } from '../TypeMemberLookup.js';
+import { Analyzer } from './Analyzer.js';
+export declare class ReductionSourceMemberFinder {
+    private static readonly signatureComparisonOptions;
+    private readonly analyzer;
+    constructor(analyzer: Analyzer);
+    findField(member: types.Field, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Field | undefined;
+    findMethod(member: types.Method, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Method | undefined;
+    findIndexer(member: types.Indexer, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.Indexer | undefined;
+    findDereferenceOperator(member: types.DereferenceOperator, reductionSource: types.Type, lookupContext: TypeMemberLookupContext, diagnostics: DiagnosticAcceptor, diagnosticLocation: NodeOrDiagnosticLocation): types.DereferenceOperator | undefined;
+    private getTypeMemberLookupOptions;
+    private checkMembersHaveSameHiding;
+    private checkMembersHaveSameTypes;
+}

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

@@ -0,0 +1,15 @@
+import { Name } from '../../common/Name.js';
+import { PackageLocale } from '../../common/PackageLocale.js';
+export declare const enum ReservedNameKind {
+    Result = 0,
+    Value = 1,
+    Creation = 2,
+    Destruction = 3,
+    Stored = 4
+}
+export declare const reservedNamesByLocale: {
+    readonly [T in PackageLocale]: {
+        readonly [T in ReservedNameKind]: Name;
+    };
+};
+export declare const reservedNameKindByNameKey: { readonly [T in PackageLocale]: ReadonlyMap<string, ReservedNameKind>; };

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

@@ -0,0 +1,68 @@
+import { PackageLocale } from '../../common/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { EntityLocalizationContext, LocalizablePackageMemberEntity } from '../../entities/EntityLocalizationContext.js';
+import { AnonymousTypeEntity, Entity, EntityContainingParameter, EntityContainingTypeParameter, PackageEntity, PackageEntityMembers, PackageMemberEntity, ParameterEntity, TypeEntityMembers, TypeMemberEntity, TypeParameterEntity, TypeWithMembersOrExtensionEntity, LocalTypeEntity } from '../../entities/index.js';
+import { PackageName, SourceFile, TranslationPackageM } from '../../project/index.js';
+import * as tree from '../../tree/m/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class ResolvedTranslationPackage {
+    private static readonly maxDisplayedNotTranslatedEntitiesCount;
+    readonly localizationContext: EntityLocalizationContext;
+    readonly translatedTargetPackage: PackageEntity;
+    private readonly analyzer;
+    private readonly package_;
+    private readonly packageEntity;
+    private readonly targetPackage;
+    private readonly entityNameConflictsValidator;
+    private readonly translatedEntityByOriginal;
+    private readonly packageMemberTranslationTargetsByNode;
+    private readonly typeMemberTranslationTargetsByNode;
+    private readonly translatedPackageMembers;
+    private readonly translatedTypeMembersByTypeOrExtensionEntity;
+    constructor(analyzer: Analyzer, package_: TranslationPackageM, targetPackage: PackageEntity);
+    getTargetPackage(): PackageEntity;
+    getDefinition(): TranslationPackageM;
+    getTranslatedName(): PackageName;
+    getTranslationLocale(): PackageLocale;
+    getTranslatedPackageMembers(): PackageEntityMembers;
+    ensureAllLazyDiagnosticsReportedForSourceFile(sourceFile: SourceFile): void;
+    accumulateDiagnosticForSourceFile(sourceFile: SourceFile, diagnostics: DiagnosticAcceptor): void;
+    getPackageMemberTranslationTargets(node: tree.TranslationDeclaration): TranslationTargets<LocalizablePackageMemberEntity> | undefined;
+    getTypeMemberTranslationTargets(node: tree.TypeMemberTranslation): TranslationTargets<TypeMemberEntity> | undefined;
+    getTranslatedPackageMember(entity: LocalizablePackageMemberEntity): LocalizablePackageMemberEntity;
+    getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
+    getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
+    getTranslatedLocalTypeEntity(entity: LocalTypeEntity): LocalTypeEntity;
+    getTranslatedTypeOrExtensionMembers(translatedTypeEntity: TypeWithMembersOrExtensionEntity): TypeEntityMembers;
+    createTranslatedTypeParameters(original: readonly TypeParameterEntity[], node: tree.TranslationTypeParameterList | undefined, containingEntity: EntityContainingTypeParameter): readonly TypeParameterEntity[];
+    createTranslatedParameters(original: readonly ParameterEntity[], node: tree.TranslationParameterList | undefined, containingEntity: EntityContainingParameter): readonly ParameterEntity[];
+    static isPackageMemberEntityThatShouldBeTranslatedByUser(entity: PackageMemberEntity): boolean;
+    static isTypeMemberEntityThatShouldBeTranslatedByUser(entity: TypeMemberEntity): boolean;
+    private createTranslatedPackageMembers;
+    private createTranslatedTypeOrExtensionMembers;
+    private ensureTypeMembersHaveBeenCreated;
+    private reportPackageMemberHasAlreadyBeenTranslatedDiagnostic;
+    private reportTypeMemberHasAlreadyBeenTranslatedDiagnostic;
+    private createTranslatedNamedPackageMemberEntityWithMissingTranslation;
+    private createTranslatedTypeMemberEntityWithMissingTranslation;
+    private getPackageVariableTranslationTargets;
+    private getPackageFunctionTranslationTargets;
+    private getFunctionTypeTranslationTargets;
+    private createAndCacheTranslatedAnonymousFunctionType;
+    private getTypeTranslationTargets;
+    private getFieldOrVariantTranslationTargets;
+    private getMethodTranslationTargets;
+    private getIndexerTranslationTargets;
+    private checkTranslatedTypeParameterCount;
+    private checkTranslatedParameterCount;
+    private areTypeParameterEntitiesEqualToTranslationTypeParameters;
+    private areParameterEntitiesEqualToTranslationParameters;
+    private createNotTranslatedEntitiesDiagnostic;
+    private createTranslatedDefaultConstructorEntity;
+    private tryCreateAutomaticTranslationOfDerivedTypeMember;
+    private translationsDeclarations;
+}
+export interface TranslationTargets<T extends Entity = Entity> {
+    readonly values: readonly T[];
+    readonly areSuitable: boolean;
+}

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

@@ -0,0 +1,13 @@
+import { LocalVariableEntity } 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 ReturnTypeInferrer {
+    private readonly analyzer;
+    private readonly block;
+    private readonly resultVariable;
+    constructor(analyzer: Analyzer, block: tree.FunctionBlock, resultVariable: LocalVariableEntity | undefined);
+    infer(): types.Type;
+    private checkResultVariableIsUsedAndCollectReturnedTypes;
+    private getTypeOfResultVariableAtTheEndOfSubprogram;
+}

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

@@ -0,0 +1,131 @@
+import { TaskController } from '../../common/index.js';
+import { Diagnostic } from '../../diagnostic/Diagnostic.js';
+import * as project from '../../project/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class SourceFileAnalyzer {
+    private readonly analyzer;
+    private readonly sourceFile;
+    private readonly diagnosticArgumentFactory;
+    private readonly translationPackage_;
+    private readonly textTranslationPackage_;
+    private readonly diagnostics;
+    private readonly diagnosticAcceptor;
+    private namedDeclarationsUsageMap;
+    private readonly overrideChecker;
+    private readonly standardTypes_;
+    private get resolvedTranslationPackage();
+    private get textTranslationPackage();
+    private get isInterfacePackageFile();
+    private get standardTypes();
+    constructor(analyzer: Analyzer, sourceFile: project.SourceFileM);
+    analyze(taskController: TaskController): Promise<Diagnostic[]>;
+    private analyzeNode;
+    private checkTag;
+    private checkPackageAliasTypeDeclaration;
+    private checkTranslationsDeclaration;
+    private addNotTranslatedTextsDiagnostics;
+    private collectNotTranslatedTexts;
+    private createNotTranslatedTextsDiagnostic;
+    private checkTextTranslationDeclaration;
+    private checkPackageTypeDeclaration;
+    private checkAllFieldsOfStructureAreConst;
+    private checkStructureHasRecursiveLayout;
+    private checkStructureIsReferencedByFieldTypeRecursively;
+    private checkStructureIsReferencedByFieldsOfStructure;
+    private isReferencedAutomaticallyGeneratedBackingVariable;
+    private checkBaseObjectTypeHasAccessibleConstructors;
+    private checkAspectsHaveNotBeenExtendedWithDifferentTypeArguments;
+    private checkPackageVariableDeclaration;
+    private checkPackageFunctionDeclaration;
+    private checkPackageVariableGetterDeclaration;
+    private checkPackageVariableSetterDeclaration;
+    private checkPackageMemberBodyPresence;
+    private checkMethodDeclaration;
+    private checkFieldDeclaration;
+    private checkFieldGetterDeclaration;
+    private checkFieldSetterDeclaration;
+    private checkIndexedElementGetterDeclaration;
+    private checkIndexedElementSetterDeclaration;
+    private checkTypeMemberBodyPresence;
+    private checkTypeParameterDeclarationList;
+    private checkTypeParameterDeclaration;
+    private checkNamedTypeSpecifier;
+    private checkLocalStructuredTypeDeclaration;
+    private checkLocalFunctionTypeDeclaration;
+    private checkParameterList;
+    private checkRequiredParametersDoNotFollowOptionalParameters;
+    private parameterListCanDeclareObjectParameter;
+    private checkObjectParameterIsTheFirstParameter;
+    private checkParameterDeclaration;
+    private checkReferenceExpression;
+    private checkSwitchStatement;
+    private checkWhileStatement;
+    private checkElseIfClause;
+    private checkIfStatement;
+    private checkArgument;
+    private checkErrorVariableDeclaration;
+    private checkForStatementVariableDeclaration;
+    private checkLocalVariableDeclaration;
+    private checkBaseExpression;
+    private checkObjectExpression;
+    private checkAssignmentStatement;
+    private checkPrefixUnaryExpression;
+    private checkCatchClause;
+    private checkForStatement;
+    private checkLocalizableTextTemplateLiteral;
+    private checkLocalizableTextLiteral;
+    private checkBinaryExpression;
+    private checkAssumptionExpression;
+    private checkStatementBlock;
+    private checkFunctionBlock;
+    private checkErrorStatement;
+    private checkBreakLoopOrContinueLoopStatement;
+    private isStatementUsedInsideLoop;
+    private checkFunctionLiteral;
+    private checkFunctionBlockLiteral;
+    private checkDereferenceExpression;
+    private checkIndexedAccessExpression;
+    private checkCallExpression;
+    private checkAllDefaultConstructorArgumentsAreNamed;
+    private checkNestedFunctionDeclaration;
+    private checkPossibleGeneratorFunctionReturnType;
+    private checkReturnStatement;
+    private checkYieldStatement;
+    private checkIdentifierExpression;
+    private checkFieldAccessWithImplicitReceiver;
+    private checkOwnFieldAccessedInConstructorIsUsedBeforeBeingAssigned;
+    private isStoredFieldConsideredInitializedAtDeclaration;
+    private checkMethodAccessWithImplicitReceiver;
+    private checkLocalOrPackageVariableUsedBeforeDeclaration;
+    private checkLocalOrPackageVariableIsUsedBeforeBeingAssigned;
+    private isLocalOrPackageVariableConsideredInitializedAtDeclaration;
+    private isLocalVariableDeclaredInTheSameSubprogramInWhichUsed;
+    private checkMemberAccessExpression;
+    private checkExpressionTypeIsAssignableToTargetType;
+    private addTypeAssignabilityDiagnosticIfBothTypesResolved;
+    private checkAssignmentIsValid;
+    private checkAssignmentToIdentifierExpression;
+    private checkAssignmentToMemberAccessExpression;
+    private checkAssignmentToVariable;
+    private checkAssignmentToPackageVariable;
+    private checkAssignmentToField;
+    private checkAssignmentToParameter;
+    private checkAssignmentToLocalVariable;
+    private checkAssignmentToObjectExpression;
+    private checkAssignmentToDereferenceExpression;
+    private checkAssignmentToIndexedAccessExpression;
+    private checkOptionalChainingIsUsedOnTheLeftSideOfAssignment;
+    private checkGenericSpecializationExpression;
+    private checkTypeArgumentTypesAreAssignableToConstraints;
+    private checkIfVariableIsUnused;
+    private checkIfNestedFunctionIsUnused;
+    private checkIfTypeParameterIsUnused;
+    private checkAllCodePathsReturnOrResultVariableIsAssigned;
+    private isReceiverBaseAutoVariableAccess;
+    private attachNodeLocationAndAddDiagnostics;
+    private createAndAddDiagnostic;
+    private addDiagnostic;
+    private addDiagnostics;
+    private addDiagnosticsLocatedInAnalyzedFile;
+    private sortAndRemoveDuplicateDiagnosticsInPlace;
+}

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

@@ -0,0 +1,7 @@
+import { PackageVariableEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class SourcePackageMembersCreator {
+    static createComputedPackageVariableEntities(analyzer: Analyzer, members: Iterable<tree.PackageSingleMemberDeclaration>, entities: Map<tree.Node, PackageVariableEntity>): void;
+    private static processPackageVariableAccessorDeclarations;
+}

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

@@ -0,0 +1,9 @@
+import { FieldEntity, IndexerEntity } from '../../entities/index.js';
+import * as tree from '../../tree/m/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class SourceTypeMembersCreator {
+    static createComputedFieldEntities(analyzer: Analyzer, members: Iterable<tree.TypeSingleMemberDeclaration | tree.StaticDeclaration>, entities: Map<tree.Node, FieldEntity>): void;
+    static createIndexerEntities(analyzer: Analyzer, members: Iterable<tree.TypeSingleMemberDeclaration>, entities: Map<tree.Node, IndexerEntity>): void;
+    private static processFieldAccessorDeclarations;
+    private static processIndexedElementAccessorDeclarations;
+}

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

@@ -0,0 +1,32 @@
+import * as tree from '../../tree/m/index.js';
+import * as e from '../../entities/index.js';
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { Analyzer } from './Analyzer.js';
+import { ResolvedQualifier } from './NamedTypeResolver.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    constructor(analyzer: Analyzer, node: tree.StaticDeclaration, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): Meaning;
+    private checkTypeParameters;
+}
+export type Meaning = Meaning_resolved | Meaning_ambiguous | Meaning_unresolved;
+declare class Meaning_resolved {
+    readonly type: e.TypeEntityWithMembers;
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly kind = "resolved";
+    constructor(type: e.TypeEntityWithMembers, resolvedQualifiers: readonly ResolvedQualifier[]);
+}
+declare class Meaning_ambiguous {
+    readonly entities: readonly e.NamedTypeEntity[];
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly kind = "ambiguous";
+    constructor(entities: readonly e.NamedTypeEntity[], resolvedQualifiers: readonly ResolvedQualifier[]);
+}
+declare class Meaning_unresolved {
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly kind = "unresolved";
+    constructor(resolvedQualifiers: readonly ResolvedQualifier[]);
+}
+export {};

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

@@ -0,0 +1,6 @@
+export declare const enum SyntacticAccessKind {
+    Get = 0,
+    Set = 1,
+    GetSet = 2,
+    ReferencedValue = 3
+}

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

@@ -0,0 +1,70 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { NamedTypeEntity, PackageAliasEntity } from '../../entities/index.js';
+import { Tag } from '../../tree/m/index.js';
+import * as types from '../../types/index.js';
+import { AccessedFunction, NotSubstitutedAccessedFunction } from '../AccessedFunction.js';
+import { EntityOrPackageNameTreeNode } from '../EntityOrPackageNameTreeNode.js';
+import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
+import { Analyzer } from './Analyzer.js';
+export declare class Resolver {
+    private readonly analyzer;
+    private readonly node;
+    private readonly diagnostics;
+    private readonly semanticContext_;
+    private get semanticContext();
+    constructor(analyzer: Analyzer, node: Tag, diagnostics: DiagnosticAcceptor | undefined);
+    resolve(): ResolutionResult;
+    private resolveNameInScope;
+    private resolveNameInPackage;
+    private resolveTagType;
+    private resolveTagFunction;
+}
+export declare class ResolutionResult {
+    readonly meaning: Meaning;
+    readonly resolvedQualifiers: readonly ResolvedQualifier[];
+    readonly ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[];
+    constructor(meaning: Meaning, resolvedQualifiers: readonly ResolvedQualifier[], ambiguousDeclarations?: readonly EntityOrPackageNameTreeNode[]);
+}
+export type Meaning = Meaning_tagType | Meaning_tagFunction | Meaning_unresolved;
+declare class Meaning_tagType {
+    readonly type: types.Type;
+    readonly typeEntity: NamedTypeEntity | undefined;
+    readonly candidates: readonly types.Method[];
+    readonly suitableOrSingleConstructor: types.Method | undefined;
+    readonly kind = "tag-type";
+    constructor(type: types.Type, typeEntity: NamedTypeEntity | undefined, candidates: readonly types.Method[], suitableOrSingleConstructor: types.Method | undefined);
+}
+declare class Meaning_tagFunction {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly kind = "tag-function";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+declare class Meaning_unresolved {
+    readonly kind = "unresolved";
+}
+export type ResolvedQualifier = ResolvedQualifier_packageNameSegment | ResolvedQualifier_packageAlias | ResolvedQualifier_type | ResolvedQualifier_function;
+export declare class ResolvedQualifier_packageNameSegment {
+    readonly packageTreeNode: PackageNameTreeNode;
+    readonly kind = "package-name-segment";
+    constructor(packageTreeNode: PackageNameTreeNode);
+}
+export declare class ResolvedQualifier_packageAlias {
+    readonly packageAlias: PackageAliasEntity;
+    readonly kind = "package-alias";
+    constructor(packageAlias: PackageAliasEntity);
+}
+export declare class ResolvedQualifier_type {
+    readonly candidates: readonly NamedTypeEntity[];
+    readonly suitableTypes: readonly NamedTypeEntity[];
+    readonly kind = "type";
+    get singleSuitableType(): NamedTypeEntity | undefined;
+    constructor(candidates: readonly NamedTypeEntity[], suitableTypes: readonly NamedTypeEntity[]);
+}
+export declare class ResolvedQualifier_function {
+    readonly candidates: readonly NotSubstitutedAccessedFunction[];
+    readonly suitableOrSingleFunction: AccessedFunction | undefined;
+    readonly kind = "function";
+    constructor(candidates: readonly NotSubstitutedAccessedFunction[], suitableOrSingleFunction: AccessedFunction | undefined);
+}
+export {};

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

@@ -0,0 +1,7 @@
+import * as tree from '../../tree/m/index.js';
+export declare class TextIdentity {
+    static keyFromTextLiteralSuffix(node: tree.LocalizableTextLiteral | tree.LocalizableTextTemplateLiteral | tree.TranslationTextLiteral | tree.TranslationTextTemplate): string | undefined;
+    static keyFromLocalizableTextLiteral(node: tree.LocalizableTextLiteral): string;
+    static keyFromLocalizableTextTemplateLiteral(node: tree.LocalizableTextTemplateLiteral): string;
+    static keyFromTextTranslationSource(node: tree.TextTranslationSource): string;
+}

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

@@ -0,0 +1,28 @@
+import { DiagnosticAcceptor } from '../../diagnostic/Diagnostic.js';
+import { PackageEntity } from '../../entities/index.js';
+import { SourceFile } from '../../project/SourceFile.js';
+import { Analyzer } from './Analyzer.js';
+/**
+ * Переведённые имена проверяются по следующим правилам:
+ * - Если объявления имеют одинаковые имена на исходном языке, то они должны иметь одинаковые имена на языке перевода.
+ * - Если объявления имеют разные имена на исходном языке, то они должны иметь разные имена на языке перевода.
+ * - Для членов типа: имя расширенного члена типа должно быть таким же, как имя базового члена типа.
+ */
+export declare class TranslatedEntityNameConflictsValidator {
+    private readonly analyzer;
+    private readonly package_;
+    private readonly packageMemberDiagnostics;
+    private arePackageMembersValidated;
+    constructor(analyzer: Analyzer, package_: PackageEntity);
+    accumulateDiagnosticForSourceFile(sourceFile: SourceFile, diagnostics: DiagnosticAcceptor): void;
+    private ensurePackageMembersAreValidated;
+    private validatePackageMembers;
+    private validateTypeMembers;
+    private checkTranslatedMembersHaveSameName;
+    private checkOriginalMembersHaveSameName;
+    private getTranslatedNameNode;
+    private validateTypeParameterNameConflicts;
+    private validateParameterNameConflicts;
+    private checkOverridingMemberHasTheSameNameAsBaseMember;
+    private getTranslationDefinitionNode;
+}

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

@@ -0,0 +1,15 @@
+import { PackageEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
+import { SourceFileM, SourcePackageM } from '../../project/index.js';
+import * as tree from '../../tree/m/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class TreeQuery {
+    static getSourceFile(node: tree.Node, analyzer: Analyzer): SourceFileM;
+    static getSourcePackage(node: tree.Node, analyzer: Analyzer): SourcePackageM;
+    static getPackageEntity(node: tree.Node, analyzer: Analyzer): PackageEntity;
+}
+export declare class TypeMemberQuery {
+    static getContainingDeclaration(node: tree.TypeMemberDeclaration): tree.TypeWithMembersOrExtensionDeclaration;
+    static getOutermostMemberBlock(node: tree.TypeMemberDeclaration): tree.TypeMemberDeclarationBlock;
+    static getContextualTypeEntity(node: tree.TypeMemberDeclaration, analyzer: Analyzer): TypeEntity | undefined;
+    static getContextualTypeOrExtensionEntity(node: tree.TypeMemberDeclaration, analyzer: Analyzer): TypeEntity | TypeExtensionEntity | undefined;
+}