@eagleoutice/flowr 2.1.7 → 2.1.9

package/documentation/print-normalized-ast-wiki.js

@@ -13,11 +13,18 @@ const path_1 = __importDefault(require("path"));
 const doc_files_1 = require("./doc-util/doc-files");
 const doc_cli_option_1 = require("./doc-util/doc-cli-option");
 const time_1 = require("../util/time");
+const doc_structure_1 = require("./doc-util/doc-structure");
+const pipeline_executor_1 = require("../core/pipeline-executor");
+const retriever_1 = require("../r-bridge/retriever");
+const visitor_1 = require("../r-bridge/lang-4.x/ast/model/processing/visitor");
+const collect_1 = require("../r-bridge/lang-4.x/ast/model/collect");
+const normalized_ast_fold_1 = require("../abstract-interpretation/normalized-ast-fold");
 async function getText(shell) {
     const rversion = (await shell.usedRVersion())?.format() ?? 'unknown';
     const now = performance.now();
     const types = (0, doc_types_1.getTypesFromFolderAsMermaid)({
         rootFolder: path_1.default.resolve('./src/r-bridge/lang-4.x/ast/model/'),
+        files: [path_1.default.resolve('./src/abstract-interpretation/normalized-ast-fold.ts')],
         typeName: 'RNode',
         inlineTypes: doc_types_1.mermaidHide
     });
@@ -40,7 +47,7 @@ ${(0, doc_code_1.codeBlock)('r', 'x <- 2 * 3 + 1')}
 Each node in the AST contains the type, the id, and the lexeme (if applicable).
 Each edge is labeled with the type of the parent-child relationship (the "role").
 
-${await (0, doc_normalized_ast_1.printNormalizedAstForCode)(shell, 'x <- 2 * 3 + 1')}
+${await (0, doc_normalized_ast_1.printNormalizedAstForCode)(shell, 'x <- 2 * 3 + 1', { showCode: false, prefix: 'flowchart LR\n' })}
 
 &nbsp;
 
@@ -49,7 +56,7 @@ ${await (0, doc_normalized_ast_1.printNormalizedAstForCode)(shell, 'x <- 2 * 3 +
 > you can either use the [Visual Studio Code extension](${doc_files_1.FlowrGithubBaseRef}/vscode-flowr) or the ${(0, doc_cli_option_1.getReplCommand)('normalize*')} 
 > command in the REPL (see the [Interface wiki page](${doc_files_1.FlowrWikiBaseRef}/Interface) for more information). 
 
-Indicative is the root expression list node, which is present in every normalized AST.
+Indicative of the normalization is the root expression list node, which is present in every normalized AST.
 In general, we provide node types for:
 
 1. literals (e.g., numbers and strings)
@@ -77,11 +84,106 @@ Most notably, the \`info\` field holds the \`id\` of the node, which is used to
 
 In summary, we have the following types:
 
-${(0, doc_types_1.printHierarchy)({ program: types.program, hierarchy: types.info, root: 'RNode', collapseFromNesting: Number.MAX_VALUE })}
+${(0, doc_structure_1.details)('Normalized AST Node Types', (0, doc_types_1.printHierarchy)({ program: types.program, hierarchy: types.info, root: 'RNode', collapseFromNesting: Number.MAX_VALUE }))}
 
-With this, the example file produced the following AST (shown from left to right for space reasons):
+The following segments intend to give you an overview of how to work with the normalized AST:
 
-${await (0, doc_normalized_ast_1.printNormalizedAstForCode)(shell, (0, doc_files_1.getFileContentFromRoot)('test/testfiles/example.R'), { prefix: 'flowchart LR\n' })}
+* [How to get a normalized AST](#how-get-a-normalized-ast)
+* [Visitors and Folds](#visitors-and-folds)
+
+## How Get a Normalized AST
+
+As explained alongside the [Interface](${doc_files_1.FlowrWikiBaseRef}/Interface#the-pipeline-executor) wiki page, you can use the 
+\`${pipeline_executor_1.PipelineExecutor.name}\` to get the normalized AST. If you are only interested in the normalization,
+a pipeline like the \`DEFAULT_NORMALIZE_PIPELINE\` suffices:
+
+${(0, doc_code_1.codeBlock)('ts', `
+async function getAst(code: string): Promise<RNode> {
+    const result = await new ${pipeline_executor_1.PipelineExecutor.name}(DEFAULT_NORMALIZE_PIPELINE, {
+        shell: new ${shell_1.RShell.name}(),
+        request: ${retriever_1.requestFromInput.name}(code.trim())
+    }).allRemainingSteps();
+    return result.normalize.ast;
+}`)}
+
+From the REPL, you can use the ${(0, doc_cli_option_1.getReplCommand)('normalize')} command. 
+
+## Traversing the Normalized AST
+
+We provide two ways to traverse the normalized AST: [Visitors](#visitors) and [Folds](#folds).
+
+### Visitors
+
+If you want a simple visitor which traverses the AST, the \`${visitor_1.visitAst.name}\` function from 
+${(0, doc_files_1.getFilePathMd)('../r-bridge/lang-4.x/ast/model/processing/visitor.ts')} is a good starting point.
+You may specify functions to be called whenever you enter and exit a node during the traversal, and any
+computation is to be done by side effects.
+For example, if you want to collect all the \`id\`s present within a normalized (sub-)ast,
+as it is done by the ${collect_1.collectAllIds.name} function, you can use the following visitor:
+
+${(0, doc_code_1.codeBlock)('ts', `
+const ids = new Set<NodeId>();
+visitAst(nodes, node => {
+    ids.add(node.info.id);
+});
+return ids;
+`)} 
+
+### Folds
+
+We formulate a fold with the base class \`${normalized_ast_fold_1.DefaultNormalizedAstFold.name}\` in ${(0, doc_files_1.getFilePathMd)('../abstract-interpretation/normalized-ast-fold.ts')}.
+Using this class, you can create your own fold behavior by overwriting the default methods.
+By default, the class provides a monoid abstraction using the _empty_ from the constructor and the _concat_ method.
+
+ 
+${(0, doc_types_1.printHierarchy)({ program: types.program, hierarchy: types.info, root: 'DefaultNormalizedAstFold' })}
+
+Now, of course, we could provide hundreds of examples here, but we use tests to verify that the fold behaves as expected
+and happily point to them at ${(0, doc_files_1.getFilePathMd)('../../test/functionality/r-bridge/normalize-ast-fold.test.ts')}.
+
+As a simple showcase, we want to use the fold to evaluate numeric expressions containing numbers, \`+\`, and \`*\` operators.
+
+${(0, doc_code_1.codeBlock)('ts', `
+class MyMathFold<Info> extends ${normalized_ast_fold_1.DefaultNormalizedAstFold.name}<number, Info> {
+    constructor() {
+    	/* use \`0\` as a placeholder empty for the monoid */
+        super(0);
+    }
+
+    protected override concat(a: number, b: number): number {
+    	/* for this example, we ignore cases that we cannot handle */ 
+        return b;
+    }
+
+    override foldRNumber(node: RNumber<Info>) {
+    	/* return the value of the number */ 
+        return node.content.num;
+    }
+
+    override foldRBinaryOp(node: RBinaryOp<Info>) {
+        if(node.operator === '+') {
+            return this.fold(node.lhs) + this.fold(node.rhs);
+        } else if(node.operator === '*') {
+            return this.fold(node.lhs) * this.fold(node.rhs);
+        } else {
+        	/* in case we cannot handle the operator we could throw an error, or just use the default behavior: */
+            return super.foldRBinaryOp(node);
+        }
+    }
+}
+`)}
+
+Now, we can use the \`${pipeline_executor_1.PipelineExecutor.name}\` to get the normalized AST and apply the fold:
+  
+${(0, doc_code_1.codeBlock)('ts', `
+const shell = new ${shell_1.RShell.name}();
+const ast = (await new ${pipeline_executor_1.PipelineExecutor.name}(DEFAULT_NORMALIZE_PIPELINE, {
+	shell, request: retrieveNormalizedAst(${shell_1.RShell.name}, '1 + 3 * 2')
+}).allRemainingSteps()).normalize.ast;
+
+const result = new MyMathFold().fold(ast);
+console.log(result); // -> 7
+`)}
 
 `;
 }

package/documentation/print-query-wiki.js

@@ -47,6 +47,13 @@ Besides this, we provide the following ways to automatically categorize and link
    For now, we _only_ offer support for linking to the last call, as the current flow dependency over-approximation is not stable.
 4. **Aliases**      (\`includeAliases\`): Consider a case like \`f <- function_of_interest\`, do you want calls to \`f\` to be included in the results? There is probably no need to combine this with a global call target!
 
+It's also possible to filter the results based on the following properties:
+
+1. **File** (\`fileFilter\`): This allows you to filter the results based on the file in which the call is located. This can be useful if you are only interested in calls in, e.g., specific folders.
+  The \`fileFilter\` property is an object made up of two properties:
+  - **Filter** (\`filter\`): A regular expression that a node's file attribute must match to be considered.
+  - **Include Undefined Files** (\`includeUndefinedFiles\`): If \`fileFilter\` is set, but a node's file attribute is not present, should we include it in the results? Defaults to \`true\`.
+
 Re-using the example code from above, the following query attaches all calls to \`mean\` to the kind \`visualize\` and the subkind \`text\`,
 all calls that start with \`read_\` to the kind \`input\` but only if they are not locally overwritten, and the subkind \`csv-file\`, and links all calls to \`points\` to the last call to \`plot\`:
 
@@ -411,7 +418,7 @@ ${(0, doc_query_1.tocForQueryType)('virtual')}
 
 Although it is probably better to consult the detailed explanations below, if you want to have a look at the scehma, here is its description:
 
-${(0, schema_1.describeSchema)(query_1.QueriesSchema, ansi_1.markdownFormatter)}
+${(0, schema_1.describeSchema)((0, query_1.QueriesSchema)(), ansi_1.markdownFormatter)}
 
 </details>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.1.7",
+  "version": "2.1.9",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -36,12 +36,13 @@
     "lint": "npm run license-compat -- --summary && npx eslint --version && npx eslint src/ test/",
     "license-compat": "license-checker --onlyAllow 'MIT;MIT OR X11;GPLv2;LGPL;GNUGPL;ISC;Apache-2.0;FreeBSD;BSD-2-Clause;clearbsd;ModifiedBSD;BSD-3-Clause;Python-2.0;Unlicense;WTFPL;BlueOak-1.0.0;CC-BY-4.0;CC-BY-3.0;CC0-1.0;0BSD'",
     "doc": "typedoc",
-    "test": "vitest --config test/vitest.config.mts",
+    "test": "vitest --exclude \"test/system-tests/**\" --config test/vitest.config.mts",
+    "test:system": "vitest --dir test/system-tests --config test/system-tests/vitest.config.mts",
     "test:coverage": "npm run test -- --coverage",
     "performance-test": "func() { cd test/performance/ && bash run-all-suites.sh $1 $2 $3; cd ../../; }; func",
     "test-full": "npm run test:coverage -- --no-watch -- --make-summary --test-installation",
     "detect-circular-deps": "npx madge  --extensions ts,tsx --circular src/",
-    "checkup": "npm run flowr -- --execute \":version\" && npm run lint && npm run test-full -- --forbid-only && docker build -t test-flowr -f scripts/Dockerfile . && npm run doc && npm-run-all wiki:*"
+    "checkup": "npm run flowr -- --execute \":version\" && npm run lint && npm run test-full -- --allowOnly=false && npm run test:system -- --no-watch && docker build -t test-flowr -f scripts/Dockerfile . && npm run doc && npm-run-all wiki:*"
   },
   "keywords": [
     "static code analysis",
@@ -84,6 +85,19 @@
       "**/node_modules/**/*",
       "**/index.ts"
     ],
+    "highlightLanguages": [
+      "bash",
+      "console",
+      "css",
+      "html",
+      "javascript",
+      "json",
+      "jsonc",
+      "json5",
+      "tsx",
+      "typescript",
+      "r"
+    ],
     "theme": "hierarchy",
     "out": "doc",
     "readme": "README.md",

package/queries/catalog/call-context-query/call-context-query-executor.js

@@ -51,6 +51,10 @@ function promoteQueryCallNames(queries) {
                 ...q,
                 callName: q.callNameExact ? exactCallNameRegex(q.callName)
                     : new RegExp(q.callName),
+                fileFilter: q.fileFilter && {
+                    ...q.fileFilter,
+                    filter: new RegExp(q.fileFilter.filter)
+                },
                 linkTo: {
                     ...q.linkTo,
                     /* we have to add another promotion layer whenever we add something without this call name */
@@ -62,7 +66,11 @@ function promoteQueryCallNames(queries) {
             return {
                 ...q,
                 callName: q.callNameExact ? exactCallNameRegex(q.callName)
-                    : new RegExp(q.callName)
+                    : new RegExp(q.callName),
+                fileFilter: q.fileFilter && {
+                    ...q.fileFilter,
+                    filter: new RegExp(q.fileFilter.filter)
+                }
             };
         }
     });
@@ -132,6 +140,15 @@ function removeIdenticalDuplicates(collector) {
         }
     }
 }
+function doesFilepathMatch(file, filter) {
+    if (filter === undefined) {
+        return true;
+    }
+    if (file === undefined) {
+        return filter.includeUndefinedFiles ?? true;
+    }
+    return filter.filter.test(file);
+}
 /**
  * Multi-stage call context query resolve.
  *
@@ -174,6 +191,10 @@ function executeCallContextQueries({ graph, ast }, queries) {
             }
         }
         for (const query of promotedQueries.filter(q => q.callName.test(info.name))) {
+            const file = ast.idMap.get(nodeId)?.info.file;
+            if (!doesFilepathMatch(file, query.fileFilter)) {
+                continue;
+            }
             let targets = undefined;
             if (query.callTargets) {
                 targets = (0, identify_link_to_last_call_relation_1.satisfiesCallTargets)(nodeId, graph, query.callTargets);
@@ -188,7 +209,7 @@ function executeCallContextQueries({ graph, ast }, queries) {
             let linkedIds = undefined;
             if (cfg && isSubCallQuery(query)) {
                 /* if we have a linkTo query, we have to find the last call */
-                const lastCall = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(nodeId, cfg.graph, graph, query.linkTo.callName);
+                const lastCall = (0, identify_link_to_last_call_relation_1.identifyLinkToLastCallRelation)(nodeId, cfg.graph, graph, query.linkTo);
                 if (lastCall) {
                     linkedIds = lastCall;
                 }

package/queries/catalog/call-context-query/call-context-query-format.d.ts

@@ -6,10 +6,23 @@ import Joi from 'joi';
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DEFAULT_DATAFLOW_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import { CallTargets } from './identify-link-to-last-call-relation';
-export interface DefaultCallContextQueryFormat<CallName extends RegExp | string> extends BaseQueryFormat {
+import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { DataflowGraphVertexInfo } from '../../../dataflow/graph/vertex';
+import type { CascadeAction } from './cascade-action';
+export interface FileFilter<FilterType> {
+    /**
+     * Regex that a node's file attribute must match to be considered
+     */
+    readonly filter: FilterType;
+    /**
+     * If `fileFilter` is set, but a nodes `file` attribute is `undefined`, should we include it in the results? Defaults to `true`.
+     */
+    readonly includeUndefinedFiles?: boolean;
+}
+export interface DefaultCallContextQueryFormat<RegexType extends RegExp | string> extends BaseQueryFormat {
     readonly type: 'call-context';
     /** Regex regarding the function name, please note that strings will be interpreted as regular expressions too! */
-    readonly callName: CallName;
+    readonly callName: RegexType;
     /**
      * Should we automatically add the `^` and `$` anchors to the regex to make it an exact match?
      */
@@ -27,6 +40,10 @@ export interface DefaultCallContextQueryFormat<CallName extends RegExp | string>
      * Consider a case like `f <- function_of_interest`, do you want uses of `f` to be included in the results?
      */
     readonly includeAliases?: boolean;
+    /**
+     * Filter that, when set, a node's file attribute must match to be considered
+     */
+    readonly fileFilter?: FileFilter<RegexType>;
 }
 /**
  * Links the current call to the last call of the given kind.
@@ -38,6 +55,16 @@ interface LinkToLastCall<CallName extends RegExp | string = RegExp | string> ext
     readonly type: 'link-to-last-call';
     /** Regex regarding the function name of the last call. Similar to {@link DefaultCallContextQueryFormat#callName}, strings are interpreted as a `RegExp`. */
     readonly callName: CallName;
+    /**
+     * Should we ignore this (source) call?
+     * Currently, there is no well working serialization for this.
+     */
+    readonly ignoreIf?: (id: NodeId, graph: DataflowGraph) => boolean;
+    /**
+     * Should we continue searching after the link was created?
+     * Currently, there is no well working serialization for this.
+     */
+    readonly cascadeIf?: (target: DataflowGraphVertexInfo, from: NodeId, graph: DataflowGraph) => CascadeAction;
 }
 export type LinkTo<CallName extends RegExp | string> = LinkToLastCall<CallName>;
 export interface SubCallContextQueryFormat<CallName extends RegExp | string = RegExp | string> extends DefaultCallContextQueryFormat<CallName> {

package/queries/catalog/call-context-query/call-context-query-format.js

@@ -26,9 +26,15 @@ exports.CallContextQueryDefinition = {
         subkind: joi_1.default.string().optional().description('The subkind of the call, this can be used to uniquely identify the respective call type when grouping the output (e.g., the normalized name, linking `ggplot` to `plot`). Defaults to `.`'),
         callTargets: joi_1.default.string().valid(...Object.values(identify_link_to_last_call_relation_1.CallTargets)).optional().description('Call targets the function may have. This defaults to `any`. Request this specifically to gain all call targets we can resolve.'),
         includeAliases: joi_1.default.boolean().optional().description('Consider a case like `f <- function_of_interest`, do you want uses of `f` to be included in the results?'),
+        fileFilter: joi_1.default.object({
+            fileFilter: joi_1.default.string().required().description('Regex that a node\'s file attribute must match to be considered'),
+            includeUndefinedFiles: joi_1.default.boolean().optional().description('If `fileFilter` is set, but a nodes `file` attribute is `undefined`, should we include it in the results? Defaults to `true`.')
+        }).optional().description('Filter that, when set, a node\'s file attribute must match to be considered'),
         linkTo: joi_1.default.object({
             type: joi_1.default.string().valid('link-to-last-call').required().description('The type of the linkTo sub-query.'),
-            callName: joi_1.default.string().required().description('Regex regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression.')
+            callName: joi_1.default.string().required().description('Regex regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression.'),
+            ignoreIf: joi_1.default.function().optional().description('Should we ignore this (source) call? Currently, there is no well working serialization for this.'),
+            cascadeIf: joi_1.default.function().optional().description('Should we continue searching after the link was created? Currently, there is no well working serialization for this.')
         }).optional().description('Links the current call to the last call of the given kind. This way, you can link a call like `points` to the latest graphics plot etc.')
     }).description('Call context query used to find calls in the dataflow graph')
 };

package/queries/catalog/call-context-query/cascade-action.d.ts

@@ -0,0 +1,8 @@
+export declare enum CascadeAction {
+    /** The action is to start the cascade */
+    Stop = "stop",
+    /** The action is to continue the cascade */
+    Continue = "continue",
+    /** The action is to skip the current node */
+    Skip = "skip"
+}

package/queries/catalog/call-context-query/cascade-action.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CascadeAction = void 0;
+var CascadeAction;
+(function (CascadeAction) {
+    /** The action is to start the cascade */
+    CascadeAction["Stop"] = "stop";
+    /** The action is to continue the cascade */
+    CascadeAction["Continue"] = "continue";
+    /** The action is to skip the current node */
+    CascadeAction["Skip"] = "skip";
+})(CascadeAction || (exports.CascadeAction = CascadeAction = {}));
+//# sourceMappingURL=cascade-action.js.map

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.d.ts

@@ -1,6 +1,10 @@
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ControlFlowGraph } from '../../../util/cfg/cfg';
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
+import type { DataflowGraphVertexFunctionCall } from '../../../dataflow/graph/vertex';
+import { RType } from '../../../r-bridge/lang-4.x/ast/model/type';
+import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { LinkTo } from './call-context-query-format';
 export declare enum CallTargets {
     /** call targets a function that is not defined locally (e.g., the call targets a library function) */
     OnlyGlobal = "global",
@@ -14,4 +18,10 @@ export declare enum CallTargets {
     Any = "any"
 }
 export declare function satisfiesCallTargets(id: NodeId, graph: DataflowGraph, callTarget: CallTargets): NodeId[] | 'no';
-export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, linkTo: RegExp): NodeId[];
+export declare function getValueOfArgument<Types extends readonly RType[] = readonly RType[]>(graph: DataflowGraph, call: DataflowGraphVertexFunctionCall | undefined, argument: {
+    name?: string;
+    index: number;
+}, additionalAllowedTypes?: Types): (RNodeWithParent & {
+    type: Types[number];
+}) | undefined;
+export declare function identifyLinkToLastCallRelation(from: NodeId, cfg: ControlFlowGraph, graph: DataflowGraph, { callName, ignoreIf, cascadeIf }: LinkTo<RegExp>): NodeId[];

package/queries/catalog/call-context-query/identify-link-to-last-call-relation.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CallTargets = void 0;
 exports.satisfiesCallTargets = satisfiesCallTargets;
+exports.getValueOfArgument = getValueOfArgument;
 exports.identifyLinkToLastCallRelation = identifyLinkToLastCallRelation;
+const graph_1 = require("../../../dataflow/graph/graph");
 const visitor_1 = require("../../../util/cfg/visitor");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const edge_1 = require("../../../dataflow/graph/edge");
@@ -10,6 +12,9 @@ const resolve_by_name_1 = require("../../../dataflow/environments/resolve-by-nam
 const identifier_1 = require("../../../dataflow/environments/identifier");
 const built_in_1 = require("../../../dataflow/environments/built-in");
 const assert_1 = require("../../../util/assert");
+const type_1 = require("../../../r-bridge/lang-4.x/ast/model/type");
+const r_function_call_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const cascade_action_1 = require("./cascade-action");
 var CallTargets;
 (function (CallTargets) {
     /** call targets a function that is not defined locally (e.g., the call targets a library function) */
@@ -74,8 +79,36 @@ function satisfiesCallTargets(id, graph, callTarget) {
             (0, assert_1.assertUnreachable)(callTarget);
     }
 }
-function identifyLinkToLastCallRelation(from, cfg, graph, linkTo) {
+function getValueOfArgument(graph, call, argument, additionalAllowedTypes) {
+    if (!call) {
+        return undefined;
+    }
+    const totalIndex = argument.name ? call.args.findIndex(arg => arg !== r_function_call_1.EmptyArgument && arg.name === argument.name) : -1;
+    let refAtIndex;
+    if (totalIndex < 0) {
+        const references = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
+        refAtIndex = references[argument.index];
+    }
+    else {
+        const arg = call.args[totalIndex];
+        refAtIndex = (0, graph_1.getReferenceOfArgument)(arg);
+    }
+    if (refAtIndex === undefined) {
+        return undefined;
+    }
+    let valueNode = graph.idMap?.get(refAtIndex);
+    if (valueNode?.type === type_1.RType.Argument) {
+        valueNode = valueNode.value;
+    }
+    if (valueNode) {
+        return !additionalAllowedTypes || additionalAllowedTypes.includes(valueNode.type) ? valueNode : undefined;
+    }
+}
+function identifyLinkToLastCallRelation(from, cfg, graph, { callName, ignoreIf, cascadeIf }) {
     const found = [];
+    if (ignoreIf && ignoreIf(from, graph)) {
+        return found;
+    }
     (0, visitor_1.visitInReverseOrder)(cfg, from, node => {
         /* we ignore the start id as it cannot be the last call */
         if (node === from) {
@@ -85,13 +118,17 @@ function identifyLinkToLastCallRelation(from, cfg, graph, linkTo) {
         if (vertex === undefined || vertex[0].tag !== vertex_1.VertexType.FunctionCall) {
             return;
         }
-        if (linkTo.test(vertex[0].name)) {
+        if (callName.test(vertex[0].name)) {
+            const act = cascadeIf ? cascadeIf(vertex[0], from, graph) : cascade_action_1.CascadeAction.Stop;
+            if (act === cascade_action_1.CascadeAction.Skip) {
+                return;
+            }
             const tar = satisfiesCallTargets(vertex[0].id, graph, CallTargets.MustIncludeGlobal);
             if (tar === 'no') {
-                return true;
+                return act === cascade_action_1.CascadeAction.Stop;
             }
             found.push(node);
-            return true;
+            return act === cascade_action_1.CascadeAction.Stop;
         }
     });
     return found;

package/queries/catalog/dependencies-query/dependencies-query-format.js

@@ -83,6 +83,8 @@ exports.ReadFunctions = [
     { name: 'read.ssd', argIdx: 0, argName: 'file' },
     { name: 'read.systat', argIdx: 0, argName: 'file' },
     { name: 'read.xport', argIdx: 0, argName: 'file' },
+    // car
+    { name: 'Import', argIdx: 0, argName: 'file' },
 ];
 exports.WriteFunctions = [
     { name: 'save', argIdx: 0, argName: '...' },
@@ -138,6 +140,8 @@ exports.WriteFunctions = [
     { name: 'tiff', argIdx: 0, argName: 'file' },
     { name: 'X11', argIdx: 0, argName: 'file' },
     { name: 'quartz', argIdx: 0, argName: 'file' },
+    // car
+    { name: 'Export', argIdx: 0, argName: 'file' },
 ];
 function printResultSection(title, infos, result, sectionSpecifics) {
     if (infos.length <= 0) {

package/queries/query.d.ts

@@ -450,9 +450,9 @@ type OmitFromValues<T, K extends string | number | symbol> = {
 export type QueryResultsWithoutMeta<Queries extends Query> = OmitFromValues<Omit<QueryResults<Queries['type']>, '.meta'>, '.meta'>;
 export type Queries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = readonly (QueryArgumentsWithType<Base> | VirtualQueryArgumentsWithType<Base, VirtualArguments>)[];
 export declare function executeQueries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>>(data: BasicQueryData, queries: Queries<Base, VirtualArguments>): QueryResults<Base>;
-export declare const SupportedQueriesSchema: Joi.AlternativesSchema<any>;
+export declare function SupportedQueriesSchema(): Joi.AlternativesSchema<any>;
 export declare const CompoundQuerySchema: Joi.ObjectSchema<any>;
-export declare const VirtualQuerySchema: Joi.AlternativesSchema<any>;
-export declare const AnyQuerySchema: Joi.AlternativesSchema<any>;
-export declare const QueriesSchema: Joi.ArraySchema<any[]>;
+export declare function VirtualQuerySchema(): Joi.AlternativesSchema<any>;
+export declare function AnyQuerySchema(): Joi.AlternativesSchema<any>;
+export declare function QueriesSchema(): Joi.ArraySchema<any[]>;
 export {};

package/queries/query.js

@@ -3,9 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueriesSchema = exports.AnyQuerySchema = exports.VirtualQuerySchema = exports.CompoundQuerySchema = exports.SupportedQueriesSchema = exports.SupportedQueries = void 0;
+exports.CompoundQuerySchema = exports.SupportedQueries = void 0;
 exports.executeQueriesOfSameType = executeQueriesOfSameType;
 exports.executeQueries = executeQueries;
+exports.SupportedQueriesSchema = SupportedQueriesSchema;
+exports.VirtualQuerySchema = VirtualQuerySchema;
+exports.AnyQuerySchema = AnyQuerySchema;
+exports.QueriesSchema = QueriesSchema;
 const call_context_query_format_1 = require("./catalog/call-context-query/call-context-query-format");
 const assert_1 = require("../util/assert");
 const virtual_queries_1 = require("./virtual-query/virtual-queries");
@@ -74,14 +78,22 @@ function executeQueries(data, queries) {
     };
     return results;
 }
-exports.SupportedQueriesSchema = joi_1.default.alternatives(Object.values(exports.SupportedQueries).map(q => q.schema)).description('Supported queries');
+function SupportedQueriesSchema() {
+    return joi_1.default.alternatives(Object.values(exports.SupportedQueries).map(q => q.schema)).description('Supported queries');
+}
 exports.CompoundQuerySchema = joi_1.default.object({
     type: joi_1.default.string().valid('compound').required().description('The type of the query.'),
     query: joi_1.default.string().required().description('The query to run on the file analysis information.'),
     commonArguments: joi_1.default.object().required().description('Common arguments for all queries.'),
     arguments: joi_1.default.array().items(joi_1.default.object()).required().description('Arguments for each query.')
 }).description('Compound query used to combine queries of the same type');
-exports.VirtualQuerySchema = joi_1.default.alternatives(exports.CompoundQuerySchema).description('Virtual queries (used for structure)');
-exports.AnyQuerySchema = joi_1.default.alternatives(exports.SupportedQueriesSchema, exports.VirtualQuerySchema).description('Any query');
-exports.QueriesSchema = joi_1.default.array().items(exports.AnyQuerySchema).description('Queries to run on the file analysis information (in the form of an array)');
+function VirtualQuerySchema() {
+    return joi_1.default.alternatives(exports.CompoundQuerySchema).description('Virtual queries (used for structure)');
+}
+function AnyQuerySchema() {
+    return joi_1.default.alternatives(SupportedQueriesSchema(), VirtualQuerySchema()).description('Any query');
+}
+function QueriesSchema() {
+    return joi_1.default.array().items(AnyQuerySchema()).description('Queries to run on the file analysis information (in the form of an array)');
+}
 //# sourceMappingURL=query.js.map

package/r-bridge/lang-4.x/ast/model/model.d.ts

@@ -145,6 +145,9 @@ export type ROther<Info> = RComment<Info> | RLineDirective<Info>;
  * All other subtypes (like {@link RLoopConstructs}) listed above
  * can be used to restrict the kind of node. They do not have to be
  * exclusive, some nodes can appear in multiple subtypes.
+ *
+ * @see {@link recoverName} - to receive the name/lexeme from such a node
+ * @see {@link recoverContent} - for a more rigorous approach to get the content of a node within a {@link DataflowGraph|dataflow graph}
  */
 export type RNode<Info = NoInfo> = RExpressionList<Info> | RFunctions<Info> | ROther<Info> | RConstructs<Info> | RNamedAccess<Info> | RIndexAccess<Info> | RUnaryOp<Info> | RBinaryOp<Info> | RSingleNode<Info> | RPipe<Info>;
 export type OtherInfoNode = RNode | RDelimiter;

package/r-bridge/lang-4.x/ast/model/nodes/r-number.d.ts

@@ -1,7 +1,11 @@
 import type { Leaf, Location, NoInfo } from '../model';
 import type { RType } from '../type';
 import type { RNumberValue } from '../../../convert-values';
-/** includes numeric, integer, and complex */
+/**
+ * A number like `3`, `-2.14`, `1L`, or `2i`.
+ * Includes numeric, integer, and complex.
+ * See {@link RNumberValue} for more information.
+ */
 export interface RNumber<Info = NoInfo> extends Leaf<Info>, Location {
     readonly type: RType.Number;
     content: RNumberValue;

package/r-bridge/lang-4.x/ast/model/processing/node-id.d.ts

@@ -7,7 +7,12 @@ export type NodeId<T extends string | number = string | number> = T & {
 /** used so that we do not have to store strings for the default numeric ids */
 export declare function normalizeIdToNumberIfPossible(id: NodeId): NodeId;
 /**
- * Recovers the lexeme of a node from its id in the idmap.
+ * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
+ *
+ * @see {@link recoverContent} - to recover the content of a node
  */
 export declare function recoverName(id: NodeId, idMap?: AstIdMap): string | undefined;
+/**
+ * Recovers the content of a {@link RNode|node} from its id in the {@link DataflowGraph|dataflow graph}.
+ */
 export declare function recoverContent(id: NodeId, graph: DataflowGraph): string | undefined;

package/r-bridge/lang-4.x/ast/model/processing/node-id.js

@@ -15,11 +15,16 @@ function normalizeIdToNumberIfPossible(id) {
     return id;
 }
 /**
- * Recovers the lexeme of a node from its id in the idmap.
+ * Recovers the lexeme of a {@link RNode|node} from its id in the {@link AstIdMap|id map}.
+ *
+ * @see {@link recoverContent} - to recover the content of a node
  */
 function recoverName(id, idMap) {
     return idMap?.get(id)?.lexeme;
 }
+/**
+ * Recovers the content of a {@link RNode|node} from its id in the {@link DataflowGraph|dataflow graph}.
+ */
 function recoverContent(id, graph) {
     const vertex = graph.getVertex(id);
     if (vertex === undefined) {

package/r-bridge/lang-4.x/ast/model/processing/visitor.d.ts

@@ -4,7 +4,7 @@ export type OnEnter<OtherInfo> = (node: RNode<OtherInfo>) => (boolean | void);
 /** Similar to {@link OnEnter} but called when leaving a node. Can't stop exploration as the subtree is already visited! */
 export type OnExit<OtherInfo> = (node: RNode<OtherInfo>) => void;
 /**
- * Collects all node ids within a tree given by a respective root node
+ * Visits all node ids within a tree given by a respective root node using a depth-first search with prefix order.
  *
  * @param nodes          - The root id nodes to start collecting from
  * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)

package/r-bridge/lang-4.x/ast/model/processing/visitor.js

@@ -100,7 +100,7 @@ class NodeVisitor {
     }
 }
 /**
- * Collects all node ids within a tree given by a respective root node
+ * Visits all node ids within a tree given by a respective root node using a depth-first search with prefix order.
  *
  * @param nodes          - The root id nodes to start collecting from
  * @param onVisit        - Called before visiting the subtree of each node. Can be used to stop visiting the subtree starting with this node (return `true` stop)