@abaplint/transpiler-cli 2.14.11 → 2.14.12

package/build/bundle.js

@@ -29854,6 +29854,7 @@ const expressions_1 = __webpack_require__(/*! ../2_statements/expressions */ "./
 const _builtin_1 = __webpack_require__(/*! ./_builtin */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_builtin.js");
 const position_1 = __webpack_require__(/*! ../../position */ "./node_modules/@abaplint/core/build/src/position.js");
 const _syntax_input_1 = __webpack_require__(/*! ./_syntax_input */ "./node_modules/@abaplint/core/build/src/abap/5_syntax/_syntax_input.js");
+const version_1 = __webpack_require__(/*! ../../version */ "./node_modules/@abaplint/core/build/src/version.js");
 class BasicTypes {
     constructor(input) {
         this.input = input;
@@ -30079,7 +30080,14 @@ class BasicTypes {
         }
         const chainText = typeName.concatTokens().toUpperCase();
         const f = this.input.scope.getDDIC().lookupBuiltinType(chainText, length, decimals, qualifiedName);
-        if (f !== undefined) {
+        if (f instanceof Types.Integer8Type
+            && !(0, version_1.releaseAtLeast)(this.input.scope.getRelease(), version_1.Release.v750)
+            && !this.input.scope.getOpenABAP()) {
+            const message = "Type INT8 requires 7.50";
+            this.input.issues.push((0, _syntax_input_1.syntaxIssue)(this.input, typeName.getFirstToken(), message));
+            return basic_1.VoidType.get(_syntax_input_1.CheckSyntaxKey);
+        }
+        else if (f !== undefined) {
             return f;
         }
         const typ = this.input.scope.findType(chainText);
@@ -44563,6 +44571,10 @@ class InsertInternal {
             if (sourceType instanceof basic_1.IntegerType && targetType instanceof basic_1.Integer8Type) {
                 error = true;
             }
+            else if (targetType instanceof basic_1.TableType && targetType.isWithHeader() && sourceType instanceof basic_1.TableType) {
+                // LINES OF into a table with header line, compare the row types
+                error = new _type_utils_1.TypeUtils(input.scope).isAssignable(sourceType.getRowType(), targetType.getRowType()) === false;
+            }
             else if (new _type_utils_1.TypeUtils(input.scope).isAssignable(sourceType, targetType) === false) {
                 error = true;
             }
@@ -73714,7 +73726,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.js"
-        return "2.120.86";
+        return "2.120.87";
     }
     getDDICReferences() {
         return this.ddicReferences;
@@ -77371,6 +77383,7 @@ const Expressions = __importStar(__webpack_require__(/*! ../abap/2_statements/ex
 const Statements = __importStar(__webpack_require__(/*! ../abap/2_statements/statements */ "./node_modules/@abaplint/core/build/src/abap/2_statements/statements/index.js"));
 const Structures = __importStar(__webpack_require__(/*! ../abap/3_structures/structures */ "./node_modules/@abaplint/core/build/src/abap/3_structures/structures/index.js"));
 const edit_helper_1 = __webpack_require__(/*! ../edit_helper */ "./node_modules/@abaplint/core/build/src/edit_helper.js");
+const tokens_1 = __webpack_require__(/*! ../abap/1_lexer/tokens */ "./node_modules/@abaplint/core/build/src/abap/1_lexer/tokens/index.js");
 class AlignTypeExpressionsConf extends _basic_rule_config_1.BasicRuleConfig {
     constructor() {
         super(...arguments);
@@ -77538,12 +77551,18 @@ ENDINTERFACE.`,
             let column = 0;
             const st = t.findDirectStatements(Statements.Type);
             for (const s of st) {
-                const name = s.getChildren()[1];
+                const children = s.getChildren();
+                const length = s.findDirectExpression(Expressions.ConstantFieldLength);
+                const nameEnd = (length !== null && length !== void 0 ? length : children[1]).getLastToken().getEnd();
+                const after = children[length ? 3 : 2];
+                if (after === undefined || after.getFirstToken() instanceof tokens_1.Punctuation) {
+                    continue; // no TYPE clause, eg. "foo(1)," with implicit type
+                }
                 fields.push({
-                    nameEnd: name.getLastToken().getEnd(),
-                    after: s.getChildren()[2].getFirstToken().getStart()
+                    nameEnd: nameEnd,
+                    after: after.getFirstToken().getStart()
                 });
-                column = Math.max(column, name.getFirstToken().getEnd().getCol() + 1);
+                column = Math.max(column, nameEnd.getCol() + 1);
             }
             issues.push(...this.check(fields, column, file));
         }
@@ -85489,6 +85508,17 @@ Make sure to test the downported code, it might not always be completely correct
                     }
                 }
             }
+            // INSERT with a 702 built-in function as the operand parses in the low version, but 702
+            // reads the function as a method call, "Method SUBSTRING does not exist"
+            if (ret.length === 0) {
+                for (let i = 0; i < lowStatements.length; i++) {
+                    const issue = this.outlineInsertBuiltin(lowStatements[i], highStatements[i], lowFile, highSyntax);
+                    if (issue) {
+                        ret.push(issue);
+                        break;
+                    }
+                }
+            }
             // INTO after WHERE parses as a valid SELECT in the low version, but is only allowed in
             // strict SQL syntax, so move it also when the statement is no longer Unknown
             if (ret.length === 0) {
@@ -86321,6 +86351,40 @@ ${indentation}`);
         }
         return undefined;
     }
+    /** INSERT substring( ... ) INTO TABLE tab, the operand is outlined into a variable */
+    outlineInsertBuiltin(low, high, lowFile, highSyntax) {
+        var _a;
+        if (!(high.get() instanceof Statements.InsertInternal)) {
+            return undefined;
+        }
+        else if (this.lowReg.getConfig().isOpenABAP()) {
+            return undefined;
+        }
+        else if (low.getFirstToken().getStart() instanceof virtual_position_1.VirtualPosition) {
+            return undefined;
+        }
+        // the whole operand is the call, a longer expression is outlined by replaceInsertExpression
+        const source = high.getChildren()[1];
+        if (!(source instanceof nodes_1.ExpressionNode)
+            || !(source.get() instanceof Expressions.SimpleSource4 || source.get() instanceof Expressions.Source)
+            || source.getChildren().length !== 1
+            || !(((_a = source.getFirstChild()) === null || _a === void 0 ? void 0 : _a.get()) instanceof Expressions.MethodCallChain)) {
+            return undefined;
+        }
+        const type = this.builtinReturnType(source, lowFile, highSyntax);
+        if (type === undefined) {
+            return undefined;
+        }
+        const uniqueName = this.uniqueName(high.getFirstToken().getStart(), lowFile.getFilename(), highSyntax);
+        const indentation = " ".repeat(high.getFirstToken().getStart().getCol() - 1);
+        const code = `DATA ${uniqueName} TYPE ${type}.\n` +
+            indentation + `${uniqueName} = ${source.concatTokens()}.\n` +
+            indentation;
+        const fix1 = edit_helper_1.EditHelper.insertAt(lowFile, high.getFirstToken().getStart(), code);
+        const fix2 = edit_helper_1.EditHelper.replaceRange(lowFile, source.getFirstToken().getStart(), source.getLastToken().getEnd(), uniqueName);
+        const fix = edit_helper_1.EditHelper.merge(fix2, fix1);
+        return issue_1.Issue.atToken(lowFile, source.getFirstToken(), "Outline built-in function in INSERT", this.getMetadata().key, this.conf.severity, fix);
+    }
     /** the ABAP type returned by the built-in function this Source starts with, or undefined
      * if it does not start with one, or with one that predates 702 */
     builtinReturnType(source, lowFile, highSyntax) {
@@ -115623,6 +115687,7 @@ exports.PopulateTables = PopulateTables;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.DatabaseSchemaReuse = void 0;
+const OPERATORS = { EQ: "=", NE: "<>", LT: "<", LE: "<=", GT: ">", GE: ">=" };
 class DatabaseSchemaReuse {
     myQuote;
     constructor(quote) {
@@ -115632,31 +115697,68 @@ class DatabaseSchemaReuse {
         return this.myQuote + name.toLowerCase() + this.myQuote;
     }
     buildVIEW(view) {
-        const fields = view.getFields();
-        let firstTabname = "";
-        const columns = fields?.map((f) => {
-            firstTabname = this.quote(f.TABNAME.toLowerCase());
-            return firstTabname + "." + f.FIELDNAME.toLowerCase() + " AS " + f.VIEWFIELD.toLowerCase();
+        const fields = view.getFields() || [];
+        const columns = fields.map((f) => {
+            return this.quote(f.TABNAME) + "." + f.FIELDNAME.toLowerCase() + " AS " + f.VIEWFIELD.toLowerCase();
         }).join(", ");
-        let from = "";
-        let previous = "";
-        for (const j of view.getJoin() || []) {
-            if (previous === "") {
-                from += this.quote(j.LTAB.toLowerCase()) + " INNER JOIN " + this.quote(j.RTAB.toLowerCase()) + " ON " + this.quote(j.LTAB.toLowerCase()) + "." + j.LFIELD.toLowerCase() + " = " + this.quote(j.RTAB.toLowerCase()) + "." + j.RFIELD.toLowerCase();
-            }
-            else if (previous === j.LTAB + "," + j.RTAB) {
-                from += " AND " + this.quote(j.LTAB.toLowerCase()) + "." + j.LFIELD.toLowerCase() + " = " + this.quote(j.RTAB.toLowerCase()) + "." + j.RFIELD.toLowerCase();
-            }
-            else {
-                from += " INNER JOIN " + this.quote(j.RTAB.toLowerCase()) + " ON " + this.quote(j.LTAB.toLowerCase()) + "." + j.LFIELD.toLowerCase() + " = " + this.quote(j.RTAB.toLowerCase()) + "." + j.RFIELD.toLowerCase();
-            }
-            previous = j.LTAB + "," + j.RTAB;
-        }
-        from = from.trim();
-        if (from === "") {
-            from = firstTabname;
-        }
-        return `CREATE VIEW ${this.quote(view.getName().toLowerCase())} AS SELECT ${columns} FROM ${from};\n`;
+        // a DD28J row compares two fields, or without RFIELD a field to the constant in RTAB, eg. 'EN'
+        const joins = view.getJoin() || [];
+        let pending = joins.filter(j => j.RFIELD !== undefined && j.RFIELD !== "");
+        const constants = joins.filter(j => j.RFIELD === undefined || j.RFIELD === "");
+        // start from the table of the first view field, typically the root table, then repeatedly
+        // join a table that has conditions on the tables already joined, LTAB is not always the new one
+        const tables = [];
+        const conditions = {};
+        const add = (table) => {
+            tables.push(table);
+            const on = pending.filter(j => tables.includes(j.LTAB) && tables.includes(j.RTAB));
+            pending = pending.filter(j => on.includes(j) === false);
+            conditions[table] = [...on, ...constants.filter(j => j.LTAB === table)].map(j => this.condition(view, j));
+        };
+        const first = fields[0]?.TABNAME;
+        const root = first !== undefined && (pending.length === 0 || pending.some(j => j.LTAB === first || j.RTAB === first))
+            ? first : (pending[0] || constants[0])?.LTAB;
+        if (root === undefined) {
+            throw new Error(`View ${view.getName()}: no tables`);
+        }
+        add(root);
+        while (pending.length > 0) {
+            // tables without conditions on the joined ones are cross joined
+            const next = pending.find(j => tables.includes(j.LTAB) || tables.includes(j.RTAB)) || pending[0];
+            add(tables.includes(next.LTAB) ? next.RTAB : next.LTAB);
+        }
+        for (const c of constants) {
+            if (tables.includes(c.LTAB) === false) {
+                add(c.LTAB);
+            }
+        }
+        let from = this.quote(tables[0]);
+        for (const table of tables.slice(1)) {
+            from += conditions[table].length === 0
+                ? " CROSS JOIN " + this.quote(table)
+                : " INNER JOIN " + this.quote(table) + " ON " + conditions[table].join(" AND ");
+        }
+        if (conditions[tables[0]].length > 0) {
+            from += " WHERE " + conditions[tables[0]].join(" AND ");
+        }
+        return `CREATE VIEW ${this.quote(view.getName())} AS SELECT ${columns} FROM ${from};\n`;
+    }
+    condition(view, j) {
+        const operator = OPERATORS[j.OPERATOR];
+        if (operator === undefined) {
+            throw new Error(`View ${view.getName()}: join operator ${j.OPERATOR} not supported`);
+        }
+        const right = j.RFIELD === undefined || j.RFIELD === ""
+            ? this.escape(j.RTAB)
+            : this.quote(j.RTAB) + "." + j.RFIELD.toLowerCase();
+        return this.quote(j.LTAB) + "." + j.LFIELD.toLowerCase() + " " + operator + " " + right;
+    }
+    // the constant keeps its single quotes, statements are inside a javascript string template
+    escape(value) {
+        let ret = value.replace(/\\/g, "\\\\");
+        ret = ret.replace(/`/g, "\\`");
+        ret = ret.replace(/\${/g, "\\${");
+        return ret;
     }
 }
 exports.DatabaseSchemaReuse = DatabaseSchemaReuse;
@@ -118863,6 +118965,7 @@ const abaplint = __importStar(__webpack_require__(/*! @abaplint/core */ "./node_
 const chunk_1 = __webpack_require__(/*! ../chunk */ "./node_modules/@abaplint/transpiler/build/src/chunk.js");
 const type_name_or_infer_1 = __webpack_require__(/*! ./type_name_or_infer */ "./node_modules/@abaplint/transpiler/build/src/expressions/type_name_or_infer.js");
 const types_1 = __webpack_require__(/*! ../types */ "./node_modules/@abaplint/transpiler/build/src/types.js");
+const field_assignment_1 = __webpack_require__(/*! ./field_assignment */ "./node_modules/@abaplint/transpiler/build/src/expressions/field_assignment.js");
 class NewObjectTranspiler {
     transpile(node, traversal) {
         const ret = new chunk_1.Chunk();
@@ -118907,10 +119010,48 @@ class NewObjectTranspiler {
             ret.appendString(traversal.toType(type) + ".set(await (new " + clas + "()).constructor_(" + para + "))");
         }
         else {
-            const source = node.findFirstExpression(abaplint.Expressions.Source);
+            // a new data object with a copy of the value, never the source itself; async, as sources can await
             const typeCode = traversal.toType(type);
-            const sourceCode = source === undefined ? typeCode : traversal.traverse(source).getCode();
-            ret.appendString("((() => {const r = new abap.types.DataReference(" + typeCode + "); r.assign(" + sourceCode + "); return r; })())");
+            const setCode = this.buildValue(node, type, traversal);
+            ret.appendString("(await (async () => {const r = new abap.types.DataReference(" + typeCode + "); r.assign(" + typeCode + ");" + setCode + " return r; })())");
+        }
+        return ret;
+    }
+    buildValue(node, type, traversal) {
+        let ret = "";
+        const parameters = node.findDirectExpression(core_1.Expressions.ParameterListS);
+        if (parameters) {
+            // NEW ty( a = 1 b = 2 ), components of a structure
+            for (const p of parameters.findDirectExpressions(core_1.Expressions.ParameterS)) {
+                const name = p.findDirectExpression(core_1.Expressions.ParameterName).concatTokens().toLowerCase();
+                const source = traversal.traverse(p.findDirectExpression(core_1.Expressions.Source)).getCode();
+                ret += ` r.getPointer().setField("${name}", ${source});`;
+            }
+            return ret;
+        }
+        const single = node.getChildren()[3];
+        if (single instanceof core_1.Nodes.ExpressionNode && single.get() instanceof core_1.Expressions.Source) {
+            return ` r.getPointer().set(${traversal.traverse(single).getCode()});`;
+        }
+        else if (!(type instanceof abaplint.BasicTypes.TableType)) {
+            return ret;
+        }
+        // NEW tab( ( 1 ) ( a = 2 ) ), table lines
+        const rowType = traversal.toType(type.getRowType());
+        let row = "";
+        for (const c of node.getChildren().slice(3)) {
+            if (c instanceof core_1.Nodes.TokenNode) {
+                if (c.getFirstToken().getStr() === ")" && row !== "") {
+                    ret += ` r.getPointer().appendThis(${rowType}${row});`;
+                    row = "";
+                }
+            }
+            else if (c.get() instanceof core_1.Expressions.Source) {
+                row += `.set(${traversal.traverse(c).getCode()})`;
+            }
+            else if (c.get() instanceof core_1.Expressions.FieldAssignment && c instanceof core_1.Nodes.ExpressionNode) {
+                row += new field_assignment_1.FieldAssignmentTranspiler().transpile(c, traversal).getCode();
+            }
         }
         return ret;
     }
@@ -135039,6 +135180,9 @@ class ClassImplementationTranspiler {
     transpile(node, traversal) {
         const ret = new chunk_1.Chunk();
         for (const c of node.getChildren()) {
+            if (c.get() instanceof abaplint.Statements.EndClass) {
+                ret.appendString(this.buildPartiallyImplementedStubs(node, traversal));
+            }
             ret.appendChunk(traversal.traverse(c));
             if (c.get() instanceof abaplint.Statements.ClassImplementation) {
                 ret.appendString(this.buildConstructor(node.getFirstStatement(), traversal));
@@ -135054,6 +135198,103 @@ class ClassImplementationTranspiler {
         return ret;
     }
     ///////////////////////////////
+    /** INTERFACES ... PARTIALLY IMPLEMENTED: the interface methods the test class
+     * does not implement exist on a system and raise CX_SY_DYN_CALL_ILLEGAL_METHOD
+     * when called. Emits a method of that shape under the name the implementation
+     * would have had, so the call ends in that exception and not in a TypeError */
+    buildPartiallyImplementedStubs(node, traversal) {
+        const token = node.findFirstExpression(abaplint.Expressions.ClassName)?.getFirstToken();
+        if (token === undefined) {
+            return "";
+        }
+        const cdef = traversal.getClassDefinition(token);
+        const scope = traversal.findCurrentScopeByToken(token);
+        if (cdef === undefined || scope === undefined) {
+            return "";
+        }
+        const partial = cdef.getImplementing().filter(i => i.partial === true);
+        if (partial.length === 0) {
+            return "";
+        }
+        // the methods the class implements itself, by the emitted name
+        const implemented = new Set();
+        for (const m of node.findAllStatements(abaplint.Statements.MethodImplementation)) {
+            const name = m.findFirstExpression(abaplint.Expressions.MethodName)?.getFirstToken().getStr();
+            if (name !== undefined) {
+                implemented.add(traversal_1.Traversal.escapeNamespace(name.replace("~", "$").toLowerCase()));
+            }
+        }
+        // an interface a superclass implements is inherited, with the real implementations,
+        // a stub for one of its methods would override those
+        const inherited = new Set();
+        let sup = cdef.getSuperClass();
+        while (sup !== undefined) {
+            const sdef = traversal.findClassDefinition(sup, scope);
+            for (const name of this.findIncludedInterfaces(sdef?.getImplementing().map(i => i.name) || [], scope, traversal)) {
+                inherited.add(name);
+            }
+            sup = sdef?.getSuperClass();
+        }
+        let ret = "";
+        for (const name of this.findIncludedInterfaces(partial.map(i => i.name), scope, traversal)) {
+            if (inherited.has(name)) {
+                continue;
+            }
+            const intf = traversal.findInterfaceDefinition(name, scope);
+            if (intf === undefined) {
+                continue;
+            }
+            const prefix = traversal_1.Traversal.escapeNamespace(intf.getName().toLowerCase()) + "$";
+            for (const m of intf.getMethodDefinitions().getAll()) {
+                const emitted = prefix + traversal_1.Traversal.escapeNamespace(m.getName().toLowerCase());
+                if (implemented.has(emitted)) {
+                    continue;
+                }
+                implemented.add(emitted);
+                ret += this.buildNotImplementedMethod(emitted, m, token.getStr().toLowerCase(), intf.getName(), token, traversal);
+            }
+        }
+        return ret;
+    }
+    /** the interfaces, upper cased, with the interfaces they include, recursively */
+    findIncludedInterfaces(names, scope, traversal) {
+        const ret = [];
+        const queue = [...names];
+        while (queue.length > 0) {
+            const name = queue.shift().toUpperCase();
+            if (ret.includes(name)) {
+                continue;
+            }
+            ret.push(name);
+            const intf = traversal.findInterfaceDefinition(name, scope);
+            queue.push(...(intf?.getImplementing().map(i => i.name) || []));
+        }
+        return ret;
+    }
+    /** the method a system generates for an interface method the test class leaves
+     * out under PARTIALLY IMPLEMENTED: calling it raises CX_SY_DYN_CALL_ILLEGAL_METHOD
+     * (ABAP keyword documentation, INTERFACES - PARTIALLY IMPLEMENTED), the class and
+     * method named, instead of a JavaScript TypeError no CATCH sees */
+    buildNotImplementedMethod(emitted, m, className, interfaceName, token, traversal) {
+        const unique = m.getParameters().getAll().length > 0 ? "INPUT" : "";
+        const exception = traversal.lookupClassOrInterface("'CX_SY_DYN_CALL_ILLEGAL_METHOD'", token, true);
+        const classUpper = className.toUpperCase();
+        const methodUpper = interfaceName.toUpperCase() + "~" + m.getName().toUpperCase();
+        const notFound = `CX_SY_DYN_CALL_ILLEGAL_METHOD not found, ${classUpper}->${methodUpper} is not implemented`;
+        const body = `if (${exception} === undefined) { throw new Error("${notFound}"); }\n` +
+            `throw await new ${exception}().constructor_({` +
+            `classname: new abap.types.String().set("${classUpper}"), ` +
+            `methodname: new abap.types.String().set("${methodUpper}")});\n`;
+        let ret = "";
+        if (m.isStatic() === true) {
+            // in ABAP static methods can be called with instance arrows, "->"
+            ret += "async " + emitted + "(" + unique + ") {\n" +
+                "return " + traversal_1.Traversal.escapeNamespace(className) + "." + emitted + "(" + unique + ");\n" +
+                "}\n" + "static ";
+        }
+        ret += "async " + emitted + "(" + unique + ") {\n" + body + "}\n";
+        return ret;
+    }
     hasConstructor(node) {
         for (const m of node.findAllStatements(abaplint.Statements.MethodImplementation)) {
             const name = m.findFirstExpression(abaplint.Expressions.MethodName)?.getFirstToken().getStr();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler-cli",
-  "version": "2.14.11",
+  "version": "2.14.12",
   "description": "Transpiler - Command Line Interface",
   "funding": "https://github.com/sponsors/larshp",
   "bin": {
@@ -27,8 +27,8 @@
   "author": "abaplint",
   "license": "MIT",
   "devDependencies": {
-    "@abaplint/core": "^2.120.86",
-    "@abaplint/transpiler": "^2.14.11",
+    "@abaplint/core": "^2.120.87",
+    "@abaplint/transpiler": "^2.14.12",
     "@types/glob": "^9.0.0",
     "@types/node": "^26.6.5",
     "@types/progress": "^2.0.7",