@abaplint/transpiler 2.11.16 → 2.11.17

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

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

package/build/src/expressions/field_assignment.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldAssignmentTranspiler = void 0;
+const core_1 = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+class FieldAssignmentTranspiler {
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        const field = node.findDirectExpression(core_1.Expressions.FieldSub);
+        if (field === undefined) {
+            throw new Error("FieldAssignmentTranspiler, Expected FieldSub");
+        }
+        const source = node.findDirectExpression(core_1.Expressions.Source);
+        if (source === undefined) {
+            throw new Error("FieldAssignmentTranspiler, Expected Source");
+        }
+        ret.appendString(`.setField("${field.concatTokens().toLowerCase()}", ${traversal.traverse(source).getCode()})`);
+        return ret;
+    }
+}
+exports.FieldAssignmentTranspiler = FieldAssignmentTranspiler;
+//# sourceMappingURL=field_assignment.js.map

package/build/src/expressions/source.js

@@ -6,6 +6,7 @@ const _1 = require(".");
 const constant_1 = require("./constant");
 const chunk_1 = require("../chunk");
 const transpile_types_1 = require("../transpile_types");
+const value_body_1 = require("./value_body");
 class SourceTranspiler {
     addGet;
     constructor(addGet = false) {
@@ -84,6 +85,13 @@ class SourceTranspiler {
                     ret.appendString(traversal.traverse(c.getFirstChild()).getCode());
                     ret.appendString(")");
                 }
+                else if (c.get() instanceof core_1.Expressions.ValueBody) {
+                    const typ = node.findFirstExpression(core_1.Expressions.TypeNameOrInfer);
+                    if (typ === undefined) {
+                        throw new Error("TypeNameOrInfer not found in ValueBody");
+                    }
+                    ret.appendChunk(new value_body_1.ValueBodyTranspiler().transpile(typ, c, traversal));
+                }
                 else {
                     ret.appendString("SourceUnknown-" + c.get().constructor.name);
                 }

package/build/src/expressions/sql_cond.js

@@ -95,6 +95,10 @@ class SQLCondTranspiler {
             ret += this.sqlSource(source, traversal, filename, table);
             return ret;
         }
+        if (fieldNameExpression && c.getChildren().length === 3 && c.concatTokens().toUpperCase().endsWith(" IS NULL")) {
+            ret += fieldName + " IS NULL";
+            return ret;
+        }
         if (fieldName === undefined || operator === undefined || source === undefined) {
             throw new Error("SQL Condition, transpiler todo2, " + c.concatTokens());
         }

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

@@ -1,7 +1,8 @@
-import { Nodes } from "@abaplint/core";
+import { AbstractType, Nodes } from "@abaplint/core";
 import { IExpressionTranspiler } from "./_expression_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class TypeNameOrInfer implements IExpressionTranspiler {
+    findType(node: Nodes.ExpressionNode, traversal: Traversal): AbstractType;
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/type_name_or_infer.js

@@ -4,7 +4,7 @@ exports.TypeNameOrInfer = void 0;
 const chunk_1 = require("../chunk");
 const transpile_types_1 = require("../transpile_types");
 class TypeNameOrInfer {
-    transpile(node, traversal) {
+    findType(node, traversal) {
         let type;
         const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
         if (node.concatTokens() === "#") {
@@ -16,6 +16,10 @@ class TypeNameOrInfer {
         if (type === undefined) {
             throw new Error("TypeNameOrInfer, type not found: " + node.concatTokens());
         }
+        return type;
+    }
+    transpile(node, traversal) {
+        const type = this.findType(node, traversal);
         const ret = new chunk_1.Chunk();
         ret.appendString(transpile_types_1.TranspileTypes.toType(type));
         return ret;

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

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

package/build/src/expressions/value_body.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueBodyTranspiler = 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 value_body_line_1 = require("./value_body_line");
+const field_assignment_1 = require("./field_assignment");
+class ValueBodyTranspiler {
+    transpile(typ, body, traversal) {
+        if (!(typ.get() instanceof core_1.Expressions.TypeNameOrInfer)) {
+            throw new Error("ValueBodyTranspiler, Expected TypeNameOrInfer");
+        }
+        const ret = new chunk_1.Chunk().appendString(new type_name_or_infer_1.TypeNameOrInfer().transpile(typ, traversal).getCode());
+        const context = new type_name_or_infer_1.TypeNameOrInfer().findType(typ, traversal);
+        for (const child of body.getChildren()) {
+            if (child.get() instanceof core_1.Expressions.FieldAssignment && child instanceof core_1.Nodes.ExpressionNode) {
+                ret.appendString(new field_assignment_1.FieldAssignmentTranspiler().transpile(child, traversal).getCode());
+            }
+            else if (child.get() instanceof core_1.Expressions.ValueBodyLine && child instanceof core_1.Nodes.ExpressionNode) {
+                if (!(context instanceof core_1.BasicTypes.TableType)) {
+                    throw new Error("ValueBodyTranspiler, Expected BasicTypes");
+                }
+                const rowType = context.getRowType();
+                ret.appendString(new value_body_line_1.ValueBodyLineTranspiler().transpile(rowType, child, traversal).getCode());
+            }
+            else {
+                throw new Error("ValueBodyTranspiler, unknown " + child.get().constructor.name);
+            }
+        }
+        return ret;
+    }
+}
+exports.ValueBodyTranspiler = ValueBodyTranspiler;
+//# sourceMappingURL=value_body.js.map

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

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

package/build/src/expressions/value_body_line.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueBodyLineTranspiler = void 0;
+const core_1 = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+const transpile_types_1 = require("../transpile_types");
+const field_assignment_1 = require("./field_assignment");
+class ValueBodyLineTranspiler {
+    transpile(rowType, line, traversal) {
+        const ret = new chunk_1.Chunk();
+        ret.appendString(`.appendThis(${transpile_types_1.TranspileTypes.toType(rowType)}`);
+        for (const child of line.getChildren()) {
+            if (child instanceof core_1.Nodes.TokenNode) {
+                // last or first parenthesis
+                continue;
+            }
+            else if (child.get() instanceof core_1.Expressions.FieldAssignment && child instanceof core_1.Nodes.ExpressionNode) {
+                ret.appendString(new field_assignment_1.FieldAssignmentTranspiler().transpile(child, traversal).getCode());
+            }
+            else {
+                throw new Error("ValueBodyLineTranspiler, unknown " + child.get().constructor.name);
+            }
+        }
+        ret.appendString(`)`);
+        return ret;
+    }
+}
+exports.ValueBodyLineTranspiler = ValueBodyLineTranspiler;
+//# sourceMappingURL=value_body_line.js.map

package/build/src/statements/append.js

@@ -29,7 +29,8 @@ class AppendTranspiler {
         }
         else {
             const options = [];
-            const s = node.findDirectExpression(abaplint.Expressions.SimpleSource4);
+            const s = node.findDirectExpression(abaplint.Expressions.SimpleSource4)
+                || node.findDirectExpression(abaplint.Expressions.Source);
             if (s) {
                 const option = new chunk_1.Chunk().appendString("source: ");
                 option.appendChunk(traversal.traverse(s));

package/build/src/statements/insert_internal.js

@@ -6,14 +6,14 @@ const chunk_1 = require("../chunk");
 class InsertInternalTranspiler {
     transpile(node, traversal) {
         const options = [];
-        let source = node.findDirectExpression(abaplint.Expressions.SimpleSource4);
+        const source = node.findDirectExpression(abaplint.Expressions.SimpleSource4)
+            || node.findDirectExpression(abaplint.Expressions.Source);
         const target = node.findDirectExpression(abaplint.Expressions.Target);
         const concat = node.concatTokens().toUpperCase();
         if (concat.startsWith("INSERT LINES OF ")) {
-            source = node.findDirectExpression(abaplint.Expressions.Source);
             options.push("lines: true");
         }
-        if (source === undefined) {
+        if (concat.startsWith("INSERT INITIAL LINE ")) {
             options.push("initial: true");
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.11.16",
+  "version": "2.11.17",
   "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.163",
+    "@abaplint/core": "^2.113.165",
     "source-map": "^0.7.6"
   },
   "devDependencies": {