@abaplint/transpiler 2.11.44 → 2.11.46

package/build/src/expressions/cond_body.d.ts

@@ -0,0 +1,6 @@
+import { Nodes } from "@abaplint/core";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class CondBodyTranspiler {
+    transpile(typ: Nodes.ExpressionNode, body: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+}

package/build/src/expressions/cond_body.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CondBodyTranspiler = void 0;
+const core_1 = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+const type_name_or_infer_1 = require("./type_name_or_infer");
+const transpile_types_1 = require("../transpile_types");
+const cond_1 = require("./cond");
+const source_1 = require("./source");
+class CondBodyTranspiler {
+    transpile(typ, body, traversal) {
+        if (!(typ.get() instanceof core_1.Expressions.TypeNameOrInfer)) {
+            throw new Error("CondBodyTranspiler, Expected TypeNameOrInfer");
+        }
+        else if (body.findDirectExpression(core_1.Expressions.Let)) {
+            throw new Error("CondBodyTranspiler, Let not supported, todo");
+        }
+        const whenThen = [];
+        const expressions = [];
+        for (const c of body.getChildren()) {
+            if (c instanceof core_1.Nodes.TokenNode) {
+                if (c.concatTokens() === "ELSE") {
+                    break;
+                }
+            }
+            else {
+                expressions.push(c);
+            }
+        }
+        for (let i = 0; i < expressions.length; i = i + 2) {
+            whenThen.push({ when: expressions[i], then: expressions[i + 1] });
+        }
+        const type = new type_name_or_infer_1.TypeNameOrInfer().findType(typ, traversal);
+        const target = transpile_types_1.TranspileTypes.toType(type);
+        const ret = new chunk_1.Chunk();
+        ret.appendString("(" + target + ".set(");
+        ret.appendString("await (async () => {\n");
+        for (const { when, then } of whenThen) {
+            let condition = "";
+            if (when.get() instanceof core_1.Expressions.Cond) {
+                condition = new cond_1.CondTranspiler().transpile(when, traversal).getCode();
+            }
+            else {
+                throw new Error("CondBodyTranspiler, Expected Cond, todo, " + when.get().constructor.name);
+            }
+            let value = "";
+            if (then.get() instanceof core_1.Expressions.Source) {
+                value = new source_1.SourceTranspiler().transpile(then, traversal).getCode();
+            }
+            else {
+                throw new Error("CondBodyTranspiler, Expected Source, todo, " + then.get().constructor.name);
+            }
+            ret.appendString(`if (${condition}) { return ${value}; }\n`);
+        }
+        const els = body.findExpressionAfterToken("ELSE");
+        if (els) {
+            if (!(els.get() instanceof core_1.Expressions.Source)) {
+                throw new Error("CondBodyTranspiler, Expected Source, todo, " + els.get().constructor.name);
+            }
+            const value = new source_1.SourceTranspiler().transpile(els, traversal).getCode();
+            ret.appendString(`return ${value};\n`);
+        }
+        else {
+            ret.appendString(`return ${target};\n`);
+        }
+        ret.appendString("})()))");
+        return ret;
+    }
+}
+exports.CondBodyTranspiler = CondBodyTranspiler;
+//# sourceMappingURL=cond_body.js.map

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

@@ -26,6 +26,7 @@ export * from "./let";
 export * from "./message_number";
 export * from "./method_call_body";
 export * from "./method_call_chain";
+export * from "./cond_body";
 export * from "./method_call_param";
 export * from "./new_object";
 export * from "./method_call";

package/build/src/expressions/index.js

@@ -42,6 +42,7 @@ __exportStar(require("./let"), exports);
 __exportStar(require("./message_number"), exports);
 __exportStar(require("./method_call_body"), exports);
 __exportStar(require("./method_call_chain"), exports);
+__exportStar(require("./cond_body"), exports);
 __exportStar(require("./method_call_param"), exports);
 __exportStar(require("./new_object"), exports);
 __exportStar(require("./method_call"), exports);

package/build/src/expressions/source.js

@@ -92,6 +92,9 @@ class SourceTranspiler {
                 else if (c.get() instanceof core_1.Expressions.CorrespondingBody) {
                     continue;
                 }
+                else if (c.get() instanceof core_1.Expressions.CondBody) {
+                    continue;
+                }
                 else {
                     ret.appendString("SourceUnknown$" + c.get().constructor.name);
                 }
@@ -136,6 +139,17 @@ class SourceTranspiler {
                 }
                 ret.appendChunk(new corresponding_body_1.CorrespondingBodyTranspiler().transpile(typ, correspondingBody, traversal));
             }
+            else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr().toUpperCase() === "COND") {
+                const typ = node.findDirectExpression(core_1.Expressions.TypeNameOrInfer);
+                if (typ === undefined) {
+                    throw new Error("TypeNameOrInfer not found in CondBody");
+                }
+                const condBody = node.findDirectExpression(core_1.Expressions.CondBody);
+                if (condBody === undefined) {
+                    throw new Error("CondBody not found");
+                }
+                ret.appendChunk(new _1.CondBodyTranspiler().transpile(typ, condBody, traversal));
+            }
             else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr().toUpperCase() === "REF") {
                 const infer = node.findDirectExpression(core_1.Expressions.TypeNameOrInfer);
                 if (infer?.concatTokens() !== "#") {

package/build/src/statements/raise.js

@@ -10,7 +10,10 @@ class RaiseTranspiler {
         const classNameToken = node.findFirstExpression(abaplint.Expressions.ClassName)?.getFirstToken();
         const className = classNameToken?.getStr();
         if (className === undefined) {
-            const s = node.findFirstExpression(abaplint.Expressions.SimpleSource2);
+            let s = node.findFirstExpression(abaplint.Expressions.SimpleSource2);
+            if (s === undefined) {
+                s = node.findFirstExpression(abaplint.Expressions.Source);
+            }
             if (s === undefined) {
                 const name = node.findFirstExpression(abaplint.Expressions.ExceptionName)?.concatTokens().toLowerCase();
                 return new chunk_1.Chunk().append(`throw new abap.ClassicError({classic: "${name}"});`, node, traversal);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.11.44",
+  "version": "2.11.46",
   "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.113.182",
+    "@abaplint/core": "^2.113.184",
     "source-map": "^0.7.6"
   },
   "devDependencies": {