@eagleoutice/flowr 1.5.1 → 2.0.0

package/reconstruct/reconstruct.js

@@ -6,9 +6,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reconstructToCode = exports.autoSelectLibrary = exports.doNotAutoSelect = exports.reconstructLogger = void 0;
-const r_bridge_1 = require("../r-bridge");
 const log_1 = require("../util/log");
 const assert_1 = require("../util/assert");
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const stateful_fold_1 = require("../r-bridge/lang-4.x/ast/model/processing/stateful-fold");
 function plain(text) {
     return [{ line: text, indent: 0 }];
 }
@@ -16,35 +17,42 @@ exports.reconstructLogger = log_1.log.getSubLogger({ name: 'reconstruct' });
 const getLexeme = (n) => n.info.fullLexeme ?? n.lexeme ?? '';
 const reconstructAsLeaf = (leaf, configuration) => {
     const selectionHasLeaf = configuration.selection.has(leaf.info.id) || configuration.autoSelectIf(leaf);
-    if (selectionHasLeaf) {
-        return foldToConst(leaf);
-    }
-    else {
-        return [];
-    }
-    // reconstructLogger.trace(`reconstructAsLeaf: ${leaf.info.id} (${selectionHasLeaf ? 'y' : 'n'}):  ${JSON.stringify(wouldBe)}`)
-    // return selectionHasLeaf ? wouldBe : []
+    return selectionHasLeaf ? foldToConst(leaf) : [];
 };
 const foldToConst = (n) => plain(getLexeme(n));
 function indentBy(lines, indent) {
     return lines.map(({ line, indent: i }) => ({ line, indent: i + indent }));
 }
-function reconstructExpressionList(exprList, expressions, configuration) {
-    if (isSelected(configuration, exprList)) {
-        return plain(getLexeme(exprList));
-    }
+function reconstructExpressionList(exprList, _grouping, expressions, config) {
     const subExpressions = expressions.filter(e => e.length > 0);
     if (subExpressions.length === 0) {
-        return [];
+        if (isSelected(config, exprList)) {
+            return plain('{}');
+        }
+        else {
+            return [];
+        }
     }
     else if (subExpressions.length === 1) {
-        return subExpressions[0];
+        if (!isSelected(config, exprList)) {
+            return subExpressions[0];
+        }
+        const [fst] = subExpressions;
+        const g = exprList.grouping;
+        if (g && fst.length > 0) {
+            const start = g[0].content;
+            const end = g[1].content;
+            fst[0].line = `${start}${start === '{' ? ' ' : ''}${fst[0].line}`;
+            fst[fst.length - 1].line = `${fst[fst.length - 1].line}${end === '}' ? ' ' : ''}${end}`;
+        }
+        return fst;
     }
     else {
+        const g = exprList.grouping;
         return [
-            { line: '{', indent: 0 },
+            ...(g ? plain(g[0].content) : plain('{')),
             ...indentBy(subExpressions.flat(), 1),
-            { line: '}', indent: 0 }
+            ...(g ? plain(g[1].content) : plain('}'))
         ];
     }
 }
@@ -69,153 +77,161 @@ function reconstructUnaryOp(leaf, operand, configuration) {
         return foldToConst(leaf);
     }
 }
-function reconstructBinaryOp(n, lhs, rhs, configuration) {
-    if (isSelected(configuration, n)) {
-        return plain(getLexeme(n));
-    }
+function reconstructBinaryOp(n, lhs, rhs, config) {
     if (lhs.length === 0 && rhs.length === 0) {
-        return [];
+        if (isSelected(config, n)) {
+            return plain(getLexeme(n));
+        }
+        else {
+            return [];
+        }
     }
-    if (lhs.length === 0) { // if we have no lhs, only return rhs
+    else if (lhs.length === 0) { // if we have no lhs, only return rhs
         return rhs;
     }
-    if (rhs.length === 0) { // if we have no rhs we have to keep everything to get the rhs
-        return plain(getLexeme(n));
+    else if (rhs.length === 0) {
+        if (isSelected(config, n)) {
+            return plain(getLexeme(n));
+        }
+        else {
+            return lhs;
+        }
     }
     return reconstructRawBinaryOperator(lhs, n.type === "RPipe" /* RType.Pipe */ ? '|>' : n.operator, rhs);
 }
-function reconstructForLoop(loop, variable, vector, body, configuration) {
-    if (isSelected(configuration, loop)) {
-        return plain(getLexeme(loop));
+function reconstructForLoop(loop, variable, vector, body, config) {
+    if (!isSelected(config, loop) && variable.length === 0 && vector.length === 0) {
+        return body;
     }
-    if (body.length === 0 && variable.length === 0 && vector.length === 0) {
+    else if (body.length === 0 && variable.length === 0 && vector.length === 0) {
         return [];
     }
+    else if (body.length <= 1) {
+        // 'inline'
+        return [{
+                line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)}) ${body.length === 0 ? '{}' : body[0].line}`,
+                indent: 0
+            }];
+    }
+    else if (body[0].line === '{' && body[body.length - 1].line === '}') {
+        // 'block'
+        return [
+            { line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)}) {`, indent: 0 },
+            ...body.slice(1, body.length - 1),
+            { line: '}', indent: 0 }
+        ];
+    }
     else {
-        if (body.length <= 1) {
-            // 'inline'
-            return [{ line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)}) ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
-        }
-        else if (body[0].line === '{' && body[body.length - 1].line === '}') {
-            // 'block'
-            return [
-                { line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)}) {`, indent: 0 },
-                ...body.slice(1, body.length - 1),
-                { line: '}', indent: 0 }
-            ];
-        }
-        else {
-            // unknown
-            return [
-                { line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)})`, indent: 0 },
-                ...indentBy(body, 1)
-            ];
-        }
+        // unknown
+        return [
+            { line: `for(${getLexeme(loop.variable)} in ${getLexeme(loop.vector)})`, indent: 0 },
+            ...indentBy(body, 1)
+        ];
     }
 }
 function reconstructRepeatLoop(loop, body, configuration) {
-    if (isSelected(configuration, loop)) {
-        return plain(getLexeme(loop));
+    const sel = isSelected(configuration, loop);
+    if (!sel) {
+        return body;
     }
-    else if (body.length === 0) {
-        return [];
+    else if (body.length <= 1) {
+        // 'inline'
+        return [{ line: `repeat ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
+    }
+    else if (body[0].line === '{' && body[body.length - 1].line === '}') {
+        // 'block'
+        return [
+            { line: 'repeat {', indent: 0 },
+            ...body.slice(1, body.length - 1),
+            { line: '}', indent: 0 }
+        ];
     }
     else {
-        if (body.length <= 1) {
-            // 'inline'
-            return [{ line: `repeat ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
+        // unknown
+        return [
+            { line: 'repeat', indent: 0 },
+            ...indentBy(body, 1)
+        ];
+    }
+}
+function reconstructIfThenElse(ifThenElse, condition, then, otherwise, config) {
+    otherwise ??= [];
+    if (then.length === 0 && otherwise.length === 0) {
+        if (isSelected(config, ifThenElse)) {
+            return [{ line: `if(${getLexeme(ifThenElse.condition)}) { }`, indent: 0 }];
         }
-        else if (body[0].line === '{' && body[body.length - 1].line === '}') {
-            // 'block'
+        else if (condition.length > 0) {
+            return condition;
+        }
+        else {
+            return [];
+        }
+    }
+    else if (otherwise.length === 0) {
+        if (isSelected(config, ifThenElse)) {
             return [
-                { line: 'repeat {', indent: 0 },
-                ...body.slice(1, body.length - 1),
-                { line: '}', indent: 0 }
+                { line: `if(${getLexeme(ifThenElse.condition)}) ${then[0].line}`, indent: 0 },
+                ...indentBy(then.splice(1), 1)
             ];
         }
         else {
-            // unknown
+            return then;
+        }
+    }
+    else if (then.length === 0) {
+        if (isSelected(config, ifThenElse)) {
             return [
-                { line: 'repeat', indent: 0 },
-                ...indentBy(body, 1)
+                { line: `if(${getLexeme(ifThenElse.condition)}) { } else ${otherwise[0].line}`, indent: 0 },
+                ...indentBy(otherwise.splice(1), 1)
             ];
         }
-    }
-}
-function removeExpressionListWrap(code) {
-    if (code.length > 0 && code[0].line === '{' && code[code.length - 1].line === '}') {
-        return indentBy(code.slice(1, code.length - 1), -1);
+        else {
+            return otherwise;
+        }
     }
     else {
-        return code;
+        const thenRemainder = indentBy(then.slice(1), 1);
+        if (thenRemainder.length > 0) {
+            if (!thenRemainder[thenRemainder.length - 1].line.trim().endsWith('else')) {
+                thenRemainder[thenRemainder.length - 1].line += ' else ';
+            }
+        }
+        return [
+            { line: `if(${getLexeme(ifThenElse.condition)}) ${then[0].line} ${then.length === 1 ? 'else' : ''}`, indent: 0 },
+            ...thenRemainder,
+            { line: `${otherwise[0].line}`, indent: 0 },
+            ...indentBy(otherwise.splice(1), 1)
+        ];
     }
 }
-function reconstructIfThenElse(ifThenElse, condition, when, otherwise, configuration) {
-    if (isSelected(configuration, ifThenElse)) {
-        return plain(getLexeme(ifThenElse));
+function reconstructWhileLoop(loop, condition, body, configuration) {
+    const sel = isSelected(configuration, loop);
+    if (!sel && condition.length === 0) {
+        return body;
     }
-    otherwise ??= [];
-    if (condition.length === 0 && when.length === 0 && otherwise.length === 0) {
+    else if (body.length === 0 && condition.length === 0) {
         return [];
     }
-    if (otherwise.length === 0 && when.length === 0) {
-        return [
-            { line: `if(${getLexeme(ifThenElse.condition)}) { }`, indent: 0 }
-        ];
-    }
-    else if (otherwise.length === 0) {
-        return [
-            { line: `if(${getLexeme(ifThenElse.condition)}) {`, indent: 0 },
-            ...indentBy(removeExpressionListWrap(when), 1),
-            { line: '}', indent: 0 }
-        ];
+    else if (body.length <= 1) {
+        // 'inline'
+        return [{ line: `while(${getLexeme(loop.condition)}) ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
     }
-    else if (when.length === 0) {
+    else if (body[0].line === '{' && body[body.length - 1].line === '}') {
+        // 'block'
         return [
-            { line: `if(${getLexeme(ifThenElse.condition)}) { } else {`, indent: 0 },
-            ...indentBy(removeExpressionListWrap(otherwise), 1),
+            { line: `while(${getLexeme(loop.condition)}) {`, indent: 0 },
+            ...body.slice(1, body.length - 1),
             { line: '}', indent: 0 }
         ];
     }
     else {
+        // unknown
         return [
-            { line: `if(${getLexeme(ifThenElse.condition)}) {`, indent: 0 },
-            ...indentBy(removeExpressionListWrap(when), 1),
-            { line: '} else {', indent: 0 },
-            ...indentBy(removeExpressionListWrap(otherwise), 1),
-            { line: '}', indent: 0 }
+            { line: `while(${getLexeme(loop.condition)})`, indent: 0 },
+            ...indentBy(body, 1)
         ];
     }
 }
-function reconstructWhileLoop(loop, condition, body, configuration) {
-    if (isSelected(configuration, loop)) {
-        return plain(getLexeme(loop));
-    }
-    if (body.length === 0 && condition.length === 0) {
-        return [];
-    }
-    else {
-        if (body.length <= 1) {
-            // 'inline'
-            return [{ line: `while(${getLexeme(loop.condition)}) ${body.length === 0 ? '{}' : body[0].line}`, indent: 0 }];
-        }
-        else if (body[0].line === '{' && body[body.length - 1].line === '}') {
-            // 'block'
-            return [
-                { line: `while(${getLexeme(loop.condition)}) {`, indent: 0 },
-                ...body.slice(1, body.length - 1),
-                { line: '}', indent: 0 }
-            ];
-        }
-        else {
-            // unknown
-            return [
-                { line: `while(${getLexeme(loop.condition)})`, indent: 0 },
-                ...indentBy(body, 1)
-            ];
-        }
-    }
-}
 function reconstructParameters(parameters) {
     // const baseParameters = parameters.flatMap(p => plain(getLexeme(p)))
     return parameters.map(p => {
@@ -227,24 +243,19 @@ function reconstructParameters(parameters) {
         }
     });
 }
-function reconstructFoldAccess(node, accessed, access, configuration) {
-    if (isSelected(configuration, node)) {
-        return plain(getLexeme(node));
-    }
+function isNotEmptyArgument(a) {
+    return a !== r_function_call_1.EmptyArgument;
+}
+function reconstructFoldAccess(node, accessed, access) {
     if (accessed.length === 0) {
-        if (typeof access === 'string') {
-            return [];
-        }
-        else {
-            return access.filter(assert_1.isNotNull).flat();
-        }
+        return access.filter(isNotEmptyArgument).flat();
+    }
+    else if (access.every(a => a === r_function_call_1.EmptyArgument || a.length === 0)) {
+        return accessed;
     }
     return plain(getLexeme(node));
 }
-function reconstructArgument(argument, name, value, configuration) {
-    if (isSelected(configuration, argument)) {
-        return plain(getLexeme(argument));
-    }
+function reconstructArgument(argument, name, value) {
     if (argument.name !== undefined && name !== undefined && name.length > 0) {
         return plain(`${getLexeme(argument.name)}=${argument.value ? getLexeme(argument.value) : ''}`);
     }
@@ -252,9 +263,9 @@ function reconstructArgument(argument, name, value, configuration) {
         return value ?? [];
     }
 }
-function reconstructParameter(parameter, name, value, configuration) {
-    if (isSelected(configuration, parameter)) {
-        return plain(getLexeme(parameter));
+function reconstructParameter(parameter, name, defaultValue, configuration) {
+    if (!isSelected(configuration, parameter)) {
+        return [];
     }
     if (parameter.defaultValue !== undefined && name.length > 0) {
         return plain(`${getLexeme(parameter.name)}=${getLexeme(parameter.defaultValue)}`);
@@ -266,48 +277,45 @@ function reconstructParameter(parameter, name, value, configuration) {
         return name;
     }
 }
-function reconstructFunctionDefinition(definition, functionParameters, body, configuration) {
+function reconstructFunctionDefinition(definition, functionParameters, body, config) {
     // if a definition is not selected, we only use the body - slicing will always select the definition
-    if (!isSelected(configuration, definition) && functionParameters.every(p => p.length === 0)) {
-        return body;
+    if (functionParameters.every(p => p.length === 0)) {
+        const empty = body === undefined || body.length === 0;
+        const selected = isSelected(config, definition);
+        if (empty && selected) { // give function stub
+            return plain(`function(${reconstructParameters(definition.parameters).join(', ')}) { }`);
+        }
+        else if (!selected) { // do not require function
+            return body;
+        }
     }
     const parameters = reconstructParameters(definition.parameters).join(', ');
     if (body.length <= 1) {
         // 'inline'
-        const bodyStr = body.length === 0 ? '' : `${body[0].line} `; /* add suffix space */
+        const bodyStr = body.length === 0 ? '{ }' : `${body[0].line}`;
         // we keep the braces in every case because I do not like no-brace functions
-        return [{ line: `function(${parameters}) { ${bodyStr}}`, indent: 0 }];
-    }
-    else if (body[0].line === '{' && body[body.length - 1].line === '}') {
-        // 'block'
-        return [
-            { line: `function(${parameters}) {`, indent: 0 },
-            ...body.slice(1, body.length - 1),
-            { line: '}', indent: 0 }
-        ];
+        return [{ line: `function(${parameters}) ${bodyStr}`, indent: 0 }];
     }
     else {
-        // unknown -> we add the braces just to be sure
+        // 'block'
         return [
-            { line: `function(${parameters}) {`, indent: 0 },
-            ...indentBy(body, 1),
-            { line: '}', indent: 0 }
+            { line: `function(${parameters}) ${body[0].line}`, indent: 0 },
+            ...body.slice(1),
         ];
     }
 }
 function reconstructSpecialInfixFunctionCall(args, call) {
     (0, assert_1.guard)(args.length === 2, () => `infix special call must have exactly two arguments, got: ${args.length} (${JSON.stringify(args)})`);
     (0, assert_1.guard)(call.flavor === 'named', `infix special call must be named, got: ${call.flavor}`);
-    const lhs = args[0];
-    const rhs = args[1];
+    const [lhs, rhs] = args;
     if ((lhs === undefined || lhs.length === 0) && (rhs === undefined || rhs.length === 0)) {
         return [];
     }
     // else if (rhs === undefined || rhs.length === 0) {
     // if rhs is undefined we still  have to keep both now, but reconstruct manually :/
-    if (lhs !== undefined && lhs.length > 0) {
+    if (lhs !== r_function_call_1.EmptyArgument && lhs.length > 0) {
         const lhsText = lhs.map(l => `${getIndentString(l.indent)}${l.line}`).join('\n');
-        if (rhs !== undefined && rhs.length > 0) {
+        if (rhs !== r_function_call_1.EmptyArgument && rhs.length > 0) {
             const rhsText = rhs.map(l => `${getIndentString(l.indent)}${l.line}`).join('\n');
             return plain(`${lhsText} ${call.functionName.content} ${rhsText}`);
         }
@@ -318,10 +326,20 @@ function reconstructSpecialInfixFunctionCall(args, call) {
     return plain(`${getLexeme(call.arguments[0])} ${call.functionName.content} ${getLexeme(call.arguments[1])}`);
 }
 function reconstructFunctionCall(call, functionName, args, configuration) {
+    const selected = isSelected(configuration, call);
+    if (!selected) {
+        const f = args.filter(a => a !== r_function_call_1.EmptyArgument && a.length !== 0);
+        if (f.length === 0) {
+            return [];
+        }
+        else if (f.length === 1) {
+            return f[0];
+        }
+    }
     if (call.infixSpecial === true) {
         return reconstructSpecialInfixFunctionCall(args, call);
     }
-    if (call.flavor === 'named' && isSelected(configuration, call)) {
+    if (call.flavor === 'named' && selected) {
         return plain(getLexeme(call));
     }
     const filteredArgs = args.filter(a => a !== undefined && a.length > 0);
@@ -329,15 +347,17 @@ function reconstructFunctionCall(call, functionName, args, configuration) {
         return [];
     }
     if (args.length === 0) {
-        (0, assert_1.guard)(functionName.length === 1, `without args, we need the function name to be present! got: ${JSON.stringify(functionName)}`);
-        if (call.flavor === 'unnamed' && !functionName[0].line.endsWith(')')) {
-            functionName[0].line = `(${functionName[0].line})`;
+        (0, assert_1.guard)(functionName.length > 0, `without args, we need the function name to be present! got: ${JSON.stringify(functionName)}`);
+        const last = functionName[functionName.length - 1];
+        if (call.flavor === 'unnamed' && !last.line.endsWith(')')) {
+            functionName[0].line = `(${functionName[0].line}`;
+            last.line += ')';
         }
-        if (!functionName[0].line.endsWith('()')) {
+        if (!last.line.endsWith('()')) {
             // add empty call braces if not present
-            functionName[0].line += '()';
+            last.line += '()';
         }
-        return [{ line: functionName[0].line, indent: functionName[0].indent }];
+        return functionName;
     }
     else {
         return plain(getLexeme(call));
@@ -367,19 +387,9 @@ const reconstructAstFolds = {
     foldLogical: reconstructAsLeaf,
     foldSymbol: reconstructAsLeaf,
     foldAccess: reconstructFoldAccess,
-    binaryOp: {
-        foldLogicalOp: reconstructBinaryOp,
-        foldArithmeticOp: reconstructBinaryOp,
-        foldComparisonOp: reconstructBinaryOp,
-        foldAssignment: reconstructBinaryOp,
-        foldPipe: reconstructBinaryOp,
-        foldModelFormula: reconstructBinaryOp
-    },
-    unaryOp: {
-        foldArithmeticOp: reconstructUnaryOp,
-        foldLogicalOp: reconstructUnaryOp,
-        foldModelFormula: reconstructUnaryOp
-    },
+    foldBinaryOp: reconstructBinaryOp,
+    foldPipe: reconstructBinaryOp,
+    foldUnaryOp: reconstructUnaryOp,
     other: {
         foldComment: reconstructAsLeaf,
         foldLineDirective: reconstructAsLeaf
@@ -425,7 +435,7 @@ function removeOuterExpressionListIfApplicable(result, autoSelected) {
  * @returns The number of times `autoSelectIf` triggered, as well as the reconstructed code itself.
  */
 function reconstructToCode(ast, selection, autoSelectIf = autoSelectLibrary) {
-    if (exports.reconstructLogger.settings.minLevel >= 1 /* LogLevel.Trace */) {
+    if (exports.reconstructLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
         exports.reconstructLogger.trace(`reconstruct ast with ids: ${JSON.stringify([...selection])}`);
     }
     // we use a wrapper to count the number of times the autoSelectIf predicate triggered
@@ -438,10 +448,8 @@ function reconstructToCode(ast, selection, autoSelectIf = autoSelectLibrary) {
         return result;
     };
     // fold of the normalized ast
-    const result = (0, r_bridge_1.foldAstStateful)(ast.ast, { selection, autoSelectIf: autoSelectIfWrapper }, reconstructAstFolds);
-    if (exports.reconstructLogger.settings.minLevel >= 1 /* LogLevel.Trace */) {
-        exports.reconstructLogger.trace('reconstructed ast before string conversion: ', JSON.stringify(result));
-    }
+    const result = (0, stateful_fold_1.foldAstStateful)(ast.ast, { selection, autoSelectIf: autoSelectIfWrapper }, reconstructAstFolds);
+    (0, log_1.expensiveTrace)(exports.reconstructLogger, () => `reconstructed ast before string conversion: ${JSON.stringify(result)}`);
     return removeOuterExpressionListIfApplicable(result, autoSelected);
 }
 exports.reconstructToCode = reconstructToCode;

package/slicing/criterion/collect-all.d.ts

@@ -4,8 +4,9 @@
  * @module
  */
 import type { MergeableRecord } from '../../util/objects';
-import type { NodeId, RNodeWithParent } from '../../r-bridge';
 import type { SlicingCriteria } from './parse';
+import type { RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /**
  * Defines the filter for collecting all possible slicing criteria.
  * @see DefaultAllVariablesFilter
@@ -13,12 +14,12 @@ import type { SlicingCriteria } from './parse';
 export interface SlicingCriteriaFilter extends MergeableRecord {
     /**
    * Inclusive minimum size of the slicing criteria (number of included slice points).
-   * Should be at least `1` to make sense (and of course at most {@link SlicingCriteriaFilter#maximumSize | maximum size}).
+   * Should be at least `1` to make sense (and of course at most {@link SlicingCriteriaFilter#maximumSize|maximum size}).
    */
     minimumSize: number;
     /**
    * Inclusive maximum size of the slicing criteria (number of included slice points).
-   * Should be at least `1` to make sense (and of course at least {@link SlicingCriteriaFilter#minimumSize | minimum size}).
+   * Should be at least `1` to make sense (and of course at least {@link SlicingCriteriaFilter#minimumSize|minimum size}).
    * <p>
    * Be really careful with this one, as the number of possible slicing criteria can grow exponentially with the maximum size.
    */

package/slicing/criterion/collect-all.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectAllSlicingCriteria = void 0;
 const assert_1 = require("../../util/assert");
 const arrays_1 = require("../../util/arrays");
+const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 /**
  * Will create all possible slicing criteria for the given ast, based on the {@link SlicingCriteriaFilter}.
  * The slicing criteria will be *ordered* (i.e., it will not return `[1:2,3:4]` and `[3:4,1:2]` if `maximumSize` \> 1).
@@ -16,7 +17,10 @@ function* collectAllSlicingCriteria(ast, filter) {
         return;
     }
     for (const combination of (0, arrays_1.getUniqueCombinationsOfSize)(potentialSlicingNodes, filter.minimumSize, filter.maximumSize)) {
-        yield combination.map(n => `$${n}`);
+        const c = combination.filter(n => n !== undefined && n !== r_function_call_1.EmptyArgument);
+        if (c.length > 0) {
+            yield c.map(n => `$${n}`);
+        }
     }
 }
 exports.collectAllSlicingCriteria = collectAllSlicingCriteria;

package/slicing/criterion/filters/all-variables.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultAllVariablesFilter = void 0;
-const r_bridge_1 = require("../../../r-bridge");
 const assert_1 = require("../../../util/assert");
+const fold_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/fold");
+const r_symbol_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol");
+const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 exports.DefaultAllVariablesFilter = {
     minimumSize: 1,
     maximumSize: 1,
@@ -14,21 +16,11 @@ const defaultAllVariablesCollectorFolds = {
     foldNumber: onLeaf,
     foldString: onLeaf,
     foldLogical: onLeaf,
-    foldSymbol: (symbol) => (0, r_bridge_1.isSpecialSymbol)(symbol) ? [] : [symbol.info.id],
-    foldAccess: (_, name, access) => Array.isArray(access) ? [...name, ...access.filter(assert_1.isNotNull).flat()] : name,
-    binaryOp: {
-        foldLogicalOp: onBinary,
-        foldArithmeticOp: onBinary,
-        foldComparisonOp: onBinary,
-        foldAssignment: onBinary,
-        foldPipe: onBinary,
-        foldModelFormula: onBinary
-    },
-    unaryOp: {
-        foldLogicalOp: (_, operator) => operator,
-        foldArithmeticOp: (_, operator) => operator,
-        foldModelFormula: (_, operator) => operator
-    },
+    foldSymbol: (symbol) => (0, r_symbol_1.isSpecialSymbol)(symbol) ? [] : [symbol.info.id],
+    foldAccess: (_, name, access) => [...name, ...access.filter(assert_1.isNotNull).flat()],
+    foldBinaryOp: onBinary,
+    foldPipe: onBinary,
+    foldUnaryOp: (_, operator) => operator,
     loop: {
         foldFor: (_, a, b, c) => [...a, ...b, ...c],
         foldWhile: (_, a, b) => [...a, ...b],
@@ -41,23 +33,23 @@ const defaultAllVariablesCollectorFolds = {
         foldLineDirective: onLeaf
     },
     foldIfThenElse: (_, a, b, c) => [...a, ...b, ...(c ?? [])],
-    foldExprList: (_, a) => a.flat(),
+    foldExprList: (_, _grouping, a) => a.flat(),
     functions: {
         foldFunctionDefinition: (_, a, b) => [...a.flat(), ...b],
         foldFunctionCall: (c, a, b) => {
-            const args = b.flatMap(b => b !== undefined ? b.flat() : []);
+            const args = b.flatMap(b => b !== r_function_call_1.EmptyArgument ? b.flat() : []);
             if (c.flavor === 'named') {
                 return c.functionName.content === 'library' ? args.slice(1) : args;
             }
             else {
-                return [...a, ...args];
+                return [...a.filter(x => x !== r_function_call_1.EmptyArgument), ...args];
             }
         },
-        foldArgument: (_, a, b) => b ?? [],
-        foldParameter: (_, a, b) => b ?? []
+        foldArgument: (_, _a, b) => b ?? [],
+        foldParameter: (_, _a, b) => b ?? []
     }
 };
 function defaultAllVariablesCollector(ast) {
-    return (0, r_bridge_1.foldAst)(ast, defaultAllVariablesCollectorFolds);
+    return (0, fold_1.foldAst)(ast, defaultAllVariablesCollectorFolds);
 }
 //# sourceMappingURL=all-variables.js.map