@eagleoutice/flowr 2.1.7 → 2.1.9

package/README.md

@@ -34,7 +34,6 @@ We welcome every contribution! Please check out the [contributing guidelines](ht
 ### Contributors
 
 <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
-<!--suppress ALL -->
 <!-- prettier-ignore-start -->
 <!-- markdownlint-disable -->
 <table>
@@ -42,6 +41,7 @@ We welcome every contribution! Please check out the [contributing guidelines](ht
     <tr>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/EagleoutIce"><img src="https://avatars.githubusercontent.com/u/9303573?v=4?s=100" width="100px;" alt="Florian Sihler"/><br /><sub><b>Florian Sihler</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=EagleoutIce" title="Code">💻</a> <a href="#ideas-EagleoutIce" title="Ideas, Planning, & Feedback">🤔</a> <a href="#maintenance-EagleoutIce" title="Maintenance">🚧</a> <a href="#projectManagement-EagleoutIce" title="Project Management">📆</a> <a href="#research-EagleoutIce" title="Research">🔬</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=EagleoutIce" title="Tests">⚠️</a> <a href="#talk-EagleoutIce" title="Talks">📢</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://ellpeck.de/"><img src="https://avatars.githubusercontent.com/u/5741138?v=4?s=100" width="100px;" alt="Ell"/><br /><sub><b>Ell</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=Ellpeck" title="Code">💻</a> <a href="#maintenance-Ellpeck" title="Maintenance">🚧</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=Ellpeck" title="Tests">⚠️</a> <a href="#plugin-Ellpeck" title="Plugin/utility libraries">🔌</a></td>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/gigalasr"><img src="https://avatars.githubusercontent.com/u/25102989?v=4?s=100" width="100px;" alt="Lars"/><br /><sub><b>Lars</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=gigalasr" title="Code">💻</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=gigalasr" title="Tests">⚠️</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://lukas.pietzschmann.org/"><img src="https://avatars.githubusercontent.com/u/49213919?v=4?s=100" width="100px;" alt="Lukas Pietzschmann"/><br /><sub><b>Lukas Pietzschmann</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=LukasPietzschmann" title="Code">💻</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=LukasPietzschmann" title="Tests">⚠️</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/bjthehun"><img src="https://avatars.githubusercontent.com/u/38729215?v=4?s=100" width="100px;" alt="Benedikt Jutz"/><br /><sub><b>Benedikt Jutz</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=bjthehun" title="Code">💻</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=bjthehun" title="Tests">⚠️</a></td>
       <td align="center" valign="top" width="14.28%"><a href="https://github.com/Core5563"><img src="https://avatars.githubusercontent.com/u/140061253?v=4?s=100" width="100px;" alt="Core5563"/><br /><sub><b>Core5563</b></sub></a><br /><a href="https://github.com/flowr-analysis/flowr/commits?author=Core5563" title="Code">💻</a> <a href="https://github.com/flowr-analysis/flowr/commits?author=Core5563" title="Tests">⚠️</a></td>
@@ -61,6 +61,7 @@ We welcome every contribution! Please check out the [contributing guidelines](ht
 
 <!-- markdownlint-restore -->
 <!-- prettier-ignore-end -->
+
 <!-- ALL-CONTRIBUTORS-LIST:END -->
 
 ----

package/abstract-interpretation/normalized-ast-fold.d.ts

@@ -0,0 +1,124 @@
+import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
+import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
+import type { RFunctionCall } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RFunctionDefinition } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-definition';
+import { RType } from '../r-bridge/lang-4.x/ast/model/type';
+import type { RForLoop } from '../r-bridge/lang-4.x/ast/model/nodes/r-for-loop';
+import type { RWhileLoop } from '../r-bridge/lang-4.x/ast/model/nodes/r-while-loop';
+import type { RRepeatLoop } from '../r-bridge/lang-4.x/ast/model/nodes/r-repeat-loop';
+import type { RIfThenElse } from '../r-bridge/lang-4.x/ast/model/nodes/r-if-then-else';
+import type { RBinaryOp } from '../r-bridge/lang-4.x/ast/model/nodes/r-binary-op';
+import type { RPipe } from '../r-bridge/lang-4.x/ast/model/nodes/r-pipe';
+import type { RUnaryOp } from '../r-bridge/lang-4.x/ast/model/nodes/r-unary-op';
+import type { RParameter } from '../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
+import type { RArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+import type { RAccess } from '../r-bridge/lang-4.x/ast/model/nodes/r-access';
+import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import type { RBreak } from '../r-bridge/lang-4.x/ast/model/nodes/r-break';
+import type { RComment } from '../r-bridge/lang-4.x/ast/model/nodes/r-comment';
+import type { RNext } from '../r-bridge/lang-4.x/ast/model/nodes/r-next';
+import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
+import type { RLineDirective } from '../r-bridge/lang-4.x/ast/model/nodes/r-line-directive';
+import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+type FoldOfType<T extends RType, Returns = void, Info = NoInfo> = (node: Extract<RNode<Info>, {
+    type: T;
+}>) => Returns;
+/** explicitly excludes types that are not visitable */
+export type FoldableRType = Exclude<RType, RType.Delimiter>;
+/**
+ * Describes the fold functions for each node type.
+ */
+export type NormalizedAstFold<Returns = void, Info = NoInfo> = {
+    [K in FoldableRType as `fold${Capitalize<K>}`]: FoldOfType<K, Returns, Info>;
+};
+/**
+ * Describes the type of a mapping object,
+ * which maps the type of the normalized AST node to the corresponding fold function.
+ */
+export type FittingNormalizedAstFold<Returns = void, Info = NoInfo> = Readonly<{
+    [K in FoldableRType]: FoldOfType<K, Returns, Info>;
+}>;
+export type SingleOrArrayOrNothing<T> = T | readonly (T | null | undefined)[] | null | undefined;
+export type EntryExitVisitor<Info> = ((node: RNode<Info>) => void) | undefined;
+/**
+ * Default implementation of a fold over the normalized AST (using the classic fold traversal).
+ * To modify the behavior, please extend this class and overwrite the methods of interest.
+ * You can control the value passing (`Returns` generic)
+ * by providing sensible Monoid behavior overwriting the {@link DefaultNormalizedAstFold#concat|concat} method
+ * and supplying the empty value in the constructor.
+ *
+ * @note By providing `entry` and `exit` you can use this as an extension to the simpler {@link visitAst} function but without
+ *       the early termination within the visitors (for this, you can overwrite the respective `fold*` methods).
+ *
+ * @example First you want to create your own fold:
+ *
+ * ```ts
+ * let marker = false;
+ * class MyNumberFold<Info> extends DefaultNormalizedAstFold<void, Info> {
+ *     override foldRNumber(node: RNumber<Info>) {
+ *         super.foldRNumber(node);
+ *         marker = true;
+ *     }
+ * }
+ * ```
+ * This one does explicitly not use the return functionality (and hence acts more as a conventional visitor).
+ * Now let us suppose we have a normalized AST as an {@link RNode} in the variable `ast`
+ * and want to check if the AST contains a number:
+ *
+ * ```ts
+ * const result = new MyNumberFold().fold(ast);
+ * ```
+ *
+ * Please take a look at the corresponding tests or the wiki pages for more information on how to use this fold.
+ */
+export declare class DefaultNormalizedAstFold<Returns = void, Info = NoInfo> implements NormalizedAstFold<Returns, Info> {
+    protected readonly enter: EntryExitVisitor<Info>;
+    protected readonly exit: EntryExitVisitor<Info>;
+    protected readonly empty: Returns;
+    /**
+     * Empty must provide a sensible default whenever you want to have `Returns` as non-`void`
+     * (e.g., whenever you want your visitors to be able to return a value).
+     */
+    constructor(empty: Returns, enter?: EntryExitVisitor<Info>, exit?: EntryExitVisitor<Info>);
+    /**
+     * Monoid::concat
+     *
+     *
+     * @see {@link https://en.wikipedia.org/wiki/Monoid}
+     * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
+     */
+    protected concat(_a: Returns, _b: Returns): Returns;
+    /**
+     * overwrite this method, if you have a faster way to concat multiple nodes
+     *
+     * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
+     */
+    protected concatAll(nodes: readonly Returns[]): Returns;
+    fold(nodes: SingleOrArrayOrNothing<RNode<Info> | typeof EmptyArgument>): Returns;
+    protected foldSingle(node: RNode<Info>): Returns;
+    foldRAccess(access: RAccess<Info>): Returns;
+    foldRArgument(argument: RArgument<Info>): Returns;
+    foldRBinaryOp(binaryOp: RBinaryOp<Info>): Returns;
+    foldRExpressionList(exprList: RExpressionList<Info>): Returns;
+    foldRForLoop(loop: RForLoop<Info>): Returns;
+    foldRFunctionCall(call: RFunctionCall<Info>): Returns;
+    foldRFunctionDefinition(definition: RFunctionDefinition<Info>): Returns;
+    foldRIfThenElse(ite: RIfThenElse<Info>): Returns;
+    foldRParameter(parameter: RParameter<Info>): Returns;
+    foldRPipe(pipe: RPipe<Info>): Returns;
+    foldRRepeatLoop(loop: RRepeatLoop<Info>): Returns;
+    foldRUnaryOp(unaryOp: RUnaryOp<Info>): Returns;
+    foldRWhileLoop(loop: RWhileLoop<Info>): Returns;
+    foldRBreak(_node: RBreak<Info>): Returns;
+    foldRComment(_node: RComment<Info>): Returns;
+    foldRLineDirective(_node: RLineDirective<Info>): Returns;
+    foldRLogical(_node: RLogical<Info>): Returns;
+    foldRNext(_node: RNext<Info>): Returns;
+    foldRNumber(_node: RNumber<Info>): Returns;
+    foldRString(_node: RString<Info>): Returns;
+    foldRSymbol(_node: RSymbol<Info>): Returns;
+    protected readonly folds: FittingNormalizedAstFold<Returns, Info>;
+}
+export {};

package/abstract-interpretation/normalized-ast-fold.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultNormalizedAstFold = void 0;
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
+/**
+ * Default implementation of a fold over the normalized AST (using the classic fold traversal).
+ * To modify the behavior, please extend this class and overwrite the methods of interest.
+ * You can control the value passing (`Returns` generic)
+ * by providing sensible Monoid behavior overwriting the {@link DefaultNormalizedAstFold#concat|concat} method
+ * and supplying the empty value in the constructor.
+ *
+ * @note By providing `entry` and `exit` you can use this as an extension to the simpler {@link visitAst} function but without
+ *       the early termination within the visitors (for this, you can overwrite the respective `fold*` methods).
+ *
+ * @example First you want to create your own fold:
+ *
+ * ```ts
+ * let marker = false;
+ * class MyNumberFold<Info> extends DefaultNormalizedAstFold<void, Info> {
+ *     override foldRNumber(node: RNumber<Info>) {
+ *         super.foldRNumber(node);
+ *         marker = true;
+ *     }
+ * }
+ * ```
+ * This one does explicitly not use the return functionality (and hence acts more as a conventional visitor).
+ * Now let us suppose we have a normalized AST as an {@link RNode} in the variable `ast`
+ * and want to check if the AST contains a number:
+ *
+ * ```ts
+ * const result = new MyNumberFold().fold(ast);
+ * ```
+ *
+ * Please take a look at the corresponding tests or the wiki pages for more information on how to use this fold.
+ */
+class DefaultNormalizedAstFold {
+    enter;
+    exit;
+    empty;
+    /**
+     * Empty must provide a sensible default whenever you want to have `Returns` as non-`void`
+     * (e.g., whenever you want your visitors to be able to return a value).
+     */
+    constructor(empty, enter, exit) {
+        this.empty = empty;
+        this.enter = enter;
+        this.exit = exit;
+    }
+    /**
+     * Monoid::concat
+     *
+     *
+     * @see {@link https://en.wikipedia.org/wiki/Monoid}
+     * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
+     */
+    concat(_a, _b) {
+        return this.empty;
+    }
+    /**
+     * overwrite this method, if you have a faster way to concat multiple nodes
+     *
+     * @see {@link DefaultNormalizedAstFold#concatAll|concatAll}
+     */
+    concatAll(nodes) {
+        return nodes.reduce((acc, n) => this.concat(acc, n), this.empty);
+    }
+    fold(nodes) {
+        if (Array.isArray(nodes)) {
+            const n = nodes;
+            return this.concatAll(n.filter(n => n && n !== r_function_call_1.EmptyArgument).map(node => this.foldSingle(node)));
+        }
+        else if (nodes) {
+            return this.foldSingle(nodes);
+        }
+        return this.empty;
+    }
+    foldSingle(node) {
+        this.enter?.(node);
+        const type = node.type;
+        // @ts-expect-error -- ts may be unable to infer that the type is correct
+        const result = this.folds[type]?.(node);
+        this.exit?.(node);
+        return result;
+    }
+    foldRAccess(access) {
+        let accessed = this.foldSingle(access.accessed);
+        if (access.operator === '[' || access.operator === '[[') {
+            accessed = this.concat(accessed, this.fold(access.access));
+        }
+        return accessed;
+    }
+    foldRArgument(argument) {
+        return this.concat(this.fold(argument.name), this.fold(argument.value));
+    }
+    foldRBinaryOp(binaryOp) {
+        return this.concat(this.foldSingle(binaryOp.lhs), this.foldSingle(binaryOp.rhs));
+    }
+    foldRExpressionList(exprList) {
+        return this.concat(this.fold(exprList.grouping), this.fold(exprList.children));
+    }
+    foldRForLoop(loop) {
+        return this.concatAll([this.foldSingle(loop.variable), this.foldSingle(loop.vector), this.foldSingle(loop.body)]);
+    }
+    foldRFunctionCall(call) {
+        return this.concat(this.foldSingle(call.named ? call.functionName : call.calledFunction), this.fold(call.arguments));
+    }
+    foldRFunctionDefinition(definition) {
+        return this.concat(this.fold(definition.parameters), this.foldSingle(definition.body));
+    }
+    foldRIfThenElse(ite) {
+        return this.concatAll([this.foldSingle(ite.condition), this.foldSingle(ite.then), this.fold(ite.otherwise)]);
+    }
+    foldRParameter(parameter) {
+        return this.concat(this.foldSingle(parameter.name), this.fold(parameter.defaultValue));
+    }
+    foldRPipe(pipe) {
+        return this.concat(this.foldSingle(pipe.lhs), this.foldSingle(pipe.rhs));
+    }
+    foldRRepeatLoop(loop) {
+        return this.foldSingle(loop.body);
+    }
+    foldRUnaryOp(unaryOp) {
+        return this.foldSingle(unaryOp.operand);
+    }
+    foldRWhileLoop(loop) {
+        return this.concat(this.foldSingle(loop.condition), this.foldSingle(loop.body));
+    }
+    foldRBreak(_node) {
+        return this.empty;
+    }
+    foldRComment(_node) {
+        return this.empty;
+    }
+    foldRLineDirective(_node) {
+        return this.empty;
+    }
+    foldRLogical(_node) {
+        return this.empty;
+    }
+    foldRNext(_node) {
+        return this.empty;
+    }
+    foldRNumber(_node) {
+        return this.empty;
+    }
+    foldRString(_node) {
+        return this.empty;
+    }
+    foldRSymbol(_node) {
+        return this.empty;
+    }
+    folds = {
+        [type_1.RType.Access]: n => this.foldRAccess(n),
+        [type_1.RType.Argument]: n => this.foldRArgument(n),
+        [type_1.RType.BinaryOp]: n => this.foldRBinaryOp(n),
+        [type_1.RType.Break]: n => this.foldRBreak(n),
+        [type_1.RType.Comment]: n => this.foldRComment(n),
+        [type_1.RType.ExpressionList]: n => this.foldRExpressionList(n),
+        [type_1.RType.ForLoop]: n => this.foldRForLoop(n),
+        [type_1.RType.FunctionCall]: n => this.foldRFunctionCall(n),
+        [type_1.RType.FunctionDefinition]: n => this.foldRFunctionDefinition(n),
+        [type_1.RType.IfThenElse]: n => this.foldRIfThenElse(n),
+        [type_1.RType.LineDirective]: n => this.foldRLineDirective(n),
+        [type_1.RType.Logical]: n => this.foldRLogical(n),
+        [type_1.RType.Next]: n => this.foldRNext(n),
+        [type_1.RType.Number]: n => this.foldRNumber(n),
+        [type_1.RType.Parameter]: n => this.foldRParameter(n),
+        [type_1.RType.Pipe]: n => this.foldRPipe(n),
+        [type_1.RType.RepeatLoop]: n => this.foldRRepeatLoop(n),
+        [type_1.RType.String]: n => this.foldRString(n),
+        [type_1.RType.Symbol]: n => this.foldRSymbol(n),
+        [type_1.RType.UnaryOp]: n => this.foldRUnaryOp(n),
+        [type_1.RType.WhileLoop]: n => this.foldRWhileLoop(n),
+    };
+}
+exports.DefaultNormalizedAstFold = DefaultNormalizedAstFold;
+//# sourceMappingURL=normalized-ast-fold.js.map

package/benchmark/summarizer/first-phase/process.js

@@ -42,6 +42,7 @@ const shell_1 = require("../../../r-bridge/shell");
 const retriever_1 = require("../../../r-bridge/retriever");
 const visitor_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/visitor");
 const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
+const arrays_1 = require("../../../util/arrays");
 const tempfile = (() => {
     let _tempfile = undefined;
     return () => {
@@ -244,15 +245,15 @@ async function summarizeSlicerStats(stats, report = () => {
 }
 function summarizeSummarizedMeasurement(data) {
     data = data.filter(assert_1.isNotUndefined);
-    const min = data.map(d => d.min).filter(assert_1.isNotUndefined).reduce((a, b) => Math.min(a, b), Infinity);
-    const max = data.map(d => d.max).filter(assert_1.isNotUndefined).reduce((a, b) => Math.max(a, b), -Infinity);
+    const min = Math.min(...data.map(d => d.min).filter(assert_1.isNotUndefined));
+    const max = Math.max(...data.map(d => d.max).filter(assert_1.isNotUndefined));
     // calculate median of medians (don't just average the median!)
     const medians = data.map(d => d.median).filter(assert_1.isNotUndefined).sort((a, b) => a - b);
     const median = medians[Math.floor(medians.length / 2)];
-    const mean = data.map(d => d.mean).filter(assert_1.isNotUndefined).reduce((a, b) => a + b, 0) / data.length;
+    const mean = (0, arrays_1.arraySum)(data.map(d => d.mean).filter(assert_1.isNotUndefined)) / data.length;
     // Method 1 of https://www.statology.org/averaging-standard-deviations/
-    const std = Math.sqrt(data.map(d => d.std ** 2).filter(assert_1.isNotUndefined).reduce((a, b) => a + b, 0) / data.length);
-    const total = data.map(d => d.total).filter(assert_1.isNotUndefined).reduce((a, b) => a + b, 0);
+    const std = Math.sqrt((0, arrays_1.arraySum)(data.map(d => d.std ** 2).filter(assert_1.isNotUndefined)) / data.length);
+    const total = (0, arrays_1.arraySum)(data.map(d => d.total).filter(assert_1.isNotUndefined));
     return { min, max, median, mean, std, total };
 }
 function summarizeSummarizedReductions(reductions) {

package/cli/repl/commands/repl-dataflow.js

@@ -11,13 +11,16 @@ async function dataflow(shell, remainingLine) {
         request: (0, retriever_1.requestFromInput)(remainingLine.trim())
     }).allRemainingSteps();
 }
+function handleString(code) {
+    return code.startsWith('"') ? JSON.parse(code) : code;
+}
 exports.dataflowCommand = {
     description: `Get mermaid code for the dataflow graph of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
     usageExample: ':dataflow',
     aliases: ['d', 'df'],
     script: false,
     fn: async (output, shell, remainingLine) => {
-        const result = await dataflow(shell, remainingLine);
+        const result = await dataflow(shell, handleString(remainingLine));
         output.stdout((0, dfg_1.graphToMermaid)({ graph: result.dataflow.graph, includeEnvironments: false }).string);
     }
 };
@@ -27,7 +30,7 @@ exports.dataflowStarCommand = {
     aliases: ['d*', 'df*'],
     script: false,
     fn: async (output, shell, remainingLine) => {
-        const result = await dataflow(shell, remainingLine);
+        const result = await dataflow(shell, handleString(remainingLine));
         output.stdout((0, dfg_1.graphToMermaidUrl)(result.dataflow.graph, false));
     }
 };

package/cli/repl/commands/repl-normalize.js

@@ -11,13 +11,16 @@ async function normalize(shell, remainingLine) {
         request: (0, retriever_1.requestFromInput)(remainingLine.trim())
     }).allRemainingSteps();
 }
+function handleString(code) {
+    return code.startsWith('"') ? JSON.parse(code) : code;
+}
 exports.normalizeCommand = {
     description: `Get mermaid code for the normalized AST of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
     usageExample: ':normalize',
     aliases: ['n'],
     script: false,
     fn: async (output, shell, remainingLine) => {
-        const result = await normalize(shell, remainingLine);
+        const result = await normalize(shell, handleString(remainingLine));
         output.stdout((0, ast_1.normalizedAstToMermaid)(result.normalize.ast));
     }
 };
@@ -27,7 +30,7 @@ exports.normalizeStarCommand = {
     aliases: ['n*'],
     script: false,
     fn: async (output, shell, remainingLine) => {
-        const result = await normalize(shell, remainingLine);
+        const result = await normalize(shell, handleString(remainingLine));
         output.stdout((0, ast_1.normalizedAstToMermaidUrl)(result.normalize.ast));
     }
 };

package/cli/repl/commands/repl-query.js

@@ -19,7 +19,7 @@ async function getDataflow(shell, remainingLine) {
 function printHelp(output) {
     output.stderr(`Format: ${(0, ansi_1.italic)(':query "<query>" <code>', output.formatter)}`);
     output.stdout('The query is an array of query objects to represent multiple queries. Each query object may have the following properties:');
-    output.stdout((0, schema_1.describeSchema)(query_1.AnyQuerySchema, output.formatter));
+    output.stdout((0, schema_1.describeSchema)((0, query_1.AnyQuerySchema)(), output.formatter));
     output.stdout(`\n\nThe example ${(0, ansi_1.italic)(':query "[{\\"type\\": \\"call-context\\", \\"callName\\": \\"mean\\" }]" mean(1:10)', output.formatter)} would return the call context of the mean function.`);
     output.stdout('As a convenience, we interpret any (non-help) string not starting with \'[\' as a regex for the simple call-context query.');
     output.stdout(`Hence, ${(0, ansi_1.italic)(':query "mean" mean(1:10)', output.formatter)} is equivalent to the above example.`);
@@ -38,7 +38,7 @@ async function processQueryArgs(line, shell, output) {
     let parsedQuery = [];
     if (query.startsWith('[')) {
         parsedQuery = JSON.parse(query);
-        const validationResult = query_1.QueriesSchema.validate(parsedQuery);
+        const validationResult = (0, query_1.QueriesSchema)().validate(parsedQuery);
         if (validationResult.error) {
             output.stderr(`Invalid query: ${validationResult.error.message}`);
             printHelp(output);

package/cli/repl/server/messages/message-query.js

@@ -12,7 +12,7 @@ exports.requestQueryMessage = {
         type: joi_1.default.string().valid('request-query').required().description('The type of the message.'),
         id: joi_1.default.string().optional().description('If you give the id, the response will be sent to the client with the same id.'),
         filetoken: joi_1.default.string().required().description('The filetoken of the file/data retrieved from the analysis request.'),
-        query: query_1.QueriesSchema.required().description('The query to run on the file analysis information.')
+        query: (0, query_1.QueriesSchema)().required().description('The query to run on the file analysis information.')
     }).description('Request a query to be run on the file analysis information.')
 };
 exports.responseQueryMessage = {

package/cli/slicer-app.js

@@ -29,7 +29,7 @@ async function getSlice() {
     (0, assert_1.guard)(options.input !== undefined, 'input must be given');
     (0, assert_1.guard)(options.criterion !== undefined, 'a slicing criterion must be given');
     await slicer.init(options['input-is-text']
-        ? { request: 'text', content: options.input }
+        ? { request: 'text', content: options.input.replaceAll('\\n', '\n') }
         : { request: 'file', content: options.input }, options['no-magic-comments'] ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect));
     let mappedSlices = [];
     let reconstruct = undefined;

package/core/steps/pipeline/pipeline.d.ts

@@ -22,6 +22,16 @@ export interface Pipeline<T extends IPipelineStep = IPipelineStep> {
  * @see Pipeline for details
  */
 export type PipelineStepNames<P extends Pipeline> = PipelineStep<P>['name'];
+/**
+ * Returns the steps included in the given pipeline.
+ * @example
+ * ```ts
+ * type Pipeline = typeof DEFAULT_DATAFLOW_PIPELINE
+ * // Pipeline is now Pipeline<step1 | step2 | ...>
+ * type Steps = PipelineStep<typeof DEFAULT_DATAFLOW_PIPELINE>
+ * // Steps is now just step1 | step2 | ...
+ * ```
+ */
 export type PipelineStep<P extends Pipeline> = P extends Pipeline<infer U> ? U : never;
 /**
  * Meta-information attached to every step result
@@ -35,10 +45,51 @@ export interface PipelinePerStepMetaInformation {
         readonly timing: number;
     };
 }
+/**
+ * Returns the step with the given name from the given pipeline.
+ *
+ * @example
+ * ```ts
+ * type Foo = PipelineStepWithName<typeof DEFAULT_DATAFLOW_PIPELINE, 'parse'>
+ * // Foo is now only the "parse" step from the DEFAULT_DATAFLOW_PIPELINE
+ * ```
+ */
 export type PipelineStepWithName<P extends Pipeline, Name extends PipelineStepName> = P extends Pipeline<infer U> ? U extends IPipelineStep<Name> ? U : never : never;
+/**
+ * Returns the processor function of the step with the given name from the given pipeline.
+ * @see {@link PipelineStepWithName}
+ */
 export type PipelineStepProcessorWithName<P extends Pipeline, Name extends PipelineStepName> = PipelineStepWithName<P, Name>['processor'];
+/**
+ * Returns the printer function of the step with the given name from the given pipeline.
+ * @see {@link PipelineStepWithName}
+ */
 export type PipelineStepPrintersWithName<P extends Pipeline, Name extends PipelineStepName> = PipelineStepWithName<P, Name>['printer'];
+/**
+ * Returns the output type of the step with the given name from the given pipeline.
+ *
+ * @example
+ * ```ts
+ * type Foo = PipelineStepOutputWithName<typeof DEFAULT_DATAFLOW_PIPELINE, 'parse'>
+ * // Foo contains the ParseStepOutput & PipelinePerStepMetaInformation type (ie the parse output and meta information)
+ * @see {@link PipelineStepWithName}
+ * ```
+ */
 export type PipelineStepOutputWithName<P extends Pipeline, Name extends PipelineStepName> = Awaited<ReturnType<PipelineStepProcessorWithName<P, Name>>> & PipelinePerStepMetaInformation;
+/**
+ * Returns a union type that represents the required inputs to be passed to the given pipeline.
+ *
+ * @example
+ * ```ts
+ * type Foo = PipelineInput<typeof DEFAULT_DATAFLOW_PIPELINE>
+ * // Foo contains ParseRequiredInput & NormalizeRequiredInput
+ * ```
+ *
+ * In short, this can be useful whenever you want to describe _all_ inputs a complete
+ * pipeline needs to run through (i.e., the union of all inputs required by the individual steps).
+ *
+ * @see {@link PipelineOutput}
+ */
 export type PipelineInput<P extends Pipeline> = UnionToIntersection<PipelineStep<P>['requiredInput']>;
 /**
  * Only gets the union of 'requiredInput' of those PipelineSteps which have a 'execute' field of type 'OncePerRequest'.
@@ -47,6 +98,18 @@ export type PipelineInput<P extends Pipeline> = UnionToIntersection<PipelineStep
 export type PipelinePerRequestInput<P extends Pipeline> = {
     [K in PipelineStepNames<P>]: PipelineStepWithName<P, K>['executed'] extends PipelineStepStage.OncePerFile ? never : PipelineStepWithName<P, K>['requiredInput'];
 }[PipelineStepNames<P>];
+/**
+ * Returns an object type that represents the types of the outputs that will result from running the given pipeline, each as the step's name mapped to its PipelineStepOutputWithName.
+ * @example
+ * ```ts
+ * type Foo = PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>
+ * // Foo contains {
+ * //   parse: ParseStepOutput & PipelinePerStepMetaInformation,
+ * //   normalize: NormalizeStepOutput & PipelinePerStepMetaInformation,
+ * //   ...
+ * // }
+ * ```
+ */
 export type PipelineOutput<P extends Pipeline> = {
     [K in PipelineStepNames<P>]: PipelineStepOutputWithName<P, K>;
 };

package/dataflow/environments/default-builtin-config.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultBuiltinConfig = void 0;
+const identify_link_to_last_call_relation_1 = require("../../queries/catalog/call-context-query/identify-link-to-last-call-relation");
+const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+const cascade_action_1 = require("../../queries/catalog/call-context-query/cascade-action");
 /**
  * Contains the built-in definitions recognized by flowR
  */
@@ -40,10 +43,45 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['print', 'message', 'warning'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     // graphics base
     { type: 'function', names: ['plot', 'plot.new', 'curve', 'map', 'image', 'boxplot', 'dotchart', 'sunflowerplot', 'barplot', 'matplot', 'hist', 'stem', 'density', 'smoothScatter', 'contour', 'persp'],
-        processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^pdf|jpeg|png|windows|postscript|xfig|bitmap|pictex|cairo_pdf|svg|bmp|tiff|X11|quartz$/ } }, assumePrimitive: true },
+        processor: 'builtin:default',
+        config: {
+            forceArgs: 'all',
+            hasUnknownSideEffects: {
+                type: 'link-to-last-call',
+                ignoreIf: (source, graph) => {
+                    /* map with add = true appends to an existing plot */
+                    return (source.name === 'map' && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, source, {
+                        index: 11,
+                        name: 'add'
+                    }, [type_1.RType.Logical])?.content === true);
+                },
+                callName: /^(pdf|jpeg|png|windows|postscript|xfig|bitmap|pictex|cairo_pdf|svg|bmp|tiff|X11|quartz)$/
+            }
+        }, assumePrimitive: true },
     // graphics addons
-    { type: 'function', names: ['points', 'abline', 'mtext', 'lines', 'text', 'legend', 'title', 'axis', 'polygon', 'polypath', 'pie', 'rect', 'segments', 'arrows', 'symbols', 'tiplabels'],
-        processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^dev\.new|dev\.copy|plot\.new|xspline|sunflowerplot|dotchart|plot|map|image|curve|boxplot|barplot|matplot|hist|stem|density|smoothScatter|contour|persp$/ } }, assumePrimitive: true },
+    { type: 'function', names: ['points', 'abline', 'map', 'mtext', 'lines', 'text', 'legend', 'title', 'axis', 'polygon', 'polypath', 'pie', 'rect', 'segments', 'arrows', 'symbols', 'tiplabels'],
+        processor: 'builtin:default', config: {
+            forceArgs: 'all',
+            hasUnknownSideEffects: {
+                type: 'link-to-last-call',
+                callName: /^(dev\.new|dev\.copy|plot\.new|xspline|sunflowerplot|dotchart|plot|map|image|curve|boxplot|barplot|matplot|hist|stem|density|smoothScatter|contour|persp)$/,
+                ignoreIf: (source, graph) => {
+                    const sourceVertex = graph.getVertex(source);
+                    /* map with add = true appends to an existing plot */
+                    return (sourceVertex?.name === 'map' && (0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, sourceVertex, {
+                        index: 11,
+                        name: 'add'
+                    }, [type_1.RType.Logical])?.content !== true);
+                },
+                cascadeIf: (target, _, graph) => {
+                    /* map with add = true appends to an existing plot */
+                    return target.name === 'map' ? ((0, identify_link_to_last_call_relation_1.getValueOfArgument)(graph, target, {
+                        index: 11,
+                        name: 'add'
+                    }, [type_1.RType.Logical])?.content === true ? cascade_action_1.CascadeAction.Continue : cascade_action_1.CascadeAction.Stop) : cascade_action_1.CascadeAction.Stop;
+                }
+            }
+        }, assumePrimitive: true },
     { type: 'function', names: ['('], processor: 'builtin:default', config: { returnsNthArgument: 0 }, assumePrimitive: true },
     { type: 'function', names: ['load', 'load_all', 'setwd', 'set.seed'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
     { type: 'function', names: ['eval', 'body', 'formals', 'environment'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
@@ -60,8 +98,9 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['get'], processor: 'builtin:get', config: {}, assumePrimitive: false },
     { type: 'function', names: ['library', 'require'], processor: 'builtin:library', config: {}, assumePrimitive: false },
     { type: 'function', names: ['<-', '='], processor: 'builtin:assignment', config: { canBeReplacement: true }, assumePrimitive: true },
-    { type: 'function', names: [':=', 'assign'], processor: 'builtin:assignment', config: {}, assumePrimitive: true },
-    { type: 'function', names: ['delayedAssign'], processor: 'builtin:assignment', config: { quoteSource: true }, assumePrimitive: true },
+    { type: 'function', names: [':='], processor: 'builtin:assignment', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['assign'], processor: 'builtin:assignment', config: { targetVariable: true }, assumePrimitive: true },
+    { type: 'function', names: ['delayedAssign'], processor: 'builtin:assignment', config: { quoteSource: true, targetVariable: true }, assumePrimitive: true },
     { type: 'function', names: ['<<-'], processor: 'builtin:assignment', config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: ['->'], processor: 'builtin:assignment', config: { swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
     { type: 'function', names: ['->>'], processor: 'builtin:assignment', config: { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
@@ -83,7 +122,7 @@ exports.DefaultBuiltinConfig = [
             /* downloader and installer functions (R, devtools, BiocManager) */
             'library.dynam', 'install.packages', 'install', 'install_github', 'install_gitlab', 'install_bitbucket', 'install_url', 'install_git', 'install_svn', 'install_local', 'install_version', 'update_packages',
             /* weird env attachments */
-            'attach', 'detach', 'unname', 'rm', 'remove'
+            'attach', 'unname', 'data'
         ],
         processor: 'builtin:default',
         config: { hasUnknownSideEffects: true },