@artel/artc 0.6.25276 → 0.6.25278

package/build/{chunk-MT6TPXET.js → chunk-L44WWCT7.js}

@@ -3,18 +3,18 @@ import {
   CompilationLoader,
   DefaultNamesOfDirectoriesToIgnore,
   Diagnostic,
-  DiagnosticCollector,
   DiagnosticData,
   Emitter,
+  SourceFileAnalyzer,
   SourcePackageDependencyGraph,
   WellKnownDeclarationsLoadError,
   __async,
   createTsInteropInputsForCompilation
-} from "./chunk-LX6LUKPR.js";
+} from "./chunk-A2QTLTGI.js";
 
 // source/executor/Compiler.ts
 var Compiler = class {
-  static loadCompilation(projectUri, sourcesProvider, tsLibrariesProvider, diagnostics, options, cancellationToken) {
+  static loadCompilation(projectUri, sourcesProvider, tsLibrariesProvider, diagnostics, taskController, options) {
     return __async(this, null, function* () {
       const loaderOptions = {
         treatRootAsPackageIfConfigIsMissing: true,
@@ -25,16 +25,16 @@ var Compiler = class {
       const { loadResult } = yield CompilationLoader.loadUsingSourcesProvider(
         projectUri,
         sourcesProvider,
+        taskController,
         loaderOptions,
         diagnostics,
         options?.workspaceUri,
-        DefaultNamesOfDirectoriesToIgnore,
-        cancellationToken
+        DefaultNamesOfDirectoriesToIgnore
       );
       return loadResult.compilation;
     });
   }
-  static createAnalyzer(compilation, tsLibrariesProvider, diagnostics, _cancellationToken) {
+  static createAnalyzer(compilation, tsLibrariesProvider, diagnostics, _taskController) {
     return __async(this, null, function* () {
       const tsInteropInputs = createTsInteropInputsForCompilation(compilation, tsLibrariesProvider);
       try {
@@ -48,15 +48,15 @@ var Compiler = class {
       }
     });
   }
-  static analyze(analyzer, diagnostics, cancellationToken) {
+  static analyze(analyzer, diagnostics, taskController) {
     return __async(this, null, function* () {
       let hasErrorsPreventingCompilation = false;
       const sourcePackageGraph = new SourcePackageDependencyGraph(analyzer);
-      const packages = Array.from(sourcePackageGraph.enumeratePackages(0 /* JavaScript */));
+      const packages = Array.from(sourcePackageGraph.packagesForTargetPlatform(0 /* JavaScript */));
       for (const pkg of packages) {
         for (const sourceFile of pkg.sourceFiles) {
-          const diagnosticCollector = new DiagnosticCollector(analyzer, sourceFile);
-          const fileDiagnostics = yield diagnosticCollector.collect(cancellationToken);
+          const sourceFileAnalyzer = new SourceFileAnalyzer(analyzer, sourceFile);
+          const fileDiagnostics = yield sourceFileAnalyzer.analyze(taskController);
           for (const diagnostic of fileDiagnostics) {
             diagnostics?.addDiagnostic(diagnostic);
             hasErrorsPreventingCompilation ||= pkg.kind === "program" && fileDiagnostics.some((d) => d.data.kind === 0 /* Error */);
@@ -66,21 +66,21 @@ var Compiler = class {
       return !hasErrorsPreventingCompilation;
     });
   }
-  static emit(analyzer, outputUri, outputAcceptor, _diagnostics, emitOptions, cancellationToken) {
+  static emit(analyzer, outputUri, outputAcceptor, diagnostics, taskController, emitOptions) {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
-        _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
+        diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
           403 /* ProgramWithoutMainPackageCannotBeCompiled */
         ), void 0));
         return void 0;
       }
       const emitter = new Emitter(analyzer, emitOptions);
-      yield emitter.emitToFileSystem(outputUri, outputAcceptor, cancellationToken);
+      yield emitter.emitToFileSystem(outputUri, outputAcceptor, taskController);
       const launchUri = outputUri.append(Emitter.LaunchFileName);
       return launchUri;
     });
   }
-  static emitToString(analyzer, _diagnostics, emitOptions, cancellationToken) {
+  static emitToString(analyzer, _diagnostics, taskController, emitOptions) {
     return __async(this, null, function* () {
       if (analyzer.compilation.mainPackage === void 0) {
         _diagnostics?.addDiagnostic(new Diagnostic(DiagnosticData.withCode(
@@ -89,7 +89,7 @@ var Compiler = class {
         return "";
       }
       const emitter = new Emitter(analyzer, emitOptions);
-      const result = yield emitter.emitToString(cancellationToken);
+      const result = yield emitter.emitToString(taskController);
       return result;
     });
   }

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

@@ -1,5 +1,5 @@
 import { Name } from '../common/index.js';
-import { FunctionEntity, MethodEntity, PackageOrNestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../entities/index.js';
+import { MethodEntity, NamedFunctionEntity, PackageOrNestedFunctionEntity, ParameterEntity, TypeParameterEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { Analyzer } from './Analyzer.js';
 import { SubstitutedFunction } from './SubstitutedFunction.js';
@@ -44,7 +44,7 @@ export declare class AccessedFunction_substitutedFunction implements IAccessedFu
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
-    getEntity(): FunctionEntity;
+    getEntity(): NamedFunctionEntity;
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getOuterSubstitutions(): types.Substitutions | undefined;
@@ -58,7 +58,7 @@ interface IAccessedFunction {
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly AccessedFunctionParameter[];
     getReturnType(): types.Type;
-    getEntity(): FunctionEntity;
+    getEntity(): NamedFunctionEntity;
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getOuterSubstitutions(): types.Substitutions | undefined;

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

@@ -15,6 +15,6 @@ export declare class AnalyzedTextTranslationPackage {
     getTranslationLocale(): string;
     getEntitiesByTextKey(textKey: TextKey): readonly TextTranslationEntity[] | undefined;
     private createEntitiesByTextKey;
-    private enumerableTextTranslationDeclarations;
-    private enumerableTranslationsDeclarations;
+    private textTranslationDeclarations;
+    private translationsDeclarations;
 }

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

@@ -12,32 +12,34 @@ export declare class AnalyzedTranslationPackage {
     private readonly analyzer;
     private readonly package_;
     private readonly targetPackage;
-    private readonly diagnostics;
+    private readonly entityNameConflictsValidator;
     private readonly localizedPackageByOriginalReferencedPackage;
     private readonly translatedEntityByOriginal;
-    private hasCreatedPackageMembers;
-    private readonly typesOrExtensionsWithCreatedMembers;
     private readonly packageMemberTranslationTargetsByNode;
     private readonly typeMemberTranslationTargetsByNode;
+    private readonly translatedPackageMembers;
+    private readonly translatedTypeMembersByTypeOrExtensionEntity;
     constructor(analyzer: Analyzer, package_: TranslationPackage, targetPackage: PackageEntity);
     getTargetPackage(): PackageEntity;
     getDefinition(): TranslationPackage;
     getTranslatedName(): PackageName;
     getTranslationLocale(): PackageLocale;
     getLocalizedPackageByOriginalReferencedPackage(): ReadonlyMap<PackageEntity, PackageEntity>;
-    accumulateDiagnosticsForSourceFile(sourceFile: SourceFile, diagnostics: DiagnosticAcceptor): void;
+    getTranslatedPackageMembers(): PackageEntityMembers;
+    ensureAllLazyDiagnosticsReportedForSourceFile(sourceFile: SourceFile): void;
+    accumulateDiagnosticForSourceFile(sourceFile: SourceFile, diagnostics: DiagnosticAcceptor): void;
     getPackageMemberTranslationTargets(node: tree.TranslationDeclaration): TranslationTargets<PackageMemberEntity> | undefined;
     getTypeMemberTranslationTargets(node: tree.TypeMemberTranslation): TranslationTargets<TypeMemberEntity> | undefined;
     getTranslatedPackageMember(entity: PackageMemberEntity): PackageMemberEntity;
     getTranslatedTypeMember(entity: TypeMemberEntity): TypeMemberEntity;
     getTranslatedAnonymousTypeEntity(entity: AnonymousTypeEntity): AnonymousTypeEntity;
-    createTranslatedPackageMembers(): PackageEntityMembers;
-    createTranslatedTypeOrExtensionMembers(translatedTypeEntity: TypeWithMembersOrExtensionEntity, typeTranslationDeclaration: tree.TypeTranslationDeclaration | undefined): TypeEntityMembers;
+    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 ensurePackageMembersHaveBeenCreated;
+    private createTranslatedPackageMembers;
+    private createTranslatedTypeOrExtensionMembers;
     private ensureTypeMembersHaveBeenCreated;
     private reportPackageMemberHasAlreadyBeenTranslatedDiagnostic;
     private reportTypeMemberHasAlreadyBeenTranslatedDiagnostic;
@@ -59,7 +61,8 @@ export declare class AnalyzedTranslationPackage {
     private createNotTranslatedEntitiesDiagnostic;
     private createLocalizedPackageByOriginalReferencedPackage;
     private createTranslatedDefaultConstructorEntity;
-    private enumerateTranslationsDeclarations;
+    private tryCreateAutomaticTranslationOfDerivedTypeMember;
+    private translationsDeclarations;
 }
 export interface TranslationTargets<T extends Entity = Entity> {
     readonly values: readonly T[];

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { CancellationToken, DisplayableOrPrimitive, Name, PackageLocale, Query, Range, TypeWithMembersOrTypeExtensionDeclaration, WithDiagnostics } from '../common/index.js';
+import { DisplayableOrPrimitive, Name, PackageLocale, Query, Range, TaskController, TypeWithMembersOrTypeExtensionDeclaration, WithDiagnostics } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor, DiagnosticLocation } from '../diagnostic/Diagnostic.js';
 import { DiagnosticCode } from '../diagnostic/DiagnosticCode.js';
 import { DiagnosticFlags, DiagnosticKind } from '../diagnostic/DiagnosticData.js';
@@ -91,7 +91,6 @@ export declare class Analyzer {
     private readonly prefixUnaryExpressionOperatorResolutionResults;
     private readonly binaryExpressionUserDefinableOperatorResolutionResults;
     private readonly assignmentStatementOperatorResolutionResults;
-    private readonly parametersOfFunctionBlockLiterals;
     private readonly extendedTypes;
     private readonly analyzedTranslationPackages;
     private readonly analyzedTextTranslationPackages;
@@ -138,7 +137,7 @@ export declare class Analyzer {
     getUnambiguousTargetReferenceType(targetType: types.Type | undefined): types.Type | undefined;
     resolveMemberAccessExpressionFirstStage(node: tree.MemberAccessExpression): memberAccessExpressionResolution.FirstStageResolutionResult;
     resolveMemberAccessExpression(node: tree.MemberAccessExpression, analysisOptions?: ExpressionAnalysisOptions): memberAccessExpressionResolution.ResolutionResult;
-    enumeratePackageImports(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
+    getPackageImportsOfDirective(packageImportDirectives: Iterable<tree.PackageImportDirective>): Iterable<tree.PackageImport>;
     getSourceFileMembers(node: tree.SourceFile): SourceFileMembers;
     resolveCallExpression(node: tree.CallExpression, analysisOptions?: ExpressionAnalysisOptions): callExpressionMeaning.ResolutionResult;
     getRespectiveParameter(node: tree.Argument): MatchResultParameter | undefined;
@@ -204,7 +203,7 @@ export declare class Analyzer {
      *   возвращаемого значения допустимо). В таком случае это генератор, не возвращающий ни одного элемента.
      */
     isFunctionGenerator(node: FunctionDeclaration): boolean;
-    enumerateAspects(type: types.Type): Iterable<types.StructuredType>;
+    allAspectsOfType(type: types.Type): Iterable<types.StructuredType>;
     checkTypeIsBasedOnAspect(type: types.Type, aspectEntity: e.StructuredTypeEntity): boolean;
     resolvePrefixUnaryExpressionUserDefinableOperator(node: tree.PrefixUnaryExpression): WithDiagnostics<types.Operator>;
     resolveBinaryExpressionUserDefinableOperator(node: tree.BinaryExpression, operatorKind: BinaryOperatorKind): WithDiagnostics<types.Operator>;
@@ -260,7 +259,6 @@ export declare class Analyzer {
     excludeTypeFromUnion(initialType: types.Type, excludedType: types.Type): types.Type;
     isParameterVariadic(entity: e.VariableEntity): boolean;
     getDefaultTypeParameterConstraint(locale: PackageLocale): types.Type;
-    getFunctionBlockLiteralParameters(node: tree.FunctionBlockLiteral): readonly e.ParameterEntity[];
     getExtendedType(node: tree.TypeExtensionDeclaration): WithDiagnostics<e.NamedTypeEntity>;
     getAnalyzedTranslationPackageIfTargetResolved(package_: project.TranslationPackage): AnalyzedTranslationPackage | undefined;
     getAnalyzedTextTranslationPackageIfTargetResolved(package_: project.TextTranslationPackage): AnalyzedTextTranslationPackage | undefined;
@@ -286,9 +284,9 @@ export declare class Analyzer {
     instantiateTypeMemberByIdentitySubstitution(entity: e.TypeMemberEntity): types.TypeMember;
     createPackageMemberHiding(node: tree.PackageMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
     createTypeMemberHiding(node: tree.TypeMemberDeclaration, modifierFlags: ModifierFlags): e.EntityHidingLevel | undefined;
-    collectDeclarationsUsageOfPackages(targetPlatform: PlatformKind, cancellationToken?: CancellationToken | undefined): Promise<Map<tree.SourceFile, DeclarationsUsageMap>>;
-    getDeclarationsUsageOfSourceFile(sourceFile: tree.SourceFile, cancellationToken: CancellationToken | undefined): Promise<DeclarationsUsageMap>;
-    getPackageAndStaticVariablesInitializationDiagnostics(pkg: SourcePackage, cancellationToken: CancellationToken | undefined): Promise<readonly Diagnostic[]>;
+    collectDeclarationsUsageOfPackages(targetPlatform: PlatformKind, taskController: TaskController): Promise<Map<tree.SourceFile, DeclarationsUsageMap>>;
+    getDeclarationsUsageOfSourceFile(sourceFile: tree.SourceFile, taskController: TaskController): Promise<DeclarationsUsageMap>;
+    getPackageAndStaticVariablesInitializationDiagnostics(pkg: SourcePackage, taskController: TaskController): Promise<readonly Diagnostic[]>;
     createDefaultConstructors(typeEntity: e.StructuredTypeEntity, fields: readonly e.FieldEntity[]): readonly e.ConstructorEntity[];
     createBackingPackageVariables(declaredMembers: readonly (e.NamedPackageMemberEntity | e.PackageAliasEntity)[], pkg: e.PackageEntity): e.PackageVariableEntity[];
     createBackingFields(declaredMembers: readonly e.NamedTypeMemberEntity[], type: e.TypeEntity): e.FieldEntity[];
@@ -308,8 +306,7 @@ export declare class Analyzer {
     createAmbiguousNamedScopeDeclarationAccessDiagnostic(declarations: readonly semanticContext.NamedDeclaration[], node: tree.Node): Diagnostic;
     addDiagnosticComputedLazily(diagnostic: Diagnostic): void;
     getAcceptorForDiagnosticsComputedLazily(): DiagnosticAcceptor;
-    getSourceFileDiagnosticsComputedLazily(sourceFile: project.SourceFile): readonly Diagnostic[];
-    getDiagnosticsWithoutLocationComputedLazily(): readonly Diagnostic[];
+    accumulateSourceFileDiagnosticsComputedLazily(sourceFile: project.SourceFile, diagnostics: DiagnosticAcceptor): void;
     validateSourcePackageMemberConflicts(pkg: project.ProgramPackage): readonly Diagnostic[];
     getNotExplicitlyImplementedAbstractMembers(typeEntity: e.TypeEntityWithMembers): readonly types.TypeMember[];
     getTypeMemberImplementationCheckResult(typeEntity: e.TypeEntityWithMembers): TypeMemberImplementationCheckResult;
@@ -388,9 +385,10 @@ declare class Type {
     ofExpression(node: tree.Expression, analysisOptions?: ExpressionAnalysisOptions): types.Type;
     ofTypeSpecifier(node: tree.TypeSpecifier): types.Type;
     ofAccessedOperator(operator: types.Operator): types.Type;
-    ofRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral, analysisOptions?: ExpressionAnalysisOptions): types.FunctionType;
-    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral, analysisOptions?: ExpressionAnalysisOptions): types.FunctionType;
-    ofFunctionLiteral(node: tree.FunctionLiteral, analysisOptions?: ExpressionAnalysisOptions): types.FunctionType;
+    private ofFunctionBlockLiteral;
+    private ofFunctionLiteral;
+    private ofRegularOrBlockFunctionLiteral;
+    private createFunctionTypeOfFunctionEntity;
     private ofArrayLiteral;
     private ofAssertionExpression;
     private ofAssumptionExpression;
@@ -431,10 +429,6 @@ declare class Type {
     private ofUnionTypeSpecifier;
     private ofIntersectionTypeSpecifier;
     private ofInvalidTypeSpecifier;
-    private createFunctionLiteralType;
-    private createFunctionBlockLiteralType;
-    private inferAndCacheReturnTypeOfRegularOrBlockFunctionLiteral;
-    private replaceReturnTypeOfFunctionType;
     private reportReturnTypeCanNotBeInferredDiagnostic;
     private getNarrowedTypeIfNarrowableReference;
 }
@@ -485,6 +479,8 @@ declare class Entity {
     private readonly packageAliasEntities;
     private readonly translationTextTemplateParameterEntities;
     private readonly textTranslationDeclarationEntities;
+    private readonly functionLiteralEntities;
+    private readonly functionBlockLiteralEntities;
     constructor(analyzer: Analyzer);
     ofPackage(pkg: SourcePackage): e.PackageEntity;
     ofPackageVariableDeclaration(node: tree.PackageVariableDeclaration): e.PackageVariableEntity;
@@ -531,6 +527,12 @@ declare class Entity {
     ofTypeWithMembersOrExtensionDeclaration(node: TypeWithMembersOrTypeExtensionDeclaration): e.TypeWithMembersOrExtensionEntity;
     ofTranslationTextTemplateParameter(node: tree.TranslationTextTemplateParameter): e.ParameterEntity;
     ofTextTranslationDeclaration(node: tree.TextTranslationSource): e.TextTranslationEntity;
+    ofFunctionLiteral(node: tree.FunctionLiteral): e.AnonymousFunctionEntity;
+    ofFunctionBlockLiteral(node: tree.FunctionBlockLiteral): e.AnonymousFunctionEntity;
+    ofRegularOrBlockFunctionLiteral(node: RegularOrBlockFunctionLiteral): e.AnonymousFunctionEntity;
+    ofFunctionLiteralInternal(node: tree.FunctionLiteral): e.FunctionLiteralEntity;
+    ofFunctionBlockLiteralInternal(node: tree.FunctionBlockLiteral): e.FunctionBlockLiteralEntity;
+    ofFunctionLiteralParameterDeclarationInternal(node: tree.ParameterDeclaration, literal: tree.FunctionLiteral): e.FunctionLiteralParameterDeclarationEntity;
     private getContainingPackageLoadedFromDts;
     private createComputedFieldEntities;
     private createDereferenceOperatorEntities;
@@ -599,8 +601,8 @@ declare class OverriddenMember {
     private checkMethodOverridesOrShadowsMethod;
     private checkOperatorOverridesOrShadowsOperator;
     private checkIndexerOverridesOrShadowsIndexer;
-    private enumerateTypeMemberLookups;
-    private enumerateTypesForOverriddenMemberLookup;
+    private typeMemberLookups;
+    private typesForOverriddenMemberLookup;
     private entityCanOverrideOrShadow;
 }
 export declare enum ShadowReason {

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

@@ -1,4 +1,4 @@
-import { CancellationToken } from '../common/index.js';
+import { TaskController } from '../common/index.js';
 import { Entity, NamedEntity } from '../entities/index.js';
 import * as tree from '../tree/index.js';
 import { Analyzer } from './Analyzer.js';
@@ -7,7 +7,7 @@ export declare class DeclarationsUsageCounter {
     private readonly sourceFile;
     private readonly usageInfoByEntity;
     constructor(analyzer: Analyzer, sourceFile: tree.SourceFile);
-    count(cancellationToken?: CancellationToken | undefined): Promise<DeclarationsUsageMap>;
+    count(taskController: TaskController): Promise<DeclarationsUsageMap>;
     private recordUsage;
 }
 export declare class DeclarationsUsageMap {

package/build/types/analysis/{DiagnosticCollector.d.ts → SourceFileAnalyzer.d.ts}

@@ -1,9 +1,8 @@
-import { CancellationToken } from '../common/index.js';
+import { TaskController } from '../common/index.js';
 import { Diagnostic } from '../diagnostic/Diagnostic.js';
 import * as project from '../project/index.js';
 import { Analyzer } from './index.js';
-export declare class DiagnosticCollector {
-    static readonly CancellationTokenThrottleTime = 50;
+export declare class SourceFileAnalyzer {
     private readonly analyzer;
     private readonly sourceFile;
     private readonly diagnosticArgumentFactory;
@@ -19,8 +18,8 @@ export declare class DiagnosticCollector {
     private get isInterfacePackageFile();
     private get standardTypes();
     constructor(analyzer: Analyzer, sourceFile: project.SourceFile);
-    collect(cancellationToken?: CancellationToken | undefined): Promise<Diagnostic[]>;
-    private collectNodeDiagnostics;
+    analyze(taskController: TaskController): Promise<Diagnostic[]>;
+    private analyzeNode;
     private checkTypeParameterList;
     private checkTypeParameterDeclaration;
     private checkFunctionLiteral;

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

@@ -10,9 +10,9 @@ export declare class SourcePackageDependencyGraph {
      * Перечислить все пакеты и их зависимости, включая транзитивные, начиная от корневых пакетов.
      * @param platformKind Связывать многоплатформенные пакеты с реализацией для заданной платформы.
      */
-    enumeratePackages(platformKind: PlatformKind): Iterable<SourcePackage>;
+    packagesForTargetPlatform(platformKind: PlatformKind): Iterable<SourcePackage>;
     private getNodeForPackage;
-    private enumerateNodeAndDependenciesRecursively;
+    private nodeAndDependenciesRecursively;
 }
 export interface SourcePackageDependencyGraphNode {
     /**

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

@@ -1,5 +1,5 @@
 import { Name } from '../common/index.js';
-import { FunctionEntity, PackageOrNestedFunctionEntity } from '../entities/index.js';
+import { MethodEntity, NamedFunctionEntity, PackageOrNestedFunctionEntity } from '../entities/index.js';
 import * as types from '../types/index.js';
 import { AccessedFunctionParameter } from './AccessedFunction.js';
 import { Analyzer } from './Analyzer.js';
@@ -29,7 +29,7 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     private readonly parameters;
     get debuggerDisplay(): string;
     constructor(method: types.Method, substitutions: types.Substitutions);
-    getEntity(): FunctionEntity;
+    getEntity(): MethodEntity;
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;
@@ -39,7 +39,7 @@ export declare class SubstitutedFunction_typeMember implements ISubstitutedFunct
     isAsync(): boolean;
 }
 interface ISubstitutedFunction {
-    getEntity(): FunctionEntity;
+    getEntity(): NamedFunctionEntity;
     getName(): Name;
     getSignatureType(analyzer: Analyzer): types.FunctionType;
     getSubstitutions(): types.Substitutions;

package/build/types/analysis/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/Translation.d.ts

@@ -19,8 +19,7 @@ export declare class SourceTranslationDefinition {
 }
 export type SourceTranslationDefinitionNode = tree.TranslationDeclaration | tree.TypeMemberTranslation;
 export declare class IntrinsicTranslationDefinition {
-    readonly isMissingTranslationReplacement: boolean;
     readonly kind = "intrinsic";
-    constructor(isMissingTranslationReplacement?: boolean);
+    constructor();
     equals(other: TranslationDefinition): boolean;
 }

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

@@ -1,7 +1,7 @@
 export * from './Analyzer.js';
 export * from './ArgumentsToParametersMatcher.js';
 export * from './DeclarationsUsageCounter.js';
-export * from './DiagnosticCollector.js';
+export * from './SourceFileAnalyzer.js';
 export * from './FindModifier.js';
 export * from './SourcePackageDependencyGraph.js';
 export * from './Visitor.js';

package/build/types/analysis/semantic-context/Declarations.d.ts

@@ -1,5 +1,5 @@
 import { Name } from '../../common/index.js';
-import { EntityHidingLevel, FunctionEntity, NamedTypeEntity, PackageAliasEntity, PackageOrNestedFunctionEntity, VariableEntity } from '../../entities/index.js';
+import { EntityHidingLevel, MethodEntity, NamedFunctionEntity, NamedTypeEntity, PackageAliasEntity, PackageOrNestedFunctionEntity, VariableEntity } from '../../entities/index.js';
 import * as types from '../../types/index.js';
 import { PackageNameTreeNode } from '../ImportedPackageNameTree.js';
 export type TypeOrContainerWithTypes = NamedDeclaration_type | NamedDeclaration_packageAlias | NamedDeclaration_packageNameSegment;
@@ -26,13 +26,13 @@ export declare class NamedDeclarationFunction_typeMember implements INamedDeclar
     readonly value: types.Method;
     constructor(value: types.Method);
     getName(): Name;
-    getEntity(): FunctionEntity;
+    getEntity(): MethodEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
 }
 interface INamedDeclarationFunction {
     getName(): Name;
-    getEntity(): FunctionEntity;
+    getEntity(): NamedFunctionEntity;
     getTypeParameterArity(): number;
     isHidden(): EntityHidingLevel | undefined;
 }

package/build/types/analysis/semantic-context/SemanticContextBase.d.ts

@@ -38,7 +38,7 @@ export declare abstract class SemanticContextBase {
     getOperatorsByKind(kind: OperatorKind, noInstanceMembers?: boolean): readonly types.Operator[];
     getTypeExtensionsByType(type: TypeEntity): readonly TypeExtensionEntity[];
     getPrimaryTextTranslationEntityByTextKey(key: TextKey): TextTranslationEntity | undefined;
-    private enumerateSemanticContexts;
+    private semanticContexts;
     private getSourceFileContext;
 }
 export type SubprogramInfo = SubprogramInfo.Function | SubprogramInfo.Operator | SubprogramInfo.Constructor | SubprogramInfo.Destructor | SubprogramInfo.Getter | SubprogramInfo.Setter | SubprogramInfo.PackageConstructor | SubprogramInfo.PackageEntryPoint | SubprogramInfo.FunctionLiteral | SubprogramInfo.TextTranslationFunction;
@@ -136,7 +136,7 @@ export declare namespace SubprogramInfo {
         isGenerator(): boolean;
         allowsAsyncCalls(): boolean;
         getNode(): RegularOrBlockFunctionLiteral;
-        private getSignatureType;
+        private getEntity;
     }
     export class TextTranslationFunction implements ISubprogramInfo {
         readonly kind = "text-translation-function";

package/build/types/api/Api.d.ts

@@ -6,7 +6,7 @@ export type { Meaning as AutotypeCallExpressionMeaning } from '../analysis/Autot
 export type { Meaning as BaseExpressionMeaning } from '../analysis/BaseExpressionMeaning.js';
 export type { Meaning as CallExpressionMeaning } from '../analysis/CallExpressionMeaning.js';
 export type { Meaning as DereferenceExpressionMeaning } from '../analysis/DereferenceExpressionMeaning.js';
-export * from '../analysis/DiagnosticCollector.js';
+export * from '../analysis/SourceFileAnalyzer.js';
 export * from '../analysis/FindModifier.js';
 export type { Meaning as IdentifierExpressionMeaning, ResolutionResult as IdentifierExpressionResolutionResult } from '../analysis/IdentifierExpressionMeaning.js';
 export * from '../analysis/ImportedPackageNameTree.js';

package/build/types/common/TaskController.d.ts

@@ -0,0 +1,14 @@
+import { CancellationToken } from './CancellationToken.js';
+export declare class TaskController {
+    private checkCount;
+    private lastTimeMs;
+    private timeSliceMs;
+    readonly cancellationToken: CancellationToken | undefined;
+    constructor(timeSliceMs?: number, cancellationToken?: CancellationToken);
+    shouldYieldOnceOutOf100(): boolean;
+    shouldYield(onceOutOf?: number): boolean;
+    isCancellationRequested(): boolean;
+    throwIfCancellationRequested(): void;
+    yieldTask(timeMs?: number): Promise<void>;
+}
+export declare function yieldTask(timeMs?: number): Promise<void>;

package/build/types/common/TreeTraversal.d.ts

@@ -1,13 +1,14 @@
 import * as tree from '../tree/index.js';
-import { CancellationToken } from './index.js';
-export declare function traverseTreeWithCancellationToken(root: tree.Node, cancellationToken: CancellationToken | undefined, throttleTimeMs: number, visitTokens: boolean, visitNodeCb: (node: tree.Node, controller: TraversalController) => void): Promise<void>;
-export declare function traverseTree(root: tree.Node, visitNodeCb: (node: tree.Node, controller: TraversalController) => void): void;
+import { TaskController } from './TaskController.js';
+export declare function traverseTree(root: tree.Node, visitTokens: boolean, taskController: TaskController | undefined, nodeVisitor: (node: tree.Node, controller: TraversalController) => Promise<void> | undefined): Promise<void>;
 export declare class TraversalController {
-    isTraverseStopped: boolean;
-    isChildrenTraverseStopped: boolean;
-    shouldYieldExecution: boolean;
+    private shouldStopTraverse_;
+    private shouldSkipChildrenTraverse_;
+    readonly task?: TaskController;
+    constructor(task?: TaskController);
+    shouldStopTraverse(): boolean;
+    shouldSkipChildrenTraverse(): boolean;
     stopTraverse(): void;
-    stopChildrenTraverse(): void;
-    yieldExecutionAfterCurrentNode(): void;
-    reset(): void;
+    skipChildrenTraverse(): void;
+    resetSkipChildrenTraverse(): void;
 }

package/build/types/common/index.d.ts

@@ -24,10 +24,9 @@ export * from './PerformanceMeasurement.js';
 export * from './Query.js';
 export * from './Range.js';
 export * from './Result.js';
-export * from './ThrottledCancellationToken.js';
 export * from './TreeQuery.js';
 export * from './TreeTraversal.js';
 export * from './Uri.js';
 export * from './UserLocale.js';
 export * from './WithDiagnostics.js';
-export * from './YieldExecution.js';
+export * from './TaskController.js';

package/build/types/diagnostic/DiagnosticCode.d.ts

@@ -226,7 +226,11 @@ export declare enum DiagnosticCode {
     TheNumberOfTranslatedParametersMustBeEqualToTheNumberOfSourceParameters = 388,
     TheNumberOfTranslatedTypeParametersMustBeEqualToTheNumberOfSourceTypeParameters = 389,
     TheNameOfTheTranslatedOperatorMustMeTheSameAsSourceOperatorName = 390,
-    OnlyOneTextTranslationPackageShouldBeMarkedAsPrimary = 391,
+    TranslationOfFunctionTypeMustIncludeParameterList = 391,
+    OnlyOneTextTranslationPackageShouldBeMarkedAsPrimary = 392,
+    Declarations0And1HaveTheSameSourceNamesButDifferentTranslatedNames23 = 393,
+    TranslatedDeclarations0And1HaveTheSameTranslatedNamesButDifferentSourceNames23 = 394,
+    TranslatedOverridingMember0MustTheSameNameAsBaseMember1 = 395,
     CannotFindTsLibDirectoryBaseSearchPaths0 = 401,
     SourceFile0IsNotPartOfThePackageAndWontBeLoaded = 402,
     ProgramWithoutMainPackageCannotBeCompiled = 403,

package/build/types/emitter/Emitter.d.ts

@@ -1,5 +1,5 @@
 import { Analyzer } from '../analysis/index.js';
-import { CancellationToken, Uri } from '../common/index.js';
+import { TaskController, Uri } from '../common/index.js';
 import { JavaScriptImplementationConfig, PlatformKind } from '../project/index.js';
 import { NamedEntity, PackageEntity, PackageMemberEntity } from './Entities.js';
 import * as ir from './ir/index.js';
@@ -12,8 +12,8 @@ export declare class Emitter {
     private readonly entityMap;
     private readonly ectx;
     constructor(analyzer: Analyzer, options: EmitOptions | undefined);
-    emitToFileSystem(outputUri: Uri, outputAcceptor: OutputAcceptor, cancellationToken?: CancellationToken | undefined): Promise<void>;
-    emitToString(cancellationToken?: CancellationToken | undefined): Promise<string>;
+    emitToFileSystem(outputUri: Uri, outputAcceptor: OutputAcceptor, taskController: TaskController): Promise<void>;
+    emitToString(taskController: TaskController): Promise<string>;
     private createEmitterPackageFromSource;
     private enumerateEmittingSourcePackages;
     private createPackageWithMainFunction;

package/build/types/emitter/EmitterContext.d.ts

@@ -22,7 +22,7 @@ export declare class EmitterContext {
     isTypeEmittedAsClass(entity: TypeOrExtensionEntity): boolean;
     isRefOrPlainObjectTypeEntity(entity: TypeOrExtensionEntity): boolean;
     isAspectTypeEntity(entity: TypeOrExtensionEntity): boolean;
-    enumerateAllOverriddenMembers<T extends TypeMemberEntity>(entity: T): Iterable<T>;
+    allOverriddenMembers<T extends TypeMemberEntity>(entity: T): Iterable<T>;
 }
 export declare class WellKnownDeclarationKeys {
     static readonly jsObjectType = "Platform.JavaScript.Object";

package/build/types/emitter/EntityMap.d.ts

@@ -18,7 +18,7 @@ export declare class EntityMap {
     private readonly linkedPackages;
     constructor(analyzer: Analyzer, targetPlatform: PlatformKind);
     getVariableEntity(entity: analyzerEntities.VariableEntity): emitterEntities.VariableEntity;
-    getFunctionEntity(entity: analyzerEntities.FunctionEntity): emitterEntities.FunctionEntity;
+    getNamedFunctionEntity(entity: analyzerEntities.NamedFunctionEntity): emitterEntities.FunctionEntity;
     getOperatorEntity(entity: analyzerEntities.OperatorEntity): emitterEntities.FunctionEntity;
     getConstructorEntity(entity: analyzerEntities.ConstructorEntity): emitterEntities.FunctionEntity;
     getDestructorEntity(entity: analyzerEntities.DestructorEntity): emitterEntities.FunctionEntity;

package/build/types/entities/Entity.d.ts

@@ -90,13 +90,15 @@ export declare namespace TypeMemberEntity {
 }
 export type NamedTypeMemberEntity = FieldEntity | MethodEntity;
 export declare function isNamedTypeMemberEntity(entity: Entity): entity is NamedTypeMemberEntity;
-export type NamedEntity = VariableEntity | PackageVariantTypeEntity | FunctionEntity | TypeParameterEntity | PackageFunctionTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
+export type NamedEntity = VariableEntity | PackageVariantTypeEntity | NamedFunctionEntity | TypeParameterEntity | PackageFunctionTypeEntity | PackageStructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
 export type PackageOrNestedFunctionEntity = PackageFunctionEntity | NestedFunctionEntity;
 export type AccessorEntity = GetterEntity | SetterEntity;
 export type EntityWithTypeParameters = EntityContainingTypeParameter;
 export declare function isEntityWithTypeParameters(entity: Entity): entity is EntityWithTypeParameters;
 export type EntityWithParameters = Exclude<EntityContainingParameter, PackageEntity>;
 export declare function isEntityWithParameters(entity: Entity): entity is EntityWithParameters;
+export type NamedFunctionEntity = PackageFunctionEntity | MethodEntity | NestedFunctionEntity;
+export declare function isNamedFunctionEntity(entity: Entity): entity is NamedFunctionEntity;
 export declare class EntityContext {
     readonly containingPackage: PackageEntity;
     readonly hidingMatcher: IEntityHidingMatcher;

package/build/types/entities/EntityNaming.d.ts

@@ -5,8 +5,10 @@ export declare class EntityNaming_named {
     readonly kind = "named";
     constructor(value: Name);
     toString(): string;
+    considerEqual(other: EntityNaming, considerBackQuotes: boolean): boolean;
 }
 export declare class EntityNaming_anonymous {
     readonly kind = "anonymous";
     toString(): string;
+    considerEqual(other: EntityNaming, _considerBackQuotes: boolean): boolean;
 }