@artel/artc 0.6.25191

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

@@ -0,0 +1,342 @@
+import { SourcePackageDependencyGraph } from '../analysis/SourcePackageDependencyGraph.js';
+import * as tags from '../analysis/Tags.js';
+import { Analyzer } from '../analysis/index.js';
+import { CancellationToken, PackageLocale, Uri } from '../common/index.js';
+import { OriginalPackageMembers } from '../entities/PackageMembers.js';
+import { AliasTypeEntity, ConstructorEntity, DereferenceOperatorEntity, Entity, EntityKind, IndexerEntity, InterfacePackageEntityInfo, MethodEntity, MethodTypeEntity, PackageAliasEntity, PackageEntity, PackageEntityDefinition, PackageMemberEntity, PackageVariableEntity, StructuredTypeEntity, TypeEntity, TypeEntityWithMembers, TypeMethodEntity, TypeParameterEntity, TypeVariableEntity, VariableEntity, VariantEntity, VariantTypeEntity } from '../entities/index.js';
+import { JavaScriptImplementationConfig, PackageName, PlatformKind, ProgramPackage, SourceFile as ProjectSourceFile } from '../project/index.js';
+import * as types from '../types/index.js';
+import { EmitterPackage } from './EmitterPackage.js';
+import { EntityNameProvider, RegisteredEntityNames } from './EntityNameProviders.js';
+import * as ir from './ir/index.js';
+import { AssignmentExpression, AssignmentOperator, BaseConstructorCallExpression, BinaryExpressionOperator, BlockStatement, CallArguments, Expression, MethodAccessExpression, OrderedCallArguments, OwnConstructorCallExpression, SourceFile, TypeMethodAccessExpression, TypeVariableAccessExpression, UnorderedCallArguments, VariableAccessExpression } from './ir/index.js';
+export declare class EmitterContext {
+    readonly analyzer: Analyzer;
+    readonly targetPlatform: PlatformKind;
+    readonly extensionLikeMembers: ExtensionLikeMembers;
+    readonly type: Type;
+    readonly utils: Utils;
+    readonly membersForCopyOnWrite: MembersForCopyOnWriteContext;
+    readonly realName: RealName;
+    readonly linker: ExternalDeclarationLinker;
+    readonly helperMethods: HelperMethods;
+    readonly jsStandardTypes: JsStandardTypes;
+    readonly generatedName: GeneratedName;
+    private readonly _declarationsUsageCountResults;
+    private readonly _emitterPackages;
+    private readonly _packageMethodByPackageVariableGetter;
+    private readonly _packageMethodByPackageVariableSetter;
+    private readonly _typeMethodByIndexedGetter;
+    private readonly _typeMethodByIndexedSetter;
+    private readonly _typeDereferencedVariableVariableByDereferenceOperator;
+    private readonly _overloadedConstructorGroupByType;
+    private readonly _typeMethodNamesByType;
+    private readonly _typeMethodByPlainObjectConstructor;
+    private readonly _plainObjectDefaultEmptyConstructorByPlainObject;
+    private readonly _proxyTypeVariables;
+    private readonly _lazySystemJsPackage;
+    private readonly _esPackage;
+    private readonly _packageByPackageMember;
+    private readonly _registeredEntityNamesForCompilation;
+    private _packageGraph;
+    private readonly _isConstantPlainObjectResults;
+    get systemPackage(): PackageEntity;
+    get systemJsPackage(): PackageEntity;
+    get jsPlatformPackage(): PackageEntity;
+    get standardTypes(): types.StandardTypes;
+    get packageByPackageMember(): ReadonlyMap<Entity, EmitterPackage>;
+    get registeredEntityNamesForCompilation(): RegisteredEntityNames;
+    get packageGraph(): SourcePackageDependencyGraph;
+    private constructor();
+    static create(analyzer: Analyzer, cancellationToken: CancellationToken | undefined, targetPlatform?: PlatformKind): Promise<EmitterContext>;
+    buildIR(sourceFile: ProjectSourceFile): ir.SourceFile;
+    enumerateEmittingPackages(): Iterable<EmitterPackage>;
+    enumerateEmittingSourcePackages(): Iterable<ProgramPackage>;
+    /**
+     * Главным считается файл главного пакета, в котором находится блок "при создании" или блок "выполнить".
+     */
+    getMainFileUri(): Uri | undefined;
+    getTypeIndexedElementGetter(indexer: IndexerEntity): TypeMethodEntity;
+    getTypeIndexedElementSetter(indexer: IndexerEntity): TypeMethodEntity;
+    getTypeDereferencedVariableVariable(operator: DereferenceOperatorEntity): TypeVariableEntity;
+    getPackageMethodForPackageVariableGetter(variable: PackageVariableEntity): MethodEntity;
+    getPackageMethodForPackageVariableSetter(variable: PackageVariableEntity): MethodEntity;
+    getOverloadedConstructorGroupForType(entity: TypeEntityWithMembers): OverloadedConstructorGroup;
+    getTypeMethodNames(entity: TypeEntityWithMembers): UniqueEntityNames;
+    getTypeMethodForPlainObjectConstructor(entity: ConstructorEntity, containingType: TypeEntityWithMembers): TypeMethodEntity;
+    getPlainObjectDefaultEmptyConstructor(entity: StructuredTypeEntity): ConstructorEntity;
+    createUniqueNamesForReferencedPackageMemberEntities(ownNames: UniqueEntityNames, referencedEntities: ReferencedPackageMemberEntities): UniqueEntityNames;
+    createImportDirectivesForPackage(referencedEntities: ReferencedPackageMemberEntities, referencedEntityNames: UniqueEntityNames, mode: ImportDirectivesCreationMode, fileLocale: PackageLocale): readonly ir.Statement[];
+    /**
+     * Проверяет, является ли простой объект константным. Если объект является таковым, для него не нужно выполнять
+     * copy-on-write.
+     *
+     * @returns Возвращает `true`, если
+     * 1. Все поля объекта - конст.
+     * 2. Типы всех полей либо не являются простыми объектами, либо являются константными простыми объектами.
+     */
+    isConstantPlainObject(entity: StructuredTypeEntity, entitiesBeingChecked?: Set<StructuredTypeEntity>): boolean;
+    ifProxiedTypeVariableThenProxyTag(entity: TypeVariableEntity): tags.Tag | undefined;
+    getProxyTypeVariable(proxiedVariable: TypeVariableEntity): TypeVariableEntity;
+    private tryGetEmitterPackage;
+    private createPackageByPackageMember;
+    private createRegisteredEntityNamesForCompilation;
+}
+export type ImportDirectivesCreationMode = ImportDirectivesCreationMode.OnlyJsLibrariesDependencies | ImportDirectivesCreationMode.AllDependencies;
+export declare namespace ImportDirectivesCreationMode {
+    class OnlyJsLibrariesDependencies {
+        readonly kind = "only-js-libraries-dependencies";
+    }
+    class AllDependencies {
+        readonly package_: EmitterPackage;
+        readonly getArtelPackageImportPath: (p: EmitterPackage) => string;
+        readonly kind = "all-dependencies";
+        constructor(package_: EmitterPackage, getArtelPackageImportPath: (p: EmitterPackage) => string);
+    }
+}
+declare class Utils {
+    private readonly _ectx;
+    private _id;
+    constructor(_ectx: EmitterContext);
+    getOrderedCallArguments(callArguments: CallArguments): OrderedCallArguments;
+    orderCallArgumentsAccordingToParameters(callArguments: UnorderedCallArguments): OrderedCallArguments;
+    findOwnConstructorCall(body: BlockStatement): OwnConstructorCall | undefined;
+    findBaseConstructorCall(body: BlockStatement): BaseConstructorCall | undefined;
+    createUniqueLocalVariableEntity(locale: PackageLocale, type: types.Type): VariableEntity;
+    getBinaryExpressionOperatorFromAssignmentOperator(operator: AssignmentOperator): BinaryExpressionOperator;
+    generateId(): number;
+    createIdentitySubstitutedStructuredType(entity: StructuredTypeEntity): types.StructuredType;
+    createIdentitySubstitutedVariantType(entity: VariantTypeEntity): types.VariantType;
+    createInitializedTemporaryVariable(locale: PackageLocale, initializer: Expression, tempVariables?: VariableEntity[]): [VariableEntity, AssignmentExpression, VariableAccessExpression];
+    lowerOwnTypeVariableAccessExpression(expression: VariableAccessExpression): TypeVariableAccessExpression;
+    lowerOwnTypeMethodAccessExpression(expression: MethodAccessExpression): TypeMethodAccessExpression;
+    getPackageStructuredTypeRequired(originalName: string, packageEntity: PackageEntity): StructuredTypeEntity;
+    getPackageMethodRequired(originalName: string, packageEntity: PackageEntity): MethodEntity;
+    getTypeMethodRequired(originalName: string, type: TypeEntityWithMembers): TypeMethodEntity;
+    getTypeVariableRequired(originalName: string, type: TypeEntityWithMembers): TypeVariableEntity;
+    getTypeConstructorRequired(type: TypeEntityWithMembers): ConstructorEntity;
+    private createReceiverForOwnMemberAccess;
+}
+declare class Type {
+    private readonly _ectx;
+    private get standardTypes();
+    constructor(_ectx: EmitterContext);
+    ofExpression(expression: Expression): types.Type;
+}
+declare class GeneratedName {
+    ofMainFunction(locale: PackageLocale): string;
+    ofPackageConstructor(locale: PackageLocale, id: number): string;
+    ofPackageRunFunction(locale: PackageLocale, id: number): string;
+    ofPlainObjectConstructor(locale: PackageLocale, id: number): string;
+    ofExtensionConstructor(locale: PackageLocale): string;
+    ofExtensionMethodTargetParameter(locale: PackageLocale): string;
+    ofGlobalVariableGetter(locale: PackageLocale, originalName: string): string;
+    ofGlobalVariableSetter(locale: PackageLocale, originalName: string): string;
+    ofTypeVariableGetter(locale: PackageLocale, originalName: string): string;
+    ofTypeVariableSetter(locale: PackageLocale, originalName: string): string;
+    ofTypeIndexedElementGetter(locale: PackageLocale): string;
+    ofTypeIndexedElementSetter(locale: PackageLocale): string;
+    ofTypeDereferencedVariable(locale: PackageLocale): string;
+    ofTypeBackingVariable(locale: PackageLocale, originalName: string): string;
+    ofTempVariable(locale: PackageLocale, id: number): string;
+    ofDefaultImport(locale: PackageLocale, id: number): string;
+    ofNamespaceImport(locale: PackageLocale, id: number): string;
+    ofRefCountVariable(locale: PackageLocale): string;
+    ofAddReferenceMethod(locale: PackageLocale): string;
+    ofRemoveReferenceMethod(locale: PackageLocale): string;
+    ofShallowCopyMethod(locale: PackageLocale): string;
+    ofMergedConstructorIdParameter(locale: PackageLocale): string;
+    ofMergedConstructorParameter(locale: PackageLocale, id: number): string;
+    ofAnonymousType(locale: PackageLocale): string;
+    ofPlainObjectMethodNewThisVariable(locale: PackageLocale): string;
+    ofPlainObjectMethodResultNewThisProperty(locale: PackageLocale): string;
+    ofPlainObjectMethodResultResultProperty(locale: PackageLocale): string;
+    ofProxyVariable(locale: PackageLocale, originalName: string): string;
+}
+type OwnConstructorCall = {
+    expression: OwnConstructorCallExpression;
+    statementIndex: number;
+};
+type BaseConstructorCall = {
+    expression: BaseConstructorCallExpression;
+    statementIndex: number;
+};
+declare class ExtensionLikeMembers {
+    private readonly _ectx;
+    private readonly _methodSubstitutions;
+    private readonly _getterSubstitutions;
+    private readonly _setterSubstitutions;
+    private readonly _constructorSubstitutions;
+    constructor(_ectx: EmitterContext);
+    isExtensionLikeMethod(entity: TypeMethodEntity): ExtensionLikeMethodInfo | undefined;
+    isExtensionLikeConstructor(entity: ConstructorEntity): ExtensionLikeConstructorInfo | undefined;
+    isExtensionLikeVariable(entity: TypeVariableEntity): ExtensionLikeVariableInfo | undefined;
+    getMethodSubstitution(method: ExtensionLikeMethodInfo): TypeMethodEntity;
+    getConstructorSubstitution(constructor: ExtensionLikeConstructorInfo): TypeMethodEntity;
+    getVariableGetterSubstitution(variable: ExtensionLikeVariableInfo): TypeMethodEntity;
+    getVariableSetterSubstitution(variable: ExtensionLikeVariableInfo): TypeMethodEntity;
+    private ifContainerOfExtensionLikeMemberThenTargetType;
+    private createTargetParameter;
+}
+export declare class ExtensionLikeMethodInfo {
+    readonly entity: TypeMethodEntity;
+    readonly targetType: types.Type;
+    constructor(entity: TypeMethodEntity, targetType: types.Type);
+}
+export declare class ExtensionLikeConstructorInfo {
+    readonly entity: ConstructorEntity;
+    readonly targetType: types.Type;
+    constructor(entity: ConstructorEntity, targetType: types.Type);
+}
+export declare class ExtensionLikeVariableInfo {
+    readonly entity: TypeVariableEntity;
+    readonly targetType: types.Type;
+    constructor(entity: TypeVariableEntity, targetType: types.Type);
+}
+export declare class MembersForCopyOnWriteContext {
+    private readonly _ectx;
+    private readonly _membersForCopyOnWrite;
+    constructor(_ectx: EmitterContext);
+    ofType(entity: StructuredTypeEntity): MembersForCopyOnWrite;
+    private createReferenceCountField;
+    private createAddReferenceMethod;
+    private createRemoveReferenceMethod;
+    private createShallowCopyMethod;
+    private createIdentitySubstitutedType;
+}
+export declare class MembersForCopyOnWrite {
+    readonly referenceCountField: TypeVariableEntity;
+    readonly incrementReferenceCountMethod: TypeMethodEntity;
+    readonly decrementReferenceCountMethod: TypeMethodEntity;
+    readonly shallowCopyMethod: TypeMethodEntity;
+    constructor(referenceCountField: TypeVariableEntity, incrementReferenceCountMethod: TypeMethodEntity, decrementReferenceCountMethod: TypeMethodEntity, shallowCopyMethod: TypeMethodEntity);
+}
+export declare class OverloadedConstructorGroup {
+    private readonly _ectx;
+    readonly constructors: readonly ConstructorEntity[];
+    private readonly _containingType;
+    readonly mergedConstructor: ConstructorEntity;
+    constructor(_ectx: EmitterContext, constructors: readonly ConstructorEntity[], _containingType: TypeEntityWithMembers);
+    getOverloadId(constructor: ConstructorEntity): number;
+    private createMergedConstructor;
+}
+export declare class UniqueEntityNames {
+    private readonly _nameByEntity;
+    private readonly _uniqueNames;
+    get nameByEntity(): ReadonlyMap<Entity, string>;
+    constructor(uniqueNameByEntity?: ReadonlyMap<Entity, string>);
+    getName(entity: Entity): string;
+    registerEntity(entity: Entity, suggestedName: string): string;
+    registerEntity(entity: Entity, nameProvider: EntityNameProvider): string;
+    registerUniqueName(entity: Entity, uniqueName: string): void;
+    private generateUniqueName;
+}
+export declare class RealName {
+    private readonly _ectx;
+    static readonly RealNameArgumentName: string;
+    constructor(_ectx: EmitterContext);
+    ofEntity(entity: Entity): string | undefined;
+    private ofTypeMethod;
+    private ofTypeVariable;
+    ofMethod(entity: MethodEntity): string | undefined;
+    private getRealName;
+    private getLinkedTypeMethodOrPreserve;
+    private getLinkedTypeVariableOrPreserve;
+}
+export type NamedEntity = VariableEntity | VariantEntity | VariantTypeEntity | MethodEntity | TypeParameterEntity | MethodTypeEntity | StructuredTypeEntity | PackageAliasEntity | AliasTypeEntity;
+declare class ExternalDeclarationLinker {
+    private readonly _ectx;
+    private readonly _targetPlatform;
+    constructor(_ectx: EmitterContext, _targetPlatform: PlatformKind);
+    link(sourceFile: SourceFile): void;
+    getLinkedVariable(variable: VariableEntity): VariableEntity | undefined;
+    getLinkedTypeVariable(variable: TypeVariableEntity): TypeVariableEntity | undefined;
+    getLinkedMethod(method: MethodEntity): MethodEntity | undefined;
+    getLinkedTypeMethod(method: TypeMethodEntity): TypeMethodEntity | undefined;
+    getLinkedIndexer(indexer: IndexerEntity): IndexerEntity | undefined;
+    getLinkedConstructor(constructor: ConstructorEntity): ConstructorEntity | undefined;
+    getLinkedTypeEntity(entity: TypeEntity): TypeEntity | undefined;
+    getLinkedType(type: types.Type): types.Type | undefined;
+    private linkVariableAccessExpression;
+    private linkInstanceVariableAccessExpression;
+    private linkMethodAccessExpression;
+    private linkInstanceMethodAccessExpression;
+    private linkAsExpression;
+    private linkIsExpression;
+    private linkIndexedAccessExpression;
+    private linkConstructorCallExpression;
+    private linkBaseConstructorCallExpression;
+    private linkTypeAccessExpression;
+    private linkPackageTypeDeclarationBaseType;
+    private entityShouldBeLinked;
+    private aspectEntityShouldBeLinked;
+    private typeShouldBeLinked;
+}
+declare class HelperMethods {
+    private readonly _ectx;
+    private readonly _integerDivisionMethod;
+    private readonly _numberIsIntegerMethod;
+    private readonly _throwErrorMethod;
+    constructor(_ectx: EmitterContext);
+    createIntegerDivisionMethodCall(dividend: Expression, divisor: Expression): Expression;
+    createNumberIsIntegerMethodCall(integer: Expression): Expression;
+    createThrowErrorMethodCall(argument?: Expression): Expression;
+    private createHelperMethodCall;
+    private findHelperMethodLazy;
+}
+declare class JsStandardTypes {
+    private readonly _ectx;
+    private readonly _numberType;
+    private readonly _integerType;
+    private readonly _textType;
+    private readonly _charType;
+    private readonly _yesNoType;
+    private readonly _noneType;
+    private readonly _methodType;
+    private readonly _referenceType;
+    private readonly _jsObject;
+    get number(): types.Type;
+    get integer(): types.Type;
+    get text(): types.Type;
+    get char(): types.Type;
+    get yesNo(): types.Type;
+    get none(): types.Type;
+    get method(): types.Type;
+    get reference(): types.Type;
+    get jsObject(): types.StructuredType;
+    constructor(ectx: EmitterContext);
+    private findStandardType;
+    private findJsType;
+}
+export declare class ReferencedPackageMemberEntities {
+    private readonly _packageByPackageMember;
+    private readonly _entitiesFromArtel;
+    private readonly _entitiesFromJs;
+    get entitiesFromArtel(): ReadonlyMap<EmitterPackage, ReadonlySet<Entity>>;
+    get entitiesFromJs(): ReadonlyMap<JavaScriptImplementationConfig, ReadonlySet<PackageMemberEntity>>;
+    constructor(_analyzer: Analyzer, node: ir.SourceFile, packageByPackageMember: ReadonlyMap<Entity, EmitterPackage>);
+    private addPackageMember;
+    private addEntityFromArtel;
+    private addEntityFromJs;
+}
+export declare class ReferencedEntityFromJs {
+    readonly value: NamedEntity;
+    readonly isDefaultImport: boolean;
+    constructor(value: NamedEntity, isDefaultImport: boolean);
+}
+export declare class EntitiesImportedFromJs {
+    readonly libraryName: string;
+    readonly values: Map<Entity, ReferencedEntityFromJs>;
+    constructor(libraryName: string, values: Map<Entity, ReferencedEntityFromJs>);
+}
+export declare class DummyPackageEntity implements PackageEntity {
+    readonly kind = EntityKind.Package;
+    getName(): PackageName;
+    getLocale(): PackageLocale;
+    getMembers(): OriginalPackageMembers;
+    isInterface(): InterfacePackageEntityInfo | undefined;
+    getImplementedInterfacePackage(): PackageEntity | undefined;
+    getSupportedPlatforms(): readonly PlatformKind[];
+    getDefinition(): PackageEntityDefinition;
+}
+export {};

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

@@ -0,0 +1,36 @@
+import { PackageLocale } from '../common/index.js';
+export declare const enum EmitterGeneratedDeclarationKind {
+    MainFunction = 0,
+    PackageConstructorPrefix = 1,
+    PackageRunFunctionPrefix = 2,
+    PlainObjectConstructorPrefix = 3,
+    ExtensionConstructor = 4,
+    ExtensionMethodTargetParameter = 5,
+    GlobalVariableGetterPrefix = 6,
+    GlobalVariableSetterPrefix = 7,
+    TypeVariableGetterPrefix = 8,
+    TypeVariableSetterPrefix = 9,
+    TypeIndexedElementGetter = 10,
+    TypeIndexedElementSetter = 11,
+    TypeDereferencedVariable = 12,
+    TypeBackingVariablePrefix = 13,
+    TempVariablePrefix = 14,
+    DefaultImportPrefix = 15,
+    NamespaceImportPrefix = 16,
+    RefCountVariable = 17,
+    AddReferenceMethod = 18,
+    RemoveReferenceMethod = 19,
+    ShallowCopyMethod = 20,
+    MergedConstructorIdParameter = 21,
+    MergedConstructorParameterPrefix = 22,
+    AnonymousType = 23,
+    PlainObjectMethodNewThisVariable = 24,
+    PlainObjectMethodResultNewThisProperty = 25,
+    PlainObjectMethodResultResultProperty = 26,
+    ProxyVariable = 27
+}
+export declare const emitterGeneratedDeclarationNamesByLocale: {
+    [T in PackageLocale]: {
+        [T in EmitterGeneratedDeclarationKind]: string;
+    };
+};

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

@@ -0,0 +1,60 @@
+import { PackageLocale, Uri } from '../common/index.js';
+import { ProgramPackage, SourcePackage } from '../project/index.js';
+import { EmitterContext, UniqueEntityNames } from './EmitterContext.js';
+import { RegisteredEntityNames } from './EntityNameProviders.js';
+import * as ir from './ir/index.js';
+export interface EmitterPackage {
+    getDefinition(): EmitterPackageDefinition;
+    getLoweredIr(): ir.SourceFile;
+    getMemberNames(): UniqueEntityNames;
+    getRegisteredEntityNames(): RegisteredEntityNames;
+    getPackageEntryPointMethods(): readonly ir.PackageMethodDeclaration[];
+    getPackageConstructorMethods(): readonly ir.PackageMethodDeclaration[];
+    getLocale(): PackageLocale;
+}
+export type EmitterPackageDefinition = EmitterPackageDefinition_source | EmitterPackageDefinition_intrinsic;
+declare class EmitterPackageDefinition_source {
+    readonly pkg: SourcePackage;
+    readonly kind = "source";
+    constructor(pkg: SourcePackage);
+}
+declare class EmitterPackageDefinition_intrinsic {
+    readonly outputUri: Uri;
+    readonly isLaunch: boolean;
+    readonly kind = "intrinsic";
+    constructor(outputUri: Uri, isLaunch: boolean);
+}
+export declare class SourceEmitterPackage implements EmitterPackage {
+    private readonly _generalLoweringResult;
+    private readonly _memberNames;
+    private readonly _ectx;
+    private readonly _package;
+    constructor(ectx: EmitterContext, package_: ProgramPackage);
+    getDefinition(): EmitterPackageDefinition_source;
+    getLoweredIr(): ir.SourceFile;
+    getMemberNames(): UniqueEntityNames;
+    getRegisteredEntityNames(): RegisteredEntityNames;
+    getPackageConstructorMethods(): readonly ir.PackageMethodDeclaration[];
+    getPackageEntryPointMethods(): readonly ir.PackageMethodDeclaration[];
+    getLocale(): PackageLocale;
+    private getGeneralLoweringResult;
+}
+export declare class IntrinsicEmitterPackage implements EmitterPackage {
+    private readonly _outputUri;
+    private readonly _isLaunch;
+    private readonly _loweredIr;
+    private readonly _memberNames;
+    private readonly _registeredEntityNames;
+    private readonly _packageEntryPointMethods;
+    private readonly _packageConstructorMethods;
+    private readonly _locale;
+    constructor(_outputUri: Uri, _isLaunch: boolean, _loweredIr: ir.SourceFile, _memberNames: UniqueEntityNames, _registeredEntityNames: RegisteredEntityNames, _packageEntryPointMethods: readonly ir.PackageMethodDeclaration[], _packageConstructorMethods: readonly ir.PackageMethodDeclaration[], _locale: PackageLocale);
+    getDefinition(): EmitterPackageDefinition;
+    getLoweredIr(): ir.SourceFile;
+    getMemberNames(): UniqueEntityNames;
+    getRegisteredEntityNames(): RegisteredEntityNames;
+    getPackageEntryPointMethods(): readonly ir.PackageMethodDeclaration[];
+    getPackageConstructorMethods(): readonly ir.PackageMethodDeclaration[];
+    getLocale(): PackageLocale;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import { Name } from '../common/index.js';
+import { Entity, EntityNaming } from '../entities/index.js';
+import { EmitterContext } from './EmitterContext.js';
+export interface EntityNameProvider extends OptionalEntityNameProvider {
+    getName(entity: Entity): string;
+}
+export interface OptionalEntityNameProvider {
+    getName(entity: Entity): string | undefined;
+}
+export declare class RegisteredEntityNames implements OptionalEntityNameProvider {
+    private readonly _registeredEntityNames;
+    get registeredEntityNames(): ReadonlyMap<Entity, string>;
+    registerName(entity: Entity, name: string): void;
+    registerNames(names: ReadonlyMap<Entity, string>): void;
+    getName(entity: Entity): string | undefined;
+}
+export declare class RealJsNameProvider implements OptionalEntityNameProvider {
+    private readonly _ectx;
+    constructor(_ectx: EmitterContext);
+    getName(entity: Entity): string | undefined;
+}
+export declare class EntityNameProviderChain implements EntityNameProvider {
+    private readonly _optionalProviders;
+    private readonly _requiredProvider;
+    constructor(_optionalProviders: readonly OptionalEntityNameProvider[], _requiredProvider: EntityNameProvider);
+    getName(entity: Entity): string;
+}
+export declare class NormalizedEntityNameProvider implements EntityNameProvider {
+    static getName(entity: Entity): string;
+    getName(entity: Entity): string;
+}
+export declare function getEntityNameRequired(entity: Entity): Name;
+export declare function getEntityNaming(entity: Entity): EntityNaming;

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

@@ -0,0 +1,17 @@
+import { VariableEntity } from '../entities/index.js';
+import { TransformationContinuationAction } from './TransformationContinuationAction.js';
+import { Expression } from './ir/index.js';
+export declare enum Kind {
+    Preserve = 0,
+    Replace = 1
+}
+export type Type = {
+    kind: Kind.Preserve;
+    action: TransformationContinuationAction;
+} | {
+    kind: Kind.Replace;
+    expression: Expression;
+    hoistedLocalVariables?: readonly VariableEntity[];
+};
+export declare function preserve(action?: TransformationContinuationAction): Type;
+export declare function replace(expression: Expression, hoistedLocalVariables?: readonly VariableEntity[]): Type;

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

@@ -0,0 +1,72 @@
+import { PackageLocale } from '../common/index.js';
+import { EmitterContext } from './EmitterContext.js';
+import { RegisteredEntityNames } from './EntityNameProviders.js';
+import { PackageMethodDeclaration, SourceFile } from './ir/index.js';
+export declare class GeneralLowering {
+    private readonly _ectx;
+    static readonly toStringArtelMethodName = "\u0432-\u0442\u0435\u043A\u0441\u0442";
+    private readonly _ctx;
+    private readonly _referenceExpressionLowering;
+    private readonly _extensionLikeMembersLowering;
+    private readonly _copyOnWriteLowering;
+    private readonly _modifyingMethodLowering;
+    private readonly _methodObjectLowering;
+    private readonly _textTemplateLowering;
+    private readonly _isExpressionLowering;
+    private readonly _enumerableLowering;
+    private readonly _overloadedConstructorsLowering;
+    private readonly _indexerSetAccessLowering;
+    private readonly _variableProxyLowering;
+    private readonly _packageEntryPointMethods;
+    private readonly _packageConstructorMethods;
+    private readonly _registeredEntityNames;
+    private readonly _lazyInlineJsMethod;
+    private get inlineJsMethod();
+    constructor(_ectx: EmitterContext, locale: PackageLocale);
+    lower(sourceFile: SourceFile): GeneralLoweringResult;
+    private excludeRedefinableMethodsFromAliasType;
+    private substituteBaseAliasType;
+    private lowerImplicitVariantAccessExpression;
+    private lowerImplicitConversionExpression;
+    private addRedefinableMethodsToPrototype;
+    private lowerMethodTypeInvokeMethodCall;
+    private lowerParamObjectMemberAccessExpression;
+    private removeObjectFromBaseTypes;
+    private removeUnnecessaryBaseConstructorCalls;
+    private registerUniqueRuntimeNamesForPackageMemberDeclarations;
+    private lowerAssignmentWithIntegerDivision;
+    private lowerBinaryExpressionWithIntegerDivision;
+    private moveInstanceFieldInitializationsToConstructor;
+    private extractStaticFieldInitializations;
+    private orderPackageMemberDeclarations;
+    private lowerInlineJsMethodCall;
+    private lowerBaseConstructorCall;
+    private lowerBlockStatementWithClauses;
+    private lowerRunStatementWithClauses;
+    private lowerNumericVariantVariants;
+    private lowerForStatementWithIndexVariable;
+    private lowerIndexerGetAccessExpression;
+    private lowerIndexerSetAccess;
+    private lowerJsIndexerGetAccessExpression;
+    private lowerJsIndexerSetAccess;
+    private lowerPackageVariableSetAccessExpression;
+    private lowerPackageVariableGetAccessExpression;
+    private lowerStructuredTypeIndexerDeclaration;
+    private lowerPackageEntryPointDeclaration;
+    private lowerPackageConstructorDeclaration;
+    private lowerComputedPackageVariableDeclaration;
+    private lowerPackageVariableGetterDeclaration;
+    private lowerPackageVariableSetterDeclaration;
+    private lowerSubprogramBody;
+    private lowerComputedTypeVariableDeclaration;
+    private registerRuntimeNamesForTypeMethods;
+    private registerRuntimeNamesForNestedMethodsOfBlockStatement;
+    private lowerTypeDereferenceOperatorDeclaration;
+}
+export declare class GeneralLoweringResult {
+    readonly sourceFile: SourceFile;
+    readonly registeredEntityNames: RegisteredEntityNames;
+    readonly packageEntryPointMethods: readonly PackageMethodDeclaration[];
+    readonly packageConstructorMethods: readonly PackageMethodDeclaration[];
+    constructor(sourceFile: SourceFile, registeredEntityNames: RegisteredEntityNames, packageEntryPointMethods: readonly PackageMethodDeclaration[], packageConstructorMethods: readonly PackageMethodDeclaration[]);
+}

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

@@ -0,0 +1,10 @@
+export * as blockStatementTransformationResult from './BlockStatementTransformationResult.js';
+export * from './EmitterPackage.js';
+export * as expressionTransformationResult from './ExpressionTransformationResult.js';
+export * from './IrBuilder.js';
+export * as packageMemberDeclarationTransformationResult from './PackageMemberDeclarationTransformationResult.js';
+export * as simpleTransformationResult from './SimpleTransformationResult.js';
+export * as statementTransformationResult from './StatementTransformationResult.js';
+export * as typeMemberDeclarationTransformationResult from './StructuredTypeMemberDeclarationTransformationResult.js';
+export * from './Transformer.js';
+export * as typeAccessExpressionTransformationResult from './TypeAccessExpressionTransformationResult.js';