@abaplint/transpiler 2.8.29 → 2.9.0

package/build/src/expressions/function_parameters.js

@@ -21,16 +21,11 @@ class FunctionParametersTranspiler {
         if (ch) {
             params.changing = traversal.traverse(ch).getCode();
         }
-        let ret = "";
+        const ret = [];
         for (const p of Object.keys(params)) {
-            if (ret === "") {
-                ret += p + ": " + params[p];
-            }
-            else {
-                ret += ", " + p + ": " + params[p];
-            }
+            ret.push(p + ": " + params[p]);
         }
-        return new chunk_1.Chunk(`{${ret}}`);
+        return new chunk_1.Chunk(`{${ret.join(", ")}}`);
     }
 }
 exports.FunctionParametersTranspiler = FunctionParametersTranspiler;

package/build/src/expressions/parameter_name.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterNameTranspiler = void 0;
+const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
 class ParameterNameTranspiler {
     transpile(node, traversal) {
         const nameToken = node.getFirstToken();
-        const name = nameToken.getStr().toLowerCase();
+        const name = traversal_1.Traversal.escapeNamespace(nameToken.getStr().toLowerCase());
         return new chunk_1.Chunk().append(name, nameToken, traversal);
     }
 }

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

@@ -0,0 +1,7 @@
+import * as abaplint from "@abaplint/core";
+import { IOutputFile, ITranspilerOptions } from "../types";
+export declare class HandleFUGR {
+    private readonly options;
+    constructor(options?: ITranspilerOptions);
+    runObject(obj: abaplint.ABAPObject, reg: abaplint.IRegistry): IOutputFile[];
+}

package/build/src/handlers/handle_fugr.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandleFUGR = void 0;
+const abaplint = require("@abaplint/core");
+const traversal_1 = require("../traversal");
+const rearranger_1 = require("../rearranger");
+const chunk_1 = require("../chunk");
+class HandleFUGR {
+    constructor(options) {
+        this.options = options;
+    }
+    // function groups are compiled into a single file, with one closure for the function groups top variables
+    runObject(obj, reg) {
+        const spaghetti = new abaplint.SyntaxLogic(reg, obj).run().spaghetti;
+        const chunk = new chunk_1.Chunk().appendString("{\n");
+        for (const file of obj.getSequencedFiles()) {
+            if (this.options?.addFilenames === true) {
+                chunk.appendString("// " + file.getFilename() + "\n");
+            }
+            const rearranged = new rearranger_1.Rearranger().run(obj.getType(), file.getStructure());
+            const contents = new traversal_1.Traversal(spaghetti, file, obj, reg, this.options).traverse(rearranged);
+            chunk.appendChunk(contents);
+            chunk.stripLastNewline();
+            chunk.runIndentationLogic(this.options?.ignoreSourceMap);
+        }
+        chunk.appendString("\n}");
+        const output = {
+            object: {
+                name: obj.getName(),
+                type: obj.getType(),
+            },
+            filename: obj.getName().toLowerCase().replace(/\//g, "#") + ".fugr.mjs",
+            chunk: chunk,
+            requires: [],
+            exports: [],
+        };
+        return [output];
+    }
+}
+exports.HandleFUGR = HandleFUGR;
+//# sourceMappingURL=handle_fugr.js.map

package/build/src/index.js

@@ -20,6 +20,7 @@ const handle_w3mi_1 = require("./handlers/handle_w3mi");
 const handle_smim_1 = require("./handlers/handle_smim");
 const handle_msag_1 = require("./handlers/handle_msag");
 const handle_oa2p_1 = require("./handlers/handle_oa2p");
+const handle_fugr_1 = require("./handlers/handle_fugr");
 class Transpiler {
     constructor(options) {
         this.options = options;
@@ -56,6 +57,9 @@ class Transpiler {
             if (obj instanceof abaplint.Objects.TypePool) {
                 output.objects.push(...new handle_type_pool_1.HandleTypePool().runObject(obj, reg));
             }
+            else if (obj instanceof abaplint.Objects.FunctionGroup) {
+                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));
             }

package/build/src/requires.js

@@ -55,6 +55,20 @@ class Requires {
                 });
             }
         }
+        /*
+        else if (obj.getType() === "FUGR") {
+          const fugr = obj as abaplint.Objects.FunctionGroup;
+          const functionModules = fugr.getModules();
+          const isFunctionModule = functionModules.find((f) => filename.includes("." + f.getName().toLowerCase() + ".")) !== undefined;
+          if (isFunctionModule) {
+            const name = Traversal.escapeNamespace(fugr.getName())?.toLowerCase();
+            add({
+              filename: name + ".fugr.sapl" + name + ".abap",
+              name: undefined,
+            });
+          }
+        }
+        */
         // always add CX_ROOT, it is used for CATCH, no catches in global interfaces
         // todo, it might be possible to remove this, as CATCH uses instanceof with dynamic registered classes
         if (obj.getType() !== "INTF") {

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

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class IncludeTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/include.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IncludeTranspiler = void 0;
+const abaplint = require("@abaplint/core");
+const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
+const rearranger_1 = require("../rearranger");
 class IncludeTranspiler {
-    transpile(_node, _traversal) {
+    transpile(node, traversal) {
+        const includeName = node.findDirectExpression(abaplint.Expressions.IncludeName)?.concatTokens();
+        if (includeName === undefined) {
+            throw new Error("INCLUDE, IncludeName not found");
+        }
+        const obj = traversal.getCurrentObject();
+        if (obj instanceof abaplint.Objects.FunctionGroup) {
+            if (includeName.toUpperCase().endsWith("XX") === false) {
+                const include = obj.getInclude(includeName);
+                if (include === undefined) {
+                    throw new Error(`Include ${includeName} not found`);
+                }
+                const sub = new traversal_1.Traversal(traversal.getSpaghetti(), include, traversal.getCurrentObject(), traversal.reg, traversal.options);
+                const rearranged = new rearranger_1.Rearranger().run(obj.getType(), include.getStructure());
+                const chunk = sub.traverse(rearranged);
+                //        console.dir(chunk.getCode());
+                return chunk;
+            }
+        }
         // todo, this will not work
         return new chunk_1.Chunk("");
     }

package/build/src/traversal.d.ts

@@ -19,6 +19,7 @@ export declare class Traversal {
     findStatementInFile(pos: abaplint.Position): abaplint.Nodes.StatementNode | undefined;
     private scopeCache;
     findCurrentScopeByToken(token: abaplint.Token): abaplint.ISpaghettiScopeNode | undefined;
+    private fuctionGroupWorkaround;
     getInterfaceDefinition(token: abaplint.Token): abaplint.IInterfaceDefinition | undefined;
     getClassDefinition(token: abaplint.Token): abaplint.IClassDefinition | undefined;
     private isClassAttribute;

package/build/src/traversal.js

@@ -78,8 +78,23 @@ class Traversal {
         else {
             this.scopeCache = undefined;
         }
+        if (node === undefined
+            && this.obj instanceof abaplint.Objects.FunctionGroup
+            && this.obj.getInclude(filename.split(".")[2])) {
+            // workaround for INCLUDEs in function groups
+            return this.fuctionGroupWorkaround(token);
+        }
         return node;
     }
+    fuctionGroupWorkaround(token) {
+        // check the function group level, it might be an INCLUDE defining the DATA
+        const functionGroupLevel = this.spaghetti.getFirstChild()?.getFirstChild();
+        const variable = functionGroupLevel?.getData().vars[token.getStr().toUpperCase()];
+        if (variable?.getStart().equals(token.getStart())) {
+            return functionGroupLevel;
+        }
+        return undefined;
+    }
     getInterfaceDefinition(token) {
         let scope = this.findCurrentScopeByToken(token);
         while (scope !== undefined) {

package/build/src/unit_test.js

@@ -336,9 +336,7 @@ run().then(() => {
         }
         for (const obj of reg.getObjects()) {
             if (obj instanceof abaplint.Objects.FunctionGroup) {
-                for (const m of obj.getModules()) {
-                    list.push(imp(`${this.escapeNamespace(obj.getName().toLowerCase())}.fugr.${this.escapeNamespace(m.getName().toLowerCase())}`));
-                }
+                list.push(imp(`${this.escapeNamespace(obj.getName().toLowerCase())}.fugr`));
             }
             else if (obj instanceof abaplint.Objects.Class) {
                 if (obj.getName().toUpperCase() !== "CL_ABAP_CHAR_UTILITIES"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.8.29",
+  "version": "2.9.0",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",