@abaplint/transpiler 2.3.27 → 2.3.29

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

@@ -3,5 +3,7 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class DoTranspiler implements IStatementTranspiler {
+    private readonly syIndexBackup;
+    constructor(syIndexBackup: string);
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/do.js

@@ -6,19 +6,24 @@ const expressions_1 = require("../expressions");
 const unique_identifier_1 = require("../unique_identifier");
 const chunk_1 = require("../chunk");
 class DoTranspiler {
+    constructor(syIndexBackup) {
+        this.syIndexBackup = syIndexBackup;
+    }
     transpile(node, traversal) {
         const found = node.findFirstExpression(abaplint.Expressions.Source);
         if (found) {
             const source = new expressions_1.SourceTranspiler(true).transpile(found, traversal).getCode();
             const idSource = unique_identifier_1.UniqueIdentifier.get();
             const id = unique_identifier_1.UniqueIdentifier.get();
-            return new chunk_1.Chunk(`const ${idSource} = ${source};
+            return new chunk_1.Chunk(`const ${this.syIndexBackup} = abap.builtin.sy.get().index.get();
+const ${idSource} = ${source};
 for (let ${id} = 0; ${id} < ${idSource}; ${id}++) {
 abap.builtin.sy.get().index.set(${id} + 1);`);
         }
         else {
             const unique = unique_identifier_1.UniqueIdentifier.get();
-            return new chunk_1.Chunk(`let ${unique} = 1;
+            return new chunk_1.Chunk(`const ${this.syIndexBackup} = abap.builtin.sy.get().index.get();
+let ${unique} = 1;
 while (true) {
 abap.builtin.sy.get().index.set(${unique}++);`);
         }

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

@@ -3,5 +3,7 @@ import { Chunk } from "../chunk";
 import { Traversal } from "../traversal";
 import { IStatementTranspiler } from "./_statement_transpiler";
 export declare class EndDoTranspiler implements IStatementTranspiler {
+    private readonly syIndexBackup;
+    constructor(syIndexBackup: string);
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/end_do.js

@@ -3,8 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndDoTranspiler = void 0;
 const chunk_1 = require("../chunk");
 class EndDoTranspiler {
+    constructor(syIndexBackup) {
+        this.syIndexBackup = syIndexBackup;
+    }
     transpile(node, traversal) {
-        return new chunk_1.Chunk().append("}", node, traversal);
+        return new chunk_1.Chunk().append(`}
+abap.builtin.sy.get().index.set(${this.syIndexBackup});\n`, node, traversal);
     }
 }
 exports.EndDoTranspiler = EndDoTranspiler;

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

@@ -3,5 +3,7 @@ import { Chunk } from "../chunk";
 import { Traversal } from "../traversal";
 import { IStatementTranspiler } from "./_statement_transpiler";
 export declare class EndWhileTranspiler implements IStatementTranspiler {
+    private readonly syIndexBackup;
+    constructor(syIndexBackup: string);
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/end_while.js

@@ -3,8 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndWhileTranspiler = void 0;
 const chunk_1 = require("../chunk");
 class EndWhileTranspiler {
+    constructor(syIndexBackup) {
+        this.syIndexBackup = syIndexBackup;
+    }
     transpile(node, traversal) {
-        return new chunk_1.Chunk().append("}", node, traversal);
+        return new chunk_1.Chunk().append(`}
+abap.builtin.sy.get().index.set(${this.syIndexBackup});\n`, node, traversal);
     }
 }
 exports.EndWhileTranspiler = EndWhileTranspiler;

package/build/src/statements/form.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormTranspiler = void 0;
 const abaplint = require("@abaplint/core");
 const chunk_1 = require("../chunk");
+const unique_identifier_1 = require("../unique_identifier");
 class FormTranspiler {
     transpile(node) {
+        unique_identifier_1.UniqueIdentifier.resetIndexBackup();
         const name = node.findFirstExpression(abaplint.Expressions.FormName).getFirstToken().getStr();
         return new chunk_1.Chunk("async function " + name + "() {");
     }

package/build/src/statements/method_implementation.js

@@ -6,6 +6,7 @@ const transpile_types_1 = require("../transpile_types");
 const traversal_1 = require("../traversal");
 const expressions_1 = require("../expressions");
 const chunk_1 = require("../chunk");
+const unique_identifier_1 = require("../unique_identifier");
 class MethodImplementationTranspiler {
     transpile(node, traversal) {
         var _a, _b;
@@ -100,9 +101,11 @@ class MethodImplementationTranspiler {
                 "return " + traversal_1.Traversal.escapeClassName(className) + "." + traversal_1.Traversal.escapeClassName(methodName) + "(" + unique + ");\n" +
                 "}\n" + "static ";
         }
+        unique_identifier_1.UniqueIdentifier.resetIndexBackup();
         const str = staticMethod + "async " + traversal_1.Traversal.escapeClassName(methodName) + "(" + unique + ") {" + after;
         return new chunk_1.Chunk().append(str, node, traversal);
     }
+    /////////////////////////////
     findMethod(name, cdef, traversal) {
         var _a, _b;
         if (cdef === undefined) {

package/build/src/statements/return.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReturnTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const unique_identifier_1 = require("../unique_identifier");
 class ReturnTranspiler {
     transpile(node, traversal) {
         let extra = "";
@@ -13,7 +14,11 @@ class ReturnTranspiler {
                 extra = " " + n.toLowerCase();
             }
         }
-        return new chunk_1.Chunk().append("return" + extra + ";", node, traversal);
+        let pre = "";
+        if (traversal.isInsideDoOrWhile(node)) {
+            pre = `abap.builtin.sy.get().index.set(${unique_identifier_1.UniqueIdentifier.getIndexBackup1()});\n`;
+        }
+        return new chunk_1.Chunk().append(pre + "return" + extra + ";", node, traversal);
     }
 }
 exports.ReturnTranspiler = ReturnTranspiler;

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

@@ -3,5 +3,7 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class WhileTranspiler implements IStatementTranspiler {
+    private readonly syIndexBackup;
+    constructor(syIndexBackup: string);
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/while.js

@@ -6,11 +6,15 @@ const expressions_1 = require("../expressions");
 const chunk_1 = require("../chunk");
 const unique_identifier_1 = require("../unique_identifier");
 class WhileTranspiler {
+    constructor(syIndexBackup) {
+        this.syIndexBackup = syIndexBackup;
+    }
     transpile(node, traversal) {
         const cond = new expressions_1.CondTranspiler().transpile(node.findFirstExpression(abaplint.Expressions.Cond), traversal);
         const unique = unique_identifier_1.UniqueIdentifier.get();
         return new chunk_1.Chunk()
-            .append(`let ${unique} = 1;
+            .append(`const ${this.syIndexBackup} = abap.builtin.sy.get().index.get();
+let ${unique} = 1;
 while (`, node, traversal)
             .appendChunk(cond)
             .appendString(`) {

package/build/src/structures/do.d.ts

@@ -0,0 +1,7 @@
+import * as abaplint from "@abaplint/core";
+import { IStructureTranspiler } from "./_structure_transpiler";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class DoTranspiler implements IStructureTranspiler {
+    transpile(node: abaplint.Nodes.StructureNode, traversal: Traversal): Chunk;
+}

package/build/src/structures/do.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoTranspiler = void 0;
+const abaplint = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+const statements_1 = require("../statements");
+const unique_identifier_1 = require("../unique_identifier");
+class DoTranspiler {
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        const syIndexBackup = unique_identifier_1.UniqueIdentifier.getIndexBackup();
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.Do) {
+                ret.appendChunk(new statements_1.DoTranspiler(syIndexBackup).transpile(c, traversal));
+                ret.appendString("\n");
+            }
+            else if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.EndDo) {
+                ret.appendChunk(new statements_1.EndDoTranspiler(syIndexBackup).transpile(c, traversal));
+            }
+            else {
+                ret.appendChunk(traversal.traverse(c));
+            }
+        }
+        return ret;
+    }
+}
+exports.DoTranspiler = DoTranspiler;
+//# sourceMappingURL=do.js.map

package/build/src/structures/function_module.js

@@ -4,6 +4,8 @@ exports.FunctionModuleTranspiler = void 0;
 const abaplint = require("@abaplint/core");
 const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
+const transpile_types_1 = require("../transpile_types");
+const unique_identifier_1 = require("../unique_identifier");
 class FunctionModuleTranspiler {
     transpile(node, traversal) {
         var _a;
@@ -16,7 +18,7 @@ class FunctionModuleTranspiler {
                     name = "FunctionModuleTranspilerNameNotFound";
                 }
                 r += `async function ${traversal_1.Traversal.escapeClassName(name)}(INPUT) {\n`;
-                r += this.findSignature(traversal, name);
+                r += this.findSignature(traversal, name, c);
             }
             else if (c.get() instanceof abaplint.Statements.EndFunction) {
                 r += "}\n";
@@ -26,10 +28,12 @@ class FunctionModuleTranspiler {
                 r += traversal.traverse(c).getCode();
             }
         }
+        unique_identifier_1.UniqueIdentifier.resetIndexBackup();
         return new chunk_1.Chunk(r);
     }
     //////////////////////
-    findSignature(traversal, name) {
+    findSignature(traversal, name, node) {
+        var _a;
         const group = traversal.getCurrentObject();
         if (group === undefined) {
             throw "FunctionModuleTranspilerGroupNotFound";
@@ -38,6 +42,7 @@ class FunctionModuleTranspiler {
         if (module === undefined) {
             throw "FunctionModuleTranspilerModuleNotFound";
         }
+        const scope = traversal.findCurrentScopeByToken(node.getLastToken());
         let ret = "";
         for (const p of module.getParameters()) {
             ret += `// ${p.direction} ${p.name} ${p.type}\n`;
@@ -49,7 +54,18 @@ class FunctionModuleTranspiler {
                 direction = "importing";
             }
             // note: all directions are optional
-            ret += `let ${p.name.toLowerCase()} = INPUT.${direction}?.${p.name.toLowerCase()};\n`;
+            const name = p.name.toLowerCase();
+            ret += `let ${name} = INPUT.${direction}?.${name};\n`;
+            if (direction === "exporting" || direction === "importing" || direction === "changing") {
+                const type = (_a = scope === null || scope === void 0 ? void 0 : scope.findVariable(name)) === null || _a === void 0 ? void 0 : _a.getType();
+                if (type !== undefined) {
+                    // todo, set DEFAULT value
+                    // todo, check for OPTIONALness and raise exceptions and stuff
+                    ret += `if (${name} === undefined) {
+            ${name} = ${new transpile_types_1.TranspileTypes().toType(type)};
+          }\n`;
+                }
+            }
         }
         return ret;
     }

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

@@ -3,10 +3,12 @@ export * from "./class_definition";
 export * from "./class_implementation";
 export * from "./constants";
 export * from "./data";
+export * from "./define";
+export * from "./do";
 export * from "./function_module";
 export * from "./interface";
+export * from "./while";
 export * from "./select";
 export * from "./try";
-export * from "./define";
 export * from "./types";
 export * from "./when";

package/build/src/structures/index.js

@@ -19,11 +19,13 @@ __exportStar(require("./class_definition"), exports);
 __exportStar(require("./class_implementation"), exports);
 __exportStar(require("./constants"), exports);
 __exportStar(require("./data"), exports);
+__exportStar(require("./define"), exports);
+__exportStar(require("./do"), exports);
 __exportStar(require("./function_module"), exports);
 __exportStar(require("./interface"), exports);
+__exportStar(require("./while"), exports);
 __exportStar(require("./select"), exports);
 __exportStar(require("./try"), exports);
-__exportStar(require("./define"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./when"), exports);
 //# sourceMappingURL=index.js.map

package/build/src/structures/while.d.ts

@@ -0,0 +1,7 @@
+import * as abaplint from "@abaplint/core";
+import { IStructureTranspiler } from "./_structure_transpiler";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class WhileTranspiler implements IStructureTranspiler {
+    transpile(node: abaplint.Nodes.StructureNode, traversal: Traversal): Chunk;
+}

package/build/src/structures/while.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhileTranspiler = void 0;
+const abaplint = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+const statements_1 = require("../statements");
+const unique_identifier_1 = require("../unique_identifier");
+class WhileTranspiler {
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        const syIndexBackup = unique_identifier_1.UniqueIdentifier.getIndexBackup();
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.While) {
+                ret.appendChunk(new statements_1.WhileTranspiler(syIndexBackup).transpile(c, traversal));
+                ret.appendString("\n");
+            }
+            else if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.EndWhile) {
+                ret.appendChunk(new statements_1.EndWhileTranspiler(syIndexBackup).transpile(c, traversal));
+            }
+            else {
+                ret.appendChunk(traversal.traverse(c));
+            }
+        }
+        return ret;
+    }
+}
+exports.WhileTranspiler = WhileTranspiler;
+//# sourceMappingURL=while.js.map

package/build/src/traversal.d.ts

@@ -38,6 +38,7 @@ export declare class Traversal {
     private dataFromInterfaces;
     determineType(node: abaplint.Nodes.ExpressionNode | abaplint.Nodes.StatementNode, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.AbstractType | undefined;
     isInsideLoop(node: abaplint.Nodes.StatementNode): boolean;
+    isInsideDoOrWhile(node: abaplint.Nodes.StatementNode): boolean;
     registerClassOrInterface(def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined): string;
     lookupClassOrInterface(name: string | undefined, token: abaplint.Token | undefined, directGlobal?: boolean): string;
     private buildPrefix;

package/build/src/traversal.js

@@ -373,6 +373,24 @@ class Traversal {
         }
         return stack.length > 0;
     }
+    isInsideDoOrWhile(node) {
+        const stack = [];
+        for (const statement of this.getFile().getStatements()) {
+            const get = statement.get();
+            if (get instanceof abaplint.Statements.While
+                || get instanceof abaplint.Statements.Do) {
+                stack.push(statement);
+            }
+            else if (get instanceof abaplint.Statements.EndWhile
+                || get instanceof abaplint.Statements.EndDo) {
+                stack.pop();
+            }
+            if (statement === node) {
+                break;
+            }
+        }
+        return stack.length > 0;
+    }
     registerClassOrInterface(def) {
         if (def === undefined) {
             return "";

package/build/src/unique_identifier.d.ts

@@ -1,5 +1,9 @@
 export declare class UniqueIdentifier {
-    static counter: number;
+    private static counter;
+    private static indexBackup;
     static reset(): void;
     static get(): string;
+    static resetIndexBackup(): void;
+    static getIndexBackup(): string;
+    static getIndexBackup1(): string;
 }

package/build/src/unique_identifier.js

@@ -11,7 +11,18 @@ class UniqueIdentifier {
         this.counter++;
         return "unique" + this.counter;
     }
+    static resetIndexBackup() {
+        this.indexBackup = 0;
+    }
+    static getIndexBackup() {
+        this.indexBackup++;
+        return "indexBackup" + this.indexBackup;
+    }
+    static getIndexBackup1() {
+        return "indexBackup1";
+    }
 }
 exports.UniqueIdentifier = UniqueIdentifier;
 UniqueIdentifier.counter = 0;
+UniqueIdentifier.indexBackup = 0;
 //# sourceMappingURL=unique_identifier.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.3.27",
+  "version": "2.3.29",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -28,7 +28,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.93.57",
+    "@abaplint/core": "^2.93.58",
     "source-map": "^0.7.4"
   },
   "devDependencies": {