@abaplint/transpiler 2.11.8 → 2.11.10

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

@@ -20,6 +20,7 @@ export * from "./field_offset";
 export * from "./field_symbol";
 export * from "./function_exporting";
 export * from "./source_field_symbol_chain";
+export * from "./type_name_or_infer";
 export * from "./function_parameters";
 export * from "./message_number";
 export * from "./method_call_body";

package/build/src/expressions/index.js

@@ -36,6 +36,7 @@ __exportStar(require("./field_offset"), exports);
 __exportStar(require("./field_symbol"), exports);
 __exportStar(require("./function_exporting"), exports);
 __exportStar(require("./source_field_symbol_chain"), exports);
+__exportStar(require("./type_name_or_infer"), exports);
 __exportStar(require("./function_parameters"), exports);
 __exportStar(require("./message_number"), exports);
 __exportStar(require("./method_call_body"), exports);

package/build/src/expressions/source.js

@@ -16,7 +16,7 @@ class SourceTranspiler {
         const children = node.getChildren();
         for (let i = 0; i < children.length; i++) {
             const c = children[i];
-            const last = i === children.length - 1;
+            const isLast = i === children.length - 1;
             if (c instanceof core_1.Nodes.ExpressionNode) {
                 if (c.get() instanceof core_1.Expressions.FieldChain) {
                     ret.appendChunk(new _1.FieldChainTranspiler(this.addGet).transpile(c, traversal));
@@ -43,7 +43,7 @@ class SourceTranspiler {
                     if (code.includes("await")) {
                         ret = new chunk_1.Chunk().appendString("(").appendChunk(ret).appendString(")");
                     }
-                    if (this.addGet && last === true) {
+                    if (this.addGet && isLast === true) {
                         ret.append(".get()", c, traversal);
                     }
                 }
@@ -59,7 +59,7 @@ class SourceTranspiler {
                 else if (c.get() instanceof core_1.Expressions.ComponentChain) {
                     ret = new chunk_1.Chunk().appendString("(").appendChunk(ret).appendString(").get().");
                     ret.appendChunk(new _1.ComponentChainTranspiler().transpile(c, traversal));
-                    if (this.addGet && last === true) {
+                    if (this.addGet && isLast === true) {
                         ret.append(".get()", c, traversal);
                     }
                 }
@@ -69,6 +69,17 @@ class SourceTranspiler {
                 else if (c.get() instanceof core_1.Expressions.TextElement) {
                     ret = new chunk_1.Chunk().appendString(`new abap.types.String().set("${c.concatTokens()}")`);
                 }
+                else if (c.get() instanceof core_1.Expressions.ConvBody) {
+                    const typ = node.findFirstExpression(core_1.Expressions.TypeNameOrInfer);
+                    if (typ === undefined) {
+                        throw new Error("TypeNameOrInfer not found in ConvBody");
+                    }
+                    ret = new chunk_1.Chunk().appendString(new _1.TypeNameOrInfer().transpile(typ, traversal).getCode());
+                    ret.appendString(".set(");
+                    // todo: handle LET
+                    ret.appendString(traversal.traverse(c.getFirstChild()).getCode());
+                    ret.appendString(")");
+                }
                 else {
                     ret.appendString("SourceUnknown-" + c.get().constructor.name);
                 }

package/build/src/expressions/type_name_or_infer.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 TypeNameOrInfer implements IExpressionTranspiler {
+    transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
+}

package/build/src/expressions/type_name_or_infer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeNameOrInfer = void 0;
+const chunk_1 = require("../chunk");
+const transpile_types_1 = require("../transpile_types");
+class TypeNameOrInfer {
+    transpile(node, traversal) {
+        let type;
+        const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
+        if (node.concatTokens() === "#") {
+            type = traversal.lookupInferred(node, scope);
+        }
+        else {
+            type = traversal.lookupType(node.getFirstChild(), scope);
+        }
+        if (type === undefined) {
+            throw new Error("TypeNameOrInfer, type not found: " + node.concatTokens());
+        }
+        const ret = new chunk_1.Chunk();
+        ret.appendString(new transpile_types_1.TranspileTypes().toType(type));
+        return ret;
+    }
+}
+exports.TypeNameOrInfer = TypeNameOrInfer;
+//# sourceMappingURL=type_name_or_infer.js.map

package/build/src/statements/loop.js

@@ -20,7 +20,8 @@ class LoopTranspiler {
         if (!(node.get() instanceof abaplint.Statements.Loop)) {
             throw new Error("LoopTranspiler, unexpected node");
         }
-        const source = traversal.traverse(node.findDirectExpression(abaplint.Expressions.SimpleSource2)).getCode();
+        const loopSource = node.findDirectExpression(abaplint.Expressions.LoopSource)?.getFirstChild();
+        const source = traversal.traverse(loopSource).getCode();
         this.unique = unique_identifier_1.UniqueIdentifier.get();
         let target = "";
         const into = node.findDirectExpression(abaplint.Expressions.LoopTarget)?.findDirectExpression(abaplint.Expressions.Target);

package/build/src/statements/message.js

@@ -41,7 +41,7 @@ class MessageTranspiler {
         }
         else {
             // exception or constant based
-            const exception = node.findDirectExpression(abaplint.Expressions.SimpleSource3);
+            const exception = node.findDirectExpression(abaplint.Expressions.MessageSourceSource)?.findDirectExpression(abaplint.Expressions.Source);
             const str = exception?.findFirstExpression(abaplint.Expressions.Constant);
             if (str) {
                 options.push("text: " + traversal.traverse(str).getCode());
@@ -64,11 +64,10 @@ class MessageTranspiler {
             if (c.getFirstToken().getStr().toUpperCase() === "WITH") {
                 withs = true;
             }
-            else if (withs === true && c.get() instanceof abaplint.Expressions.Source) {
-                w.push(traversal.traverse(c).getCode());
-            }
-            else if (withs === true && c.get() instanceof abaplint.Expressions.SimpleSource3) {
-                w.push(traversal.traverse(c).getCode());
+            else if (withs === true
+                && c.get() instanceof abaplint.Expressions.MessageSourceSource
+                && c instanceof abaplint.Nodes.ExpressionNode) {
+                w.push(traversal.traverse(c.getFirstChild()).getCode());
             }
             else if (withs === true) {
                 break;

package/build/src/statements/move.js

@@ -12,21 +12,63 @@ class MoveTranspiler {
         }
         const ret = new chunk_1.Chunk();
         const second = node.getChildren()[1]?.concatTokens();
-        if (second === "?=") {
-            ret.appendString("await abap.statements.cast(")
-                .appendChunk(targets[0])
-                .appendString(", ")
-                .appendChunk(source)
-                .append(");", node.getLastToken(), traversal);
-        }
-        else {
-            for (const target of targets.reverse()) {
-                ret.appendChunk(target)
-                    .appendString(".set(")
+        switch (second) {
+            case "?=":
+                ret.appendString("await abap.statements.cast(")
+                    .appendChunk(targets[0])
+                    .appendString(", ")
                     .appendChunk(source)
                     .append(");", node.getLastToken(), traversal);
-                source = target;
-            }
+                break;
+            case "+":
+                ret.appendChunk(targets[0])
+                    .appendString(".set(abap.operators.add(")
+                    .appendChunk(targets[0])
+                    .appendString(", ")
+                    .appendChunk(source)
+                    .append("));", node.getLastToken(), traversal);
+                break;
+            case "-":
+                ret.appendChunk(targets[0])
+                    .appendString(".set(abap.operators.minus(")
+                    .appendChunk(targets[0])
+                    .appendString(", ")
+                    .appendChunk(source)
+                    .append("));", node.getLastToken(), traversal);
+                break;
+            case "/=":
+                ret.appendChunk(targets[0])
+                    .appendString(".set(abap.operators.divide(")
+                    .appendChunk(targets[0])
+                    .appendString(", ")
+                    .appendChunk(source)
+                    .append("));", node.getLastToken(), traversal);
+                break;
+            case "*=":
+                ret.appendChunk(targets[0])
+                    .appendString(".set(abap.operators.multiply(")
+                    .appendChunk(targets[0])
+                    .appendString(", ")
+                    .appendChunk(source)
+                    .append("));", node.getLastToken(), traversal);
+                break;
+            case "&&=":
+                ret.appendChunk(targets[0])
+                    .appendString(".set(abap.operators.concat(")
+                    .appendChunk(targets[0])
+                    .appendString(", ")
+                    .appendChunk(source)
+                    .append("));", node.getLastToken(), traversal);
+                break;
+            default:
+                for (const target of targets.reverse()) {
+                    ret.appendChunk(target)
+                        .appendString(".set(")
+                        .appendChunk(source)
+                        .append(");", node.getLastToken(), traversal);
+                    source = target;
+                }
+                break;
         }
         return ret;
     }

package/build/src/transpile_types.js

@@ -82,24 +82,8 @@ class TranspileTypes {
             const list = [];
             const suffix = {};
             const asInclude = {};
-            /*
-            const skipFields: Set<string> = new Set();
-      
-            for (const c of type.getComponents()) {
-              if (c.type instanceof abaplint.BasicTypes.StructureType) {
-                for (const f of c.type.getComponents()) {
-                  skipFields.add(f.name.toLowerCase());
-                }
-              }
-            }
-              */
             for (const c of type.getComponents()) {
                 const lower = c.name.toLowerCase();
-                /*
-                if (skipFields.has(lower)) {
-                  continue; // skip fields from nested structures
-                }
-                */
                 list.push(`"` + lower + `": ` + this.toType(c.type));
                 if (c.suffix) {
                     suffix[lower] = c.suffix;

package/build/src/traversal.d.ts

@@ -39,6 +39,8 @@ export declare class Traversal {
     isTypePool(token: abaplint.Token): string | undefined;
     isInterfaceAttribute(token: abaplint.Token): string | undefined;
     private findReadOrWriteReference;
+    private findInferredTypeReference;
+    private findTypeReference;
     private buildThisAttributes;
     private buildFriendsAccess;
     buildConstructorContents(scope: abaplint.ISpaghettiScopeNode | undefined, def: abaplint.IClassDefinition): string;
@@ -48,6 +50,8 @@ export declare class Traversal {
     findClassDefinition(name: string | undefined, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.IClassDefinition | undefined;
     private dataFromInterfaces;
     private aliasesFromInterfaces;
+    lookupType(node: abaplint.Nodes.ExpressionNode, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.AbstractType | undefined;
+    lookupInferred(node: abaplint.Nodes.ExpressionNode, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.AbstractType | undefined;
     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;

package/build/src/traversal.js

@@ -402,6 +402,36 @@ class Traversal {
         }
         return undefined;
     }
+    findInferredTypeReference(token) {
+        const scope = this.findCurrentScopeByToken(token);
+        if (scope === undefined) {
+            return undefined;
+        }
+        for (const r of scope.getData().references) {
+            if (r.referenceType === abaplint.ReferenceType.InferredType
+                && r.position.getStart().equals(token.getStart())) {
+                if (r.resolved instanceof abaplint.TypedIdentifier) {
+                    return r.resolved.getType();
+                }
+            }
+        }
+        return undefined;
+    }
+    findTypeReference(token) {
+        const scope = this.findCurrentScopeByToken(token);
+        if (scope === undefined) {
+            return undefined;
+        }
+        for (const r of scope.getData().references) {
+            if (r.referenceType === abaplint.ReferenceType.TypeReference
+                && r.position.getStart().equals(token.getStart())) {
+                if (r.resolved instanceof abaplint.TypedIdentifier) {
+                    return r.resolved.getType();
+                }
+            }
+        }
+        return undefined;
+    }
     buildThisAttributes(def, cName) {
         let ret = "";
         for (const a of def.getAttributes()?.getAll() || []) {
@@ -574,6 +604,50 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         }
         return ret;
     }
+    lookupType(node, scope) {
+        if (scope === undefined) {
+            return undefined;
+        }
+        else if (!(node.get() instanceof abaplint.Expressions.TypeName)) {
+            throw new Error("lookupType, node is not a TypeName, " + node.get());
+        }
+        const name = node.concatTokens().toLowerCase();
+        switch (name) {
+            case "i":
+                return abaplint.BasicTypes.IntegerType.get();
+            case "f":
+                return new abaplint.BasicTypes.FloatType();
+            case "string":
+                return abaplint.BasicTypes.StringType.get();
+            case "xstring":
+                return abaplint.BasicTypes.XStringType.get();
+            case "d":
+                return new abaplint.BasicTypes.DateType();
+            case "t":
+                return new abaplint.BasicTypes.TimeType();
+            default:
+                break;
+        }
+        const found = this.findTypeReference(node.getFirstToken());
+        if (found !== undefined) {
+            return found;
+        }
+        const dtel = this.reg.getObject("DTEL", name);
+        if (dtel) {
+            return dtel.parseType(this.reg);
+        }
+        // todo: yea, well, yea
+        throw new Error("lookupType, type not found, " + node.concatTokens());
+    }
+    lookupInferred(node, scope) {
+        if (scope === undefined) {
+            return undefined;
+        }
+        else if (node.concatTokens() !== "#") {
+            throw new Error("lookupInferred, unexpected, " + node.get());
+        }
+        return this.findInferredTypeReference(node.getFirstToken());
+    }
     determineType(node, scope) {
         if (scope === undefined) {
             return undefined;

package/build/src/types.d.ts

@@ -63,4 +63,6 @@ export interface ITranspilerOptions {
     ignoreSourceMap?: boolean;
     /** import programs */
     importProg?: boolean;
+    /** skips version check, not recommended */
+    skipVersionCheck?: boolean;
 }

package/build/src/validation.js

@@ -121,6 +121,13 @@ class Validation {
             // this is not a constant, just a regex that happens to not match anything
             exports.config.syntax.errorNamespace = "VOID_EVERYTHING";
         }
+        if (this.options?.skipVersionCheck === true) {
+            // todo, set it to abaplint default version
+            exports.config.syntax.version = core_1.Version.v758;
+        }
+        else {
+            exports.config.syntax.version = core_1.Version.OpenABAP;
+        }
         const conf = new core_1.Config(JSON.stringify(exports.config));
         reg.setConfig(conf);
         const issues = reg.findIssues();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.11.8",
+  "version": "2.11.10",
   "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.153",
+    "@abaplint/core": "^2.113.155",
     "source-map": "^0.7.6"
   },
   "devDependencies": {