@abaplint/transpiler 2.13.79 → 2.13.82

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

@@ -5,11 +5,13 @@ import { Chunk } from "../chunk";
 export declare class MethodCallTranspiler implements IExpressionTranspiler {
     private readonly postName;
     private readonly method;
-    /** @param postName inserted between the method name and the parameters, eg. ".bind(this)"
-     *  @param method   the already resolved method reference, saves looking it up again */
+    private readonly discardResult;
+    /** @param postName      inserted between the method name and the parameters, eg. ".bind(this)"
+     *  @param method        the already resolved method reference, saves looking it up again
+     *  @param discardResult the RETURNING value of this call is not consumed */
     constructor(postName?: string, method?: {
         def: Types.MethodDefinition;
         name: string;
-    });
+    }, discardResult?: boolean);
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/method_call.js

@@ -8,11 +8,14 @@ const chunk_1 = require("../chunk");
 class MethodCallTranspiler {
     postName;
     method;
-    /** @param postName inserted between the method name and the parameters, eg. ".bind(this)"
-     *  @param method   the already resolved method reference, saves looking it up again */
-    constructor(postName = "", method) {
+    discardResult;
+    /** @param postName      inserted between the method name and the parameters, eg. ".bind(this)"
+     *  @param method        the already resolved method reference, saves looking it up again
+     *  @param discardResult the RETURNING value of this call is not consumed */
+    constructor(postName = "", method, discardResult = false) {
         this.postName = postName;
         this.method = method;
+        this.discardResult = discardResult;
     }
     transpile(node, traversal) {
         let post = "";
@@ -23,7 +26,8 @@ class MethodCallTranspiler {
         const scope = traversal.findCurrentScopeByToken(nameToken);
         const m = this.method ?? traversal.findMethodReference(nameToken, scope);
         let name = nameToken.getStr().toLowerCase();
-        if (traversal.isBuiltinMethod(nameToken)) {
+        const isBuiltin = traversal.isBuiltinMethod(nameToken);
+        if (isBuiltin) {
             // todo: this is not correct, the method name might be shadowed
             name = "abap.builtin." + name + "(";
             if (name === "abap.builtin.line_exists(" || name === "abap.builtin.line_index(") {
@@ -57,9 +61,14 @@ class MethodCallTranspiler {
         if (step === undefined) {
             throw new Error("MethodCallTranspiler, unexpected node");
         }
+        // "IS SUPPLIED" on a RETURNING parameter is true when the call is functional,
+        // the flag is only passed along when the value of this very call is consumed
+        const returning = isBuiltin === true || this.discardResult === true
+            ? undefined
+            : m?.def.getParameters().getReturning()?.getName().toLowerCase();
         const ret = new chunk_1.Chunk();
         ret.append(name, nameToken, traversal);
-        ret.appendChunk(new method_call_param_1.MethodCallParamTranspiler(m?.def).transpile(step, traversal));
+        ret.appendChunk(new method_call_param_1.MethodCallParamTranspiler(m?.def, returning).transpile(step, traversal));
         ret.appendString(post + ")");
         return ret;
     }

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

@@ -3,5 +3,9 @@ import { IExpressionTranspiler } from "./_expression_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class MethodCallChainTranspiler implements IExpressionTranspiler {
+    private readonly discardResult;
+    /** @param discardResult the value of the last call in the chain is not consumed,
+     *                       ie. the chain is a standalone CALL statement */
+    constructor(discardResult?: boolean);
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/method_call_chain.js

@@ -6,9 +6,17 @@ const traversal_1 = require("../traversal");
 const chunk_1 = require("../chunk");
 const method_call_1 = require("./method_call");
 class MethodCallChainTranspiler {
+    discardResult;
+    /** @param discardResult the value of the last call in the chain is not consumed,
+     *                       ie. the chain is a standalone CALL statement */
+    constructor(discardResult = false) {
+        this.discardResult = discardResult;
+    }
     transpile(node, traversal) {
         let ret = new chunk_1.Chunk();
         const children = node.getChildren();
+        const calls = node.findDirectExpressions(core_1.Expressions.MethodCall);
+        const lastCall = calls[calls.length - 1];
         for (const c of children) {
             if (c instanceof core_1.Nodes.ExpressionNode && c.get() instanceof core_1.Expressions.MethodCall) {
                 const isFirst = c === node.getFirstChild();
@@ -26,9 +34,10 @@ class MethodCallChainTranspiler {
                     method = traversal.findMethodReference(nameToken, traversal.findCurrentScopeByToken(nameToken));
                     prefix = traversal.constructorPrototypePrefix(nameToken, method?.def, enclosingClass);
                 }
+                const discard = this.discardResult === true && c === lastCall;
                 const sub = prefix === undefined
-                    ? traversal.traverse(c)
-                    : new method_call_1.MethodCallTranspiler(".bind(this)", method).transpile(c, traversal);
+                    ? new method_call_1.MethodCallTranspiler("", undefined, discard).transpile(c, traversal)
+                    : new method_call_1.MethodCallTranspiler(".bind(this)", method, discard).transpile(c, traversal);
                 if (sub.getCode().startsWith("abap.builtin.")
                     || sub.getCode().startsWith("await abap.builtin.")) {
                     ret.appendChunk(sub);

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

@@ -5,6 +5,12 @@ import { Traversal } from "../traversal";
 import { IExpressionTranspiler } from "./_expression_transpiler";
 export declare class MethodCallParamTranspiler implements IExpressionTranspiler {
     private readonly m;
-    constructor(m?: abaplint.Types.MethodDefinition);
+    private readonly suppliedReturning;
+    /** On a real system "RETURNING IS SUPPLIED" is true exactly when the method is called
+     * functionally, so the caller has to say so.
+     * @param m                 the resolved method definition
+     * @param suppliedReturning name of the RETURNING parameter to flag as supplied,
+     *                          ie. the call is functional and the value is consumed */
+    constructor(m?: abaplint.Types.MethodDefinition, suppliedReturning?: string);
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/method_call_param.js

@@ -3,32 +3,43 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MethodCallParamTranspiler = void 0;
 const core_1 = require("@abaplint/core");
 const chunk_1 = require("../chunk");
+const parameter_list_s_1 = require("./parameter_list_s");
 class MethodCallParamTranspiler {
     m;
-    constructor(m) {
+    suppliedReturning;
+    /** On a real system "RETURNING IS SUPPLIED" is true exactly when the method is called
+     * functionally, so the caller has to say so.
+     * @param m                 the resolved method definition
+     * @param suppliedReturning name of the RETURNING parameter to flag as supplied,
+     *                          ie. the call is functional and the value is consumed */
+    constructor(m, suppliedReturning) {
         this.m = m;
+        this.suppliedReturning = suppliedReturning;
     }
     transpile(node, traversal) {
         let name = "";
         if (!(node.get() instanceof core_1.Expressions.MethodCallParam)) {
             throw new Error("MethodCallParam, unexpected node, " + node?.get().constructor.name);
         }
+        // the RETURNING parameter is passed along when the call is functional, see the constructor
+        const extra = this.suppliedReturning === undefined ? "" : this.suppliedReturning + ": 1";
         const source = node.findDirectExpression(core_1.Expressions.Source);
         if (source) {
             const def = this.m?.getParameters().getDefaultImporting()?.toLowerCase();
             if (this.m === undefined || def === undefined) {
+                // the input is not an object, so there is nowhere to put the RETURNING flag
                 return traversal.traverse(source);
             }
             else {
                 return new chunk_1.Chunk()
                     .appendString("{" + def + ": ")
                     .appendChunk(traversal.traverse(source))
-                    .appendString("}");
+                    .appendString(extra === "" ? "}" : ", " + extra + "}");
             }
         }
         const parameters = node.findDirectExpression(core_1.Expressions.ParameterListS);
         if (parameters) {
-            return traversal.traverse(parameters);
+            return new parameter_list_s_1.ParameterListSTranspiler(extra).transpile(parameters, traversal);
         }
         else {
             const params = node.findDirectExpression(core_1.Expressions.MethodParameters);
@@ -43,7 +54,13 @@ class MethodCallParamTranspiler {
             }
         }
         name = name.replace(/}{/g, ", ");
-        return new chunk_1.Chunk(name);
+        if (extra === "") {
+            return new chunk_1.Chunk(name);
+        }
+        else if (name === "") {
+            return new chunk_1.Chunk("{" + extra + "}");
+        }
+        return new chunk_1.Chunk(name.replace(/}$/, ", " + extra + "}"));
     }
 }
 exports.MethodCallParamTranspiler = MethodCallParamTranspiler;

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

@@ -3,5 +3,8 @@ import { IExpressionTranspiler } from "./_expression_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class ParameterListSTranspiler implements IExpressionTranspiler {
+    private readonly extra;
+    /** @param extra appended as an additional field of the emitted object, eg. "result: 1" */
+    constructor(extra?: string);
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/parameter_list_s.js

@@ -4,6 +4,11 @@ exports.ParameterListSTranspiler = void 0;
 const core_1 = require("@abaplint/core");
 const chunk_1 = require("../chunk");
 class ParameterListSTranspiler {
+    extra;
+    /** @param extra appended as an additional field of the emitted object, eg. "result: 1" */
+    constructor(extra = "") {
+        this.extra = extra;
+    }
     transpile(node, traversal) {
         const parameters = [];
         for (const c of node.getChildren()) {
@@ -11,7 +16,8 @@ class ParameterListSTranspiler {
                 parameters.push(traversal.traverse(c));
             }
         }
-        return new chunk_1.Chunk().appendString("{").join(parameters).appendString("}");
+        const post = this.extra === "" ? "}" : ", " + this.extra + "}";
+        return new chunk_1.Chunk().appendString("{").join(parameters).appendString(post);
     }
 }
 exports.ParameterListSTranspiler = ParameterListSTranspiler;

package/build/src/statements/call.js

@@ -55,7 +55,8 @@ class CallTranspiler {
                 pre = build.pre + pre;
                 post += build.post;
             }
-            const chainChunk = traversal.traverse(chain);
+            // without RECEIVING the value of the last call in the chain is thrown away
+            const chainChunk = new expressions_1.MethodCallChainTranspiler(receiving === undefined).transpile(chain, traversal);
             let chainCode = chainChunk.getCode();
             if (chainCode.startsWith("await super.constructor(")) {
                 // semantics of constructors in JS vs ABAP is different, so the "constructor_" has been introduced,

package/build/src/statements/data.js

@@ -92,12 +92,19 @@ class DataTranspiler {
                 value = "\n" + traversal_1.Traversal.prefixVariable(found.getName().toLowerCase()) + ".set(\"" + enumDefault + "\");";
             }
         }
+        let packedDecimals;
+        if (found.getType() instanceof abaplint.BasicTypes.PackedType) {
+            const decimals = node.findFirstExpression(abaplint.Expressions.Decimals)?.findFirstExpression(abaplint.Expressions.Integer);
+            if (decimals) {
+                packedDecimals = parseInt(decimals.concatTokens(), 10);
+            }
+        }
         this.variableName = traversal_1.Traversal.prefixVariable(traversal_1.Traversal.escapeNamespace(found.getName().toLowerCase()));
         this.loopScoped = traversal.isInsideLoop(node);
         const ret = new chunk_1.Chunk()
             .appendString(this.loopScoped === true ? "var " : "let ")
             .appendString(this.variableName)
-            .appendString(" = " + transpile_types_1.TranspileTypes.toType(found.getType()))
+            .appendString(" = " + transpile_types_1.TranspileTypes.toType(found.getType(), { packedDecimals }))
             .appendString(";")
             .appendString(value);
         if (this.loopScoped === true && this.skipLoopScoping === false) {

package/build/src/statements/method_implementation.js

@@ -128,6 +128,11 @@ class MethodImplementationTranspiler {
                 }
             }
             else if (identifier.getMeta().includes("returning" /* abaplint.IdentifierMeta.MethodReturning */)) {
+                // the caller flags a consumed RETURNING value in INPUT, see MethodCallParamTranspiler,
+                // so "result IS SUPPLIED" needs the parameter even if the method has nothing else
+                if (unique === "") {
+                    unique = "INPUT";
+                }
                 after = after + transpile_types_1.TranspileTypes.declare(identifier) + "\n";
             }
         }

package/build/src/statements/select.js

@@ -56,6 +56,7 @@ class SelectTranspiler {
             throw new Error("SelectTranspiler, UNION DISTINCT todo");
         }
         let target = "undefined";
+        let intoCorrespondingStructure = false;
         if (targetOverride) {
             // SelectLoop structure uses override
             target = targetOverride;
@@ -67,7 +68,9 @@ class SelectTranspiler {
             target = traversal.traverse(node.findFirstExpression(abaplint.Expressions.SQLIntoList)).getCode();
         }
         else if (node.findFirstExpression(abaplint.Expressions.SQLIntoStructure)) {
-            target = traversal.traverse(node.findFirstExpression(abaplint.Expressions.SQLIntoStructure)).getCode();
+            const into = node.findFirstExpression(abaplint.Expressions.SQLIntoStructure);
+            target = traversal.traverse(into).getCode();
+            intoCorrespondingStructure = into.findDirectTokenByText("CORRESPONDING") !== undefined;
         }
         const tokens = node.getTokens();
         const isDistinct = tokens[0]?.getStr().toUpperCase() === "SELECT"
@@ -145,6 +148,9 @@ class SelectTranspiler {
         if (concat.includes(" APPENDING TABLE ") || concat.includes(" APPENDING CORRESPONDING FIELDS OF TABLE ")) {
             runtimeOptionsList.push(`appending: true`);
         }
+        if (intoCorrespondingStructure) {
+            runtimeOptionsList.push(`corresponding: true`);
+        }
         if (runtimeOptionsList.length > 0) {
             runtimeOptions = `, {` + runtimeOptionsList.join(", ") + `}`;
         }

package/build/src/transpile_types.d.ts

@@ -4,5 +4,7 @@ export declare class TranspileTypes {
     static declareStaticSkipVoid(pre: string, t: abaplint.TypedIdentifier): string;
     /** this returns a function, so it doesnt throw when loading the code, only when running */
     static toTypeFunction(type: abaplint.AbstractType): string;
-    static toType(type: abaplint.AbstractType): string;
+    static toType(type: abaplint.AbstractType, options?: {
+        packedDecimals?: number;
+    }): string;
 }

package/build/src/transpile_types.js

@@ -62,7 +62,7 @@ class TranspileTypes {
         // return singleton,
         return "(() => { let _t; return () => (_t ??= " + this.toType(type) + "); })()";
     }
-    static toType(type) {
+    static toType(type, options) {
         let resolved = "";
         let extra = "";
         if (type instanceof abaplint.BasicTypes.ObjectReferenceType
@@ -185,11 +185,12 @@ class TranspileTypes {
         }
         else if (type instanceof abaplint.BasicTypes.PackedType) {
             resolved = "Packed";
+            const decimals = options?.packedDecimals ?? type.getDecimals();
             if (type.getQualifiedName()) {
-                extra = "{length: " + type.getLength() + ", decimals: " + type.getDecimals() + ", qualifiedName: \"" + type.getQualifiedName() + "\"}";
+                extra = "{length: " + type.getLength() + ", decimals: " + decimals + ", qualifiedName: \"" + type.getQualifiedName() + "\"}";
             }
             else {
-                extra = "{length: " + type.getLength() + ", decimals: " + type.getDecimals() + "}";
+                extra = "{length: " + type.getLength() + ", decimals: " + decimals + "}";
             }
         }
         else if (type instanceof abaplint.BasicTypes.NumericGenericType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.13.79",
+  "version": "2.13.82",
   "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.120.44",
+    "@abaplint/core": "^2.120.45",
     "source-map": "^0.8.0"
   },
   "devDependencies": {