@artel/artc 0.6.25207 → 0.6.25208

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

@@ -1,344 +1,49 @@
-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';
+import { Analyzer } from '../analysis/Analyzer.js';
+import { Type, TypeOrExtensionEntity } from './Entities.js';
+import { EntityMap } from './EntityMap.js';
+import { Expression } 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 _lazySystemForJavaScriptPackage;
-    private readonly _lazySystemInteroperabilityPackage;
-    private readonly _esPackage;
-    private readonly _packageByPackageMember;
-    private readonly _registeredEntityNamesForCompilation;
-    private _packageGraph;
-    private readonly _isConstantPlainObjectResults;
-    get systemPackage(): PackageEntity;
-    get systemJavaScriptPackage(): PackageEntity;
-    get systemInteroperabilityPackage(): PackageEntity;
-    get platformJavaScriptPackage(): 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;
+    readonly entityMap: EntityMap;
+    readonly type: TypeUtils;
+    readonly standardTypes: StandardTypes;
+    constructor(analyzer: Analyzer, entityMap: EntityMap);
+    createIdentitySubstitutedType(entity: TypeOrExtensionEntity): Type;
+    unaliasTypeEntity(typeEntity: TypeOrExtensionEntity): Type;
 }
-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 {
+declare class TypeUtils {
     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;
+    ofExpression(expression: Expression): Type;
+    private getTypeOfComputedAccess;
+}
+declare class StandardTypes {
+    private readonly _analyzer;
+    private readonly _entityMap;
+    private _none;
+    private _yesNo;
+    private _refObject;
+    private _plainObject;
+    private _number;
+    private _integer;
+    private _text;
+    private _char;
+    private _array;
+    private _method;
+    private _textTemplate;
+    private _reference;
+    get none(): Type;
+    get yesNo(): Type;
+    get refObject(): Type;
+    get plainObject(): Type;
+    get number(): Type;
+    get integer(): Type;
+    get text(): Type;
+    get char(): Type;
+    get array(): Type;
+    get method(): Type;
+    get textTemplate(): Type;
+    get reference(): Type;
+    constructor(_analyzer: Analyzer, _entityMap: EntityMap);
 }
 export {};

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

@@ -1,8 +1,8 @@
 import { PackageLocale } from '../common/index.js';
 export declare const enum EmitterGeneratedDeclarationKind {
     MainFunction = 0,
-    PackageConstructorPrefix = 1,
-    PackageRunFunctionPrefix = 2,
+    PackageConstructor = 1,
+    PackageRunFunction = 2,
     PlainObjectConstructorPrefix = 3,
     ExtensionConstructor = 4,
     ExtensionMethodTargetParameter = 5,
@@ -13,24 +13,62 @@ export declare const enum EmitterGeneratedDeclarationKind {
     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
+    TypeDereferencedVariableGetter = 13,
+    TypeDereferencedVariableSetter = 14,
+    TypeBackingVariablePrefix = 15,
+    TempVariablePrefix = 16,
+    DefaultImportPrefix = 17,
+    NamespaceImportPrefix = 18,
+    RefCountVariable = 19,
+    AddReferenceMethod = 20,
+    RemoveReferenceMethod = 21,
+    ShallowCopyMethod = 22,
+    MergedConstructorIdParameter = 23,
+    MergedConstructorParameterPrefix = 24,
+    AnonymousType = 25,
+    PlainObjectMethodNewThisVariable = 26,
+    PlainObjectMethodResultNewThisProperty = 27,
+    PlainObjectMethodResultResultProperty = 28,
+    ProxyVariable = 29,
+    TypeConstructor = 30,
+    TypeExtensionPrefix = 31
 }
 export declare const emitterGeneratedDeclarationNamesByLocale: {
     [T in PackageLocale]: {
         [T in EmitterGeneratedDeclarationKind]: string;
     };
 };
+export declare class EmitPhaseName {
+    static ofMainFunction(locale: PackageLocale): string;
+    static ofPackageConstructor(locale: PackageLocale): string;
+    static ofPackageRunFunction(locale: PackageLocale): string;
+    static ofPlainObjectConstructor(locale: PackageLocale, id: number): string;
+    static ofExtensionConstructor(locale: PackageLocale): string;
+    static ofExtensionMethodTargetParameter(locale: PackageLocale): string;
+    static ofGlobalVariableGetter(locale: PackageLocale, originalName: string): string;
+    static ofGlobalVariableSetter(locale: PackageLocale, originalName: string): string;
+    static ofTypeVariableGetter(locale: PackageLocale, originalName: string): string;
+    static ofTypeVariableSetter(locale: PackageLocale, originalName: string): string;
+    static ofTypeIndexedElementGetter(locale: PackageLocale): string;
+    static ofTypeIndexedElementSetter(locale: PackageLocale): string;
+    static ofTypeDereferencedVariable(locale: PackageLocale): string;
+    static ofTypeDereferencedVariableGetter(locale: PackageLocale): string;
+    static ofTypeDereferencedVariableSetter(locale: PackageLocale): string;
+    static ofTypeBackingVariable(locale: PackageLocale, originalName: string): string;
+    static ofTempVariable(locale: PackageLocale, id: number): string;
+    static ofDefaultImport(locale: PackageLocale, id: number): string;
+    static ofNamespaceImport(locale: PackageLocale, id: number): string;
+    static ofRefCountVariable(locale: PackageLocale): string;
+    static ofAddReferenceMethod(locale: PackageLocale): string;
+    static ofRemoveReferenceMethod(locale: PackageLocale): string;
+    static ofShallowCopyMethod(locale: PackageLocale): string;
+    static ofMergedConstructorIdParameter(locale: PackageLocale): string;
+    static ofMergedConstructorParameter(locale: PackageLocale, id: number): string;
+    static ofAnonymousType(locale: PackageLocale): string;
+    static ofPlainObjectMethodNewThisVariable(locale: PackageLocale): string;
+    static ofPlainObjectMethodResultNewThisProperty(locale: PackageLocale): string;
+    static ofPlainObjectMethodResultResultProperty(locale: PackageLocale): string;
+    static ofProxyVariable(locale: PackageLocale, originalName: string): string;
+    static ofTypeConstructor(locale: PackageLocale): string;
+    static ofTypeExtension(locale: PackageLocale, extendedTypeName: string): string;
+}

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

@@ -0,0 +1,144 @@
+import { PackageLocale } from '../common/index.js';
+import { JavaScriptImplementationConfig } from '../project/SourcePackage.js';
+export interface MethodEntity {
+    readonly kind: 'method';
+    methodEntityKind: MethodEntityKind;
+    name: string;
+    parameters: readonly VariableEntity[];
+    returnType: Type;
+    isTypeMember: TypeMemberEntityInfo | undefined;
+    isPackageMember: boolean;
+    containingPackage: PackageEntity;
+    details: MethodEntityDetails;
+}
+export declare enum MethodEntityKind {
+    RegularMethod = 0,
+    GetterOrSetter = 1,
+    Constructor = 2,
+    Destructor = 3,
+    Operator = 4
+}
+export declare class MethodEntityDetails {
+    isAsync: boolean;
+    isPackageConstructor: boolean;
+    isPackageEntryPoint: boolean;
+    overriddenMember: MethodEntity | undefined;
+    ifRedefinableAliasTypeMethodThenRealMethod: MethodEntity | undefined;
+    isEnumeratorMethod: boolean;
+    isDefaultExport: boolean;
+    isFormerInstanceAliasTypeOrExtensionMember: boolean;
+}
+export interface VariableEntity {
+    readonly kind: 'variable';
+    name: string;
+    type: Type;
+    isTypeMember: TypeMemberEntityInfo | undefined;
+    isPackageMember: boolean;
+    containingPackage: PackageEntity;
+    getter: MethodEntity | undefined;
+    setter: MethodEntity | undefined;
+    details: VariableEntityDetails;
+}
+export declare class VariableEntityDetails {
+    isVariadicParameter: boolean;
+    overriddenMember: VariableEntity | undefined;
+    isProxiedTypeVariable: ProxiedTypeVariableInfo | undefined;
+    isDefaultExport: boolean;
+}
+export interface ProxiedTypeVariableInfo {
+    readonly tagType: TypeOrExtensionEntity;
+    readonly constructor: MethodEntity;
+}
+export type TypeMemberEntity = MethodEntity | VariableEntity;
+export interface TypeOrExtensionEntity {
+    readonly kind: 'type-or-extension';
+    name: string;
+    baseType: TypeOrExtensionEntity | undefined;
+    typeOrExtensionKind: TypeOrExtensionEntityKind;
+    members: readonly TypeMemberEntity[];
+    containingPackage: PackageEntity;
+    details: TypeOrExtensionEntityDetails;
+}
+export declare class TypeOrExtensionEntityDetails {
+    structuredTypeKind: StructuredTypeKind;
+    aliasedType: Type | undefined;
+    isDefaultExport: boolean;
+}
+export declare enum TypeOrExtensionEntityKind {
+    StructuredType = 0,
+    AliasType = 1,
+    VariantType = 2,
+    MethodType = 3,
+    ParameterType = 4,
+    TypeExtension = 5
+}
+export declare enum StructuredTypeKind {
+    RefObject = 0,
+    PlainObject = 1,
+    Aspect = 2
+}
+export type PackageMemberEntity = MethodEntity | VariableEntity | TypeOrExtensionEntity;
+export interface PackageEntity {
+    readonly kind: 'package';
+    name: string;
+    locale: PackageLocale;
+    members: readonly PackageMemberEntity[];
+    details: PackageEntityDetails;
+}
+export declare class PackageEntityDetails {
+    isJavaScriptPackage: JavaScriptImplementationConfig | undefined;
+    isSource: boolean;
+    isPackageWithMainMethod: boolean;
+}
+export interface TypeMemberEntityInfo {
+    containingType: TypeOrExtensionEntity;
+    isStatic: boolean;
+}
+export type Type = SimpleType | UnionType;
+export declare class SimpleType {
+    readonly entity: TypeOrExtensionEntity;
+    readonly typeArguments: readonly Type[];
+    readonly kind = "simple";
+    constructor(entity: TypeOrExtensionEntity, typeArguments: readonly Type[]);
+}
+export declare class UnionType {
+    readonly types: readonly Type[];
+    readonly kind = "union";
+    constructor(types: readonly Type[]);
+}
+export type Entity = VariableEntity | MethodEntity | TypeOrExtensionEntity | PackageEntity;
+export type NamedEntity = VariableEntity | MethodEntity | TypeOrExtensionEntity;
+export declare function isComputedVariableEntity(entity: VariableEntity): boolean;
+export declare class IntrinsicVariableEntity implements VariableEntity {
+    name: string;
+    type: Type;
+    containingPackage: PackageEntity;
+    readonly kind = "variable";
+    isVariadicParameter: boolean;
+    isTypeMember: TypeMemberEntityInfo | undefined;
+    isPackageMember: boolean;
+    getter: MethodEntity | undefined;
+    setter: MethodEntity | undefined;
+    details: VariableEntityDetails;
+    constructor(name: string, type: Type, containingPackage: PackageEntity);
+}
+export declare class IntrinsicMethodEntity implements MethodEntity {
+    methodEntityKind: MethodEntityKind;
+    name: string;
+    parameters: readonly VariableEntity[];
+    returnType: Type;
+    containingPackage: PackageEntity;
+    readonly kind = "method";
+    isTypeMember: TypeMemberEntityInfo | undefined;
+    isPackageMember: boolean;
+    details: MethodEntityDetails;
+    constructor(methodEntityKind: MethodEntityKind, name: string, parameters: readonly VariableEntity[], returnType: Type, containingPackage: PackageEntity);
+}
+export declare class IntrinsicPackageEntity implements PackageEntity {
+    name: string;
+    locale: PackageLocale;
+    readonly kind = "package";
+    members: readonly PackageMemberEntity[];
+    details: PackageEntityDetails;
+    constructor(name: string, locale: PackageLocale);
+}

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

@@ -0,0 +1,45 @@
+import { Analyzer } from '../analysis/Analyzer.js';
+import * as analyzerEntities from '../entities/index.js';
+import { PlatformKind } from '../project/SourcePackage.js';
+import * as analyzerTypes from '../types/index.js';
+import * as emitterEntities from './Entities.js';
+/**
+ * Отображает неизменяемые сущности этапа анализа на изменяемые сущности этапа генерации кода, а также
+ * - заменяет сущности из интерфейсных пакетов на сущности из реализационных пакетов для заданной целевой платформы,
+ * - заменяет имя сущности на НастоящееИмя, если указан соответствующий тег.
+ */
+export declare class EntityMap {
+    private readonly _analyzer;
+    private readonly _targetPlatform;
+    private readonly _variables;
+    private readonly _methods;
+    private readonly _typeOrExtensions;
+    private readonly _packages;
+    private readonly _linkedPackages;
+    private readonly _enumeratorMethod;
+    private get enumeratorMethod();
+    constructor(analyzer: Analyzer, targetPlatform: PlatformKind);
+    getVariableEntity(entity: analyzerEntities.VariableEntity): emitterEntities.VariableEntity;
+    getVariantEntity(entity: analyzerEntities.VariantEntity): emitterEntities.VariableEntity;
+    getMethodEntity(entity: analyzerEntities.MethodEntity): emitterEntities.MethodEntity;
+    getConstructorEntity(entity: analyzerEntities.ConstructorEntity): emitterEntities.MethodEntity;
+    getDestructorEntity(entity: analyzerEntities.DestructorEntity): emitterEntities.MethodEntity;
+    getGetterEntity(entity: analyzerEntities.GetterEntity): emitterEntities.MethodEntity;
+    getSetterEntity(entity: analyzerEntities.SetterEntity): emitterEntities.MethodEntity;
+    getUnaryOperatorEntity(entity: analyzerEntities.UnaryOperatorEntity): emitterEntities.MethodEntity;
+    getBinaryOperatorEntity(entity: analyzerEntities.BinaryOperatorEntity): emitterEntities.MethodEntity;
+    getStructuredTypeEntity(entity: analyzerEntities.StructuredTypeEntity): emitterEntities.TypeOrExtensionEntity;
+    getVariantTypeEntity(entity: analyzerEntities.VariantTypeEntity): emitterEntities.TypeOrExtensionEntity;
+    getTypeParameterEntity(entity: analyzerEntities.TypeParameterEntity): emitterEntities.TypeOrExtensionEntity;
+    getMethodTypeEntity(entity: analyzerEntities.MethodTypeEntity): emitterEntities.TypeOrExtensionEntity;
+    getAliasTypeEntity(entity: analyzerEntities.AliasTypeEntity): emitterEntities.TypeOrExtensionEntity;
+    getTypeExtensionEntity(entity: analyzerEntities.TypeExtensionEntity): emitterEntities.TypeOrExtensionEntity;
+    getTypeOrExtensionEntity(entity: analyzerEntities.TypeEntity | analyzerEntities.TypeExtensionEntity): emitterEntities.TypeOrExtensionEntity;
+    getPackageEntity(entity: analyzerEntities.PackageEntity): emitterEntities.PackageEntity;
+    getType(type: analyzerTypes.Type): emitterEntities.Type;
+    private getPackageEntityInternal;
+    private createTypeMembers;
+    private getContainingPackageAndAccumulateIfMember;
+    private getNameText;
+    private isDefaultExport;
+}