@abaplint/core 2.80.2 → 2.80.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/build/src/abap/2_statements/statements/replace.js +1 -1
  2. package/build/src/abap/flow/flow_graph.js +134 -0
  3. package/build/src/abap/flow/statement_flow.js +146 -190
  4. package/build/src/lsp/language_server.js +3 -1
  5. package/build/src/registry.js +1 -1
  6. package/build/src/rules/align_parameters.js +82 -8
  7. package/package.json +2 -2
package/build/src/abap/2_statements/statements/replace.js CHANGED
@@ -7,7 +7,7 @@ class Replace {
7
7
  getMatcher() {
8
8
  const length = (0, combi_1.seq)("LENGTH", expressions_1.Source);
9
9
  const offset = (0, combi_1.seq)("OFFSET", expressions_1.Source);
10
- const section = (0, combi_1.seq)((0, combi_1.opt)("IN"), "SECTION", (0, combi_1.per)(offset, length), "OF", expressions_1.Source);
10
+ const section = (0, combi_1.seq)((0, combi_1.opt)("IN"), "SECTION", (0, combi_1.per)(offset, length), "OF", expressions_1.Target);
11
11
  const source = (0, combi_1.seq)((0, combi_1.opt)("OF"), expressions_1.FindType, expressions_1.Source);
12
12
  const cas = (0, combi_1.alt)("IGNORING CASE", "RESPECTING CASE");
13
13
  const repl = (0, combi_1.seq)("REPLACEMENT COUNT", expressions_1.Target);
package/build/src/abap/flow/flow_graph.js ADDED
@@ -0,0 +1,134 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.FlowGraph = void 0;
4
+ class FlowGraph {
5
+ constructor(counter) {
6
+ this.label = "undefined";
7
+ this.edges = {};
8
+ this.start = "start#" + counter;
9
+ this.end = "end#" + counter;
10
+ }
11
+ getStart() {
12
+ return this.start;
13
+ }
14
+ getEnd() {
15
+ return this.end;
16
+ }
17
+ addEdge(from, to) {
18
+ if (this.edges[from] === undefined) {
19
+ this.edges[from] = {};
20
+ }
21
+ this.edges[from][to] = true;
22
+ }
23
+ removeEdge(from, to) {
24
+ if (this.edges[from] === undefined) {
25
+ return;
26
+ }
27
+ delete this.edges[from][to];
28
+ if (Object.keys(this.edges[from]).length === 0) {
29
+ delete this.edges[from];
30
+ }
31
+ }
32
+ listEdges() {
33
+ const list = [];
34
+ for (const from of Object.keys(this.edges)) {
35
+ for (const to of Object.keys(this.edges[from])) {
36
+ list.push({ from, to });
37
+ }
38
+ }
39
+ return list;
40
+ }
41
+ listNodes() {
42
+ const set = new Set();
43
+ for (const l of this.listEdges()) {
44
+ set.add(l.from);
45
+ set.add(l.to);
46
+ }
47
+ return Array.from(set.values());
48
+ }
49
+ hasEdges() {
50
+ return Object.keys(this.edges).length > 0;
51
+ }
52
+ /** return value: end node of to graph */
53
+ addGraph(from, to) {
54
+ if (to.hasEdges() === false) {
55
+ return from;
56
+ }
57
+ this.addEdge(from, to.getStart());
58
+ to.listEdges().forEach(e => this.addEdge(e.from, e.to));
59
+ return to.getEnd();
60
+ }
61
+ toJSON() {
62
+ return JSON.stringify(this.edges);
63
+ }
64
+ toTextEdges() {
65
+ let graph = "";
66
+ for (const l of this.listEdges()) {
67
+ graph += `"${l.from}" -> "${l.to}";\n`;
68
+ }
69
+ return graph.trim();
70
+ }
71
+ setLabel(label) {
72
+ this.label = label;
73
+ }
74
+ toDigraph() {
75
+ return `digraph G {
76
+ labelloc="t";
77
+ label="${this.label}";
78
+ graph [fontname = "helvetica"];
79
+ node [fontname = "helvetica", shape="box"];
80
+ edge [fontname = "helvetica"];
81
+ ${this.toTextEdges()}
82
+ }`;
83
+ }
84
+ listSources(node) {
85
+ const set = new Set();
86
+ for (const l of this.listEdges()) {
87
+ if (node === l.to) {
88
+ set.add(l.from);
89
+ }
90
+ }
91
+ return Array.from(set.values());
92
+ }
93
+ listTargets(node) {
94
+ const set = new Set();
95
+ for (const l of this.listEdges()) {
96
+ if (node === l.from) {
97
+ set.add(l.to);
98
+ }
99
+ }
100
+ return Array.from(set.values());
101
+ }
102
+ /** removes all nodes containing "#" that have one ingoing and one outgoing edge */
103
+ reduce() {
104
+ for (const node of this.listNodes()) {
105
+ if (node.includes("#") === false) {
106
+ continue;
107
+ }
108
+ const sources = this.listSources(node);
109
+ const targets = this.listTargets(node);
110
+ if (sources.length > 0 && targets.length > 0) {
111
+ // hash node in the middle of the graph
112
+ for (const s of sources) {
113
+ this.removeEdge(s, node);
114
+ }
115
+ for (const t of targets) {
116
+ this.removeEdge(node, t);
117
+ }
118
+ for (const s of sources) {
119
+ for (const t of targets) {
120
+ this.addEdge(s, t);
121
+ }
122
+ }
123
+ }
124
+ if (node.startsWith("end#") && sources.length === 0) {
125
+ for (const t of targets) {
126
+ this.removeEdge(node, t);
127
+ }
128
+ }
129
+ }
130
+ return this;
131
+ }
132
+ }
133
+ exports.FlowGraph = FlowGraph;
134
+ //# sourceMappingURL=flow_graph.js.map
package/build/src/abap/flow/statement_flow.js CHANGED
@@ -1,211 +1,184 @@
1
1
  "use strict";
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
- exports.StatementFlow = exports.dumpFlows = exports.dumpFlowsWithDescription = void 0;
3
+ exports.StatementFlow = void 0;
4
4
  const nodes_1 = require("../nodes");
5
5
  const Structures = require("../3_structures/structures");
6
6
  const Statements = require("../2_statements/statements");
7
7
  const Expressions = require("../2_statements/expressions");
8
- function dumpFlowsWithDescription(flows) {
9
- let ret = "";
10
- for (const f of flows) {
11
- ret += f.description + ": [" + f.statements.map(b => b === null || b === void 0 ? void 0 : b.get().constructor.name).join(",") + "]\n";
12
- }
13
- return ret.trim();
14
- }
15
- exports.dumpFlowsWithDescription = dumpFlowsWithDescription;
16
- function dumpFlows(flows) {
17
- const ret = "[" + flows.map(f => "[" + f.statements.map(b => b === null || b === void 0 ? void 0 : b.get().constructor.name).join(",") + "]").join(",");
18
- return ret + "]";
19
- }
20
- exports.dumpFlows = dumpFlows;
21
- function findBody(f) {
22
- var _a;
23
- return ((_a = f.findDirectStructure(Structures.Body)) === null || _a === void 0 ? void 0 : _a.getChildren()) || [];
24
- }
25
- function removeDuplicates(flows) {
26
- const result = [];
27
- for (const f of flows) {
28
- let duplicate = false;
29
- for (const r of result) {
30
- if (f.statements.length !== r.statements.length) {
31
- continue;
32
- }
33
- duplicate = true;
34
- for (let index = 0; index < f.statements.length; index++) {
35
- if (f.statements[index] !== r.statements[index]) {
36
- duplicate = false;
37
- break;
38
- }
39
- }
40
- }
41
- if (duplicate === false) {
42
- result.push(f);
43
- }
44
- }
45
- return result;
46
- }
47
- function pruneByStatement(flows, type) {
48
- const result = [];
49
- for (const f of flows) {
50
- const nodes = [];
51
- for (const n of f.statements) {
52
- nodes.push(n);
53
- if (n.get() instanceof type) {
54
- break;
55
- }
56
- }
57
- result.push({ statements: nodes });
58
- }
59
- return removeDuplicates(result);
60
- }
61
- ////////////////////////////////////////////////////////////////
8
+ const flow_graph_1 = require("./flow_graph");
62
9
  class StatementFlow {
10
+ constructor() {
11
+ this.counter = 0;
12
+ }
63
13
  build(stru) {
64
14
  var _a, _b;
65
15
  const ret = [];
66
16
  const forms = stru.findAllStructures(Structures.Form);
67
17
  for (const f of forms) {
68
- let body = this.traverseBody(findBody(f));
69
- const formName = (_a = f.findFirstExpression(Expressions.FormName)) === null || _a === void 0 ? void 0 : _a.concatTokens();
70
- body = body.map((b) => { return { description: "FORM " + formName, statements: b.statements }; });
71
- ret.push(...body);
18
+ const formName = "FORM " + ((_a = f.findFirstExpression(Expressions.FormName)) === null || _a === void 0 ? void 0 : _a.concatTokens());
19
+ this.counter = 1;
20
+ const graph = this.traverseBody(this.findBody(f), { procedureEnd: "end#1" });
21
+ graph.setLabel(formName);
22
+ ret.push(graph);
72
23
  }
73
24
  const methods = stru.findAllStructures(Structures.Method);
74
25
  for (const f of methods) {
75
- let body = this.traverseBody(findBody(f));
76
- const methodName = (_b = f.findFirstExpression(Expressions.MethodName)) === null || _b === void 0 ? void 0 : _b.concatTokens();
77
- body = body.map((b) => { return { description: "METHOD " + methodName, statements: b.statements }; });
78
- ret.push(...body);
26
+ const methodName = "METHOD " + ((_b = f.findFirstExpression(Expressions.MethodName)) === null || _b === void 0 ? void 0 : _b.concatTokens());
27
+ this.counter = 1;
28
+ const graph = this.traverseBody(this.findBody(f), { procedureEnd: "end#1" });
29
+ graph.setLabel(methodName);
30
+ ret.push(graph);
79
31
  }
80
- return ret;
32
+ return ret.map(f => f.reduce());
33
+ }
34
+ findBody(f) {
35
+ var _a;
36
+ return ((_a = f.findDirectStructure(Structures.Body)) === null || _a === void 0 ? void 0 : _a.getChildren()) || [];
81
37
  }
82
- traverseBody(children) {
83
- let flows = [{ statements: [] }];
38
+ buildName(statement) {
39
+ let token = undefined;
40
+ const colon = statement.getColon();
41
+ if (colon === undefined) {
42
+ token = statement.getFirstToken();
43
+ }
44
+ else {
45
+ for (const t of statement.getTokens()) {
46
+ if (t.getStart().isAfter(colon.getEnd())) {
47
+ token = t;
48
+ break;
49
+ }
50
+ }
51
+ }
52
+ if (token === undefined) {
53
+ return "tokenError";
54
+ }
55
+ return statement.get().constructor.name +
56
+ ":" + token.getRow() +
57
+ "," + token.getCol();
58
+ }
59
+ traverseBody(children, context) {
60
+ const graph = new flow_graph_1.FlowGraph(this.counter++);
84
61
  if (children.length === 0) {
85
- return [];
62
+ graph.addEdge(graph.getStart(), graph.getEnd());
63
+ return graph;
86
64
  }
87
- for (let i = 0; i < children.length; i++) {
88
- const c = children[i];
89
- // console.dir(c);
65
+ let current = graph.getStart();
66
+ for (const c of children) {
90
67
  if (c.get() instanceof Structures.Normal) {
91
68
  const firstChild = c.getFirstChild(); // "Normal" only has one child
92
69
  if (firstChild instanceof nodes_1.StatementNode) {
93
- flows.forEach(f => f.statements.push(firstChild));
94
- // current.push(firstChild);
95
- // console.dir("push: " + firstChild.constructor.name);
96
- if (firstChild.get() instanceof Statements.Check
97
- || firstChild.get() instanceof Statements.Assert) {
98
- const after = children.slice(i + 1, children.length);
99
- for (const b of this.traverseBody(after)) {
100
- for (const f of [...flows]) {
101
- flows.push({ statements: [...f.statements, ...b.statements] });
102
- }
70
+ const name = this.buildName(firstChild);
71
+ graph.addEdge(current, name);
72
+ current = name;
73
+ if (firstChild.get() instanceof Statements.Check) {
74
+ if (context.loopStart) {
75
+ graph.addEdge(name, context.loopStart);
76
+ }
77
+ else {
78
+ graph.addEdge(name, context.procedureEnd);
103
79
  }
104
- break;
80
+ }
81
+ else if (firstChild.get() instanceof Statements.Assert) {
82
+ graph.addEdge(name, context.procedureEnd);
83
+ }
84
+ else if (firstChild.get() instanceof Statements.Continue && context.loopStart) {
85
+ graph.addEdge(name, context.loopStart);
86
+ return graph;
105
87
  }
106
88
  else if (firstChild.get() instanceof Statements.Exit) {
107
- break;
89
+ if (context.loopEnd) {
90
+ graph.addEdge(name, context.loopEnd);
91
+ }
92
+ else {
93
+ graph.addEdge(name, context.procedureEnd);
94
+ }
95
+ return graph;
108
96
  }
109
97
  else if (firstChild.get() instanceof Statements.Return) {
110
- break;
98
+ graph.addEdge(name, context.procedureEnd);
99
+ return graph;
111
100
  }
112
101
  }
113
102
  else if (firstChild instanceof nodes_1.StructureNode) {
114
- // console.dir("firstch: " + firstChild.get().constructor.name);
115
- const found = this.traverseStructure(firstChild);
116
- // console.dir("found: " + dump(found));
117
- const n = [];
118
- for (const existing of flows) {
119
- for (const fo of found) {
120
- const add = { statements: [...existing.statements, ...fo.statements] };
121
- n.push(add);
122
- }
123
- }
124
- // console.dir(dump(n));
125
- flows = n;
103
+ const sub = this.traverseStructure(firstChild, context);
104
+ current = graph.addGraph(current, sub);
126
105
  }
127
106
  }
128
107
  }
129
- return flows;
108
+ graph.addEdge(current, graph.getEnd());
109
+ return graph;
130
110
  }
131
- traverseStructure(n) {
132
- let flows = [];
111
+ traverseStructure(n, context) {
112
+ const graph = new flow_graph_1.FlowGraph(this.counter++);
133
113
  if (n === undefined) {
134
- return flows;
114
+ return graph;
135
115
  }
116
+ let current = graph.getStart();
136
117
  const type = n.get();
137
- if (type instanceof Structures.Form) {
138
- const formst = n.findDirectStatement(Statements.Form);
139
- let bodyFlows = this.traverseBody(findBody(n));
140
- // console.dir(bodyFlows);
141
- bodyFlows = bodyFlows.map(a => { return { statements: [formst, ...a.statements] }; });
142
- flows.push(...bodyFlows);
143
- }
144
- else if (type instanceof Structures.Any) {
145
- for (const c of n.getChildren()) {
146
- // console.dir("yep");
147
- if (c instanceof nodes_1.StructureNode && c.get() instanceof Structures.Form) {
148
- flows.push(...this.traverseStructure(c));
149
- }
150
- else if (c instanceof nodes_1.StructureNode && c.get() instanceof Structures.If) {
151
- flows.push(...this.traverseStructure(c));
152
- }
153
- else {
154
- console.dir("any, todo, " + c.constructor.name + ", " + c.get().constructor.name);
155
- }
156
- }
157
- }
158
- else if (type instanceof Structures.Try) {
159
- // TODO: this does not take exceptions into account
160
- const firstTry = n.getFirstStatement();
161
- let allPossibleBody = this.traverseBody(findBody(n));
162
- allPossibleBody = allPossibleBody.map(b => { return { statements: [firstTry, ...b.statements] }; });
163
- if (allPossibleBody.length === 0) {
164
- allPossibleBody.push({ statements: [firstTry] });
165
- }
166
- flows.push(...allPossibleBody);
167
- for (const c of n.findDirectStructures(Structures.Catch)) {
168
- const firstCatch = c.getFirstStatement();
169
- const catchBodies = this.traverseBody(findBody(c));
170
- for (const bodyFlow of allPossibleBody) {
171
- for (const catchFlow of catchBodies) {
172
- flows.push({ statements: [...bodyFlow.statements, firstCatch, ...catchFlow.statements] });
173
- }
174
- if (catchBodies.length === 0) {
175
- flows.push({ statements: [...bodyFlow.statements, firstCatch] });
176
- }
177
- }
178
- }
179
- // TODO, handle CLEANUP
180
- }
181
- else if (type instanceof Structures.If) {
182
- const collect = [n.findDirectStatement(Statements.If)];
183
- let bodyFlows = this.traverseBody(findBody(n));
184
- bodyFlows = bodyFlows.map(b => { return { statements: [...collect, ...b.statements] }; });
185
- flows.push(...bodyFlows);
118
+ if (type instanceof Structures.If) {
119
+ const ifName = this.buildName(n.findDirectStatement(Statements.If));
120
+ const sub = this.traverseBody(this.findBody(n), context);
121
+ graph.addEdge(current, ifName);
122
+ graph.addGraph(ifName, sub);
123
+ graph.addEdge(sub.getEnd(), graph.getEnd());
124
+ current = ifName;
186
125
  for (const e of n.findDirectStructures(Structures.ElseIf)) {
187
126
  const elseifst = e.findDirectStatement(Statements.ElseIf);
188
127
  if (elseifst === undefined) {
189
128
  continue;
190
129
  }
191
- collect.push(elseifst);
192
- let bodyFlows = this.traverseBody(findBody(e));
193
- bodyFlows = bodyFlows.map(b => { return { statements: [...collect, ...b.statements] }; });
194
- flows.push(...bodyFlows);
130
+ const elseIfName = this.buildName(elseifst);
131
+ const sub = this.traverseBody(this.findBody(e), context);
132
+ graph.addEdge(current, elseIfName);
133
+ graph.addGraph(elseIfName, sub);
134
+ graph.addEdge(sub.getEnd(), graph.getEnd());
135
+ current = elseIfName;
195
136
  }
196
137
  const els = n.findDirectStructure(Structures.Else);
197
138
  const elsest = els === null || els === void 0 ? void 0 : els.findDirectStatement(Statements.Else);
198
139
  if (els && elsest) {
199
- let bodyFlows = this.traverseBody(findBody(els));
200
- bodyFlows = bodyFlows.map(b => { return { statements: [...collect, elsest, ...b.statements] }; });
201
- flows.push(...bodyFlows);
140
+ const elseName = this.buildName(elsest);
141
+ const sub = this.traverseBody(this.findBody(els), context);
142
+ graph.addEdge(current, elseName);
143
+ graph.addGraph(elseName, sub);
144
+ graph.addEdge(sub.getEnd(), graph.getEnd());
202
145
  }
203
146
  else {
204
- flows.push({ statements: [...collect] });
147
+ graph.addEdge(ifName, graph.getEnd());
205
148
  }
206
149
  }
150
+ else if (type instanceof Structures.Loop
151
+ || type instanceof Structures.While
152
+ || type instanceof Structures.With
153
+ || type instanceof Structures.Provide
154
+ || type instanceof Structures.Select
155
+ || type instanceof Structures.Do) {
156
+ const loopName = this.buildName(n.getFirstStatement());
157
+ const sub = this.traverseBody(this.findBody(n), Object.assign(Object.assign({}, context), { loopStart: loopName, loopEnd: graph.getEnd() }));
158
+ graph.addEdge(current, loopName);
159
+ graph.addGraph(loopName, sub);
160
+ graph.addEdge(sub.getEnd(), loopName);
161
+ graph.addEdge(loopName, graph.getEnd());
162
+ }
163
+ else if (type instanceof Structures.Try) {
164
+ const tryName = this.buildName(n.getFirstStatement());
165
+ const body = this.traverseBody(this.findBody(n), context);
166
+ graph.addEdge(current, tryName);
167
+ graph.addGraph(tryName, body);
168
+ graph.addEdge(body.getEnd(), graph.getEnd());
169
+ for (const c of n.findDirectStructures(Structures.Catch)) {
170
+ const catchName = this.buildName(c.getFirstStatement());
171
+ const catchBody = this.traverseBody(this.findBody(c), context);
172
+ // TODO: this does not take exceptions into account
173
+ graph.addEdge(body.getEnd(), catchName);
174
+ graph.addGraph(catchName, catchBody);
175
+ graph.addEdge(catchBody.getEnd(), graph.getEnd());
176
+ }
177
+ // TODO, handle CLEANUP
178
+ }
207
179
  else if (type instanceof Structures.Case) {
208
- const cas = n.getFirstStatement();
180
+ const caseName = this.buildName(n.getFirstStatement());
181
+ graph.addEdge(current, caseName);
209
182
  let othersFound = false;
210
183
  for (const w of n.findDirectStructures(Structures.When)) {
211
184
  const first = w.getFirstStatement();
@@ -215,16 +188,19 @@ class StatementFlow {
215
188
  if (first.get() instanceof Statements.WhenOthers) {
216
189
  othersFound = true;
217
190
  }
218
- let bodyFlows = this.traverseBody(findBody(w));
219
- bodyFlows = bodyFlows.map(b => { return { statements: [cas, first, ...b.statements] }; });
220
- flows.push(...bodyFlows);
191
+ const firstName = this.buildName(first);
192
+ const sub = this.traverseBody(this.findBody(w), context);
193
+ graph.addEdge(caseName, firstName);
194
+ graph.addGraph(firstName, sub);
195
+ graph.addEdge(sub.getEnd(), graph.getEnd());
221
196
  }
222
197
  if (othersFound === false) {
223
- flows.push({ statements: [cas] });
198
+ graph.addEdge(caseName, graph.getEnd());
224
199
  }
225
200
  }
226
201
  else if (type instanceof Structures.CaseType) {
227
- const cas = n.getFirstStatement();
202
+ const caseName = this.buildName(n.getFirstStatement());
203
+ graph.addEdge(current, caseName);
228
204
  let othersFound = false;
229
205
  for (const w of n.findDirectStructures(Structures.WhenType)) {
230
206
  const first = w.getFirstStatement();
@@ -234,40 +210,20 @@ class StatementFlow {
234
210
  if (first.get() instanceof Statements.WhenOthers) {
235
211
  othersFound = true;
236
212
  }
237
- let bodyFlows = this.traverseBody(findBody(w));
238
- bodyFlows = bodyFlows.map(b => { return { statements: [cas, first, ...b.statements] }; });
239
- flows.push(...bodyFlows);
213
+ const firstName = this.buildName(first);
214
+ const sub = this.traverseBody(this.findBody(w), context);
215
+ graph.addEdge(caseName, firstName);
216
+ graph.addGraph(firstName, sub);
217
+ graph.addEdge(sub.getEnd(), graph.getEnd());
240
218
  }
241
219
  if (othersFound === false) {
242
- flows.push({ statements: [cas] });
243
- }
244
- }
245
- else if (type instanceof Structures.Loop
246
- || type instanceof Structures.While
247
- || type instanceof Structures.With
248
- || type instanceof Structures.Provide
249
- || type instanceof Structures.Select
250
- || type instanceof Structures.Do) {
251
- const loop = n.getFirstStatement();
252
- const bodyFlows = this.traverseBody(findBody(n));
253
- for (const b of bodyFlows) {
254
- flows.push({ statements: [loop, ...b.statements] });
255
- }
256
- for (const b1 of bodyFlows) {
257
- for (const b2 of bodyFlows) {
258
- const add = [loop, ...b1.statements, ...b2.statements];
259
- flows.push({ statements: add });
260
- }
220
+ graph.addEdge(caseName, graph.getEnd());
261
221
  }
262
- flows.push({ statements: [loop] });
263
- flows = pruneByStatement(flows, Statements.Exit);
264
- flows = pruneByStatement(flows, Statements.Continue);
265
- flows = pruneByStatement(flows, Statements.Return);
266
222
  }
267
223
  else {
268
- console.dir("todo, " + n.get().constructor.name);
224
+ console.dir("StatementFlow,todo, " + n.get().constructor.name);
269
225
  }
270
- return flows;
226
+ return graph;
271
227
  }
272
228
  }
273
229
  exports.StatementFlow = StatementFlow;
package/build/src/lsp/language_server.js CHANGED
@@ -121,7 +121,9 @@ class LanguageServer {
121
121
  if (stru === undefined) {
122
122
  return "empty structure";
123
123
  }
124
- return (0, statement_flow_1.dumpFlowsWithDescription)(new statement_flow_1.StatementFlow().build(stru)).replace(/\],\[/, "],\n[");
124
+ const graphs = new statement_flow_1.StatementFlow().build(stru);
125
+ const wiz = graphs.map(g => g.toDigraph());
126
+ return JSON.stringify(wiz);
125
127
  }
126
128
  }
127
129
  exports.LanguageServer = LanguageServer;
package/build/src/registry.js CHANGED
@@ -68,7 +68,7 @@ class Registry {
68
68
  }
69
69
  static abaplintVersion() {
70
70
  // magic, see build script "version.sh"
71
- return "2.80.2";
71
+ return "2.80.6";
72
72
  }
73
73
  getDDICReferences() {
74
74
  return this.references;
package/build/src/rules/align_parameters.js CHANGED
@@ -6,10 +6,7 @@ const Expressions = require("../abap/2_statements/expressions");
6
6
  const _abap_rule_1 = require("./_abap_rule");
7
7
  const _basic_rule_config_1 = require("./_basic_rule_config");
8
8
  const _irule_1 = require("./_irule");
9
- // todo, NEW #()
10
- // todo, RaiseEvent
11
- // todo, CREATE OBJECT
12
- // todo, RAISE
9
+ const __1 = require("..");
13
10
  class AlignParametersConf extends _basic_rule_config_1.BasicRuleConfig {
14
11
  }
15
12
  exports.AlignParametersConf = AlignParametersConf;
@@ -22,8 +19,17 @@ class AlignParameters extends _abap_rule_1.ABAPRule {
22
19
  return {
23
20
  key: "align_parameters",
24
21
  title: "Align Parameters",
25
- shortDescription: `Checks for vertially aligned parameters in function module calls, method calls and VALUE constructors.`,
26
- extendedInformation: `https://github.com/SAP/styleguides/blob/master/clean-abap/CleanABAP.md#align-parameters
22
+ shortDescription: `Checks for vertially aligned parameters`,
23
+ extendedInformation: `Checks:
24
+ * function module calls
25
+ * method calls
26
+ * VALUE constructors
27
+ * NEW constructors
28
+ * RAISE EXCEPTION statements
29
+ * CREATE OBJECT statements
30
+ * RAISE EVENT statements
31
+
32
+ https://github.com/SAP/styleguides/blob/master/clean-abap/CleanABAP.md#align-parameters
27
33
 
28
34
  Does not take effect on non functional method calls, use https://rules.abaplint.org/functional_writing/
29
35
 
@@ -69,6 +75,8 @@ foo = VALUE #(
69
75
  candidates.push(...this.functionParameterCandidates(stru));
70
76
  candidates.push(...this.methodCallParamCandidates(stru));
71
77
  candidates.push(...this.valueBodyCandidates(stru));
78
+ candidates.push(...this.raiseAndCreateCandidates(stru));
79
+ candidates.push(...this.newCandidates(stru));
72
80
  for (const c of candidates) {
73
81
  const i = this.checkCandidate(c, file);
74
82
  if (i) {
@@ -90,13 +98,54 @@ foo = VALUE #(
90
98
  }
91
99
  for (const p of candidate.parameters) {
92
100
  if (p.eq.getCol() !== expectedEqualsColumn) {
93
- const pos = candidate.parameters[0].eq;
94
101
  const message = "Align parameters to column " + expectedEqualsColumn;
95
- return issue_1.Issue.atPosition(file, pos, message, this.getMetadata().key);
102
+ return issue_1.Issue.atPosition(file, p.eq, message, this.getMetadata().key);
96
103
  }
97
104
  }
98
105
  return undefined;
99
106
  }
107
+ newCandidates(stru) {
108
+ const candidates = [];
109
+ for (const vb of stru.findAllExpressionsRecursive(Expressions.NewObject)) {
110
+ const parameters = [];
111
+ const fieldAssignments = vb.findDirectExpressions(Expressions.FieldAssignment);
112
+ if (fieldAssignments.length >= 2) {
113
+ for (const fs of fieldAssignments) {
114
+ const children = fs.getChildren();
115
+ if (children.length < 3) {
116
+ continue; // unexpected
117
+ }
118
+ parameters.push({
119
+ left: children[0],
120
+ eq: children[1].getFirstToken().getStart(),
121
+ right: children[2],
122
+ });
123
+ }
124
+ if (parameters.length > 0) {
125
+ candidates.push({ parameters });
126
+ continue;
127
+ }
128
+ }
129
+ const list = vb.findDirectExpression(Expressions.ParameterListS);
130
+ if (list) {
131
+ for (const c of list.getChildren()) {
132
+ const children = c.getChildren();
133
+ if (children.length < 3) {
134
+ continue; // unexpected
135
+ }
136
+ parameters.push({
137
+ left: children[0],
138
+ eq: children[1].getFirstToken().getStart(),
139
+ right: children[2],
140
+ });
141
+ }
142
+ if (parameters.length > 0) {
143
+ candidates.push({ parameters });
144
+ }
145
+ }
146
+ }
147
+ return candidates;
148
+ }
100
149
  valueBodyCandidates(stru) {
101
150
  const candidates = [];
102
151
  for (const vb of stru.findAllExpressionsRecursive(Expressions.ValueBody)) {
@@ -122,6 +171,31 @@ foo = VALUE #(
122
171
  }
123
172
  return candidates;
124
173
  }
174
+ raiseAndCreateCandidates(stru) {
175
+ const candidates = [];
176
+ const statements = stru.findAllStatements(__1.Statements.Raise);
177
+ statements.push(...stru.findAllStatements(__1.Statements.CreateObject));
178
+ statements.push(...stru.findAllStatements(__1.Statements.RaiseEvent));
179
+ for (const raise of statements) {
180
+ const parameters = [];
181
+ const param = raise.findDirectExpression(Expressions.ParameterListS);
182
+ for (const p of (param === null || param === void 0 ? void 0 : param.getChildren()) || []) {
183
+ const children = p.getChildren();
184
+ if (children.length < 3) {
185
+ continue; // unexpected
186
+ }
187
+ parameters.push({
188
+ left: children[0],
189
+ eq: children[1].getFirstToken().getStart(),
190
+ right: children[2],
191
+ });
192
+ }
193
+ if (parameters.length > 0) {
194
+ candidates.push({ parameters });
195
+ }
196
+ }
197
+ return candidates;
198
+ }
125
199
  methodCallParamCandidates(stru) {
126
200
  var _a, _b, _c;
127
201
  const candidates = [];
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@abaplint/core",
3
- "version": "2.80.2",
3
+ "version": "2.80.6",
4
4
  "description": "abaplint - Core API",
5
5
  "main": "build/src/index.js",
6
6
  "typings": "build/abaplint.d.ts",
@@ -64,7 +64,7 @@
64
64
  "mocha": "^9.1.3",
65
65
  "c8": "^7.10.0",
66
66
  "source-map-support": "^0.5.20",
67
- "ts-json-schema-generator": "^0.96.0",
67
+ "ts-json-schema-generator": "^0.97.0",
68
68
  "typescript": "^4.4.4"
69
69
  },
70
70
  "dependencies": {