@abaplint/core 2.80.1 → 2.80.5

package/build/src/abap/2_statements/statements/replace.js

@@ -7,7 +7,7 @@ class Replace {
     getMatcher() {
         const length = (0, combi_1.seq)("LENGTH", expressions_1.Source);
         const offset = (0, combi_1.seq)("OFFSET", expressions_1.Source);
-        const section = (0, combi_1.seq)((0, combi_1.opt)("IN"), "SECTION", (0, combi_1.per)(offset, length), "OF", expressions_1.Source);
+        const section = (0, combi_1.seq)((0, combi_1.opt)("IN"), "SECTION", (0, combi_1.per)(offset, length), "OF", expressions_1.Target);
         const source = (0, combi_1.seq)((0, combi_1.opt)("OF"), expressions_1.FindType, expressions_1.Source);
         const cas = (0, combi_1.alt)("IGNORING CASE", "RESPECTING CASE");
         const repl = (0, combi_1.seq)("REPLACEMENT COUNT", expressions_1.Target);

package/build/src/abap/5_syntax/basic_types.js

@@ -455,6 +455,7 @@ class BasicTypes {
                 // lookup in local and global scope
                 const obj = this.scope.findObjectDefinition(className);
                 if (obj === undefined && this.scope.getDDIC().inErrorNamespace(className) === false) {
+                    this.scope.addReference(expr.getFirstToken(), undefined, _reference_1.ReferenceType.ObjectOrientedVoidReference, this.filename, { ooName: className.toUpperCase() });
                     return new Types.VoidType(className);
                 }
                 else if (obj === undefined) {

package/build/src/abap/flow/flow_graph.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowGraph = void 0;
+class FlowGraph {
+    constructor(counter) {
+        this.label = "undefined";
+        this.edges = {};
+        this.start = "start#" + counter;
+        this.end = "end#" + counter;
+    }
+    getStart() {
+        return this.start;
+    }
+    getEnd() {
+        return this.end;
+    }
+    addEdge(from, to) {
+        if (this.edges[from] === undefined) {
+            this.edges[from] = {};
+        }
+        this.edges[from][to] = true;
+    }
+    removeEdge(from, to) {
+        if (this.edges[from] === undefined) {
+            return;
+        }
+        delete this.edges[from][to];
+        if (Object.keys(this.edges[from]).length === 0) {
+            delete this.edges[from];
+        }
+    }
+    listEdges() {
+        const list = [];
+        for (const from of Object.keys(this.edges)) {
+            for (const to of Object.keys(this.edges[from])) {
+                list.push({ from, to });
+            }
+        }
+        return list;
+    }
+    listNodes() {
+        const set = new Set();
+        for (const l of this.listEdges()) {
+            set.add(l.from);
+            set.add(l.to);
+        }
+        return Array.from(set.values());
+    }
+    hasEdges() {
+        return Object.keys(this.edges).length > 0;
+    }
+    /** return value: end node of to graph */
+    addGraph(from, to) {
+        if (to.hasEdges() === false) {
+            return from;
+        }
+        this.addEdge(from, to.getStart());
+        to.listEdges().forEach(e => this.addEdge(e.from, e.to));
+        return to.getEnd();
+    }
+    toJSON() {
+        return JSON.stringify(this.edges);
+    }
+    toTextEdges() {
+        let graph = "";
+        for (const l of this.listEdges()) {
+            graph += `"${l.from}" -> "${l.to}";\n`;
+        }
+        return graph.trim();
+    }
+    setLabel(label) {
+        this.label = label;
+    }
+    toDigraph() {
+        return `digraph G {
+labelloc="t";
+label="${this.label}";
+graph [fontname = "helvetica"];
+node [fontname = "helvetica"];
+edge [fontname = "helvetica"];
+${this.toTextEdges()}
+}`;
+    }
+    listSources(node) {
+        const set = new Set();
+        for (const l of this.listEdges()) {
+            if (node === l.to) {
+                set.add(l.from);
+            }
+        }
+        return Array.from(set.values());
+    }
+    listTargets(node) {
+        const set = new Set();
+        for (const l of this.listEdges()) {
+            if (node === l.from) {
+                set.add(l.to);
+            }
+        }
+        return Array.from(set.values());
+    }
+    /** removes all nodes containing "#" that have one ingoing and one outgoing edge */
+    reduce() {
+        for (const node of this.listNodes()) {
+            if (node.includes("#") === false) {
+                continue;
+            }
+            const sources = this.listSources(node);
+            const targets = this.listTargets(node);
+            if (sources.length > 0 && targets.length > 0) {
+                // hash node in the middle of the graph
+                for (const s of sources) {
+                    this.removeEdge(s, node);
+                }
+                for (const t of targets) {
+                    this.removeEdge(node, t);
+                }
+                for (const s of sources) {
+                    for (const t of targets) {
+                        this.addEdge(s, t);
+                    }
+                }
+            }
+            if (node.startsWith("end#") && sources.length === 0) {
+                for (const t of targets) {
+                    this.removeEdge(node, t);
+                }
+            }
+        }
+        return this;
+    }
+}
+exports.FlowGraph = FlowGraph;
+//# sourceMappingURL=flow_graph.js.map

package/build/src/abap/flow/statement_flow.js

@@ -1,195 +1,184 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatementFlow = exports.dumpFlow = void 0;
+exports.StatementFlow = void 0;
 const nodes_1 = require("../nodes");
 const Structures = require("../3_structures/structures");
 const Statements = require("../2_statements/statements");
-function dumpFlow(flows) {
-    const ret = "[" + flows.map(f => "[" + f.statements.map(b => b === null || b === void 0 ? void 0 : b.get().constructor.name).join(",") + "]").join(",");
-    return ret + "]";
-}
-exports.dumpFlow = dumpFlow;
-function findBody(f) {
-    var _a;
-    return ((_a = f.findDirectStructure(Structures.Body)) === null || _a === void 0 ? void 0 : _a.getChildren()) || [];
-}
-function removeDuplicates(flows) {
-    const result = [];
-    for (const f of flows) {
-        let duplicate = false;
-        for (const r of result) {
-            if (f.statements.length !== r.statements.length) {
-                continue;
-            }
-            duplicate = true;
-            for (let index = 0; index < f.statements.length; index++) {
-                if (f.statements[index] !== r.statements[index]) {
-                    duplicate = false;
-                    break;
-                }
-            }
-        }
-        if (duplicate === false) {
-            result.push(f);
-        }
-    }
-    return result;
-}
-function pruneByStatement(flows, type) {
-    const result = [];
-    for (const f of flows) {
-        const nodes = [];
-        for (const n of f.statements) {
-            nodes.push(n);
-            if (n.get() instanceof type) {
-                break;
-            }
-        }
-        result.push({ statements: nodes });
-    }
-    return removeDuplicates(result);
-}
-////////////////////////////////////////////////////////////////
+const Expressions = require("../2_statements/expressions");
+const flow_graph_1 = require("./flow_graph");
+// Levels: top, FORM, METHOD, FUNCTION-MODULE, (MODULE, AT, END-OF-*, GET, START-OF-SELECTION, TOP-OF-PAGE)
+//
+// Loop branching: LOOP, DO, WHILE,SELECT(loop), WITH, PROVIDE
+//
+// Branching: IF, CASE, CASE TYPE OF, TRY, ON, CATCH SYSTEM-EXCEPTIONS, AT
+//
+// Conditional exits: CHECK, ASSERT
+//
+// Exits: RETURN, EXIT, RAISE(not RESUMABLE), MESSAGE(type E and A?), CONTINUE, REJECT, RESUME, STOP
+//
+// Not handled? INCLUDE + malplaced macro calls
+/////////////////////////////////////
+// TODO: handling static exceptions(only static), refactor some logic from UncaughtException to common file
+// TODO: RAISE
 class StatementFlow {
+    constructor() {
+        this.counter = 0;
+    }
     build(stru) {
+        var _a, _b;
         const ret = [];
         const forms = stru.findAllStructures(Structures.Form);
         for (const f of forms) {
-            ret.push(...this.traverseBody(findBody(f)));
+            const formName = "FORM " + ((_a = f.findFirstExpression(Expressions.FormName)) === null || _a === void 0 ? void 0 : _a.concatTokens());
+            this.counter = 1;
+            const graph = this.traverseBody(this.findBody(f), "end#1", undefined);
+            graph.setLabel(formName);
+            ret.push(graph);
         }
         const methods = stru.findAllStructures(Structures.Method);
         for (const f of methods) {
-            ret.push(...this.traverseBody(findBody(f)));
+            const methodName = "METHOD " + ((_b = f.findFirstExpression(Expressions.MethodName)) === null || _b === void 0 ? void 0 : _b.concatTokens());
+            this.counter = 1;
+            const graph = this.traverseBody(this.findBody(f), "end#1", undefined);
+            graph.setLabel(methodName);
+            ret.push(graph);
         }
-        return ret;
+        return ret.map(f => f.reduce());
+    }
+    findBody(f) {
+        var _a;
+        return ((_a = f.findDirectStructure(Structures.Body)) === null || _a === void 0 ? void 0 : _a.getChildren()) || [];
     }
-    traverseBody(children) {
-        let flows = [{ statements: [] }];
+    buildName(statement) {
+        // note: there might be multiple statements on the same line
+        return statement.get().constructor.name +
+            ":" + statement.getFirstToken().getRow() +
+            "," + statement.getFirstToken().getCol();
+    }
+    traverseBody(children, procedureEnd, loopStart) {
+        const graph = new flow_graph_1.FlowGraph(this.counter++);
         if (children.length === 0) {
-            return [];
+            graph.addEdge(graph.getStart(), graph.getEnd());
+            return graph;
         }
-        for (let i = 0; i < children.length; i++) {
-            const c = children[i];
-            //      console.dir(c);
+        let current = graph.getStart();
+        for (const c of children) {
             if (c.get() instanceof Structures.Normal) {
                 const firstChild = c.getFirstChild(); // "Normal" only has one child
                 if (firstChild instanceof nodes_1.StatementNode) {
-                    flows.forEach(f => f.statements.push(firstChild));
-                    //          current.push(firstChild);
-                    //          console.dir("push: " + firstChild.constructor.name);
-                    if (firstChild.get() instanceof Statements.Check
-                        || firstChild.get() instanceof Statements.Assert) {
-                        const after = children.slice(i + 1, children.length);
-                        for (const b of this.traverseBody(after)) {
-                            for (const f of [...flows]) {
-                                flows.push({ statements: [...f.statements, ...b.statements] });
-                            }
+                    const name = this.buildName(firstChild);
+                    graph.addEdge(current, name);
+                    current = name;
+                    if (firstChild.get() instanceof Statements.Check) {
+                        if (loopStart) {
+                            graph.addEdge(name, loopStart);
+                        }
+                        else {
+                            graph.addEdge(name, procedureEnd);
                         }
-                        break;
+                    }
+                    else if (firstChild.get() instanceof Statements.Assert) {
+                        graph.addEdge(name, procedureEnd);
+                    }
+                    else if (firstChild.get() instanceof Statements.Continue && loopStart) {
+                        graph.addEdge(name, loopStart);
+                        return graph;
                     }
                     else if (firstChild.get() instanceof Statements.Exit) {
-                        break;
+                        if (loopStart) {
+                            // hmm, perhaps this should hit loop end instead?
+                            graph.addEdge(name, loopStart);
+                        }
+                        else {
+                            graph.addEdge(name, procedureEnd);
+                        }
+                        return graph;
                     }
                     else if (firstChild.get() instanceof Statements.Return) {
-                        break;
+                        graph.addEdge(name, procedureEnd);
+                        return graph;
                     }
                 }
                 else if (firstChild instanceof nodes_1.StructureNode) {
-                    //          console.dir("firstch: " + firstChild.get().constructor.name);
-                    const found = this.traverseStructure(firstChild);
-                    //          console.dir("found: " + dump(found));
-                    const n = [];
-                    for (const existing of flows) {
-                        for (const fo of found) {
-                            const add = { statements: [...existing.statements, ...fo.statements] };
-                            n.push(add);
-                        }
-                    }
-                    //          console.dir(dump(n));
-                    flows = n;
+                    const sub = this.traverseStructure(firstChild, procedureEnd, loopStart);
+                    current = graph.addGraph(current, sub);
                 }
             }
         }
-        return flows;
+        graph.addEdge(current, graph.getEnd());
+        return graph;
     }
-    traverseStructure(n) {
-        let flows = [];
+    traverseStructure(n, procedureEnd, loopStart) {
+        const graph = new flow_graph_1.FlowGraph(this.counter++);
         if (n === undefined) {
-            return flows;
+            return graph;
         }
+        let current = graph.getStart();
         const type = n.get();
-        if (type instanceof Structures.Form) {
-            const formst = n.findDirectStatement(Statements.Form);
-            let bodyFlows = this.traverseBody(findBody(n));
-            //      console.dir(bodyFlows);
-            bodyFlows = bodyFlows.map(a => { return { statements: [formst, ...a.statements] }; });
-            flows.push(...bodyFlows);
-        }
-        else if (type instanceof Structures.Any) {
-            for (const c of n.getChildren()) {
-                //        console.dir("yep");
-                if (c instanceof nodes_1.StructureNode && c.get() instanceof Structures.Form) {
-                    flows.push(...this.traverseStructure(c));
-                }
-                else if (c instanceof nodes_1.StructureNode && c.get() instanceof Structures.If) {
-                    flows.push(...this.traverseStructure(c));
-                }
-                else {
-                    console.dir("any, todo, " + c.constructor.name + ", " + c.get().constructor.name);
-                }
-            }
-        }
-        else if (type instanceof Structures.Try) {
-            // TODO: this does not take exceptions into account
-            const firstTry = n.getFirstStatement();
-            let allPossibleBody = this.traverseBody(findBody(n));
-            allPossibleBody = allPossibleBody.map(b => { return { statements: [firstTry, ...b.statements] }; });
-            if (allPossibleBody.length === 0) {
-                allPossibleBody.push({ statements: [firstTry] });
-            }
-            flows.push(...allPossibleBody);
-            for (const c of n.findDirectStructures(Structures.Catch)) {
-                const firstCatch = c.getFirstStatement();
-                const catchBodies = this.traverseBody(findBody(c));
-                for (const bodyFlow of allPossibleBody) {
-                    for (const catchFlow of catchBodies) {
-                        flows.push({ statements: [...bodyFlow.statements, firstCatch, ...catchFlow.statements] });
-                    }
-                    if (catchBodies.length === 0) {
-                        flows.push({ statements: [...bodyFlow.statements, firstCatch] });
-                    }
-                }
-            }
-            // TODO, handle CLEANUP
-        }
-        else if (type instanceof Structures.If) {
-            const collect = [n.findDirectStatement(Statements.If)];
-            let bodyFlows = this.traverseBody(findBody(n));
-            bodyFlows = bodyFlows.map(b => { return { statements: [...collect, ...b.statements] }; });
-            flows.push(...bodyFlows);
+        if (type instanceof Structures.If) {
+            const ifName = this.buildName(n.findDirectStatement(Statements.If));
+            const sub = this.traverseBody(this.findBody(n), procedureEnd, loopStart);
+            graph.addEdge(current, ifName);
+            graph.addGraph(ifName, sub);
+            graph.addEdge(sub.getEnd(), graph.getEnd());
+            current = ifName;
             for (const e of n.findDirectStructures(Structures.ElseIf)) {
                 const elseifst = e.findDirectStatement(Statements.ElseIf);
                 if (elseifst === undefined) {
                     continue;
                 }
-                collect.push(elseifst);
-                let bodyFlows = this.traverseBody(findBody(e));
-                bodyFlows = bodyFlows.map(b => { return { statements: [...collect, ...b.statements] }; });
-                flows.push(...bodyFlows);
+                const elseIfName = this.buildName(elseifst);
+                const sub = this.traverseBody(this.findBody(e), procedureEnd, loopStart);
+                graph.addEdge(current, elseIfName);
+                graph.addGraph(elseIfName, sub);
+                graph.addEdge(sub.getEnd(), graph.getEnd());
+                current = elseIfName;
             }
             const els = n.findDirectStructure(Structures.Else);
             const elsest = els === null || els === void 0 ? void 0 : els.findDirectStatement(Statements.Else);
             if (els && elsest) {
-                let bodyFlows = this.traverseBody(findBody(els));
-                bodyFlows = bodyFlows.map(b => { return { statements: [...collect, elsest, ...b.statements] }; });
-                flows.push(...bodyFlows);
+                const elseName = this.buildName(elsest);
+                const sub = this.traverseBody(this.findBody(els), procedureEnd, loopStart);
+                graph.addEdge(current, elseName);
+                graph.addGraph(elseName, sub);
+                graph.addEdge(sub.getEnd(), graph.getEnd());
             }
             else {
-                flows.push({ statements: [...collect] });
+                graph.addEdge(ifName, graph.getEnd());
+            }
+        }
+        else if (type instanceof Structures.Loop
+            || type instanceof Structures.While
+            || type instanceof Structures.With
+            || type instanceof Structures.Provide
+            || type instanceof Structures.Select
+            || type instanceof Structures.Do) {
+            const loopName = this.buildName(n.getFirstStatement());
+            const sub = this.traverseBody(this.findBody(n), procedureEnd, loopName);
+            graph.addEdge(current, loopName);
+            graph.addGraph(loopName, sub);
+            graph.addEdge(sub.getEnd(), loopName);
+            graph.addEdge(loopName, graph.getEnd());
+        }
+        else if (type instanceof Structures.Try) {
+            const tryName = this.buildName(n.getFirstStatement());
+            const body = this.traverseBody(this.findBody(n), procedureEnd, loopStart);
+            graph.addEdge(current, tryName);
+            graph.addGraph(tryName, body);
+            graph.addEdge(body.getEnd(), graph.getEnd());
+            for (const c of n.findDirectStructures(Structures.Catch)) {
+                const catchName = this.buildName(c.getFirstStatement());
+                const catchBody = this.traverseBody(this.findBody(c), procedureEnd, loopStart);
+                // TODO: this does not take exceptions into account
+                graph.addEdge(body.getEnd(), catchName);
+                graph.addGraph(catchName, catchBody);
+                graph.addEdge(catchBody.getEnd(), graph.getEnd());
             }
+            // TODO, handle CLEANUP
         }
         else if (type instanceof Structures.Case) {
-            const cas = n.getFirstStatement();
+            const caseName = this.buildName(n.getFirstStatement());
+            graph.addEdge(current, caseName);
             let othersFound = false;
             for (const w of n.findDirectStructures(Structures.When)) {
                 const first = w.getFirstStatement();
@@ -199,16 +188,19 @@ class StatementFlow {
                 if (first.get() instanceof Statements.WhenOthers) {
                     othersFound = true;
                 }
-                let bodyFlows = this.traverseBody(findBody(w));
-                bodyFlows = bodyFlows.map(b => { return { statements: [cas, first, ...b.statements] }; });
-                flows.push(...bodyFlows);
+                const firstName = this.buildName(first);
+                const sub = this.traverseBody(this.findBody(w), procedureEnd, loopStart);
+                graph.addEdge(caseName, firstName);
+                graph.addGraph(firstName, sub);
+                graph.addEdge(sub.getEnd(), graph.getEnd());
             }
             if (othersFound === false) {
-                flows.push({ statements: [cas] });
+                graph.addEdge(caseName, graph.getEnd());
             }
         }
         else if (type instanceof Structures.CaseType) {
-            const cas = n.getFirstStatement();
+            const caseName = this.buildName(n.getFirstStatement());
+            graph.addEdge(current, caseName);
             let othersFound = false;
             for (const w of n.findDirectStructures(Structures.WhenType)) {
                 const first = w.getFirstStatement();
@@ -218,40 +210,20 @@ class StatementFlow {
                 if (first.get() instanceof Statements.WhenOthers) {
                     othersFound = true;
                 }
-                let bodyFlows = this.traverseBody(findBody(w));
-                bodyFlows = bodyFlows.map(b => { return { statements: [cas, first, ...b.statements] }; });
-                flows.push(...bodyFlows);
+                const firstName = this.buildName(first);
+                const sub = this.traverseBody(this.findBody(w), procedureEnd, loopStart);
+                graph.addEdge(caseName, firstName);
+                graph.addGraph(firstName, sub);
+                graph.addEdge(sub.getEnd(), graph.getEnd());
             }
             if (othersFound === false) {
-                flows.push({ statements: [cas] });
-            }
-        }
-        else if (type instanceof Structures.Loop
-            || type instanceof Structures.While
-            || type instanceof Structures.With
-            || type instanceof Structures.Provide
-            || type instanceof Structures.Select
-            || type instanceof Structures.Do) {
-            const loop = n.getFirstStatement();
-            const bodyFlows = this.traverseBody(findBody(n));
-            for (const b of bodyFlows) {
-                flows.push({ statements: [loop, ...b.statements] });
-            }
-            for (const b1 of bodyFlows) {
-                for (const b2 of bodyFlows) {
-                    const add = [loop, ...b1.statements, ...b2.statements];
-                    flows.push({ statements: add });
-                }
+                graph.addEdge(caseName, graph.getEnd());
             }
-            flows.push({ statements: [loop] });
-            flows = pruneByStatement(flows, Statements.Exit);
-            flows = pruneByStatement(flows, Statements.Continue);
-            flows = pruneByStatement(flows, Statements.Return);
         }
         else {
             console.dir("todo, " + n.get().constructor.name);
         }
-        return flows;
+        return graph;
     }
 }
 exports.StatementFlow = StatementFlow;

package/build/src/lsp/language_server.js

@@ -121,7 +121,9 @@ class LanguageServer {
         if (stru === undefined) {
             return "empty structure";
         }
-        return (0, statement_flow_1.dumpFlow)(new statement_flow_1.StatementFlow().build(stru)).replace(/\],\[/, "],\n[");
+        const graphs = new statement_flow_1.StatementFlow().build(stru);
+        const wiz = graphs.map(g => g.toDigraph());
+        return JSON.stringify(wiz);
     }
 }
 exports.LanguageServer = LanguageServer;

package/build/src/registry.js

@@ -68,7 +68,7 @@ class Registry {
     }
     static abaplintVersion() {
         // magic, see build script "version.sh"
-        return "2.80.1";
+        return "2.80.5";
     }
     getDDICReferences() {
         return this.references;

package/build/src/rules/align_parameters.js

@@ -6,10 +6,7 @@ const Expressions = require("../abap/2_statements/expressions");
 const _abap_rule_1 = require("./_abap_rule");
 const _basic_rule_config_1 = require("./_basic_rule_config");
 const _irule_1 = require("./_irule");
-// todo, NEW #()
-// todo, RaiseEvent
-// todo, CREATE OBJECT
-// todo, RAISE
+const __1 = require("..");
 class AlignParametersConf extends _basic_rule_config_1.BasicRuleConfig {
 }
 exports.AlignParametersConf = AlignParametersConf;
@@ -22,8 +19,17 @@ class AlignParameters extends _abap_rule_1.ABAPRule {
         return {
             key: "align_parameters",
             title: "Align Parameters",
-            shortDescription: `Checks for vertially aligned parameters in function module calls, method calls and VALUE constructors.`,
-            extendedInformation: `https://github.com/SAP/styleguides/blob/master/clean-abap/CleanABAP.md#align-parameters
+            shortDescription: `Checks for vertially aligned parameters`,
+            extendedInformation: `Checks:
+* function module calls
+* method calls
+* VALUE constructors
+* NEW constructors
+* RAISE EXCEPTION statements
+* CREATE OBJECT statements
+* RAISE EVENT statements
+
+https://github.com/SAP/styleguides/blob/master/clean-abap/CleanABAP.md#align-parameters
 
 Does not take effect on non functional method calls, use https://rules.abaplint.org/functional_writing/
 
@@ -69,6 +75,8 @@ foo = VALUE #(
         candidates.push(...this.functionParameterCandidates(stru));
         candidates.push(...this.methodCallParamCandidates(stru));
         candidates.push(...this.valueBodyCandidates(stru));
+        candidates.push(...this.raiseAndCreateCandidates(stru));
+        candidates.push(...this.newCandidates(stru));
         for (const c of candidates) {
             const i = this.checkCandidate(c, file);
             if (i) {
@@ -90,13 +98,54 @@ foo = VALUE #(
         }
         for (const p of candidate.parameters) {
             if (p.eq.getCol() !== expectedEqualsColumn) {
-                const pos = candidate.parameters[0].eq;
                 const message = "Align parameters to column " + expectedEqualsColumn;
-                return issue_1.Issue.atPosition(file, pos, message, this.getMetadata().key);
+                return issue_1.Issue.atPosition(file, p.eq, message, this.getMetadata().key);
             }
         }
         return undefined;
     }
+    newCandidates(stru) {
+        const candidates = [];
+        for (const vb of stru.findAllExpressionsRecursive(Expressions.NewObject)) {
+            const parameters = [];
+            const fieldAssignments = vb.findDirectExpressions(Expressions.FieldAssignment);
+            if (fieldAssignments.length >= 2) {
+                for (const fs of fieldAssignments) {
+                    const children = fs.getChildren();
+                    if (children.length < 3) {
+                        continue; // unexpected
+                    }
+                    parameters.push({
+                        left: children[0],
+                        eq: children[1].getFirstToken().getStart(),
+                        right: children[2],
+                    });
+                }
+                if (parameters.length > 0) {
+                    candidates.push({ parameters });
+                    continue;
+                }
+            }
+            const list = vb.findDirectExpression(Expressions.ParameterListS);
+            if (list) {
+                for (const c of list.getChildren()) {
+                    const children = c.getChildren();
+                    if (children.length < 3) {
+                        continue; // unexpected
+                    }
+                    parameters.push({
+                        left: children[0],
+                        eq: children[1].getFirstToken().getStart(),
+                        right: children[2],
+                    });
+                }
+                if (parameters.length > 0) {
+                    candidates.push({ parameters });
+                }
+            }
+        }
+        return candidates;
+    }
     valueBodyCandidates(stru) {
         const candidates = [];
         for (const vb of stru.findAllExpressionsRecursive(Expressions.ValueBody)) {
@@ -122,6 +171,31 @@ foo = VALUE #(
         }
         return candidates;
     }
+    raiseAndCreateCandidates(stru) {
+        const candidates = [];
+        const statements = stru.findAllStatements(__1.Statements.Raise);
+        statements.push(...stru.findAllStatements(__1.Statements.CreateObject));
+        statements.push(...stru.findAllStatements(__1.Statements.RaiseEvent));
+        for (const raise of statements) {
+            const parameters = [];
+            const param = raise.findDirectExpression(Expressions.ParameterListS);
+            for (const p of (param === null || param === void 0 ? void 0 : param.getChildren()) || []) {
+                const children = p.getChildren();
+                if (children.length < 3) {
+                    continue; // unexpected
+                }
+                parameters.push({
+                    left: children[0],
+                    eq: children[1].getFirstToken().getStart(),
+                    right: children[2],
+                });
+            }
+            if (parameters.length > 0) {
+                candidates.push({ parameters });
+            }
+        }
+        return candidates;
+    }
     methodCallParamCandidates(stru) {
         var _a, _b, _c;
         const candidates = [];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abaplint/core",
-    "version": "2.80.1",
+    "version": "2.80.5",
     "description": "abaplint - Core API",
     "main": "build/src/index.js",
     "typings": "build/abaplint.d.ts",
@@ -64,7 +64,7 @@
         "mocha": "^9.1.3",
         "c8": "^7.10.0",
         "source-map-support": "^0.5.20",
-        "ts-json-schema-generator": "^0.96.0",
+        "ts-json-schema-generator": "^0.97.0",
         "typescript": "^4.4.4"
     },
     "dependencies": {