@abaplint/transpiler 2.1.86 → 2.1.88

package/build/src/expressions/compare_operator.js

@@ -40,6 +40,12 @@ class CompareOperatorTranspiler {
                 return new chunk_1.Chunk().append("na", node, traversal);
             case "NP":
                 return new chunk_1.Chunk().append("np", node, traversal);
+            case "O":
+                return new chunk_1.Chunk().append("o", node, traversal);
+            case "Z":
+                return new chunk_1.Chunk().append("z", node, traversal);
+            case "M":
+                return new chunk_1.Chunk().append("m", node, traversal);
             default:
                 return new chunk_1.Chunk().append("compareoperatortodo" + op, node, traversal);
         }

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

@@ -6,4 +6,6 @@ export declare class SQLCondTranspiler implements IExpressionTranspiler {
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
     private sqlIn;
     private basicCondition;
+    private sqlSource;
+    private basicConditionNew;
 }

package/build/src/expressions/sql_cond.js

@@ -55,15 +55,29 @@ class SQLCondTranspiler {
     basicCondition(c, traversal) {
         let ret = "";
         if (c.getChildren().length !== 3) {
-            throw new Error("SQL Condition, transpiler todo, " + c.concatTokens() + ", " + c.getChildren().length);
+            return this.basicConditionNew(c, traversal);
+            //      throw new Error("SQL Condition, transpiler todo1, " + c.concatTokens() + ", " + c.getChildren().length);
         }
         const fieldName = c.findDirectExpression(abaplint.Expressions.SQLFieldName);
         const operator = c.findDirectExpression(abaplint.Expressions.SQLCompareOperator);
         const source = c.findDirectExpression(abaplint.Expressions.SQLSource);
         if (fieldName === undefined || operator === undefined || source === undefined) {
-            throw new Error("SQL Condition, transpiler todo, " + c.concatTokens());
+            throw new Error("SQL Condition, transpiler todo2, " + c.concatTokens());
         }
         ret += fieldName.concatTokens() + " " + operator.concatTokens() + " ";
+        ret += this.sqlSource(source, traversal);
+        /*
+        const simple = source.findDirectExpression(abaplint.Expressions.SimpleSource3);
+        if (simple && simple.findDirectExpression(abaplint.Expressions.Constant) === undefined) {
+          ret += "'\" + " + new SimpleSource3Transpiler(true).transpile(simple, traversal).getCode() + " + \"'";
+        } else {
+          ret += source.concatTokens();
+        }
+        */
+        return ret;
+    }
+    sqlSource(source, traversal) {
+        let ret = "";
         const simple = source.findDirectExpression(abaplint.Expressions.SimpleSource3);
         if (simple && simple.findDirectExpression(abaplint.Expressions.Constant) === undefined) {
             ret += "'\" + " + new simple_source3_1.SimpleSource3Transpiler(true).transpile(simple, traversal).getCode() + " + \"'";
@@ -73,6 +87,25 @@ class SQLCondTranspiler {
         }
         return ret;
     }
+    basicConditionNew(node, traversal) {
+        let ret = "";
+        for (const child of node.getChildren()) {
+            if (ret !== "") {
+                ret += " ";
+            }
+            if (child.get() instanceof abaplint.Expressions.SQLFieldName) {
+                ret += child.concatTokens();
+            }
+            else if (child.get() instanceof abaplint.Expressions.SQLSource
+                && child instanceof abaplint.Nodes.ExpressionNode) {
+                ret += this.sqlSource(child, traversal);
+            }
+            else {
+                ret += child.concatTokens();
+            }
+        }
+        return ret;
+    }
 }
 exports.SQLCondTranspiler = SQLCondTranspiler;
 //# sourceMappingURL=sql_cond.js.map

package/build/src/statements/check.d.ts

@@ -4,5 +4,4 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class CheckTranspiler implements IStatementTranspiler {
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
-    private isInsideLoop;
 }

package/build/src/statements/check.js

@@ -11,7 +11,7 @@ class CheckTranspiler {
         ret.append("if (!(", node, traversal);
         ret.appendChunk(cond);
         ret.appendString(")) {\n");
-        if (this.isInsideLoop(node, traversal)) {
+        if (traversal.isInsideLoop(node)) {
             ret.appendString("continue;");
         }
         else {
@@ -20,28 +20,6 @@ class CheckTranspiler {
         ret.append("\n}", node.getLastToken(), traversal);
         return ret;
     }
-    isInsideLoop(node, traversal) {
-        const stack = [];
-        for (const statement of traversal.getFile().getStatements()) {
-            const get = statement.get();
-            if (get instanceof abaplint.Statements.Loop
-                || get instanceof abaplint.Statements.While
-                || get instanceof abaplint.Statements.SelectLoop
-                || get instanceof abaplint.Statements.Do) {
-                stack.push(statement);
-            }
-            else if (get instanceof abaplint.Statements.EndLoop
-                || get instanceof abaplint.Statements.EndWhile
-                || get instanceof abaplint.Statements.EndSelect
-                || get instanceof abaplint.Statements.EndDo) {
-                stack.pop();
-            }
-            if (statement === node) {
-                break;
-            }
-        }
-        return stack.length > 0;
-    }
 }
 exports.CheckTranspiler = CheckTranspiler;
 //# sourceMappingURL=check.js.map

package/build/src/statements/exit.js

@@ -2,9 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExitTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const return_1 = require("./return");
 class ExitTranspiler {
     transpile(node, traversal) {
-        return new chunk_1.Chunk().append("break;", node, traversal);
+        if (traversal.isInsideLoop(node)) {
+            return new chunk_1.Chunk().append("break;", node, traversal);
+        }
+        else {
+            return new return_1.ReturnTranspiler().transpile(node, traversal);
+        }
     }
 }
 exports.ExitTranspiler = ExitTranspiler;

package/build/src/traversal.d.ts

@@ -37,6 +37,7 @@ export declare class Traversal {
     findClassDefinition(name: string, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.IClassDefinition | undefined;
     private dataFromInterfaces;
     determineType(node: abaplint.Nodes.ExpressionNode | abaplint.Nodes.StatementNode, scope: abaplint.ISpaghettiScopeNode | undefined): abaplint.AbstractType | undefined;
+    isInsideLoop(node: abaplint.Nodes.StatementNode): boolean;
     registerClassOrInterface(def: abaplint.IClassDefinition | abaplint.IInterfaceDefinition | undefined): string;
     lookupClassOrInterface(name: string | undefined, token: abaplint.Token | undefined, directGlobal?: boolean): string;
     private buildPrefix;

package/build/src/traversal.js

@@ -271,7 +271,7 @@ class Traversal {
         }
         // handle aliases after initialization of carrier variables
         for (const a of def.getAliases().getAll()) {
-            ret += "this." + a.getName().toLowerCase() + " = this." + a.getComponent().replace("~", "$").toLowerCase() + ";\n";
+            ret += "this." + a.getName().toLowerCase() + " = this." + Traversal.escapeClassName(a.getComponent().replace("~", "$").toLowerCase()) + ";\n";
         }
         // constants can be accessed both statically and via reference
         for (const c of def.getAttributes().getConstants()) {
@@ -350,7 +350,28 @@ class Traversal {
         }
         return context;
     }
-    ////////////////////////////
+    isInsideLoop(node) {
+        const stack = [];
+        for (const statement of this.getFile().getStatements()) {
+            const get = statement.get();
+            if (get instanceof abaplint.Statements.Loop
+                || get instanceof abaplint.Statements.While
+                || get instanceof abaplint.Statements.SelectLoop
+                || get instanceof abaplint.Statements.Do) {
+                stack.push(statement);
+            }
+            else if (get instanceof abaplint.Statements.EndLoop
+                || get instanceof abaplint.Statements.EndWhile
+                || get instanceof abaplint.Statements.EndSelect
+                || get instanceof abaplint.Statements.EndDo) {
+                stack.pop();
+            }
+            if (statement === node) {
+                break;
+            }
+        }
+        return stack.length > 0;
+    }
     registerClassOrInterface(def) {
         if (def === undefined) {
             return "";

package/build/src/validation.js

@@ -30,10 +30,12 @@ exports.config = {
         "allowed_object_types": {
             "allowed": ["INTF", "CLAS", "PROG", "DEVC", "TABL", "SHLP", "XSLT", "SHMA", "SICF", "NROB", "TYPE", "DTEL", "DOMA", "TTYP", "MSAG", "FUGR"],
         },
-        "exit_or_check": {
-            "allowCheck": true,
-            "allowExit": false,
-        },
+        /*
+            "exit_or_check": {
+              "allowCheck": true,
+              "allowExit": false,
+            },
+        */
         "unknown_types": true,
         "ambiguous_statement": true,
         "implement_methods": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.1.86",
+  "version": "2.1.88",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",