@artel/artc 0.6.26039 → 0.8.26001

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;
+}

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

@@ -0,0 +1,52 @@
+import { TypeParameterEntity } 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 { ExpressionAnalysisOptions } from './ExpressionAnalysisOptions.js';
+export type Argument = SourceArgument | IntrinsicArgument;
+export interface SourceArgument {
+    readonly kind: 'source';
+    readonly expression: tree.Expression;
+}
+export interface IntrinsicArgument {
+    readonly kind: 'intrinsic';
+    readonly type: types.Type;
+}
+export declare class ArgumentWithTargetParameterInfo {
+    readonly value: Argument;
+    readonly parameterType: types.Type;
+    constructor(value: Argument, parameterType: types.Type);
+}
+export declare class TypeArgumentInferrer {
+    private readonly analyzer;
+    private readonly typeParameters;
+    private readonly arguments;
+    private readonly analysisOptions;
+    private readonly returnType;
+    private readonly outerSubstitutions;
+    private readonly inferenceStates;
+    /**
+     * Специальный экземпляр типа, который используется как признак того, что вывод аргументов типа не удался.
+     */
+    private readonly unresolvedType;
+    private inferenceHasFailed;
+    constructor(analyzer: Analyzer, typeParameters: readonly TypeParameterEntity[], args: readonly ArgumentWithTargetParameterInfo[], analysisOptions: ExpressionAnalysisOptions, returnType: types.Type | undefined, outerTypeSubstitutions: types.Substitutions | undefined);
+    infer(): readonly types.Type[] | undefined;
+    private inferFirstStage;
+    private inferSecondStage;
+    private inferFromTypes;
+    private inferToParameterType;
+    private inferToStructuredType;
+    private inferToReducedType;
+    private inferFromSubstitutions;
+    private inferToUnionType;
+    private inferFromFunctionTypes;
+    private inferFromUnionType;
+    private createSubstitutions;
+    private inferFromTargetTypeDependentExpression;
+    private tryGetInferredType;
+    private tryFixTypeParametersContainedByTypesOfFunctionParameters;
+    private typeContainsTypeParameter;
+    private substitutionsContainTypeParameter;
+    private isDefinitelyTargetTypeDependentExpression;
+}

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

@@ -0,0 +1,11 @@
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+export declare class TypeInferrer {
+    private readonly analyzer;
+    private getType;
+    private typeInferringState;
+    private hasDetectedInferenceCycle_;
+    get hasDetectedInferenceCycle(): boolean;
+    constructor(analyzer: Analyzer, getType: () => types.Type);
+    inferType(): types.Type;
+}

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

@@ -1,5 +1,5 @@
 import { Name } from '../../common/index.js';
-import { NamedTypeMemberEntity, TypeEntity, TypeExtensionEntity } from '../../entities/index.js';
+import { NamedTypeMemberEntity, TypeEntity, TypeExtensionEntity, TypeWithMembersOrExtensionEntity, OperatorKind } from '../../entities/index.js';
 import * as types from '../../types/index.js';
 import { Analyzer } from '../Analyzer.js';
 import { DialectSpecificBoundTypeMemberLookup } from '../DialectSpecificBoundTypeMemberLookup.js';
@@ -10,11 +10,14 @@ export declare class TypeMemberLookupM {
     static ofType(analyzer: Analyzer, type: types.Type): TypeMemberLookupM;
     static ofTypeEntity(analyzer: Analyzer, entity: TypeEntity): TypeMemberLookupM;
     static ofTypeExtension(analyzer: Analyzer, typeExtension: TypeExtensionEntity): TypeMemberLookupM;
+    static ofTypeOrExtensionEntity(analyzer: Analyzer, typeEntity: TypeWithMembersOrExtensionEntity): TypeMemberLookupM;
     getNamedMembers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getNamedMembersByName(name: Name, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getMatchingNamedMembersByName(name: Name, memberToMatch: NamedTypeMemberEntity, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.NamedTypeMember[];
     getConstructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
     getDestructors(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
+    getOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
+    getOperatorsByKind(kind: OperatorKind, context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Method[];
     getIndexers(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.Indexer[];
     getDereferenceOperators(context: TypeMemberLookupContext | undefined, options?: TypeMemberLookupOptions): readonly types.DereferenceOperator[];
 }

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

@@ -0,0 +1,31 @@
+import { PackageLocale } from '../../common/index.js';
+import * as types from '../../types/index.js';
+import { Analyzer } from './Analyzer.js';
+import * as controlFlow from './control-flow/index.js';
+import { NarrowableReference } from './control-flow/index.js';
+export declare class TypeNarrower {
+    private readonly analyzer;
+    private readonly reference;
+    private readonly initialType;
+    private readonly locale;
+    private readonly controlFlowNode;
+    private readonly typeByNode;
+    private readonly isVariableAssignedInLoopCheckResults;
+    constructor(analyzer: Analyzer, reference: NarrowableReference, locale: PackageLocale, initialType: types.Type, controlFlowNode: controlFlow.Node);
+    static getTypeOfExpression(analyzer: Analyzer, referenceExpression: controlFlow.NarrowableReferenceExpression, initialType: types.Type, controlFlowNode: controlFlow.Node): types.Type;
+    getType(): types.Type;
+    private getTypeAtControlFlowNode;
+    private getTypeAtCondition;
+    private getTypeAtAssignment;
+    private getTypeAtLocalOrPackageVariableDeclaration;
+    private getTypeAtSplit;
+    private getTypeAtLoop;
+    private getTypeAtAssignmentWithImplicitConversionOrToReducedType;
+    private getTypeAtIsFunctionCallExpression;
+    private getTypeAtComparisonWithNull;
+    private getTypeAtAssignmentOrDeclaration;
+    private addTypeIfUnique;
+    private checkIfVariableIsAssignedInLoop;
+    private checkIfVariableIsAssignedAtNode;
+    private isSameReferenceAsNarrowedExpression;
+}

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

@@ -0,0 +1,9 @@
+import { NamedTypeEntity } from '../../entities/index.js';
+export declare class Resolver {
+    static resolve<TCandidate extends ICandidate>(candidates: readonly TCandidate[], argumentCount: number): readonly TCandidate[];
+    static resolveByNamedTypeEntities<T extends NamedTypeEntity>(candidates: readonly T[], argumentCount: number): readonly T[];
+}
+export interface ICandidate {
+    getParameterCount(): number;
+    getRequiredParameterCount(): number;
+}