@abaplint/transpiler 2.13.100 → 2.14.0

package/build/src/chunk.d.ts

@@ -39,6 +39,9 @@ export declare class Chunk {
         sourcePaths?: {
             [filename: string]: string;
         };
+        sourceContents?: {
+            [filename: string]: string;
+        };
     }): string;
 }
 export {};

package/build/src/chunk.js

@@ -218,6 +218,12 @@ class Chunk {
             original: m.original,
             generated: { line: m.generated.line + offset, column: m.generated.column },
         }));
+        for (const source of new Set(this.mappings.map(m => m.source))) {
+            const contents = options?.sourceContents?.[source];
+            if (contents !== undefined) {
+                sourceMapGenerator.setSourceContent(sourcePaths[source] ?? source, contents);
+            }
+        }
         const json = sourceMapGenerator.toJSON();
         json.file = generatedFilename;
         json.sourceRoot = "";

package/build/src/db/cds_database_view.d.ts

@@ -0,0 +1,19 @@
+import * as abaplint from "@abaplint/core";
+/** SQL for the supported relational subset of CDS. Never discard unknown syntax. */
+export declare class CDSDatabaseView {
+    private readonly reg;
+    private viewName;
+    private readonly sources;
+    constructor(reg: abaplint.IRegistry);
+    build(obj: abaplint.Objects.DataDefinition): string | undefined;
+    private source;
+    private join;
+    private element;
+    private expression;
+    private field;
+    private fieldParts;
+    private name;
+    private keyword;
+    private quote;
+    private unsupported;
+}

package/build/src/db/cds_database_view.js

@@ -0,0 +1,215 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDSDatabaseView = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
+const cds = abaplint.ExpressionsCDS;
+/** SQL for the supported relational subset of CDS. Never discard unknown syntax. */
+class CDSDatabaseView {
+    reg;
+    viewName = "";
+    sources = [];
+    constructor(reg) {
+        this.reg = reg;
+    }
+    build(obj) {
+        this.viewName = obj.getName();
+        const tree = new abaplint.CDSParser().parse(obj.findSourceFile());
+        if (tree === undefined) {
+            return this.unsupported("could not parse CDS definition");
+        }
+        else if (!(tree.get() instanceof cds.CDSDefineView)) {
+            return undefined; // Abstract/custom entities have no database view.
+        }
+        const name = tree.findDirectExpression(cds.CDSName);
+        const select = tree.findDirectExpression(cds.CDSSelect);
+        if (name === undefined || select === undefined) {
+            return this.unsupported("expected a SELECT view");
+        }
+        this.viewName = this.name(name);
+        for (const child of tree.getChildren()) {
+            if (child === name || child === select || child.get() instanceof cds.CDSAnnotation) {
+                continue;
+            }
+            this.keyword(child, ["DEFINE", "ROOT", "VIEW", "ENTITY", "AS", ";"]);
+        }
+        const source = select.findDirectExpression(cds.CDSSource);
+        if (source === undefined) {
+            return this.unsupported("missing source");
+        }
+        const from = [this.source(source)];
+        for (const join of select.findDirectExpressions(cds.CDSJoin)) {
+            from.push(this.join(join));
+        }
+        const elements = select.findDirectExpressions(cds.CDSElement);
+        if (elements.length === 0) {
+            return this.unsupported("expected explicit projected fields");
+        }
+        const columns = elements.map(e => this.element(e)).join(", ");
+        let where = "";
+        for (const child of select.getChildren()) {
+            if (child === source || child.get() instanceof cds.CDSJoin || child.get() instanceof cds.CDSElement) {
+                continue;
+            }
+            else if (child.get() instanceof cds.CDSWhere) {
+                where = " " + this.expression(child);
+            }
+            else {
+                this.keyword(child, ["SELECT", "DISTINCT", "FROM", "{", "}", ","]);
+            }
+        }
+        const distinct = select.findDirectTokenByText("DISTINCT") ? "DISTINCT " : "";
+        return `CREATE VIEW ${this.quote(this.viewName)} AS SELECT ${distinct}${columns} FROM ${from.join(" ")}${where};`;
+    }
+    source(node) {
+        const nameNode = node.findDirectExpression(cds.CDSPrefixedName);
+        if (nameNode === undefined) {
+            return this.unsupported("expected a table source");
+        }
+        const name = this.name(nameNode);
+        if (this.reg.getObject("TABL", name)?.getType() !== "TABL") {
+            return this.unsupported(`source ${name} does not resolve to a TABL`);
+        }
+        const as = node.findDirectExpression(cds.CDSAs);
+        const alias = as?.findDirectExpression(cds.CDSName) || node.findDirectExpression(cds.CDSName);
+        for (const child of node.getChildren()) {
+            if (child !== nameNode && child !== as && child !== alias) {
+                return this.unsupported("source parameters, filters or nested joins");
+            }
+        }
+        this.sources.push(alias ? this.name(alias) : name);
+        return this.quote(name) + (alias ? " AS " + this.quote(this.name(alias)) : "");
+    }
+    join(node) {
+        const sources = node.findDirectExpressions(cds.CDSSource);
+        const conditions = node.findDirectExpressions(cds.CDSCondition);
+        const words = node.getDirectTokens().map(t => t.getStr().toUpperCase()).join(" ");
+        const match = /^(?:(INNER|LEFT OUTER|RIGHT OUTER|CROSS) )?JOIN(?: ON)?$/.exec(words);
+        if (sources.length !== 1 || match === null) {
+            return this.unsupported("join shape: " + node.concatTokens());
+        }
+        const kind = match[1] || "INNER";
+        if (conditions.length !== (kind === "CROSS" ? 0 : 1)) {
+            return this.unsupported("join requires an ON condition (except CROSS JOIN)");
+        }
+        const source = this.source(sources[0]);
+        return kind + " JOIN " + source + (conditions.length ? " ON " + this.expression(conditions[0]) : "");
+    }
+    element(node) {
+        const field = node.findDirectExpression(cds.CDSPrefixedName);
+        const as = node.findDirectExpression(cds.CDSAs);
+        for (const child of node.getChildren()) {
+            if (child === field || child === as || child.get() instanceof cds.CDSAnnotation) {
+                continue;
+            }
+            this.keyword(child, ["KEY"]);
+        }
+        if (field === undefined) {
+            return this.unsupported("expected a projected source field");
+        }
+        const parts = this.fieldParts(field);
+        const alias = as?.findDirectExpression(cds.CDSName);
+        return this.field(field) + " AS " + this.quote(alias ? this.name(alias) : parts[parts.length - 1]);
+    }
+    expression(node) {
+        if (node instanceof abaplint.Nodes.TokenNode) {
+            return this.keyword(node, ["WHERE", "AND", "OR", "NOT", "IS", "NULL", "LIKE", "ESCAPE", "BETWEEN",
+                "=", "!", "<", ">", "(", ")"]);
+        }
+        else if (node.get() instanceof cds.CDSPrefixedName) {
+            if (node.getTokens().map(t => t.getStr()).join("").toLowerCase() === "$session.system_language") {
+                return "'E'";
+            }
+            return this.field(node);
+        }
+        else if (node.get() instanceof cds.CDSString || node.get() instanceof cds.CDSInteger) {
+            return node.getTokens().map(t => t.getStr()).join("");
+        }
+        else if (node.get() instanceof cds.CDSCondition || node.get() instanceof cds.CDSWhere) {
+            const parts = [];
+            for (const child of node.getChildren()) {
+                const part = this.expression(child);
+                if (["<", ">", "!"].includes(parts[parts.length - 1]) && ["=", ">"].includes(part)) {
+                    parts[parts.length - 1] += part;
+                }
+                else {
+                    parts.push(part);
+                }
+            }
+            return parts.join(" ");
+        }
+        return this.unsupported(node.concatTokens());
+    }
+    field(node) {
+        const parts = this.fieldParts(node);
+        if (parts.length === 1 && this.sources.length === 1) {
+            parts.unshift(this.sources[0]);
+        }
+        else if (parts.length === 2 && !this.sources.includes(parts[0])) {
+            return this.unsupported("unknown source qualifier " + parts[0]);
+        }
+        return parts.map(p => this.quote(p)).join(".");
+    }
+    fieldParts(node) {
+        const text = node.getTokens().map(t => t.getStr()).join("").toLowerCase();
+        const parts = text.split(".");
+        if (parts.length > 2 || parts.some(p => !/^(\/\w+\/)?\w+$/.test(p))) {
+            return this.unsupported("field path " + text);
+        }
+        return parts;
+    }
+    name(node) {
+        const name = node.getTokens().map(t => t.getStr()).join("").toLowerCase();
+        if (!/^(\/\w+\/)?\w+$/.test(name)) {
+            return this.unsupported("identifier " + name);
+        }
+        return name;
+    }
+    keyword(node, allowed) {
+        const text = node.concatTokens().toUpperCase();
+        if (!(node instanceof abaplint.Nodes.TokenNode) || !allowed.includes(text)) {
+            return this.unsupported(node.concatTokens());
+        }
+        return text;
+    }
+    quote(name) {
+        return '"' + name.toLowerCase().replace(/"/g, '""') + '"';
+    }
+    unsupported(detail) {
+        throw new Error(`CDS view ${this.viewName}: unsupported database definition: ${detail}`);
+    }
+}
+exports.CDSDatabaseView = CDSDatabaseView;
+//# sourceMappingURL=cds_database_view.js.map

package/build/src/db/index.d.ts

@@ -5,6 +5,7 @@ export declare class DatabaseSetup {
     private readonly reg;
     constructor(reg: abaplint.IRegistry);
     run(options?: ITranspilerOptions | undefined): DatabaseSetupResult;
+    private buildCDSViews;
     private driver;
     private buildInsert;
 }

package/build/src/db/index.js

@@ -39,6 +39,7 @@ const sqlite_database_schema_1 = require("./schema_generation/sqlite_database_sc
 const pg_database_schema_1 = require("./schema_generation/pg_database_schema");
 const snowflake_database_schema_1 = require("./schema_generation/snowflake_database_schema");
 const populate_tables_1 = require("./populate_tables");
+const cds_database_view_1 = require("./cds_database_view");
 /////////////////////////
 // NOTES
 /////////////////////////
@@ -50,9 +51,11 @@ class DatabaseSetup {
         this.reg = reg;
     }
     run(options) {
+        // CDS views are dialect independent SQL, added after the tables and views they select from
+        const cdsViews = this.buildCDSViews();
         return {
             schemas: {
-                sqlite: this.driver(new sqlite_database_schema_1.SQLiteDatabaseSchema(this.reg)),
+                sqlite: [...this.driver(new sqlite_database_schema_1.SQLiteDatabaseSchema(this.reg)), ...cdsViews],
                 // HANA takes the PG schema unchanged -- measured against HANA Express
                 // on a tree of 77 tables. The one thing it needs is that identifiers
                 // reach it quoted in UPPER case, and that is not a dialect of DDL: the
@@ -61,13 +64,25 @@ class DatabaseSetup {
                 // here. (Unquoted would nearly work and then meet a column called
                 // `cross`, which is one of HANA's reserved words.)
                 hdb: this.driver(new pg_database_schema_1.PGDatabaseSchema(this.reg)),
-                pg: this.driver(new pg_database_schema_1.PGDatabaseSchema(this.reg)),
-                snowflake: this.driver(new snowflake_database_schema_1.SnowflakeDatabaseSchema(this.reg)),
+                pg: [...this.driver(new pg_database_schema_1.PGDatabaseSchema(this.reg)), ...cdsViews],
+                snowflake: [...this.driver(new snowflake_database_schema_1.SnowflakeDatabaseSchema(this.reg)), ...cdsViews],
             },
             insert: this.buildInsert(options),
         };
     }
     ////////////////////
+    buildCDSViews() {
+        const views = [];
+        for (const obj of this.reg.getObjects()) {
+            if (obj instanceof abaplint.Objects.DataDefinition) {
+                const view = new cds_database_view_1.CDSDatabaseView(this.reg).build(obj);
+                if (view !== undefined) {
+                    views.push(view);
+                }
+            }
+        }
+        return views;
+    }
     driver(schemaGenerator) {
         const statements = [];
         // CREATE TABLEs

package/build/src/expressions/compare.js

@@ -53,12 +53,12 @@ class CompareTranspiler {
                 const field = concat.replace(" IS NOT REQUESTED", "").toLowerCase();
                 return new chunk_1.Chunk().appendString(pre + "INPUT && INPUT." + field + " === undefined && INPUT.importing?." + field + " === undefined");
             }
-            if (concat.includes(" IS INSTANCE OF ")) {
-                const notted = concat.startsWith("NOT ") || concat.includes(" IS NOT INSTANCE OF ");
+            if (concat.includes(" IS INSTANCE OF ") || concat.includes(" IS NOT INSTANCE OF ")) {
+                const notted = concat.startsWith("NOT ") !== concat.includes(" IS NOT INSTANCE OF ");
                 const falsed = notted ? " === false" : "";
                 const expr = node.findDirectExpression(core_1.Expressions.ClassName);
                 const cname = expr?.concatTokens();
-                const lookup = traversal.lookupClassOrInterface(cname, expr?.getFirstToken());
+                const lookup = cname?.toUpperCase() === "OBJECT" ? '"OBJECT"' : traversal.lookupClassOrInterface(cname, expr?.getFirstToken());
                 return new chunk_1.Chunk().appendString("abap.compare.instance_of(").appendChunk(s0).appendString(`, ${lookup})` + falsed);
             }
         }

package/build/src/handlers/handle_abap.d.ts

@@ -1,9 +1,11 @@
 import * as abaplint from "@abaplint/core";
 import { IOutputFile, ITranspilerOptions } from "../types";
 import { Chunk } from "../chunk";
+import { OutputLayout } from "../output_layout";
 export declare class HandleABAP {
+    private readonly layout;
     private readonly options;
-    constructor(options?: ITranspilerOptions);
+    constructor(options?: ITranspilerOptions, layout?: OutputLayout);
     runObject(obj: abaplint.ABAPObject, reg: abaplint.IRegistry): IOutputFile[];
     /** merges the locals def and imp into one mjs file */
     private rearrangeClassLocals;

package/build/src/handlers/handle_abap.js

@@ -39,10 +39,12 @@ const traversal_1 = require("../traversal");
 const requires_1 = require("../requires");
 const rearranger_1 = require("../rearranger");
 const chunk_1 = require("../chunk");
-const initialization_1 = require("../initialization");
+const output_layout_1 = require("../output_layout");
 class HandleABAP {
+    layout;
     options;
-    constructor(options) {
+    constructor(options, layout = new output_layout_1.OutputLayout()) {
+        this.layout = layout;
         this.options = options;
     }
     runObject(obj, reg) {
@@ -143,11 +145,12 @@ class HandleABAP {
             if (filename === output.filename) {
                 continue;
             }
+            const specifier = (0, output_layout_1.importPath)(this.layout.file(output.object, output.filename), this.layout.sourceModule(r.filename));
             if (name) {
-                contents.appendString("const {" + traversal_1.Traversal.escapeNamespace(name) + "} = await import(\"./" + (0, initialization_1.escapeFilenameForImport)(filename) + "\");\n");
+                contents.appendString("const {" + traversal_1.Traversal.escapeNamespace(name) + "} = await import(\"" + specifier + "\");\n");
             }
             else {
-                contents.appendString("await import(\"./" + (0, initialization_1.escapeFilenameForImport)(filename) + "\");\n");
+                contents.appendString("await import(\"" + specifier + "\");\n");
             }
         }
         contents.appendChunk(output.chunk);

package/build/src/handlers/handle_smim.d.ts

@@ -1,5 +1,8 @@
 import * as abaplint from "@abaplint/core";
 import { IOutputFile } from "../types";
+import { OutputLayout } from "../output_layout";
 export declare class HandleSMIM {
+    private readonly layout;
+    constructor(layout?: OutputLayout);
     runObject(obj: abaplint.Objects.MIMEObject, _reg: abaplint.IRegistry): IOutputFile[];
 }

package/build/src/handlers/handle_smim.js

@@ -2,7 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HandleSMIM = void 0;
 const chunk_1 = require("../chunk");
+const output_layout_1 = require("../output_layout");
 class HandleSMIM {
+    layout;
+    constructor(layout = new output_layout_1.OutputLayout()) {
+        this.layout = layout;
+        // Asset paths are relative to the output root.
+    }
     runObject(obj, _reg) {
         const filename = obj.getXMLFile()?.getFilename().replace(".xml", ".mjs").toLowerCase();
         if (filename === undefined) {
@@ -10,9 +16,10 @@ class HandleSMIM {
         }
         obj.parse();
         const dataFile = obj.getDataFile();
+        const dataFilename = dataFile ? this.layout.file({ name: obj.getName(), type: obj.getType() }, dataFile.getFilename()) : undefined;
         const chunk = new chunk_1.Chunk().appendString(`abap.SMIM["${obj.getName().toUpperCase()}"] = {
   "objectType": "SMIM",
-  "filename": ${JSON.stringify(dataFile?.getFilename())},
+  "filename": ${JSON.stringify(dataFilename)},
   "url": ${JSON.stringify(obj.getURL())},
   "class": ${JSON.stringify(obj.getClass())},
 };`);

package/build/src/handlers/handle_w3mi.d.ts

@@ -1,5 +1,8 @@
 import * as abaplint from "@abaplint/core";
 import { IOutputFile } from "../types";
+import { OutputLayout } from "../output_layout";
 export declare class HandleW3MI {
+    private readonly layout;
+    constructor(layout?: OutputLayout);
     runObject(obj: abaplint.Objects.WebMIME, _reg: abaplint.IRegistry): IOutputFile[];
 }

package/build/src/handlers/handle_w3mi.js

@@ -2,8 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HandleW3MI = void 0;
 const chunk_1 = require("../chunk");
+const output_layout_1 = require("../output_layout");
 const w3mi_name_1 = require("../w3mi_name");
 class HandleW3MI {
+    layout;
+    constructor(layout = new output_layout_1.OutputLayout()) {
+        this.layout = layout;
+        // Asset paths are relative to the output root.
+    }
     runObject(obj, _reg) {
         const filename = obj.getXMLFile()?.getFilename().replace(".xml", ".mjs").toLowerCase();
         if (filename === undefined) {
@@ -11,9 +17,10 @@ class HandleW3MI {
         }
         obj.parse();
         const dataFile = obj.getDataFile();
+        const dataFilename = dataFile ? this.layout.file({ name: obj.getName(), type: obj.getType() }, dataFile.getFilename()) : undefined;
         const chunk = new chunk_1.Chunk().appendString(`abap.W3MI["${(0, w3mi_name_1.w3miObjectName)(obj)}"] = {
   "objectType": "W3MI",
-  "filename": ${JSON.stringify(dataFile?.getFilename())},
+  "filename": ${JSON.stringify(dataFilename)},
 };`);
         const output = {
             object: {

package/build/src/index.d.ts

@@ -1,14 +1,15 @@
 import * as abaplint from "@abaplint/core";
 import { config } from "./validation";
-import { IFile, IOutput, IProgress, ITranspilerOptions, ITranspilerPlugin, IOutputFile, UnknownTypesEnum } from "./types";
+import { IFile, IOutput, IProgress, ITranspilerOptions, IOutputFile, UnknownTypesEnum } from "./types";
 import { Chunk } from "./chunk";
 import { DatabaseSetupResult } from "./db/database_setup_result";
-export { config, ITranspilerOptions, ITranspilerPlugin, IFile, IProgress, IOutputFile, IOutput, UnknownTypesEnum, Chunk, DatabaseSetupResult };
+import { OutputFolders } from "./output_layout";
+export { OutputLayout, OutputFolders, importPath } from "./output_layout";
+export { config, ITranspilerOptions, IFile, IProgress, IOutputFile, IOutput, UnknownTypesEnum, Chunk, DatabaseSetupResult };
 export declare class Transpiler {
     private readonly options;
-    private readonly plugin;
-    constructor(options?: ITranspilerOptions, plugin?: ITranspilerPlugin);
+    constructor(options?: ITranspilerOptions);
     runRaw(files: IFile[]): Promise<IOutput>;
-    run(reg: abaplint.IRegistry, progress?: IProgress): Promise<IOutput>;
+    run(reg: abaplint.IRegistry, progress?: IProgress, folders?: OutputFolders): Promise<IOutput>;
     protected validate(reg: abaplint.IRegistry): void;
 }

package/build/src/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Transpiler = exports.Chunk = exports.UnknownTypesEnum = exports.config = void 0;
+exports.Transpiler = exports.Chunk = exports.UnknownTypesEnum = exports.config = exports.importPath = exports.OutputLayout = void 0;
 const abaplint = __importStar(require("@abaplint/core"));
 const validation_1 = require("./validation");
 Object.defineProperty(exports, "config", { enumerable: true, get: function () { return validation_1.config; } });
@@ -57,12 +57,14 @@ const handle_msag_1 = require("./handlers/handle_msag");
 const handle_oa2p_1 = require("./handlers/handle_oa2p");
 const handle_fugr_1 = require("./handlers/handle_fugr");
 const initialization_1 = require("./initialization");
+const output_layout_1 = require("./output_layout");
+var output_layout_2 = require("./output_layout");
+Object.defineProperty(exports, "OutputLayout", { enumerable: true, get: function () { return output_layout_2.OutputLayout; } });
+Object.defineProperty(exports, "importPath", { enumerable: true, get: function () { return output_layout_2.importPath; } });
 class Transpiler {
     options;
-    plugin;
-    constructor(options, plugin) {
+    constructor(options) {
         this.options = options;
-        this.plugin = plugin;
         if (this.options === undefined) {
             this.options = {};
         }
@@ -76,23 +78,22 @@ class Transpiler {
         const reg = new abaplint.Registry().addFiles(memory);
         return this.run(reg);
     }
-    async run(reg, progress) {
+    async run(reg, progress, folders) {
         // Validation installs the transpiler configuration and findIssues() parses
         // dirty registries. Parsing before that would be wasted because setConfig()
         // marks every registry object dirty again.
         this.validate(reg);
+        const layout = new output_layout_1.OutputLayout(reg, folders);
         const dbSetup = new db_1.DatabaseSetup(reg).run(this.options);
-        this.plugin?.amendDatabaseSetup?.(dbSetup, reg, this.options || {});
         const output = {
             objects: [],
-            unitTestScript: new unit_test_1.UnitTest().unitTestScript(reg, this.options?.skip),
-            unitTestScriptOpen: new unit_test_1.UnitTest().unitTestScriptOpen(reg, this.options?.skip),
+            unitTestScript: new unit_test_1.UnitTest(layout).unitTestScript(reg, this.options?.skip),
+            unitTestScriptOpen: new unit_test_1.UnitTest(layout).unitTestScriptOpen(reg, this.options?.skip),
             initializationScript: "",
             initializationScript2: "",
             databaseSetup: dbSetup,
             reg: reg,
         };
-        const pluginOutputs = [];
         progress?.set(reg.getObjectCount().total, "Building");
         for (const obj of reg.getObjects()) {
             await progress?.tick("Building, " + obj.getName());
@@ -109,7 +110,7 @@ class Transpiler {
                 output.objects.push(...new handle_fugr_1.HandleFUGR(this.options).runObject(obj, reg));
             }
             else if (obj instanceof abaplint.ABAPObject) {
-                output.objects.push(...new handle_abap_1.HandleABAP(this.options).runObject(obj, reg));
+                output.objects.push(...new handle_abap_1.HandleABAP(this.options, layout).runObject(obj, reg));
             }
             else if (obj instanceof abaplint.Objects.Oauth2Profile) {
                 output.objects.push(...new handle_oa2p_1.HandleOA2P().runObject(obj, reg));
@@ -130,30 +131,25 @@ class Transpiler {
                 output.objects.push(...new handle_table_type_1.HandleTableType().runObject(obj, reg));
             }
             else if (obj instanceof abaplint.Objects.MIMEObject) {
-                output.objects.push(...new handle_smim_1.HandleSMIM().runObject(obj, reg));
+                output.objects.push(...new handle_smim_1.HandleSMIM(layout).runObject(obj, reg));
             }
             else if (obj instanceof abaplint.Objects.WebMIME) {
-                output.objects.push(...new handle_w3mi_1.HandleW3MI().runObject(obj, reg));
+                output.objects.push(...new handle_w3mi_1.HandleW3MI(layout).runObject(obj, reg));
             }
             else if (obj instanceof abaplint.Objects.MessageClass) {
                 output.objects.push(...new handle_msag_1.HandleMSAG().runObject(obj, reg));
             }
-            else if (this.plugin !== undefined) {
-                const handled = this.plugin.handleObject(obj, reg, this.options || {});
-                if (handled !== undefined) {
-                    output.objects.push(...handled);
-                    pluginOutputs.push(...handled);
-                }
-            }
         }
-        // after the object loop, plugin output files are imported by the initialization scripts
-        output.initializationScript = new initialization_1.Initialization().script(reg, dbSetup, this.options, false, pluginOutputs);
-        output.initializationScript2 = new initialization_1.Initialization().script(reg, dbSetup, this.options, true, pluginOutputs);
+        output.initializationScript = new initialization_1.Initialization(layout).script(reg, dbSetup, this.options, false);
+        output.initializationScript2 = new initialization_1.Initialization(layout).script(reg, dbSetup, this.options, true);
+        for (const file of output.objects) {
+            file.filename = layout.file(file.object, file.filename);
+        }
         return output;
     }
     // ///////////////////////////////
     validate(reg) {
-        const issues = new validation_1.Validation(this.options, this.plugin).run(reg);
+        const issues = new validation_1.Validation(this.options).run(reg);
         if (issues.length > 0) {
             const messages = issues.map(i => i.getKey() + ", " +
                 i.getMessage() + ", " +

package/build/src/initialization.d.ts

@@ -1,10 +1,13 @@
 import { DatabaseSetupResult } from "./db/database_setup_result";
 import * as abaplint from "@abaplint/core";
-import { ITranspilerOptions, IOutputFile } from "./types";
+import { ITranspilerOptions } from "./types";
+import { OutputLayout } from "./output_layout";
 export declare function escapeNamespaceFilename(filename: string): string;
 export declare function escapeFilenameForImport(filename: string): string;
 export declare class Initialization {
-    script(reg: abaplint.IRegistry, dbSetup: DatabaseSetupResult, options: ITranspilerOptions | undefined, useImport?: boolean, pluginOutputs?: readonly IOutputFile[]): string;
+    private readonly layout;
+    constructor(layout?: OutputLayout);
+    script(reg: abaplint.IRegistry, dbSetup: DatabaseSetupResult, options: ITranspilerOptions | undefined, useImport?: boolean): string;
     private buildImports;
     private hasClassConstructor;
 }

package/build/src/initialization.js

@@ -38,6 +38,7 @@ exports.escapeNamespaceFilename = escapeNamespaceFilename;
 exports.escapeFilenameForImport = escapeFilenameForImport;
 const abaplint = __importStar(require("@abaplint/core"));
 const handle_fugr_1 = require("./handlers/handle_fugr");
+const output_layout_1 = require("./output_layout");
 function escapeNamespaceFilename(filename) {
     // ES modules are resolved and cached as URLs. This means that special characters must be
     // percent-encoded, such as # with %23 and ? with %3F.
@@ -55,7 +56,12 @@ function escapeFilenameForImport(filename) {
     return filename.replace(/%/g, "%25").replace(/#/g, "%23");
 }
 class Initialization {
-    script(reg, dbSetup, options, useImport, pluginOutputs) {
+    layout;
+    constructor(layout = new output_layout_1.OutputLayout()) {
+        this.layout = layout;
+        // Flat output unless the caller supplies ownership information.
+    }
+    script(reg, dbSetup, options, useImport) {
         let ret = "";
         if (useImport === true) {
             ret = `/* eslint-disable import/newline-after-import */
@@ -98,28 +104,24 @@ globalThis.abap = new runtime.ABAP();\n`;
         }
         ret += `}\n\n`;
         ret += `await initializeABAP();\n\n`;
-        ret += `${this.buildImports(reg, useImport, options, pluginOutputs)}`;
+        ret += `${this.buildImports(reg, useImport, options)}`;
         if (options?.setup?.postFunction !== undefined) {
             ret += `\n\nawait setup.${options?.setup?.postFunction}();\n`;
         }
         return ret;
     }
-    buildImports(reg, useImport, options, pluginOutputs) {
+    buildImports(reg, useImport, options) {
         // note: ES modules are hoised, so use the dynamic import(), due to setting of globalThis.abap
         // some sorting required: eg. a class constructor using constant from interface
         const list = [];
         const late = [];
         const imp = (filename) => {
-            if (useImport === true) {
-                return `import "./${filename}.mjs";`;
-            }
-            else {
-                return `await import("./${filename}.mjs");`;
-            }
+            const specifier = (0, output_layout_1.importPath)("init.mjs", filename);
+            return {
+                filename: specifier.split("/").pop(),
+                code: useImport === true ? `import "${specifier}";` : `await import("${specifier}");`,
+            };
         };
-        for (const pluginOutput of pluginOutputs || []) {
-            list.push(imp(pluginOutput.filename.replace(/\.mjs$/i, "")));
-        }
         for (const obj of reg.getObjects()) {
             if (obj instanceof abaplint.Objects.Table
                 || obj instanceof abaplint.Objects.DataElement
@@ -131,11 +133,11 @@ globalThis.abap = new runtime.ABAP();\n`;
                 || obj instanceof abaplint.Objects.TypePool
                 || obj instanceof abaplint.Objects.TableType
                 || obj instanceof abaplint.Objects.View) {
-                list.push(imp(`${escapeNamespaceFilename(obj.getName().toLowerCase())}.${obj.getType().toLowerCase()}`));
+                list.push(imp(this.layout.objectModule(obj)));
             }
         }
         for (const obj of reg.getObjects()) {
-            const name = imp(`${escapeNamespaceFilename(obj.getName().toLowerCase())}.${obj.getType().toLowerCase()}`);
+            const name = imp(this.layout.objectModule(obj));
             if (obj instanceof abaplint.Objects.Class
                 && obj.getName().toUpperCase() !== "CL_ABAP_CHAR_UTILITIES"
                 && this.hasClassConstructor(reg, obj)) {
@@ -155,7 +157,9 @@ globalThis.abap = new runtime.ABAP();\n`;
                 list.push(name);
             }
         }
-        return [...list.sort(), ...late].join("\n");
+        // Folder names must not change the original module initialization order.
+        list.sort((a, b) => a.filename < b.filename ? -1 : a.filename > b.filename ? 1 : 0);
+        return [...list, ...late].map(entry => entry.code).join("\n");
     }
     // class constructors might make early use of eg. constants from interfaces
     // sub classes will import() super classes and trigger a class constructor of the super

package/build/src/output_layout.d.ts

@@ -0,0 +1,17 @@
+import * as abaplint from "@abaplint/core";
+import { IObjectIdentifier } from "./types";
+/** Source filenames to output folders. Omit this map to retain flat output. */
+export type OutputFolders = ReadonlyMap<string, string>;
+/** Browser-safe paths: generated modules use POSIX paths on every platform. */
+export declare class OutputLayout {
+    private readonly grouped;
+    private readonly objectFolders;
+    private readonly sourceFolders;
+    constructor(reg?: abaplint.IRegistry, folders?: OutputFolders);
+    private key;
+    file(obj: IObjectIdentifier, filename: string): string;
+    sourceModule(filename: string): string;
+    objectModule(obj: abaplint.IObject, suffix?: string): string;
+}
+/** Escape each segment without turning directory separators into namespace markers. */
+export declare function importPath(from: string, to: string): string;

package/build/src/output_layout.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputLayout = void 0;
+exports.importPath = importPath;
+/** Browser-safe paths: generated modules use POSIX paths on every platform. */
+class OutputLayout {
+    grouped;
+    objectFolders = new Map();
+    sourceFolders = new Map();
+    constructor(reg, folders) {
+        this.grouped = folders !== undefined;
+        if (folders === undefined) {
+            return;
+        }
+        for (const [filename, folder] of folders) {
+            this.sourceFolders.set(filename.toLowerCase(), folder);
+        }
+        for (const obj of reg?.getObjects() || []) {
+            const owners = new Set(obj.getFiles().map(f => this.sourceFolders.get(f.getFilename().toLowerCase()))
+                .filter((folder) => folder !== undefined));
+            if (owners.size !== 1) {
+                throw new Error("Ambiguous output ownership for " + obj.getType() + " " + obj.getName());
+            }
+            const folder = [...owners][0];
+            this.objectFolders.set(this.key({ type: obj.getType(), name: obj.getName() }), folder);
+            for (const file of obj.getFiles()) {
+                // Class locals are merged into a single module.
+                this.sourceFolders.set(file.getFilename().toLowerCase().replace(/\.locals_(def|imp)\.abap$/, ".locals.abap"), folder);
+            }
+        }
+    }
+    key(obj) {
+        return obj.type.toUpperCase() + ":" + obj.name.toUpperCase();
+    }
+    file(obj, filename) {
+        const folder = this.objectFolders.get(this.key(obj));
+        if (this.grouped && folder === undefined) {
+            throw new Error("Missing output ownership for " + obj.type + " " + obj.name);
+        }
+        if (folder !== undefined && (filename.startsWith("/") || /[\\:]/.test(filename)
+            || filename.split("/").some(segment => segment === "" || segment === "." || segment === ".."))) {
+            throw new Error("Invalid output filename: " + filename);
+        }
+        return folder === undefined ? filename : folder + "/" + filename;
+    }
+    sourceModule(filename) {
+        const folder = this.sourceFolders.get(filename.toLowerCase());
+        if (this.grouped && folder === undefined) {
+            throw new Error("Missing output ownership for source " + filename);
+        }
+        const module = filename.replace(/\.abap$/i, ".mjs").toLowerCase();
+        return folder === undefined ? module : folder + "/" + module;
+    }
+    objectModule(obj, suffix = "") {
+        const identifier = { name: obj.getName(), type: obj.getType() };
+        const filename = obj.getName().toLowerCase().replace(/\//g, "#") + "." + obj.getType().toLowerCase() + suffix + ".mjs";
+        return this.file(identifier, filename);
+    }
+}
+exports.OutputLayout = OutputLayout;
+/** Escape each segment without turning directory separators into namespace markers. */
+function importPath(from, to) {
+    const source = from.split("/").slice(0, -1);
+    const target = to.split("/");
+    while (source.length > 0 && target.length > 0 && source[0] === target[0]) {
+        source.shift();
+        target.shift();
+    }
+    const relative = [...source.map(() => ".."), ...target].join("/");
+    const escaped = relative.split("/").map(segment => encodeURIComponent(segment)).join("/");
+    return escaped.startsWith("../") ? escaped : "./" + escaped;
+}
+//# sourceMappingURL=output_layout.js.map

package/build/src/statements/assign.d.ts

@@ -4,5 +4,8 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class AssignTranspiler implements IStatementTranspiler {
     private tableExpressionSafeSource;
+    /** ASSIGN of a statically specified data object, e.g. a variable, an attribute or an offset/length,
+     *  does not set sy-subrc, a dereference, a table expression or COMPONENT does */
+    private isStaticDataObject;
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/assign.js

@@ -55,6 +55,22 @@ throw error;
 }
 })())`;
     }
+    /** ASSIGN of a statically specified data object, e.g. a variable, an attribute or an offset/length,
+     *  does not set sy-subrc, a dereference, a table expression or COMPONENT does */
+    isStaticDataObject(node, source) {
+        const concat = node.concatTokens().toUpperCase();
+        if (source === undefined
+            || concat.startsWith("ASSIGN COMPONENT ")
+            || concat.includes(" INCREMENT ")
+            || concat.includes(" ELSE UNASSIGN")
+            || source.findFirstExpression(abaplint.Expressions.Dereference) !== undefined
+            || source.findFirstExpression(abaplint.Expressions.TableExpression) !== undefined) {
+            return false;
+        }
+        // field symbols are left as they are, not measured
+        const first = source.findFirstExpression(abaplint.Expressions.FieldChain)?.getFirstChild();
+        return first !== undefined && !(first.get() instanceof abaplint.Expressions.SourceFieldSymbol);
+    }
     transpile(node, traversal) {
         const assignSource = node.findDirectExpression(abaplint.Expressions.AssignSource);
         const sourceExpressions = assignSource?.findDirectExpressionsMulti([abaplint.Expressions.Source, abaplint.Expressions.SimpleSource3]) || [];
@@ -94,6 +110,9 @@ throw error;
             }
             else {
                 options.push("source: " + sources.pop());
+                if (this.isStaticDataObject(node, sourceExprForCheck)) {
+                    options.push("keepSubrc: true");
+                }
             }
         }
         else {

package/build/src/statements/class_implementation.js

@@ -57,7 +57,7 @@ static INTERNAL_TYPE = 'CLAS';
 static INTERNAL_NAME = '${traversal.buildInternalName(token.getStr(), def)}';
 static IMPLEMENTED_INTERFACES = [${this.findImplementedByClass(traversal, def, scope).map(e => `"` + e.toUpperCase() + `"`).join(",")}];
 static ATTRIBUTES = {${Array.from(traversal.buildAttributes(def, scope)).join(",\n")}};
-static METHODS = {${traversal.buildMethods(def).join(",\n")}};`, node, traversal);
+static METHODS = {${traversal.buildMethods(def, scope).join(",\n")}};`, node, traversal);
     }
     findImplementedInterface(traversal, def, scope) {
         if (def === undefined || scope === undefined) {

package/build/src/statements/method_implementation.js

@@ -100,6 +100,16 @@ class MethodImplementationTranspiler {
                     else {
                         after += `let ${varPrefixed} = ${unique}?.${varName};\n`;
                     }
+                    if (passByValue === true) {
+                        // pass by value: the method works on its own copy, also for a generic type,
+                        // which keeps the type of the actual parameter.
+                        // A field symbol that is unassigned or assigned with CASTING is passed on as it is
+                        after += `if (${varPrefixed} instanceof abap.types.FieldSymbol) {
+  if (${varPrefixed}.getPointer()?.clone !== undefined) { ${varPrefixed} = ${varPrefixed}.getPointer().clone(); }
+} else if (${unique}?.${varName} !== undefined && ${varPrefixed}?.clone !== undefined) {
+  ${varPrefixed} = ${varPrefixed}.clone();
+}\n`;
+                    }
                     if (type instanceof abaplint.BasicTypes.NumericGenericType) {
                         after += `if (${varPrefixed}.constructor.name === "Character") {
   ${varPrefixed} = ${transpile_types_1.TranspileTypes.toType(identifier.getType())};

package/build/src/statements/select.js

@@ -296,10 +296,10 @@ abap.builtin.sy.get().dbcnt.set(${target}.getArrayLength());
             + ` : (("" + ${code}.get()).trim() === "" ? "" : "${keyword} " + ${code}.get()))`;
     }
     dynamicHavingClause(code) {
-        return `((value) => {
-const condition = value instanceof abap.types.Table || value instanceof abap.types.HashedTable
-  ? value.array().map(row => row.get()).join(" ") : value.get();
-return condition.trim() === "" ? "" : "HAVING " + abap.expandDynamic(condition, (name) => {try { return eval(name);} catch {}});
+        return `((value) => {
+const condition = value instanceof abap.types.Table || value instanceof abap.types.HashedTable
+  ? value.array().map(row => row.get()).join(" ") : value.get();
+return condition.trim() === "" ? "" : "HAVING " + abap.expandDynamic(condition, (name) => {try { return eval(name);} catch {}});
 })(${code})`;
     }
     isWhereExpression(node, expression) {

package/build/src/structures/interface.js

@@ -54,8 +54,11 @@ class InterfaceTranspiler {
                 ret += `static INTERNAL_TYPE = 'INTF';\n`;
                 ret += `static INTERNAL_NAME = '${traversal.buildInternalName(token.getStr(), def)}';\n`;
                 ret += `static ATTRIBUTES = {${Array.from(traversal.buildAttributes(def, scope)).join(",\n")}};\n`;
-                ret += `static METHODS = {${traversal.buildMethods(def).join(",\n")}};\n`;
-                // todo, add IMPLEMENTED_INTERFACES ?
+                ret += `static METHODS = {${traversal.buildMethods(def, scope).join(",\n")}};\n`;
+                const interfaces = def?.getImplementing().map(i => `"${i.name.toUpperCase()}"`) || [];
+                if (interfaces.length > 0) {
+                    ret += `static IMPLEMENTED_INTERFACES = [${interfaces.join(",")}];\n`;
+                }
             }
             else if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.EndInterface) {
                 ret += "}\n";

package/build/src/transpile_types.js

@@ -68,8 +68,22 @@ class TranspileTypes {
         if (type instanceof abaplint.BasicTypes.ObjectReferenceType
             || type instanceof abaplint.BasicTypes.GenericObjectReferenceType) {
             resolved = "ABAPObject";
-            extra = "{qualifiedName: " + JSON.stringify(type.getQualifiedName()?.toUpperCase()) +
-                ", RTTIName: " + JSON.stringify(type.getRTTIName()?.toUpperCase()) + "}";
+            const qualifiedName = type.getQualifiedName()
+                ?? (type instanceof abaplint.BasicTypes.ObjectReferenceType ? type.getIdentifierName() : undefined);
+            let RTTIName = type.getRTTIName();
+            if (type instanceof abaplint.BasicTypes.ObjectReferenceType && RTTIName === undefined) {
+                const id = type.getIdentifier();
+                // NEW and CAST can omit metadata; recover it from the referenced definition.
+                const [name, kind] = id.getFilename().split("/").pop().replace(/#/g, "/").split(".");
+                const local = (id instanceof abaplint.Types.ClassDefinition || id instanceof abaplint.Types.InterfaceDefinition)
+                    && id.isGlobal() === false;
+                const prefix = local && kind === "prog" ? "\\PROGRAM=" + name
+                    : local && kind === "clas" ? "\\CLASS-POOL=" + name : "";
+                const category = id instanceof abaplint.Types.InterfaceDefinition || kind === "intf" ? "INTERFACE" : "CLASS";
+                RTTIName = prefix + "\\" + category + "=" + id.getName();
+            }
+            extra = "{qualifiedName: " + JSON.stringify(qualifiedName?.toUpperCase()) +
+                ", RTTIName: " + JSON.stringify(RTTIName?.toUpperCase()) + "}";
         }
         else if (type instanceof abaplint.BasicTypes.TableType) {
             resolved = "Table";
@@ -197,6 +211,11 @@ class TranspileTypes {
             resolved = "Packed";
             extra = "{length: 8, decimals: 2}";
         }
+        else if (type instanceof abaplint.BasicTypes.PGenericType) {
+            // if not supplied its a P LENGTH 8 DECIMALS 0
+            resolved = "Packed";
+            extra = "{length: 8, decimals: 0}";
+        }
         else if (type instanceof abaplint.BasicTypes.XStringType) {
             resolved = "XString";
             if (type.getQualifiedName() !== undefined) {

package/build/src/traversal.d.ts

@@ -49,7 +49,8 @@ export declare class Traversal {
     private isClassAttribute;
     prefixAndName(t: abaplint.Token, filename?: string): string;
     private isStaticClassAttribute;
-    buildMethods(def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined): string[];
+    buildMethods(def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined, scope?: abaplint.ISpaghettiScopeNode): string[];
+    private buildMethod;
     private mapVisibility;
     buildAttributes(def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined, scope: abaplint.ISpaghettiScopeNode | undefined, prefix?: string): Set<string>;
     isBuiltinMethod(token: abaplint.Token): boolean;

package/build/src/traversal.js

@@ -355,7 +355,7 @@ class Traversal {
         }
         return undefined;
     }
-    buildMethods(def) {
+    buildMethods(def, scope) {
         const methods = [];
         if (def === undefined) {
             return methods;
@@ -366,29 +366,57 @@ class Traversal {
             throw new Error("buildMethods: unexpected undefined, " + def.getName());
         }
         for (const m of methodDefinitions.getAll()) {
-            const parameters = [];
-            for (const p of m.getParameters().getAll()) {
-                const type = transpile_types_1.TranspileTypes.toType(p.getType());
-                const optional = m.getParameters().getOptional().includes(p.getName()) ? "X" : " ";
-                let pKind = "";
-                if (pKind === "") {
-                    pKind = m.getParameters().getImporting().find((t) => { return t.getName() === p.getName(); }) ? "I" : "";
-                }
-                if (pKind === "") {
-                    pKind = m.getParameters().getChanging().find((t) => { return t.getName() === p.getName(); }) ? "C" : "";
-                }
-                if (pKind === "") {
-                    pKind = m.getParameters().getExporting().find((t) => { return t.getName() === p.getName(); }) ? "E" : "";
-                }
-                if (pKind === "") {
-                    pKind = m.getParameters().getReturning()?.getName() === p.getName() ? "R" : "";
-                }
-                parameters.push(`"${p.getName().toUpperCase()}": {"type": () => {return ${type};}, "is_optional": "${optional}", "parm_kind": "${pKind}", "type_name": "${p.getType().constructor.name}"}`);
+            methods.push(this.buildMethod(m.getName(), m, m.getVisibility()));
+        }
+        // an alias for an interface method is listed under its own name, pointing to the method
+        for (const a of def.getAliases() || []) {
+            const [intfName, methodName] = a.getComponent().split("~");
+            if (methodName === undefined) {
+                continue;
+            }
+            const aliased = this.findInterfaceDefinition(intfName, scope)?.getMethodDefinitions()?.getByName(methodName);
+            if (aliased === undefined) {
+                // not a method, or the interface is unknown
+                continue;
             }
-            methods.push(`"${m.getName().toUpperCase()}": {"visibility": "${this.mapVisibility(m.getVisibility())}", "parameters": {${parameters.join(", ")}}}`);
+            methods.push(this.buildMethod(a.getName(), aliased, a.getVisibility(), a.getComponent()));
         }
         return methods;
     }
+    buildMethod(name, m, visibility, aliasFor) {
+        const optionalNames = m.getParameters().getOptional().map(o => o.toUpperCase());
+        const parameters = [];
+        for (const p of m.getParameters().getAll()) {
+            const type = transpile_types_1.TranspileTypes.toType(p.getType());
+            const optional = optionalNames.includes(p.getName().toUpperCase()) ? "X" : " ";
+            let pKind = "";
+            if (pKind === "") {
+                pKind = m.getParameters().getImporting().find((t) => { return t.getName() === p.getName(); }) ? "I" : "";
+            }
+            if (pKind === "") {
+                pKind = m.getParameters().getChanging().find((t) => { return t.getName() === p.getName(); }) ? "C" : "";
+            }
+            if (pKind === "") {
+                pKind = m.getParameters().getExporting().find((t) => { return t.getName() === p.getName(); }) ? "E" : "";
+            }
+            if (pKind === "") {
+                pKind = m.getParameters().getReturning()?.getName() === p.getName() ? "R" : "";
+            }
+            parameters.push(`"${p.getName().toUpperCase()}": {"type": () => {return ${type};}, "is_optional": "${optional}", "parm_kind": "${pKind}", "type_name": "${p.getType().constructor.name}"}`);
+        }
+        // only written when set, a method without them is described as before
+        let extra = "";
+        if (m.isStatic() === true) {
+            extra += `"is_class": "X", `;
+        }
+        if (m.getRaising().length > 0) {
+            extra += `"exceptions": [${m.getRaising().map(e => `"${e.toUpperCase()}"`).join(", ")}], `;
+        }
+        if (aliasFor !== undefined) {
+            extra += `"alias_for": "${aliasFor.toUpperCase()}", `;
+        }
+        return `"${name.toUpperCase()}": {"visibility": "${this.mapVisibility(visibility)}", ${extra}"parameters": {${parameters.join(", ")}}}`;
+    }
     mapVisibility(vis) {
         switch (vis) {
             case abaplint.Visibility.Private:

package/build/src/types.d.ts

@@ -31,6 +31,7 @@ export interface IProgress {
 /** one javascript output file for each object */
 export interface IOutputFile {
     object: IObjectIdentifier;
+    /** POSIX path relative to the output root; includes its folder when a layout is supplied. */
     filename: string;
     chunk: Chunk;
     requires: readonly IRequire[];
@@ -40,18 +41,6 @@ export declare enum UnknownTypesEnum {
     compileError = "compileError",
     runtimeError = "runtimeError"
 }
-/** handles additional object types, may be supplied by a separate npm package */
-export interface ITranspilerPlugin {
-    /** object types handled by the plugin, merged into allowed_object_types during validation */
-    objectTypes(): string[];
-    /** returns undefined if the object is not handled by the plugin,
-     *  returned output files are imported in the initialization script,
-     *  return an empty array to accept the object without producing output */
-    handleObject(obj: abaplint.IObject, reg: abaplint.IRegistry, options: ITranspilerOptions): IOutputFile[] | undefined;
-    /** optional, called after the default schemas and inserts are built,
-     *  amend the database setup by mutating the supplied result directly */
-    amendDatabaseSetup?(dbSetup: DatabaseSetupResult, reg: abaplint.IRegistry, options: ITranspilerOptions): void;
-}
 export interface ITranspilerOptions {
     /** ignore syntax check, used for internal testing */
     ignoreSyntaxCheck?: boolean;

package/build/src/unit_test.d.ts

@@ -1,4 +1,5 @@
 import * as abaplint from "@abaplint/core";
+import { OutputLayout } from "./output_layout";
 /** @uniqueItems true */
 export type TestMethodList = {
     /** @pattern ^[a-zA-Z0-9_\/]+$ */
@@ -10,6 +11,8 @@ export type TestMethodList = {
     note?: string;
 }[];
 export declare class UnitTest {
+    private readonly layout;
+    constructor(layout?: OutputLayout);
     unitTestScriptOpen(reg: abaplint.IRegistry, _skip?: TestMethodList): string;
     private getSortedTests;
     unitTestScript(reg: abaplint.IRegistry, skip?: TestMethodList): string;

package/build/src/unit_test.js

@@ -36,8 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnitTest = void 0;
 /* eslint-disable max-len */
 const abaplint = __importStar(require("@abaplint/core"));
-const initialization_1 = require("./initialization");
+const output_layout_1 = require("./output_layout");
 class UnitTest {
+    layout;
+    constructor(layout = new output_layout_1.OutputLayout()) {
+        this.layout = layout;
+        // Test runners live at the output root.
+    }
     unitTestScriptOpen(reg, _skip) {
         let ret = `/* eslint-disable curly */
 import fs from "fs";
@@ -58,7 +63,7 @@ async function run() {
             }
             const hasTestFile = obj.getFiles().some(f => { return f.getFilename().includes(".testclasses."); });
             if (hasTestFile === true) {
-                ret += `  await import("./${(0, initialization_1.escapeNamespaceFilename)(obj.getName().toLowerCase())}.${obj.getType().toLowerCase()}.testclasses.mjs");\n`;
+                ret += `  await import("${(0, output_layout_1.importPath)("index.mjs", this.layout.objectModule(obj, ".testclasses"))}");\n`;
             }
             for (const file of obj.getABAPFiles()) {
                 for (const def of file.getInfo().listClassDefinitions()) {
@@ -120,7 +125,7 @@ run().then(() => {
                     }
                     tests.push({
                         obj,
-                        filename: `./${(0, initialization_1.escapeNamespaceFilename)(obj.getName().toLowerCase())}.${obj.getType().toLowerCase()}.testclasses.mjs`,
+                        filename: `${(0, output_layout_1.importPath)("index.mjs", this.layout.objectModule(obj, ".testclasses"))}`,
                         localClass: def.name.toLowerCase(),
                         riskLevel: def.riskLevel,
                         duration: def.duration,

package/build/src/validation.d.ts

@@ -1,9 +1,8 @@
 import { Issue, IRegistry, IConfig } from "@abaplint/core";
-import { ITranspilerOptions, ITranspilerPlugin } from "./types";
+import { ITranspilerOptions } from "./types";
 export declare const config: IConfig;
 export declare class Validation {
     private readonly options;
-    private readonly plugin;
-    constructor(options?: ITranspilerOptions, plugin?: ITranspilerPlugin);
+    constructor(options?: ITranspilerOptions);
     run(reg: IRegistry): readonly Issue[];
 }

package/build/src/validation.js

@@ -5,8 +5,12 @@ const core_1 = require("@abaplint/core");
 const types_1 = require("./types");
 const defaultAllowedObjectTypes = [
     "APIS",
+    "APLO",
     "AUTH",
+    "BDEF",
     "CLAS",
+    "DDLS",
+    "DDLX",
     "DEVC",
     "DOMA",
     "DTEL",
@@ -28,13 +32,19 @@ const defaultAllowedObjectTypes = [
     "PARA",
     "PINF",
     "PROG",
+    "SAJC",
+    "SAJT",
+    "SCO2",
     "WAPA",
     "SHLP",
     "SHMA",
+    "SIA6",
     "SICF",
     "SMIM",
     "SPLO",
     "SRFC",
+    "SRVB",
+    "SRVD",
     "SUSC",
     "SUSH",
     "SUSO",
@@ -110,10 +120,8 @@ exports.config = {
 // hmm this ^ is okay? since lines will be prefixed with "abap.builtin"?
 class Validation {
     options;
-    plugin;
-    constructor(options, plugin) {
+    constructor(options) {
         this.options = options;
-        this.plugin = plugin;
     }
     run(reg) {
         if (this.options?.ignoreSyntaxCheck === true) {
@@ -123,13 +131,6 @@ class Validation {
             exports.config.rules["check_syntax"] = true;
         }
         exports.config.rules["forbidden_identifier"]["check"] = ["^unique\\d+$"];
-        const allowed = [...defaultAllowedObjectTypes];
-        for (const type of this.plugin?.objectTypes() || []) {
-            if (allowed.includes(type.toUpperCase()) === false) {
-                allowed.push(type.toUpperCase());
-            }
-        }
-        exports.config.rules["allowed_object_types"]["allowed"] = allowed;
         if (this.options?.unknownTypes === types_1.UnknownTypesEnum.runtimeError) {
             // this is not a constant, just a regex that happens to not match anything
             exports.config.syntax.errorNamespace = "VOID_EVERYTHING";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.100",
+  "version": "2.14.0",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -29,7 +29,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.120.69",
+    "@abaplint/core": "^2.120.71",
     "source-map": "^0.8.0"
   },
   "devDependencies": {