@artel/artc 0.6.25276 → 0.6.25278

package/build/types/entities/interfaces/FunctionEntity.d.ts

@@ -4,12 +4,12 @@ import { Name } from '../../common/index.js';
 import * as tree from '../../tree/index.js';
 import * as types from '../../types/index.js';
 import { IEntity } from '../IEntity.js';
-import type { PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import type { EntityNaming, PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 import { DefinitionKind, EntityHidingLevel, EntityKind, ParameterEntity, SubstitutionApplicationMode, TypeParameterEntity } from '../index.js';
-export type FunctionEntity = PackageFunctionEntity | MethodEntity | NestedFunctionEntity;
+export type FunctionEntity = PackageFunctionEntity | MethodEntity | NestedFunctionEntity | AnonymousFunctionEntity;
 interface IFunctionEntity extends IEntity {
     readonly kind: EntityKind.Function;
-    getName(): Name;
+    getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
@@ -19,15 +19,18 @@ interface IFunctionEntity extends IEntity {
     getTags(): readonly Tag[];
     getTypeParametersArity(): number;
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
 }
 export interface PackageFunctionEntity extends IFunctionEntity {
     readonly subkind: 'package';
+    getName(): Name;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
     getOriginalEntity(): PackageFunctionEntity;
 }
 export interface MethodEntity extends IFunctionEntity {
     readonly subkind: 'method';
+    getName(): Name;
     getContainingEntity(): TypeWithMembersOrExtensionEntity;
     isStatic(): boolean;
     isOverride(): boolean;
@@ -36,18 +39,28 @@ export interface MethodEntity extends IFunctionEntity {
     isModifyingOwningPlainObject(): boolean;
     isFunctionTypeInvokeMethod(): boolean;
     getOverriddenMembers(): readonly types.Method[];
-    getTranslation(): Translation | undefined;
     getOriginalEntity(): MethodEntity;
 }
 export interface NestedFunctionEntity extends IFunctionEntity {
     readonly subkind: 'nested';
+    getName(): Name;
     getContainingPackage(): PackageEntity;
-    getTranslation(): Translation | undefined;
     getOriginalEntity(): NestedFunctionEntity;
 }
+export interface NestedFunctionEntity extends IFunctionEntity {
+    readonly subkind: 'nested';
+    getName(): Name;
+    getContainingPackage(): PackageEntity;
+    getOriginalEntity(): NestedFunctionEntity;
+}
+export interface AnonymousFunctionEntity extends IFunctionEntity {
+    readonly subkind: 'anonymous';
+    getContainingPackage(): PackageEntity;
+    getOriginalEntity(): AnonymousFunctionEntity;
+}
 export type FunctionEntityDefinition = {
     kind: DefinitionKind.Source;
-    node: tree.PackageFunctionDeclaration | tree.MethodDeclaration | tree.NestedFunctionDeclaration;
+    node: tree.PackageFunctionDeclaration | tree.MethodDeclaration | tree.NestedFunctionDeclaration | tree.FunctionLiteral | tree.FunctionBlockLiteral;
 } | {
     kind: DefinitionKind.Intrinsic;
 } | {

package/build/types/entities/interfaces/TypeParameterEntity.d.ts

@@ -2,7 +2,7 @@ import { Translation } from '../../analysis/Translation.js';
 import { Name } from '../../common/index.js';
 import * as tree from '../../tree/index.js';
 import * as types from '../../types/index.js';
-import { AliasTypeEntity, DefinitionKind, EntityHidingLevel, EntityKind, FunctionEntity, FunctionTypeEntity, ITypeEntity, StructuredTypeEntity, TypeEntityKind, VariantTypeEntity } from '../index.js';
+import { AliasTypeEntity, DefinitionKind, EntityHidingLevel, EntityKind, FunctionTypeEntity, ITypeEntity, NamedFunctionEntity, StructuredTypeEntity, TypeEntityKind, VariantTypeEntity } from '../index.js';
 export interface TypeParameterEntity extends ITypeEntity {
     readonly kind: EntityKind.Type;
     readonly typeEntityKind: TypeEntityKind.Parameter;
@@ -28,7 +28,7 @@ export type TypeParameterEntityDefinition = {
 } | {
     kind: DefinitionKind.TypeScript;
 };
-export type EntityContainingTypeParameter = VariantTypeEntity | FunctionEntity | FunctionTypeEntity | StructuredTypeEntity | AliasTypeEntity;
+export type EntityContainingTypeParameter = VariantTypeEntity | NamedFunctionEntity | FunctionTypeEntity | StructuredTypeEntity | AliasTypeEntity;
 /**
  * Класс позволяет работать с ограничением параметра шаблона, исключая циклы.
  *

package/build/types/entities/intrinsic/IntrinsicFunctionEntity.d.ts

@@ -2,7 +2,7 @@ import { Tag } from '../../analysis/Tag.js';
 import { Translation } from '../../analysis/Translation.js';
 import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as types from '../../types/index.js';
-import type { FunctionEntityDefinition, MethodEntity, PackageEntity, PackageFunctionEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import type { EntityNaming, FunctionEntityDefinition, MethodEntity, PackageEntity, PackageFunctionEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 import { EntityHidingLevel, EntityKind, ParameterEntity, SubstitutionApplicationMode, TypeParameterEntity } from '../index.js';
 export declare class IntrinsicPackageFunctionEntity implements PackageFunctionEntity {
     private readonly name;
@@ -17,6 +17,7 @@ export declare class IntrinsicPackageFunctionEntity implements PackageFunctionEn
     readonly subkind = "package";
     constructor(name: Name, typeParameters: readonly TypeParameterEntity[], parameters: readonly ParameterEntity[], returnType: types.Type, isAsync_: boolean, isHidden_: EntityHidingLevel | undefined, tags: readonly Tag[], containingPackage: PackageEntity);
     getName(): Name;
+    getNaming(): EntityNaming;
     getContainingPackage(): PackageEntity;
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly ParameterEntity[];
@@ -52,6 +53,7 @@ export declare class IntrinsicMethodEntity implements MethodEntity {
     readonly subkind = "method";
     constructor(name: Name, typeParameters: readonly TypeParameterEntity[], parameters: readonly ParameterEntity[], returnType: types.Type, isAsync_: boolean, isHidden_: EntityHidingLevel | undefined, tags: readonly Tag[], isFunctionTypeInvokeMethod_: boolean, containingEntity: TypeWithMembersOrExtensionEntity, isStatic_: boolean, isBasic_: boolean, isOverride_: boolean, isAbstract_: boolean, isModifyingOwningPlainObject_: boolean, overriddenMembers: readonly types.Method[]);
     getName(): Name;
+    getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;

package/build/types/entities/source/SourceFunctionEntity.d.ts

@@ -2,9 +2,9 @@ import { Tag } from '../../analysis/Tag.js';
 import { Translation } from '../../analysis/Translation.js';
 import { Analyzer } from '../../analysis/index.js';
 import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
-import { MethodDeclaration, NestedFunctionDeclaration, PackageFunctionDeclaration } from '../../tree/index.js';
+import * as tree from '../../tree/index.js';
 import * as types from '../../types/index.js';
-import type { FunctionEntityDefinition, MethodEntity, NestedFunctionEntity, PackageEntity, PackageFunctionEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
+import type { AnonymousFunctionEntity, EntityNaming, FunctionEntityDefinition, FunctionLiteralParameterDeclarationEntity, MethodEntity, NestedFunctionEntity, PackageEntity, PackageFunctionEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 import { EntityHidingLevel, EntityKind, ParameterEntity, SubstitutionApplicationMode, TypeParameterEntity } from '../index.js';
 export declare class PackageFunctionDeclarationEntity implements PackageFunctionEntity {
     private readonly analyzer;
@@ -18,8 +18,9 @@ export declare class PackageFunctionDeclarationEntity implements PackageFunction
     private readonly hiding;
     private modifierFlags_;
     private get modifierFlags();
-    constructor(analyzer: Analyzer, node: PackageFunctionDeclaration);
+    constructor(analyzer: Analyzer, node: tree.PackageFunctionDeclaration);
     getName(): Name;
+    getNaming(): EntityNaming;
     getContainingPackage(): PackageEntity;
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly ParameterEntity[];
@@ -48,8 +49,9 @@ export declare class MethodDeclarationEntity implements MethodEntity {
     private containingEntity;
     private modifierFlags_;
     private get modifierFlags();
-    constructor(analyzer: Analyzer, node: MethodDeclaration);
+    constructor(analyzer: Analyzer, node: tree.MethodDeclaration);
     getName(): Name;
+    getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
@@ -82,8 +84,9 @@ export declare class NestedFunctionDeclarationEntity implements NestedFunctionEn
     private readonly typeParameters;
     private readonly parameters;
     private readonly returnType;
-    constructor(analyzer: Analyzer, node: NestedFunctionDeclaration);
+    constructor(analyzer: Analyzer, node: tree.NestedFunctionDeclaration);
     getName(): Name;
+    getNaming(): EntityNaming;
     getContainingPackage(): PackageEntity;
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly ParameterEntity[];
@@ -99,3 +102,81 @@ export declare class NestedFunctionDeclarationEntity implements NestedFunctionEn
     getDialect(): PackageDialect;
     getOriginalEntity(): NestedFunctionEntity;
 }
+export declare class FunctionLiteralEntity implements AnonymousFunctionEntity, RegularOrBlockFunctionLiteralEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Function;
+    readonly subkind = "anonymous";
+    get isInferringReturnType(): boolean;
+    get isInferringIsAsync(): boolean;
+    private isTargetTypeSet;
+    private targetType;
+    private areParameterTypesSet;
+    private readonly parameters;
+    private returnType;
+    private isInferringReturnType_;
+    constructor(analyzer: Analyzer, node: tree.FunctionLiteral);
+    setTargetFunctionType(type: types.FunctionType | undefined): void;
+    dependsOnTargetType(): boolean;
+    getNaming(): EntityNaming;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly FunctionLiteralParameterDeclarationEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AnonymousFunctionEntity;
+    ensureParameterTypesAreSet(): void;
+    private ensureTargetTypeIsSet;
+    private setParameterTypes;
+}
+export declare class FunctionBlockLiteralEntity implements AnonymousFunctionEntity, RegularOrBlockFunctionLiteralEntity {
+    private readonly analyzer;
+    private readonly node;
+    readonly kind = EntityKind.Function;
+    readonly subkind = "anonymous";
+    get isInferringReturnType(): boolean;
+    get isInferringIsAsync(): boolean;
+    private parameters;
+    private isTargetTypeSet;
+    private targetType;
+    private returnType;
+    private isAsync_;
+    private isInferringReturnType_;
+    private isInferringIsAsync_;
+    constructor(analyzer: Analyzer, node: tree.FunctionBlockLiteral);
+    setTargetFunctionType(type: types.FunctionType | undefined): void;
+    dependsOnTargetType(): boolean;
+    getNaming(): EntityNaming;
+    getContainingPackage(): PackageEntity;
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+    getReturnType(): types.Type;
+    getDefinition(): FunctionEntityDefinition;
+    isAsync(): boolean;
+    isHidden(): EntityHidingLevel | undefined;
+    getTags(): readonly Tag[];
+    getTypeParametersArity(): number;
+    getSubstitutionApplicationMode(): SubstitutionApplicationMode;
+    getTranslation(): Translation | undefined;
+    getLocale(): PackageLocale;
+    getDialect(): PackageDialect;
+    getOriginalEntity(): AnonymousFunctionEntity;
+    private ensureParametersAreCreated;
+    private ensureTargetTypeIsSet;
+    private createParameters;
+}
+interface RegularOrBlockFunctionLiteralEntity {
+    readonly isInferringReturnType: boolean;
+    readonly isInferringIsAsync: boolean;
+    setTargetFunctionType(type: types.FunctionType | undefined): void;
+    dependsOnTargetType(): boolean;
+}
+export {};

package/build/types/entities/source/SourceVariableEntity.d.ts

@@ -332,8 +332,9 @@ export declare class FunctionLiteralParameterDeclarationEntity implements Parame
     readonly subkind = "parameter";
     private readonly parameterIndex;
     private readonly name;
-    private readonly type;
+    private type;
     constructor(analyzer: Analyzer, node: tree.ParameterDeclaration, functionLiteral: tree.FunctionLiteral);
+    setTypeIfHasNoTypeSpecifier(type: types.Type): void;
     getName(): Name;
     getType(): types.Type;
     getDefinition(): VariableEntityDefinition;
@@ -351,6 +352,7 @@ export declare class FunctionLiteralParameterDeclarationEntity implements Parame
     getLocale(): PackageLocale;
     getDialect(): PackageDialect;
     getOriginalEntity(): ParameterEntity;
+    private getContainingFunctionLiteralEntity;
 }
 export declare class TranslationTextTemplateParameterEntity implements ParameterEntity {
     private readonly analyzer;

package/build/types/entities/translated/TranslatedAliasTypeEntity.d.ts

@@ -43,7 +43,6 @@ export declare class TranslatedAliasTypeEntity implements AliasTypeEntity {
     getTags(): readonly Tag[];
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
     getContext(): EntityContext;
-    ensureAllDiagnosticsReported(): void;
 }
 export declare class LocalizedAliasedType extends AliasedType {
     private readonly original;

package/build/types/entities/translated/TranslatedConstructorEntity.d.ts

@@ -12,7 +12,7 @@ export declare abstract class TranslatedConstructorEntity implements Constructor
     protected readonly originalEntity: ConstructorEntity;
     protected readonly translation: Translation;
     protected readonly translationPackage: AnalyzedTranslationPackage;
-    private readonly containingEntity;
+    protected readonly containingEntity: TypeWithMembersOrExtensionEntity;
     constructor(originalEntity: ConstructorEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
     abstract getParameters(): readonly ParameterEntity[];
     getContainingEntity(): TypeWithMembersOrExtensionEntity;

package/build/types/entities/translated/TranslatedFunctionEntity.d.ts

@@ -6,7 +6,7 @@ import { Name, PackageDialect, PackageLocale } from '../../common/index.js';
 import * as tree from '../../tree/index.js';
 import * as types from '../../types/index.js';
 import { EntityHidingLevel } from '../EntityHiding.js';
-import { EntityKind, TypeWithMembersOrExtensionEntity } from '../index.js';
+import { EntityKind, EntityNaming, TypeWithMembersOrExtensionEntity } from '../index.js';
 import type { MethodEntity, PackageFunctionEntity } from '../interfaces/FunctionEntity.js';
 import { FunctionEntityDefinition } from '../interfaces/FunctionEntity.js';
 import { PackageEntity } from '../interfaces/PackageEntity.js';
@@ -31,6 +31,7 @@ export declare class TranslatedPackageFunctionEntity implements PackageFunctionE
     getDialect(): PackageDialect;
     getOriginalEntity(): PackageFunctionEntity;
     getName(): Name;
+    getNaming(): EntityNaming;
     getTypeParameters(): readonly TypeParameterEntity[];
     getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
@@ -41,21 +42,20 @@ export declare class TranslatedPackageFunctionEntity implements PackageFunctionE
     getTypeParametersArity(): number;
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
 }
-export declare class TranslatedMethodEntity implements MethodEntity {
+export declare abstract class TranslatedMethodEntity implements MethodEntity {
     readonly kind = EntityKind.Function;
     readonly subkind = "method";
-    private readonly analyzer;
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly name;
-    private readonly translationPackage;
-    private readonly containingEntity;
-    private readonly node;
-    private readonly typeParameters;
-    private readonly parameters;
+    protected readonly analyzer: Analyzer;
+    protected readonly originalEntity: MethodEntity;
+    protected readonly translation: Translation;
+    protected readonly name: Name;
+    protected readonly translationPackage: AnalyzedTranslationPackage;
+    protected readonly containingEntity: TypeWithMembersOrExtensionEntity;
     private readonly returnType;
     private readonly overriddenMembers;
-    constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.MethodTranslation | undefined);
+    constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    abstract getTypeParameters(): readonly TypeParameterEntity[];
+    abstract getParameters(): readonly ParameterEntity[];
     getContainingEntity(): TypeWithMembersOrExtensionEntity;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
@@ -63,8 +63,7 @@ export declare class TranslatedMethodEntity implements MethodEntity {
     getDialect(): PackageDialect;
     getOriginalEntity(): MethodEntity;
     getName(): Name;
-    getTypeParameters(): readonly TypeParameterEntity[];
-    getParameters(): readonly ParameterEntity[];
+    getNaming(): EntityNaming;
     getReturnType(): types.Type;
     getDefinition(): FunctionEntityDefinition;
     isStatic(): boolean;
@@ -80,3 +79,19 @@ export declare class TranslatedMethodEntity implements MethodEntity {
     getTypeParametersArity(): number;
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
 }
+export declare class SourceTranslatedMethodEntity extends TranslatedMethodEntity {
+    readonly kind = EntityKind.Function;
+    readonly subkind = "method";
+    private readonly node;
+    private readonly typeParameters;
+    private readonly parameters;
+    constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.MethodTranslation | undefined);
+    getTypeParameters(): readonly TypeParameterEntity[];
+    getParameters(): readonly ParameterEntity[];
+}
+export declare class UnfinishedIntrinsicTranslatedMethodEntity {
+    private readonly unfinishedValue_;
+    get unfinishedValue(): MethodEntity;
+    constructor(analyzer: Analyzer, originalEntity: MethodEntity, translation: Translation, name: Name, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    finish(typeParameters: readonly TypeParameterEntity[], parameters: readonly ParameterEntity[]): MethodEntity;
+}

package/build/types/entities/translated/TranslatedFunctionTypeEntity.d.ts

@@ -51,7 +51,6 @@ export declare class TranslatedPackageFunctionTypeEntity implements PackageFunct
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
     getBaseObjectType(): BaseObjectType;
     getContext(): EntityContext;
-    ensureAllDiagnosticsReported(): void;
 }
 export declare class TranslatedAnonymousFunctionTypeEntity implements AnonymousFunctionTypeEntity {
     readonly kind = EntityKind.Type;

package/build/types/entities/translated/TranslatedIndexerEntity.d.ts

@@ -8,26 +8,24 @@ import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityKind, GetterEntity, PackageEntity, SetterEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 import type { IndexerEntity, IndexerEntityDefinition } from '../interfaces/IndexerEntity.js';
 import { ParameterEntity } from '../interfaces/VariableEntity.js';
-export declare class TranslatedIndexerEntity implements IndexerEntity {
+export declare abstract class TranslatedIndexerEntity implements IndexerEntity {
     readonly kind = EntityKind.Indexer;
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly translationPackage;
-    private readonly containingEntity;
-    private readonly node;
-    private readonly parameters;
+    protected readonly originalEntity: IndexerEntity;
+    protected readonly translation: Translation;
+    protected readonly translationPackage: AnalyzedTranslationPackage;
+    protected readonly containingEntity: TypeWithMembersOrExtensionEntity;
     private readonly type;
     private readonly getter;
     private readonly setter;
     private readonly overriddenMembers;
-    constructor(originalEntity: IndexerEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.IndexerTranslation | undefined);
+    constructor(originalEntity: IndexerEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    abstract getParameters(): readonly ParameterEntity[];
     getContainingEntity(): TypeWithMembersOrExtensionEntity;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
     getLocale(): PackageLocale;
     getDialect(): PackageDialect;
     getOriginalEntity(): IndexerEntity;
-    getParameters(): readonly ParameterEntity[];
     getDefinition(): IndexerEntityDefinition;
     isHidden(): EntityHidingLevel | undefined;
     markedAbstract(): boolean;
@@ -41,3 +39,15 @@ export declare class TranslatedIndexerEntity implements IndexerEntity {
     ensureAllDiagnosticsReported?(): void;
     getTags(): readonly Tag[];
 }
+export declare class SourceTranslatedIndexerEntity extends TranslatedIndexerEntity {
+    private readonly node;
+    private readonly parameters;
+    constructor(originalEntity: IndexerEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.IndexerTranslation | undefined);
+    getParameters(): readonly ParameterEntity[];
+}
+export declare class UnfinishedIntrinsicTranslatedIndexerEntity {
+    private readonly unfinishedValue_;
+    get unfinishedValue(): IndexerEntity;
+    constructor(originalEntity: IndexerEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    finish(parameters: readonly ParameterEntity[]): IndexerEntity;
+}

package/build/types/entities/translated/TranslatedOperatorEntity.d.ts

@@ -9,18 +9,17 @@ import { EntityHidingLevel } from '../EntityHiding.js';
 import { EntityKind, OperatorKind, PackageEntity, TypeWithMembersOrExtensionEntity } from '../index.js';
 import type { OperatorEntity, OperatorEntityDefinition } from '../interfaces/OperatorEntity.js';
 import { ParameterEntity } from '../interfaces/VariableEntity.js';
-export declare class TranslatedOperatorEntity implements OperatorEntity {
+export declare abstract class TranslatedOperatorEntity implements OperatorEntity {
     readonly kind = EntityKind.Operator;
-    private readonly analyzer;
-    private readonly originalEntity;
-    private readonly translation;
-    private readonly translationPackage;
-    private readonly node;
-    private readonly containingEntity;
-    private readonly parameters;
+    protected readonly analyzer: Analyzer;
+    protected readonly originalEntity: OperatorEntity;
+    protected readonly translation: Translation;
+    protected readonly translationPackage: AnalyzedTranslationPackage;
+    protected readonly containingEntity: TypeWithMembersOrExtensionEntity;
     private readonly returnType;
     private readonly overriddenMembers;
-    constructor(analyzer: Analyzer, originalEntity: OperatorEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.MethodTranslation | undefined);
+    constructor(analyzer: Analyzer, originalEntity: OperatorEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    abstract getParameters(): readonly ParameterEntity[];
     getContainingEntity(): TypeWithMembersOrExtensionEntity;
     getContainingPackage(): PackageEntity;
     getTranslation(): Translation | undefined;
@@ -28,7 +27,6 @@ export declare class TranslatedOperatorEntity implements OperatorEntity {
     getDialect(): PackageDialect;
     getOriginalEntity(): OperatorEntity;
     getOperatorKind(): OperatorKind;
-    getParameters(): readonly ParameterEntity[];
     getReturnType(): types.Type;
     getDefinition(): OperatorEntityDefinition;
     isStatic(): boolean;
@@ -39,3 +37,16 @@ export declare class TranslatedOperatorEntity implements OperatorEntity {
     isHidden(): EntityHidingLevel | undefined;
     getTags(): readonly Tag[];
 }
+export declare class SourceTranslatedOperatorEntity extends TranslatedOperatorEntity {
+    readonly kind = EntityKind.Operator;
+    private readonly node;
+    private readonly parameters;
+    constructor(analyzer: Analyzer, originalEntity: OperatorEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity, node: tree.MethodTranslation | undefined);
+    getParameters(): readonly ParameterEntity[];
+}
+export declare class UnfinishedIntrinsicTranslatedOperatorEntity {
+    private readonly unfinishedValue_;
+    get unfinishedValue(): OperatorEntity;
+    constructor(analyzer: Analyzer, originalEntity: OperatorEntity, translation: Translation, translationPackage: AnalyzedTranslationPackage, translatedContainingEntity: TypeWithMembersOrExtensionEntity);
+    finish(parameters: readonly ParameterEntity[]): OperatorEntity;
+}

package/build/types/entities/translated/TranslatedPackageEntity.d.ts

@@ -14,7 +14,6 @@ export declare class TranslatedPackageEntity implements PackageEntity {
     private readonly translation;
     private readonly name;
     private readonly translationPackage;
-    private readonly members;
     constructor(originalEntity: PackageEntity, translation: Translation, name: PackageName, translationPackage: AnalyzedTranslationPackage);
     getName(): PackageName;
     getLocale(): PackageLocale;
@@ -29,5 +28,4 @@ export declare class TranslatedPackageEntity implements PackageEntity {
     getOriginalEntity(): PackageEntity;
     getTags(): readonly Tag[];
     getTextTranslationPackageInfo(): TextTranslationPackageEntityInfo | undefined;
-    ensureAllDiagnosticsReported(): void;
 }

package/build/types/entities/translated/TranslatedStructuredTypeEntity.d.ts

@@ -51,7 +51,6 @@ export declare class TranslatedPackageStructuredTypeEntity implements PackageStr
     getTags(): readonly Tag[];
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
     getContext(): EntityContext;
-    ensureAllDiagnosticsReported(): void;
 }
 export declare class TranslatedAnonymousStructuredTypeEntity implements AnonymousStructuredTypeEntity {
     readonly kind = EntityKind.Type;

package/build/types/entities/translated/TranslatedVariantTypeEntity.d.ts

@@ -47,7 +47,6 @@ export declare class TranslatedPackageVariantTypeEntity implements PackageVarian
     getSubstitutionApplicationMode(): SubstitutionApplicationMode;
     getBaseObjectType(): BaseObjectType;
     getContext(): EntityContext;
-    ensureAllDiagnosticsReported(): void;
 }
 export declare class TranslatedAnonymousVariantTypeEntity implements AnonymousVariantTypeEntity {
     readonly kind = EntityKind.Type;

package/build/types/executor/Compiler.d.ts

@@ -1,5 +1,5 @@
 import { Analyzer } from '../analysis/Analyzer.js';
-import { CancellationToken, Uri } from '../common/index.js';
+import { TaskController, Uri } from '../common/index.js';
 import { DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { EmitOptions, OutputAcceptor } from '../emitter/index.js';
 import { Compilation } from '../project/Compilation.js';
@@ -7,11 +7,11 @@ import { SourcesProvider } from '../project/CompilationLoader.js';
 import { TypeScriptLibrariesProvider } from '../ts-interop/TsLibrariesProvider.js';
 export type LaunchUri = Uri;
 export declare class Compiler {
-    static loadCompilation(projectUri: Uri, sourcesProvider: SourcesProvider, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, options?: LoadCompilationOptions, cancellationToken?: CancellationToken): Promise<Compilation | undefined>;
-    static createAnalyzer(compilation: Compilation, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, _cancellationToken?: CancellationToken): Promise<Analyzer | undefined>;
-    static analyze(analyzer: Analyzer, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<boolean>;
-    static emit(analyzer: Analyzer, outputUri: Uri, outputAcceptor: OutputAcceptor, _diagnostics: DiagnosticAcceptor | undefined, emitOptions?: EmitOptions, cancellationToken?: CancellationToken): Promise<LaunchUri | undefined>;
-    static emitToString(analyzer: Analyzer, _diagnostics: DiagnosticAcceptor | undefined, emitOptions?: EmitOptions, cancellationToken?: CancellationToken): Promise<string>;
+    static loadCompilation(projectUri: Uri, sourcesProvider: SourcesProvider, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, taskController: TaskController, options?: LoadCompilationOptions): Promise<Compilation | undefined>;
+    static createAnalyzer(compilation: Compilation, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, _taskController: TaskController): Promise<Analyzer | undefined>;
+    static analyze(analyzer: Analyzer, diagnostics: DiagnosticAcceptor | undefined, taskController: TaskController): Promise<boolean>;
+    static emit(analyzer: Analyzer, outputUri: Uri, outputAcceptor: OutputAcceptor, diagnostics: DiagnosticAcceptor | undefined, taskController: TaskController, emitOptions?: EmitOptions): Promise<LaunchUri | undefined>;
+    static emitToString(analyzer: Analyzer, _diagnostics: DiagnosticAcceptor | undefined, taskController: TaskController, emitOptions?: EmitOptions): Promise<string>;
 }
 export interface LoadCompilationOptions {
     workspaceUri?: Uri;

package/build/types/executor/NodeCompiler.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 { Diagnostic, DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { EmitOptions } from '../emitter/index.js';
 import { Compilation } from '../project/index.js';
@@ -10,10 +10,10 @@ export declare class NodeCompiler {
     private static get fileSystem();
     static findStandardTypeScriptLibrary(nodeModulesSearchPaths: readonly string[], defaultTsLibraryPath?: string): Promise<Uri | undefined>;
     static createTypeScriptLibrariesProvider(nodeModulesSearchPaths: readonly string[], defaultTsLibraryPath: string | undefined, diagnostics: DiagnosticAcceptor | undefined): Promise<TypeScriptLibrariesProvider | undefined>;
-    static loadCompilation(projectPath: string, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, options?: NodeCompilerLoadCompilationOptions, cancellationToken?: CancellationToken): Promise<Compilation | undefined>;
-    static createAnalyzer(compilation: Compilation, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<Analyzer | undefined>;
-    static analyze(analyzer: Analyzer, diagnostics: DiagnosticAcceptor | undefined, cancellationToken?: CancellationToken): Promise<boolean>;
-    static emit(analyzer: Analyzer, outputPath: string, diagnostics: DiagnosticAcceptor | undefined, emitOptions?: EmitOptions, cancellationToken?: CancellationToken): Promise<LaunchPath | undefined>;
+    static loadCompilation(projectPath: string, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, taskController: TaskController, options?: NodeCompilerLoadCompilationOptions): Promise<Compilation | undefined>;
+    static createAnalyzer(compilation: Compilation, tsLibrariesProvider: TypeScriptLibrariesProvider, diagnostics: DiagnosticAcceptor | undefined, taskController: TaskController): Promise<Analyzer | undefined>;
+    static analyze(analyzer: Analyzer, diagnostics: DiagnosticAcceptor | undefined, taskController: TaskController): Promise<boolean>;
+    static emit(analyzer: Analyzer, outputPath: string, diagnostics: DiagnosticAcceptor | undefined, taskController: TaskController, emitOptions?: EmitOptions): Promise<LaunchPath | undefined>;
     static compile(task: NodeCompilerTask): Promise<LaunchPath | undefined>;
 }
 export interface NodeCompilerLoadCompilationOptions {
@@ -30,7 +30,7 @@ export interface NodeCompilerTask {
     loadCompilationOptions?: NodeCompilerLoadCompilationOptions;
     defaultTsLibraryPath?: string;
     emitOptions?: EmitOptions;
-    cancellationToken?: CancellationToken;
+    controller: TaskController;
 }
 export declare class PrintingDiagnosticAcceptor implements DiagnosticAcceptor {
     private readonly noWarnings;

package/build/types/project/CompilationLoader.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, Uri } from '../common/index.js';
+import { TaskController, Uri } from '../common/index.js';
 import { Diagnostic, DiagnosticAcceptor } from '../diagnostic/Diagnostic.js';
 import { Compilation } from './Compilation.js';
 import { ConvertedConfiguration } from './configuration/ConfigurationConverter.js';
@@ -10,15 +10,15 @@ export declare class CompilationLoader {
     private readonly source;
     private readonly config;
     private readonly diagnostics;
-    private readonly cancellationToken;
+    private readonly taskController;
     private configurationsByPackageOrGroupUri;
     private constructor();
-    static loadUsingSourcesProvider(uri: Uri, sourcesProvider: SourcesProvider, options?: CompilationLoaderOptions, diagnostics?: DiagnosticAcceptor, workspaceUri?: Uri, namesOfDirectoriesToIgnore?: readonly string[], cancellationToken?: CancellationToken): Promise<{
+    static loadUsingSourcesProvider(uri: Uri, sourcesProvider: SourcesProvider, taskController: TaskController, options?: CompilationLoaderOptions, diagnostics?: DiagnosticAcceptor, workspaceUri?: Uri, namesOfDirectoriesToIgnore?: readonly string[]): Promise<{
         loadResult: CompilationLoadResult;
         fileSystemTree: fsTree.FileSystemTree;
     }>;
-    static loadFromFileSystemTree(rootDirectory: fsTree.Directory, fileSystemTree: fsTree.ReadonlyFileSystemTree, options?: CompilationLoaderOptions, diagnostics?: DiagnosticAcceptor, cancellationToken?: CancellationToken): Promise<CompilationLoadResult>;
-    static loadFromPackageContents(contents: readonly packageContent.PackageContent[], options?: CompilationLoaderOptions, diagnostics?: DiagnosticAcceptor, cancellationToken?: CancellationToken): Promise<CompilationLoadResult>;
+    static loadFromFileSystemTree(rootDirectory: fsTree.Directory, fileSystemTree: fsTree.ReadonlyFileSystemTree, taskController: TaskController, options?: CompilationLoaderOptions, diagnostics?: DiagnosticAcceptor): Promise<CompilationLoadResult>;
+    static loadFromPackageContents(contents: readonly packageContent.PackageContent[], taskController: TaskController, options?: CompilationLoaderOptions, diagnostics?: DiagnosticAcceptor): Promise<CompilationLoadResult>;
     /**
      * Ищет папку с конфигурацией (папку '.артель') в переданной папке.
      */

package/build/types/project/FileSystemTree.d.ts

@@ -60,7 +60,7 @@ export interface Directory extends IFileOrDirectory {
     readonly isDisposed: boolean;
     getChildren(): Iterable<FileOrDirectory>;
     getChild(name: string): FileOrDirectory | undefined;
-    enumerateDescendants(): Iterable<FileOrDirectory>;
+    getFlatChildren(): Iterable<FileOrDirectory>;
 }
 interface IFileOrDirectory {
     readonly uri: Uri;

package/build/types/project/PackageContentCreator.d.ts

@@ -1,3 +1,4 @@
+import { TaskController } from '../common/index.js';
 import { Directory, ReadonlyFileSystemTree } from './FileSystemTree.js';
 import { PackageContent } from './PackageContent.js';
-export declare function createPackageContentsFromFSTree(rootDirectory: Directory, fileSystemTree: ReadonlyFileSystemTree): Promise<PackageContent[]>;
+export declare function createPackageContentsFromFSTree(rootDirectory: Directory, fileSystemTree: ReadonlyFileSystemTree, taskController: TaskController): Promise<PackageContent[]>;

package/build/types/services/DefinitionService.d.ts

@@ -1,12 +1,12 @@
 import { Analyzer } from '../analysis/index.js';
-import { CancellationToken, Range } from '../common/index.js';
+import { Range, TaskController } from '../common/index.js';
 import { SourceFile } from '../project/index.js';
 import { SourceGenerationService } from './source-generation/SourceGenerationService.js';
 import { SourceLocation } from './Types.js';
 export declare class DefinitionService {
     private readonly sourceGenerationService;
     constructor(sourceGenerationService: SourceGenerationService | undefined);
-    getDefinition(analyzer: Analyzer, sourceFile: SourceFile, offset: number, cancellationToken: CancellationToken | undefined): Promise<DefinitionsAndReferenceInfo | undefined>;
+    getDefinition(analyzer: Analyzer, sourceFile: SourceFile, offset: number, taskController: TaskController): Promise<DefinitionsAndReferenceInfo | undefined>;
     private getDefinitionOfReference;
     private getReferenceTargetSourceLocation;
     private getReferenceTargetEntity;