@artel/artc 0.6.25206 → 0.6.25208

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

@@ -1,4 +1,4 @@
-import { VariableEntity } from '../entities/index.js';
+import { VariableEntity } from './Entities.js';
 import { TransformationContinuationAction } from './TransformationContinuationAction.js';
 import { Expression } from './ir/index.js';
 export declare enum Kind {

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

@@ -1,72 +1,8 @@
-import { PackageLocale } from '../common/index.js';
+import { EmitterPackage } from './Emitter.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[]);
+    private readonly _packages;
+    constructor(ectx: EmitterContext, packages: readonly EmitterPackage[]);
+    lower(): void;
 }

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

@@ -1,5 +1,4 @@
 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';

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

@@ -1,21 +1,25 @@
-import { Analyzer } from '../analysis/index.js';
 import { DeclarationsUsageCountResult } from '../analysis/DeclarationsUsageCounter.js';
+import { Analyzer } from '../analysis/index.js';
 import { SourceFile } from '../project/index.js';
+import { EntityMap } from './EntityMap.js';
 import * as ir from './ir/index.js';
 export declare class IrBuilder {
     private readonly _analyzer;
     private readonly _sourceFile;
-    private readonly _config;
+    private readonly _declarationsUsageCountResult;
+    private readonly _declarationsOfPackageSourceFilesUsageCountResults;
+    private readonly _entityMap;
     private readonly _typesCreatedFromAnonymousTypes;
+    private readonly _textTemplateToTextMethod;
     private _id;
     private _currentLoopLabel;
-    constructor(analyzer: Analyzer, sourceFile: SourceFile, config: IrBuilderConfig);
-    buildIR(): ir.SourceFile;
-    private buildSourceFile;
+    private get textTemplateToTextMethod();
+    constructor(params: IrBuilderParams);
+    build(): ir.PackageMemberDeclaration[];
     private buildPackageMemberDeclarationList;
     private buildPackageConstructorDeclaration;
+    private buildBodyOfSubprogramWithResult;
     private buildStatementBlock;
-    private buildRunStatementClause;
     private buildStatement;
     private buildAssignmentStatement;
     private buildContinueLoopStatement;
@@ -25,7 +29,8 @@ export declare class IrBuilder {
     private buildPackageStructuredTypeDeclaration;
     private buildPackageAliasTypeDeclaration;
     private buildPackageVariableDeclaration;
-    private buildComputedPackageVariable;
+    private buildPackageVariableGetterDeclaration;
+    private buildPackageVariableSetterDeclaration;
     private buildBackingPackageVariable;
     private buildPackageVariantTypeDeclaration;
     private buildVariantDeclaration;
@@ -34,11 +39,14 @@ export declare class IrBuilder {
     private buildTypeConstructorDeclaration;
     private createDefaultStructuredTypeConstructor;
     private buildTypeDestructorDeclaration;
-    private buildTypeIndexerDeclaration;
-    private buildTypeDereferenceOperatorDeclaration;
+    private buildTypeIndexedGetterDeclaration;
+    private buildTypeIndexedSetterDeclaration;
+    private buildTypeDereferencedVariableGetterDeclaration;
+    private buildTypeDereferencedVariableSetterDeclaration;
     private buildTypeMethodDeclaration;
     private buildTypeVariableDeclaration;
-    private buildComputedTypeVariable;
+    private buildTypeVariableGetterDeclaration;
+    private buildTypeVariableSetterDeclaration;
     private buildBackingTypeVariable;
     private buildDisposeStatement;
     private buildRunStatement;
@@ -51,16 +59,15 @@ export declare class IrBuilder {
     private buildNestedMethodDeclarationStatement;
     private buildParameterList;
     private buildLocalVariableDeclarationStatement;
-    private buildUnobservableStatement;
     private buildLoopStatement;
     private buildReturnStatement;
     private buildSwitchStatement;
     private isDefaultSwitchStatementCaseClause;
-    private buildTransactionalStatement;
     private buildWhileStatement;
     private buildYieldStatement;
     private buildExpression;
-    private getImplicitConversionKind;
+    private applyImplicitConversionIfRequired;
+    private convertTextTemplateToText;
     private expressionCanBeImplicitlyConverted;
     private buildArrayLiteral;
     private buildAssertionExpression;
@@ -72,12 +79,13 @@ export declare class IrBuilder {
     private buildAutotypeCallExpression;
     private buildIndexedAccessExpression;
     private buildIsExpression;
-    private buildUnobservableExpression;
     private buildNotExpression;
     private buildMethodLiteral;
     private buildParenthesizedExpression;
     private buildPrefixUnaryExpression;
     private buildPropertyAccessExpression;
+    private convertIndexedAccess;
+    private convertDereferencedVariableAccess;
     private buildReferenceExpression;
     private buildWhenTernaryExpression;
     private buildTextTemplateLiteral;
@@ -85,11 +93,11 @@ export declare class IrBuilder {
     private buildKeywordExpression;
     private buildObjectExpression;
     private buildBaseExpression;
-    private buildTransactionalExpression;
     private buildDereferenceExpression;
     private buildGenericSpecializationExpression;
     private buildDefaultMatchExpression;
     private buildIdentifierExpression;
+    private createExplicitReceiver;
     private getEntityFromType;
     private buildCallArgumentList;
     private buildAndSaveTypeIfIsAnonymousTypeSpecifier;
@@ -98,11 +106,13 @@ export declare class IrBuilder {
     private buildAnonymousVariantTypeDeclaration;
     private getUnderlyingTypeKind;
     private expressionIsCallee;
-    private preserveVariableOrUndefinedIfUnused;
     private generateLoopLabel;
     private getSourceLocation;
 }
-export interface IrBuilderConfig {
+export interface IrBuilderParams {
+    analyzer: Analyzer;
+    sourceFile: SourceFile;
     declarationsUsageCountResult: DeclarationsUsageCountResult;
     declarationsOfPackageSourceFilesUsageCountResults: readonly DeclarationsUsageCountResult[];
+    entityMap: EntityMap;
 }

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

@@ -1,16 +1,16 @@
 import * as js from '@babel/types';
 import { DebugStack } from './DebugStack.js';
-import { EntityNameProvider } from './EntityNameProviders.js';
+import { Entity } from './Entities.js';
 import * as ir from './ir/index.js';
-export interface IrToJsConfig {
+export interface IrToJsOptions {
     /**
      * static:  import { MyType } from 'my-lib'
      *
      * dynamic: const { MyType } = await import('my-lib')
      */
-    readonly importMode: ImportEmitMode;
-    readonly runtimeEntityNames: EntityNameProvider;
-    readonly attachSourceLocation?: boolean;
+    importMode?: ImportEmitMode;
+    entityNameOverrides?: ReadonlyMap<Entity, string>;
+    attachSourceLocation?: boolean;
 }
 export type ImportEmitMode = ImportEmitMode.Static | ImportEmitMode.Dynamic;
 export declare namespace ImportEmitMode {
@@ -24,12 +24,14 @@ export declare namespace ImportEmitMode {
     }
 }
 export declare class IrToJs {
-    private readonly _config;
     static readonly customImportFunctionName = "_artelImport";
     protected readonly _debugStack: DebugStack;
-    constructor(_config: IrToJsConfig);
-    convert(sourceFile: ir.SourceFile): js.File;
-    private convertSourceFile;
+    private _importMode;
+    private _entityNameOverrides;
+    private _attachSourceLocation;
+    constructor(options?: IrToJsOptions);
+    convert(pkg: ir.Package): js.File;
+    private convertPackage;
     private convertPackageMemberDeclaration;
     private convertEsModuleImportDirectiveStatement;
     private convertCjsModuleImportDirectiveStatement;
@@ -42,7 +44,6 @@ export declare class IrToJs {
     private convertPackageMethodDeclaration;
     private convertValueParameters;
     private convertPackageTypeDeclaration;
-    private convertPropertyDeclaration;
     private convertPackageVariableDeclaration;
     private convertPackageVariantTypeDeclaration;
     private convertNumericVariants;
@@ -54,6 +55,7 @@ export declare class IrToJs {
     private convertCallExpression;
     private convertCharLiteral;
     private convertNoneLiteral;
+    private convertIndexedAccessExpression;
     private convertHelperMethodCallExpression;
     private convertNotExpression;
     private convertIntegerLiteral;
@@ -76,13 +78,14 @@ export declare class IrToJs {
     private convertVariableAccessExpression;
     private convertMethodAccessExpression;
     private convertVariantAccessExpression;
-    private convertInstanceVariableAccessExpression;
+    private convertTypeVariableAccessExpression;
     private convertTypeMethodAccessExpression;
     private convertConstructorCallExpression;
     private convertCallArguments;
     private convertInlineJsExpression;
     private convertAssignmentExpression;
     private convertCommaExpression;
+    private convertBaseConstructorCallExpression;
     private convertJsIndexedAccessExpression;
     private convertJsObjectLiteral;
     private convertJsPropertyAccessExpression;
@@ -108,6 +111,9 @@ export declare class IrToJs {
     private convertTypeConstructorDeclaration;
     private convertTypeMethodDeclaration;
     private convertTypeVariableDeclaration;
+    private convertTypeVariableGetterDeclaration;
+    private convertTypeVariableSetterDeclaration;
     private addNodeLocation;
+    private getEntityName;
     private convertArrayWithErrorBoundary;
 }

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

@@ -1,9 +1,9 @@
-import { VariableEntity } from '../entities/index.js';
+import { VariableEntity } from './Entities.js';
 import { Statement } from './ir/index.js';
 export declare const enum Kind {
     Preserve = 0,
     Replace = 1,
-    ReplaceAndAddLocalVariables = 2
+    Remove = 2
 }
 export type Type = {
     kind: Kind.Preserve;
@@ -11,6 +11,9 @@ export type Type = {
     kind: Kind.Replace;
     statement: Statement;
     hoistedLocalVariables?: readonly VariableEntity[];
+} | {
+    kind: Kind.Remove;
 };
 export declare function preserve(): Type;
 export declare function replace(statement: Statement, hoistedLocalVariables?: readonly VariableEntity[]): Type;
+export declare function remove(): Type;

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

@@ -1,4 +1,3 @@
-import type { DereferenceOperatorEntity, IndexerEntity, VariableEntity } from '../entities/index.js';
 import { DebugStack } from './DebugStack.js';
 import { blockStatementTransformationResult, expressionTransformationResult, packageMemberDeclarationTransformationResult, simpleTransformationResult, statementTransformationResult, typeAccessExpressionTransformationResult, typeMemberDeclarationTransformationResult } from './Internal.js';
 import { TransformationContinuationAction } from './TransformationContinuationAction.js';
@@ -7,17 +6,17 @@ export declare class Transformer {
     readonly config: TransformationConfig;
     protected readonly _debugStack: DebugStack;
     private _hoistedLocalVariables;
-    private _transformingContainer;
-    get transformingContainer(): TransformingContainer | undefined;
+    private _transformedDeclaration;
+    get transformedDeclaration(): ir.Declaration | undefined;
     constructor(config: TransformationConfig);
-    transform(sourceFile: ir.SourceFile): void;
+    transform(pkg: ir.Package): void;
     transformPackageMemberDeclaration(declaration: ir.PackageMemberDeclaration): readonly ir.PackageMemberDeclaration[];
-    transformPackageConstructorDeclarationChildren(declaration: ir.PackageConstructorDeclaration): void;
     transformBlockStatement(statement: ir.BlockStatement): ir.BlockStatement;
     transformStatement(statement: ir.Statement): readonly ir.Statement[];
     transformAssignmentStatementChildren(statement: ir.AssignmentStatement): void;
     transformBlockStatementChildren(statement: ir.BlockStatement): void;
-    transformBlockStatementClause(clause: ir.BlockStatementClause): ir.BlockStatementClause;
+    transformOnErrorClause(node: ir.OnErrorClause): ir.OnErrorClause;
+    transformFinallyClause(node: ir.FinallyClause): ir.FinallyClause;
     transformBreakLoopStatementChildren(_statement: ir.BreakLoopStatement): void;
     transformContinueLoopStatementChildren(_statement: ir.ContinueLoopStatement): void;
     transformDisposeStatementChildren(statement: ir.DisposeStatement): void;
@@ -36,41 +35,34 @@ export declare class Transformer {
     };
     transformLocalVariableDeclarationStatementChildren(statement: ir.LocalVariableDeclarationStatement): void;
     transformLocalVariableDeclaration(declaration: ir.LocalVariableDeclaration): ir.LocalVariableDeclaration;
-    transformUnobservableStatementChildren(statement: ir.UnobservableStatement): void;
     transformLoopStatementChildren(statement: ir.LoopStatement): void;
     transformReturnStatementChildren(statement: ir.ReturnStatement): void;
     transformSwitchStatementChildren(statement: ir.SwitchStatement): void;
     transformCaseClause(caseClause: ir.CaseClause): ir.CaseClause;
-    transformTransactionalStatementChildren(statement: ir.TransactionalStatement): void;
     transformWhileStatementChildren(statement: ir.WhileStatement): void;
     transformYieldStatementChildren(statement: ir.YieldStatement): void;
     transformTryCatchFinallyStatementChildren(statement: ir.TryCatchFinallyStatement): void;
     transformEsModuleImportDirectiveStatementChildren(_statement: ir.EsModuleImportDirectiveStatement): void;
     transformCjsModuleImportDirectiveStatementChildren(_statement: ir.CjsModuleImportDirectiveStatement): void;
     transformJsNamespaceDestructuringStatementChildren(_statement: ir.JsNamespaceDestructuringStatement): void;
-    transformPackageEntryPointDeclarationChildren(declaration: ir.PackageEntryPointDeclaration): void;
     transformPackageMethodDeclarationChildren(declaration: ir.PackageMethodDeclaration): void;
     transformPackageTypeDeclarationChildren(declaration: ir.PackageTypeDeclaration): void;
     transformTypeMemberDeclaration(declaration: ir.TypeMemberDeclaration): readonly ir.TypeMemberDeclaration[];
-    transformPropertyDeclarationChildren(declaration: ir.PropertyDeclaration): void;
     transformTypeConstructorDeclarationChildren(declaration: ir.TypeConstructorDeclaration): void;
     transformTypeDestructorDeclarationChildren(declaration: ir.TypeDestructorDeclaration): void;
-    transformTypeIndexerDeclarationChildren(declaration: ir.TypeIndexerDeclaration): void;
-    transformTypeDereferenceOperatorDeclarationChildren(declaration: ir.TypeDereferenceOperatorDeclaration): void;
-    transformTypeIndexedGetterDeclaration(declaration: ir.TypeIndexedGetterDeclaration, indexer: IndexerEntity): ir.TypeIndexedGetterDeclaration;
-    transformTypeIndexedSetterDeclaration(declaration: ir.TypeIndexedSetterDeclaration, indexer: IndexerEntity): ir.TypeIndexedSetterDeclaration;
-    transformTypeDereferencedVariableGetterDeclaration(declaration: ir.TypeDereferencedVariableGetterDeclaration, indexer: DereferenceOperatorEntity): ir.TypeDereferencedVariableGetterDeclaration;
-    transformTypeDereferencedVariableSetterDeclaration(declaration: ir.TypeDereferencedVariableSetterDeclaration, indexer: DereferenceOperatorEntity): ir.TypeDereferencedVariableSetterDeclaration;
     transformTypeMethodDeclarationChildren(declaration: ir.TypeMethodDeclaration): void;
     transformTypeVariableDeclarationChildren(declaration: ir.TypeVariableDeclaration): void;
-    transformTypeVariableGetterDeclaration(declaration: ir.TypeVariableGetterDeclaration, variable: VariableEntity): ir.TypeVariableGetterDeclaration;
-    transformTypeVariableSetterDeclaration(declaration: ir.TypeVariableSetterDeclaration, variable: VariableEntity): ir.TypeVariableSetterDeclaration;
+    transformTypeIndexedGetterDeclarationChildren(declaration: ir.TypeIndexedGetterDeclaration): void;
+    transformTypeIndexedSetterDeclarationChildren(declaration: ir.TypeIndexedSetterDeclaration): void;
+    transformTypeVariableGetterDeclarationChildren(declaration: ir.TypeVariableGetterDeclaration): void;
+    transformTypeVariableSetterDeclarationChildren(declaration: ir.TypeVariableSetterDeclaration): void;
+    transformTypeDereferencedVariableGetterDeclarationChildren(declaration: ir.TypeDereferencedVariableGetterDeclaration): void;
+    transformTypeDereferencedVariableSetterDeclarationChildren(declaration: ir.TypeDereferencedVariableSetterDeclaration): void;
     transformPackageVariableDeclarationChildren(declaration: ir.PackageVariableDeclaration): void;
-    transformPackageVariableGetterDeclaration(declaration: ir.PackageVariableGetterDeclaration): ir.PackageVariableGetterDeclaration;
-    transformPackageVariableSetterDeclaration(declaration: ir.PackageVariableSetterDeclaration): ir.PackageVariableSetterDeclaration;
     transformPackageVariantTypeDeclarationChildren(declaration: ir.PackageVariantTypeDeclaration): void;
     transformVariantDeclaration(declaration: ir.VariantDeclaration): ir.VariantDeclaration;
-    transformTypeExtensionDeclarationChildren(declaration: ir.TypeExtensionDeclaration): void;
+    transformPackageVariableGetterDeclarationChildren(declaration: ir.PackageVariableGetterDeclaration): void;
+    transformPackageVariableSetterDeclarationChildren(declaration: ir.PackageVariableSetterDeclaration): void;
     transformExpression(expression: ir.Expression): ir.Expression;
     transformAsExpressionChildren(expression: ir.AsExpression): void;
     transformAssertionExpressionChildren(expression: ir.AssertionExpression): void;
@@ -85,7 +77,6 @@ export declare class Transformer {
     transformIntegerLiteralChildren(_expression: ir.IntegerLiteral): void;
     transformHelperMethodCallExpressionChildren(expression: ir.HelperMethodCallExpression): void;
     transformIsExpressionChildren(expression: ir.IsExpression): void;
-    transformUnobservableExpressionChildren(expression: ir.UnobservableExpression): void;
     transformNotExpressionChildren(expression: ir.NotExpression): void;
     transformNumericLiteralChildren(_expression: ir.NumericLiteral): void;
     transformMethodLiteralChildren(expression: ir.MethodLiteral): void;
@@ -97,12 +88,10 @@ export declare class Transformer {
     transformTernaryExpressionChildren(expression: ir.TernaryExpression): void;
     transformThisExpressionChildren(_expression: ir.ThisExpression): void;
     transformBaseExpressionChildren(_expression: ir.BaseExpression): void;
-    transformTransactionalExpressionChildren(expression: ir.TransactionalExpression): void;
     transformArrayLiteralChildren(expression: ir.ArrayLiteral): void;
     transformTypeAccessExpressionChildren(_expression: ir.TypeAccessExpression): void;
     transformVariableAccessExpressionChildren(_expression: ir.VariableAccessExpression): void;
     transformMethodAccessExpressionChildren(_expression: ir.MethodAccessExpression): void;
-    transformImplicitVariantAccessExpressionChildren(_expression: ir.ImplicitVariantAccessExpression): void;
     transformVariantAccessExpressionChildren(expression: ir.VariantAccessExpression): void;
     transformTypeAccessExpression(expression: ir.TypeAccessExpression): ir.TypeAccessExpression;
     transformInstanceVariableAccessExpressionChildren(expression: ir.TypeVariableAccessExpression): void;
@@ -117,7 +106,6 @@ export declare class Transformer {
     transformJsObjectLiteralChildren(expression: ir.JsObjectLiteral): void;
     transformJsPropertyAccessExpressionChildren(expression: ir.JsPropertyAccessExpression): void;
     transformJsFunctionLiteralChildren(expression: ir.JsFunctionLiteral): void;
-    transformImplicitConversionExpressionChildren(expression: ir.ImplicitConversionExpression): void;
     transformJsTypeOfExpressionChildren(expression: ir.JsTypeOfExpression): void;
     transformJsInstanceOfExpressionChildren(expression: ir.JsInstanceOfExpression): void;
     transformJsIdentifierExpressionChildren(_expression: ir.JsIdentifierExpression): void;
@@ -125,7 +113,6 @@ export declare class Transformer {
     transformJsObjectLiteralProperty(property: ir.JsObjectLiteralProperty): ir.JsObjectLiteralProperty;
     private transformArrayWithErrorBoundary;
     private createLocalVariableDeclarations;
-    private withTransformingContainer;
 }
 interface TransformationConfig {
     transformAssertionExpression?(expression: ir.AssertionExpression): expressionTransformationResult.Type;
@@ -135,7 +122,6 @@ interface TransformationConfig {
     transformCallExpression?(expression: ir.CallExpression): expressionTransformationResult.Type;
     transformIndexedAccessExpression?(expression: ir.IndexedAccessExpression): expressionTransformationResult.Type;
     transformIsExpression?(expression: ir.IsExpression): expressionTransformationResult.Type;
-    transformUnobservableExpression?(expression: ir.UnobservableExpression): expressionTransformationResult.Type;
     transformNotExpression?(expression: ir.NotExpression): expressionTransformationResult.Type;
     transformMethodLiteral?(expression: ir.MethodLiteral): expressionTransformationResult.Type;
     transformPrefixUnaryExpression?(expression: ir.PrefixUnaryExpression): expressionTransformationResult.Type;
@@ -145,12 +131,10 @@ interface TransformationConfig {
     transformTypeAccessExpression?(expression: ir.TypeAccessExpression): typeAccessExpressionTransformationResult.TypeAccessExpressionTransformationResult;
     transformVariableAccessExpression?(expression: ir.VariableAccessExpression): expressionTransformationResult.Type;
     transformMethodAccessExpression?(expression: ir.MethodAccessExpression): expressionTransformationResult.Type;
-    transformImplicitVariantAccessExpression?(expression: ir.ImplicitVariantAccessExpression): expressionTransformationResult.Type;
     transformVariantAccessExpression?(expression: ir.VariantAccessExpression): expressionTransformationResult.Type;
     transformTypeVariableAccessExpression?(expression: ir.TypeVariableAccessExpression): expressionTransformationResult.Type;
     transformTypeMethodAccessExpression?(expression: ir.TypeMethodAccessExpression): expressionTransformationResult.Type;
     transformTextTemplateLiteral?(expression: ir.TextTemplateLiteral): expressionTransformationResult.Type;
-    transformTransactionalExpression?(expression: ir.TransactionalExpression): expressionTransformationResult.Type;
     transformCharLiteral?(expression: ir.CharLiteral): expressionTransformationResult.Type;
     transformTextLiteral?(expression: ir.TextLiteral): expressionTransformationResult.Type;
     transformBooleanLiteral?(expression: ir.BooleanLiteral): expressionTransformationResult.Type;
@@ -171,7 +155,6 @@ interface TransformationConfig {
     transformJsObjectLiteral?(expression: ir.JsObjectLiteral): expressionTransformationResult.Type;
     transformJsPropertyAccessExpression?(expression: ir.JsPropertyAccessExpression): expressionTransformationResult.Type;
     transformJsFunctionLiteral?(expression: ir.JsFunctionLiteral): expressionTransformationResult.Type;
-    transformImplicitConversionExpression?(expression: ir.ImplicitConversionExpression): expressionTransformationResult.Type;
     transformJsTypeOfExpression?(expression: ir.JsTypeOfExpression): expressionTransformationResult.Type;
     transformJsInstanceOfExpression?(expression: ir.JsInstanceOfExpression): expressionTransformationResult.Type;
     transformJsIdentifierExpression?(expression: ir.JsIdentifierExpression): expressionTransformationResult.Type;
@@ -188,11 +171,9 @@ interface TransformationConfig {
     transformIfStatement?(statement: ir.IfStatement): statementTransformationResult.Type;
     transformNestedMethodDeclarationStatement?(statement: ir.NestedMethodDeclarationStatement): statementTransformationResult.Type;
     transformLocalVariableDeclarationStatement?(statement: ir.LocalVariableDeclarationStatement): statementTransformationResult.Type;
-    transformUnobservableStatement?(statement: ir.UnobservableStatement): statementTransformationResult.Type;
     transformLoopStatement?(statement: ir.LoopStatement): statementTransformationResult.Type;
     transformReturnStatement?(statement: ir.ReturnStatement): statementTransformationResult.Type;
     transformSwitchStatement?(statement: ir.SwitchStatement): statementTransformationResult.Type;
-    transformTransactionalStatement?(statement: ir.TransactionalStatement): statementTransformationResult.Type;
     transformWhileStatement?(statement: ir.WhileStatement): statementTransformationResult.Type;
     transformYieldStatement?(statement: ir.YieldStatement): statementTransformationResult.Type;
     transformAssignmentStatement?(statement: ir.AssignmentStatement): statementTransformationResult.Type;
@@ -200,83 +181,30 @@ interface TransformationConfig {
     transformEsModuleImportDirectiveStatement?(statement: ir.EsModuleImportDirectiveStatement): statementTransformationResult.Type;
     transformCjsModuleImportDirectiveStatement?(statement: ir.CjsModuleImportDirectiveStatement): statementTransformationResult.Type;
     transformJsNamespaceDestructuringStatement?(statement: ir.JsNamespaceDestructuringStatement): statementTransformationResult.Type;
-    transformPackageConstructorDeclaration?(declaration: ir.PackageConstructorDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
-    transformPackageEntryPointDeclaration?(declaration: ir.PackageEntryPointDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
     transformPackageMethodDeclaration?(declaration: ir.PackageMethodDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
     transformPackageTypeDeclaration?(declaration: ir.PackageTypeDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
     transformPackageVariableDeclaration?(declaration: ir.PackageVariableDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
-    transformPackageVariableGetterDeclaration?(declaration: ir.PackageVariableGetterDeclaration): simpleTransformationResult.Type<ir.PackageVariableGetterDeclaration>;
-    transformPackageVariableSetterDeclaration?(declaration: ir.PackageVariableSetterDeclaration): simpleTransformationResult.Type<ir.PackageVariableSetterDeclaration>;
+    transformPackageVariableGetterDeclaration?(declaration: ir.PackageVariableGetterDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
+    transformPackageVariableSetterDeclaration?(declaration: ir.PackageVariableSetterDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
     transformPackageVariantTypeDeclaration?(declaration: ir.PackageVariantTypeDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
-    transformTypeExtensionDeclaration?(declaration: ir.TypeExtensionDeclaration): packageMemberDeclarationTransformationResult.PackageMemberDeclarationTransformationResult;
     transformTypeVariableDeclaration?(declaration: ir.TypeVariableDeclaration): typeMemberDeclarationTransformationResult.Type;
     transformTypeMethodDeclaration?(declaration: ir.TypeMethodDeclaration): typeMemberDeclarationTransformationResult.Type;
     transformTypeConstructorDeclaration?(declaration: ir.TypeConstructorDeclaration): typeMemberDeclarationTransformationResult.Type;
     transformTypeDestructorDeclaration?(declaration: ir.TypeDestructorDeclaration): typeMemberDeclarationTransformationResult.Type;
-    transformTypeIndexerDeclaration?(declaration: ir.TypeIndexerDeclaration): typeMemberDeclarationTransformationResult.Type;
-    transformTypeDereferenceOperatorDeclaration?(declaration: ir.TypeDereferenceOperatorDeclaration): typeMemberDeclarationTransformationResult.Type;
-    transformPropertyDeclaration?(declaration: ir.PropertyDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeIndexedGetterDeclaration?(declaration: ir.TypeIndexedGetterDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeIndexedSetterDeclaration?(declaration: ir.TypeIndexedSetterDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeDereferencedVariableGetterDeclaration?(declaration: ir.TypeDereferencedVariableGetterDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeDereferencedVariableSetterDeclaration?(declaration: ir.TypeDereferencedVariableSetterDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeVariableGetterDeclaration?(declaration: ir.TypeVariableGetterDeclaration): typeMemberDeclarationTransformationResult.Type;
+    transformTypeVariableSetterDeclaration?(declaration: ir.TypeVariableSetterDeclaration): typeMemberDeclarationTransformationResult.Type;
     transformNestedMethodDeclaration?(declaration: ir.NestedMethodDeclaration): simpleTransformationResult.Type<ir.NestedMethodDeclaration>;
     transformLocalVariableDeclaration?(declaration: ir.LocalVariableDeclaration): simpleTransformationResult.Type<ir.LocalVariableDeclaration>;
     transformValueParameterDeclaration?(declaration: ir.ValueParameterDeclaration): simpleTransformationResult.Type<ir.ValueParameterDeclaration>;
     transformCaseClause?(declaration: ir.CaseClause): simpleTransformationResult.Type<ir.CaseClause>;
-    transformTypeIndexedGetterDeclaration?(declaration: ir.TypeIndexedGetterDeclaration): simpleTransformationResult.Type<ir.TypeIndexedGetterDeclaration>;
-    transformTypeIndexedSetterDeclaration?(declaration: ir.TypeIndexedSetterDeclaration): simpleTransformationResult.Type<ir.TypeIndexedSetterDeclaration>;
-    transformTypeDereferencedVariableGetterDeclaration?(declaration: ir.TypeDereferencedVariableGetterDeclaration): simpleTransformationResult.Type<ir.TypeDereferencedVariableGetterDeclaration>;
-    transformTypeDereferencedVariableSetterDeclaration?(declaration: ir.TypeDereferencedVariableSetterDeclaration): simpleTransformationResult.Type<ir.TypeDereferencedVariableSetterDeclaration>;
-    transformTypeVariableGetterDeclaration?(declaration: ir.TypeVariableGetterDeclaration): simpleTransformationResult.Type<ir.TypeVariableGetterDeclaration>;
-    transformTypeVariableSetterDeclaration?(declaration: ir.TypeVariableSetterDeclaration): simpleTransformationResult.Type<ir.TypeVariableSetterDeclaration>;
     transformVariantDeclaration?(declaration: ir.VariantDeclaration): simpleTransformationResult.Type<ir.VariantDeclaration>;
     transformCallArguments?(declaration: ir.CallArguments): simpleTransformationResult.Type<ir.CallArguments>;
     transformOnErrorClause?(clause: ir.OnErrorClause): simpleTransformationResult.Type<ir.OnErrorClause>;
     transformFinallyClause?(clause: ir.FinallyClause): simpleTransformationResult.Type<ir.FinallyClause>;
     transformJsObjectLiteralProperty?(clause: ir.JsObjectLiteralProperty): simpleTransformationResult.Type<ir.JsObjectLiteralProperty>;
 }
-export type TransformingContainer = TransformingContainer_typeMethod | TransformingContainer_typeConstructor | TransformingContainer_typeIndexedGetter | TransformingContainer_typeIndexedSetter | TransformingContainer_typeDereferencedVariableGetter | TransformingContainer_typeDereferencedVariableSetter | TransformingContainer_typeVariableGetter | TransformingContainer_typeVariableSetter;
-export declare class TransformingContainer_typeMethod {
-    readonly declaration: ir.TypeMethodDeclaration;
-    readonly kind = "type-method";
-    constructor(declaration: ir.TypeMethodDeclaration);
-}
-export declare class TransformingContainer_typeConstructor {
-    readonly declaration: ir.TypeConstructorDeclaration;
-    readonly kind = "type-constructor";
-    constructor(declaration: ir.TypeConstructorDeclaration);
-}
-export declare class TransformingContainer_typeIndexedGetter {
-    readonly declaration: ir.TypeIndexedGetterDeclaration;
-    readonly indexer: IndexerEntity;
-    readonly kind = "type-indexed-getter";
-    constructor(declaration: ir.TypeIndexedGetterDeclaration, indexer: IndexerEntity);
-}
-export declare class TransformingContainer_typeIndexedSetter {
-    readonly declaration: ir.TypeIndexedSetterDeclaration;
-    readonly indexer: IndexerEntity;
-    readonly kind = "type-indexed-setter";
-    constructor(declaration: ir.TypeIndexedSetterDeclaration, indexer: IndexerEntity);
-}
-export declare class TransformingContainer_typeDereferencedVariableGetter {
-    readonly declaration: ir.TypeDereferencedVariableGetterDeclaration;
-    readonly operator: DereferenceOperatorEntity;
-    readonly kind = "type-dereferenced-variable-getter";
-    constructor(declaration: ir.TypeDereferencedVariableGetterDeclaration, operator: DereferenceOperatorEntity);
-}
-export declare class TransformingContainer_typeDereferencedVariableSetter {
-    readonly declaration: ir.TypeDereferencedVariableSetterDeclaration;
-    readonly operator: DereferenceOperatorEntity;
-    readonly kind = "type-dereferenced-variable-setter";
-    constructor(declaration: ir.TypeDereferencedVariableSetterDeclaration, operator: DereferenceOperatorEntity);
-}
-export declare class TransformingContainer_typeVariableGetter {
-    readonly declaration: ir.TypeVariableGetterDeclaration;
-    readonly variable: VariableEntity;
-    readonly kind = "type-variable-getter";
-    constructor(declaration: ir.TypeVariableGetterDeclaration, variable: VariableEntity);
-}
-export declare class TransformingContainer_typeVariableSetter {
-    readonly declaration: ir.TypeVariableSetterDeclaration;
-    readonly variable: VariableEntity;
-    readonly kind = "type-variable-setter";
-    constructor(declaration: ir.TypeVariableSetterDeclaration, variable: VariableEntity);
-}
 export {};

package/build/types/emitter/ir/AccessedEntities.d.ts

@@ -1,19 +1,13 @@
-import { IndexerEntity, MethodEntity, VariableEntity } from '../../entities/index.js';
-import * as types from '../../types/index.js';
+import { MethodEntity, Type, VariableEntity } from '../Entities.js';
 export declare class AccessedVariable {
     readonly entity: VariableEntity;
-    readonly type: types.Type;
-    constructor(entity: VariableEntity, type: types.Type);
+    readonly type: Type;
+    constructor(entity: VariableEntity, type: Type);
     static fromEntity(entity: VariableEntity): AccessedVariable;
 }
 export declare class AccessedMethod {
     readonly entity: MethodEntity;
-    readonly returnType: types.Type;
-    constructor(entity: MethodEntity, returnType: types.Type);
+    readonly returnType: Type;
+    constructor(entity: MethodEntity, returnType: Type);
     static fromEntity(entity: MethodEntity): AccessedMethod;
 }
-export declare class AccessedIndexer {
-    readonly entity: IndexerEntity;
-    readonly type: types.Type;
-    constructor(entity: IndexerEntity, type: types.Type);
-}

package/build/types/emitter/ir/ComputedAccess.d.ts

@@ -0,0 +1,19 @@
+import { AccessKind } from '../../common/index.js';
+import { AccessedMethod } from './AccessedEntities.js';
+export type ComputedAccess = {
+    kind: AccessKind.Get;
+    getAccessor: AccessedMethod;
+} | {
+    kind: AccessKind.Set;
+    setAccessor: AccessedMethod;
+} | {
+    kind: AccessKind.GetSet;
+    getAccessor: AccessedMethod;
+    setAccessor: AccessedMethod;
+};
+export declare function isGetOrGetSet(access: ComputedAccess): access is AccessByKind<AccessKind.Get | AccessKind.GetSet>;
+export declare function isSetOrGetSet(access: ComputedAccess): access is AccessByKind<AccessKind.Set | AccessKind.GetSet>;
+type AccessByKind<TKind extends AccessKind, TAccess extends ComputedAccess = ComputedAccess> = TAccess extends {
+    kind: TKind;
+} ? TAccess : never;
+export {};

package/build/types/emitter/ir/LoweringState.d.ts

@@ -0,0 +1,25 @@
+export declare class CallExpressionLoweringState {
+    private flags;
+    constructor(flags?: MethodCallExpressionLoweringFlags);
+    get isAliasOrExtensionMethodCallLowered(): boolean;
+    set isAliasOrExtensionMethodCallLowered(value: boolean);
+    setIsAliasOrExtensionMethodCallLowered(value: boolean): this;
+    clone(): CallExpressionLoweringState;
+}
+declare const enum MethodCallExpressionLoweringFlags {
+    None = 0,
+    AliasOrExtensionMethodCallLowered = 1
+}
+export declare class ConstructorCallExpressionLoweringState {
+    private flags;
+    constructor(flags?: ConstructorCallExpressionLoweringFlags);
+    get isPlainObjectConstructorCallLowered(): boolean;
+    set isPlainObjectConstructorCallLowered(value: boolean);
+    setIsPlainObjectConstructorCallLowered(value: boolean): this;
+    clone(): ConstructorCallExpressionLoweringState;
+}
+declare const enum ConstructorCallExpressionLoweringFlags {
+    None = 0,
+    PlainObjectConstructorCallLowered = 1
+}
+export {};