@abaplint/transpiler 2.11.25 → 2.11.27

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

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

package/build/src/expressions/cast.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CastTranspiler = 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");
+class CastTranspiler {
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        const source = node.findDirectExpression(core_1.Expressions.Source);
+        if (source === undefined) {
+            throw new Error("CastTranspiler, Source not found");
+        }
+        const tni = node.findDirectExpression(core_1.Expressions.TypeNameOrInfer);
+        if (tni === undefined) {
+            throw new Error("CastTranspiler, TypeNameOrInfer not found");
+        }
+        const type = new type_name_or_infer_1.TypeNameOrInfer().findType(tni, traversal);
+        const target = transpile_types_1.TranspileTypes.toType(type);
+        const lett = node.findDirectExpression(core_1.Expressions.Let);
+        if (lett !== undefined) {
+            throw new Error("CastTranspiler, Let todo");
+        }
+        ret.appendString("await abap.statements.cast(")
+            .appendString(target)
+            .appendString(", ")
+            .appendChunk(traversal.traverse(source))
+            .append(")", node.getLastToken(), traversal);
+        return ret;
+    }
+}
+exports.CastTranspiler = CastTranspiler;
+//# sourceMappingURL=cast.js.map

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

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

package/build/src/expressions/corresponding_body.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CorrespondingBodyTranspiler = 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");
+class CorrespondingBodyTranspiler {
+    transpile(typ, body, traversal) {
+        if (!(typ.get() instanceof core_1.Expressions.TypeNameOrInfer)) {
+            throw new Error("CorrespondingBodyTranspiler, Expected TypeNameOrInfer");
+        }
+        const type = new type_name_or_infer_1.TypeNameOrInfer().findType(typ, traversal);
+        let target = transpile_types_1.TranspileTypes.toType(type);
+        let source;
+        for (const child of body.getChildren()) {
+            const c = child.get();
+            if (c instanceof core_1.Expressions.Source && child instanceof core_1.Nodes.ExpressionNode) {
+                source = traversal.traverse(child);
+            }
+            else if (c instanceof core_1.Expressions.CorrespondingBodyBase && child instanceof core_1.Nodes.ExpressionNode) {
+                source = traversal.traverse(child?.findDirectExpression(core_1.Expressions.Source));
+                target = `abap.statements.moveCorresponding(${source.getCode()}, ${target})`;
+            }
+            else {
+                throw new Error("CorrespondingBodyTranspiler, todo, " + c.constructor.name);
+            }
+        }
+        const ret = new chunk_1.Chunk();
+        ret.appendString(`abap.statements.moveCorresponding(${source.getCode()}, ${target})`);
+        return ret;
+    }
+}
+exports.CorrespondingBodyTranspiler = CorrespondingBodyTranspiler;
+//# sourceMappingURL=corresponding_body.js.map

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

@@ -13,6 +13,7 @@ export * from "./component_cond";
 export * from "./cond_sub";
 export * from "./cond";
 export * from "./constant";
+export * from "./cast";
 export * from "./database_table";
 export * from "./field_chain";
 export * from "./field_length";

package/build/src/expressions/index.js

@@ -29,6 +29,7 @@ __exportStar(require("./component_cond"), exports);
 __exportStar(require("./cond_sub"), exports);
 __exportStar(require("./cond"), exports);
 __exportStar(require("./constant"), exports);
+__exportStar(require("./cast"), exports);
 __exportStar(require("./database_table"), exports);
 __exportStar(require("./field_chain"), exports);
 __exportStar(require("./field_length"), exports);

package/build/src/expressions/method_call_chain.js

@@ -53,8 +53,11 @@ class MethodCallChainTranspiler {
             else if (c instanceof core_1.Nodes.ExpressionNode && c.get() instanceof core_1.Expressions.ComponentName) {
                 ret.append("." + c.concatTokens().toLowerCase(), c, traversal);
             }
+            else if (c instanceof core_1.Nodes.ExpressionNode && c.get() instanceof core_1.Expressions.Cast) {
+                ret.appendChunk(traversal.traverse(c));
+            }
             else {
-                ret.append("MethodCallChainTranspilerTodo-" + c.get().constructor.name, c, traversal);
+                ret.append("MethodCallChainTranspilerTodo$" + c.get().constructor.name, c, traversal);
             }
         }
         const code = ret.getCode();

package/build/src/expressions/source.js

@@ -7,6 +7,7 @@ const constant_1 = require("./constant");
 const chunk_1 = require("../chunk");
 const transpile_types_1 = require("../transpile_types");
 const value_body_1 = require("./value_body");
+const corresponding_body_1 = require("./corresponding_body");
 class SourceTranspiler {
     addGet;
     constructor(addGet = false) {
@@ -88,8 +89,11 @@ class SourceTranspiler {
                 else if (c.get() instanceof core_1.Expressions.ValueBody) {
                     continue;
                 }
+                else if (c.get() instanceof core_1.Expressions.CorrespondingBody) {
+                    continue;
+                }
                 else {
-                    ret.appendString("SourceUnknown-" + c.get().constructor.name);
+                    ret.appendString("SourceUnknown$" + c.get().constructor.name);
                 }
             }
             else if (c instanceof core_1.Nodes.TokenNode && (c.getFirstToken().getStr() === "&&" || c.getFirstToken().getStr() === "&")) {
@@ -121,6 +125,17 @@ class SourceTranspiler {
                     ret.appendString(transpile_types_1.TranspileTypes.toType(context));
                 }
             }
+            else if (c instanceof core_1.Nodes.TokenNode && c.getFirstToken().getStr().toUpperCase() === "CORRESPONDING") {
+                const typ = node.findDirectExpression(core_1.Expressions.TypeNameOrInfer);
+                if (typ === undefined) {
+                    throw new Error("TypeNameOrInfer not found in CorrespondingBody");
+                }
+                const correspondingBody = node.findDirectExpression(core_1.Expressions.CorrespondingBody);
+                if (correspondingBody === undefined) {
+                    throw new Error("CorrespondingBody not found");
+                }
+                ret.appendChunk(new corresponding_body_1.CorrespondingBodyTranspiler().transpile(typ, correspondingBody, 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/expressions/type_name_or_infer.js

@@ -5,14 +5,15 @@ const chunk_1 = require("../chunk");
 const transpile_types_1 = require("../transpile_types");
 class TypeNameOrInfer {
     findType(node, traversal) {
-        let type;
+        //    let type: AbstractType | undefined;
         const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
-        if (node.concatTokens() === "#") {
-            type = traversal.lookupInferred(node, scope);
-        }
-        else {
-            type = traversal.lookupType(node.getFirstChild(), scope);
-        }
+        //    if (node.concatTokens() === "#") {
+        const type = traversal.lookupInferred(node, scope);
+        /*
+      } else {
+        type = traversal.lookupType(node.getFirstChild() as Nodes.ExpressionNode, scope);
+      }
+        */
         if (type === undefined) {
             throw new Error("TypeNameOrInfer, type not found: " + node.concatTokens());
         }

package/build/src/traversal.js

@@ -604,6 +604,7 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         }
         return ret;
     }
+    // todo: delete this method?
     lookupType(node, scope) {
         if (scope === undefined) {
             return undefined;
@@ -673,9 +674,10 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
     lookupInferred(node, scope) {
         if (scope === undefined) {
             return undefined;
-        }
-        else if (node.concatTokens() !== "#") {
+            /*
+          } else if (node.concatTokens() !== "#") {
             throw new Error("lookupInferred, unexpected, " + node.get());
+            */
         }
         return this.findInferredTypeReference(node.getFirstToken());
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.11.25",
+  "version": "2.11.27",
   "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.171",
+    "@abaplint/core": "^2.113.173",
     "source-map": "^0.7.6"
   },
   "devDependencies": {