@eagleoutice/flowr 2.8.2 → 2.8.3

package/dataflow/environments/default-builtin-config.d.ts

@@ -101,7 +101,7 @@ export declare const DefaultBuiltinConfig: [{
     readonly assumePrimitive: false;
 }, {
     readonly type: "function";
-    readonly names: ["print", "message", "warning"];
+    readonly names: ["print", "message", "warning", "warn", "info"];
     readonly processor: "builtin:default";
     readonly config: {
         readonly returnsNthArgument: 0;
@@ -262,7 +262,7 @@ export declare const DefaultBuiltinConfig: [{
     readonly assumePrimitive: true;
 }, {
     readonly type: "function";
-    readonly names: ["stop", "abort"];
+    readonly names: ["stop", "abort", "cli_abort", "throw", "stop_bad_type", "stop_bad_element_type", "stop_bad_element_length"];
     readonly processor: "builtin:default";
     readonly config: {
         readonly useAsProcessor: "builtin:stop";

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

@@ -129,7 +129,7 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['lapply', 'sapply', 'vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
     { type: 'function', names: ['Lapply', 'Sapply', 'Vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false }, /* functool wrappers */
     { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: 'builtin:apply', config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
-    { type: 'function', names: ['print', 'message', 'warning'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
+    { type: 'function', names: ['print', 'message', 'warning', 'warn', 'info'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     // graphics base
     { type: 'function', names: exports.PlotCreate,
         processor: 'builtin:default',
@@ -232,7 +232,13 @@ exports.DefaultBuiltinConfig = [
     { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all', hasUnknownSideEffects: { type: 'link-to-last-call', callName: /^sink$/ } }, assumePrimitive: false },
     { type: 'function', names: ['switch'], processor: 'builtin:default', config: { forceArgs: [true] }, assumePrimitive: false },
     { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */, useAsProcessor: 'builtin:return' }, assumePrimitive: true },
-    { type: 'function', names: ['stop', 'abort'], processor: 'builtin:default', config: { useAsProcessor: 'builtin:stop', cfg: 4 /* ExitPointType.Error */, forceArgs: ['all'] }, assumePrimitive: false },
+    {
+        type: 'function',
+        names: ['stop', 'abort', 'cli_abort', 'throw', 'stop_bad_type', 'stop_bad_element_type', 'stop_bad_element_length'],
+        processor: 'builtin:default',
+        config: { useAsProcessor: 'builtin:stop', cfg: 4 /* ExitPointType.Error */, forceArgs: ['all'] },
+        assumePrimitive: false
+    },
     { type: 'function', names: ['try'], processor: 'builtin:try', config: { block: 'expr', handlers: {} }, assumePrimitive: true },
     { type: 'function', names: ['tryCatch', 'tryCatchLog'], processor: 'builtin:try', config: { block: 'expr', handlers: { error: 'error', finally: 'finally' } }, assumePrimitive: true },
     { type: 'function', names: ['stopifnot'], processor: 'builtin:stopifnot', config: {}, assumePrimitive: false },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.8.2",
+  "version": "2.8.3",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {

package/project/plugins/file-plugins/files/flowr-namespace-file.d.ts

@@ -4,6 +4,8 @@ export interface NamespaceInfo {
     exportedSymbols: string[];
     exportedFunctions: string[];
     exportS3Generics: Map<string, string[]>;
+    exportedPatterns: string[];
+    importedPackages: Map<string, string[] | 'all'>;
     loadsWithSideEffects: boolean;
 }
 export interface NamespaceFormat {

package/project/plugins/file-plugins/files/flowr-namespace-file.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowrNamespaceFile = void 0;
 const flowr_file_1 = require("../../../context/flowr-file");
+const resolve_args_1 = require("../../../../abstract-interpretation/data-frame/resolve-args");
 /**
  * This decorates a text file and provides access to its content in the {@link NamespaceFormat}.
  */
@@ -43,6 +44,8 @@ function parseNamespace(file) {
             exportedSymbols: [],
             exportedFunctions: [],
             exportS3Generics: new Map(),
+            exportedPatterns: [],
+            importedPackages: new Map(),
             loadsWithSideEffects: false,
         },
     };
@@ -89,12 +92,37 @@ function parseNamespace(file) {
                             exportedSymbols: [],
                             exportedFunctions: [],
                             exportS3Generics: new Map(),
+                            exportedPatterns: [],
+                            importedPackages: new Map(),
                             loadsWithSideEffects: false,
                         };
                     }
                     result[pkg].loadsWithSideEffects = true;
                     break;
                 }
+            case 'import': {
+                const pkg = args.trim();
+                result.current.importedPackages?.set(pkg, 'all');
+                break;
+            }
+            case 'importFrom': {
+                const parts = args.split(',').map(s => s.trim());
+                if (parts.length < 2) {
+                    continue;
+                }
+                const [pkg, ...symbols] = parts;
+                let arr = result.current.importedPackages?.get(pkg);
+                if (!arr || arr === 'all') {
+                    arr = [];
+                    result.current.importedPackages?.set(pkg, arr);
+                }
+                arr.push(...symbols);
+                break;
+            }
+            case 'exportPattern': {
+                result.current.exportedPatterns?.push((0, resolve_args_1.unquoteArgument)(args.trim()));
+                break;
+            }
         }
     }
     return result;

package/project/plugins/project-discovery/flowr-analyzer-project-discovery-plugin.js

@@ -57,6 +57,7 @@ class DefaultFlowrAnalyzerProjectDiscoveryPlugin extends FlowrAnalyzerProjectDis
         const requests = [];
         /* the dummy approach of collecting all files, group R and Rmd files, and be done with it */
         for (const file of (0, files_1.getAllFilesSync)(args.content, /.*/, this.ignorePathsRegex)) {
+            console.log(`Discovered file: ${file}`);
             const relativePath = path_1.default.relative(args.content, file);
             if (this.supportedExtensions.test(relativePath) && (!this.onlyTraversePaths || this.onlyTraversePaths.test(relativePath)) && !this.excludePathsRegex.test((0, built_in_source_1.platformDirname)(relativePath))) {
                 requests.push({ content: file, request: 'file' });

package/queries/catalog/dependencies-query/function-info/write-functions.js

@@ -28,10 +28,14 @@ exports.WriteFunctions = [
         }
     },
     // write functions that don't have argIndex are assumed to write to stdout
-    { package: 'base', name: 'print', linkTo: OutputRedirects, resolveValue: true },
+    { package: 'base', name: 'print', linkTo: OutputRedirects, resolveValue: false },
     { package: 'base', name: 'cat', linkTo: OutputRedirects, argName: 'file', resolveValue: true },
-    { package: 'base', name: 'message', linkTo: OutputRedirects, resolveValue: true },
-    { package: 'base', name: 'warning', linkTo: OutputRedirects, resolveValue: true },
+    { package: 'base', name: 'message', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'base', name: 'warning', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'rlang', name: 'warn', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'rlang', name: 'info', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'cli', name: 'cli_warn', linkTo: OutputRedirects, resolveValue: false },
+    { package: 'cli', name: 'cli_abort', linkTo: OutputRedirects, resolveValue: false },
     { package: 'base', name: 'writeLines', argIdx: 1, argName: 'con', resolveValue: true },
     { package: 'base', name: 'writeChar', argIdx: 1, argName: 'con', resolveValue: true },
     { package: 'base', name: 'writeBin', argIdx: 1, argName: 'con', resolveValue: true },

package/r-bridge/roxygen2/documentation-provider.d.ts

@@ -0,0 +1,15 @@
+import type { AstIdMap, ParentInformation } from '../lang-4.x/ast/model/processing/decorate';
+import type { NodeId } from '../lang-4.x/ast/model/processing/node-id';
+import type { RoxygenTag } from './roxygen-ast';
+export interface DocumentationInfo {
+    doc?: Documentation;
+}
+export type Documentation = RoxygenTag | readonly RoxygenTag[];
+/**
+ * Given a normalized AST and a node ID, returns the Roxygen documentation (if any) associated with that node.
+ * Please note that this does more than {@link parseRoxygenCommentsOfNode}, as it also traverses up the AST to find documentation.
+ * Additionally, this function instruments the normalized AST to cache the parsed documentation for future queries.
+ * @param idMap   - The AST ID map to use for looking up nodes and traversing the AST.
+ * @param nodeId  - The ID of the node to get documentation for.
+ */
+export declare function getDocumentationOf(nodeId: NodeId, idMap: AstIdMap<ParentInformation & DocumentationInfo>): Documentation | undefined;

package/r-bridge/roxygen2/documentation-provider.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDocumentationOf = getDocumentationOf;
+const roxygen_ast_1 = require("./roxygen-ast");
+const type_1 = require("../lang-4.x/ast/model/type");
+const roxygen_parse_1 = require("./roxygen-parse");
+const CommentRetriever = {
+    [type_1.RType.Comment]: n => (0, roxygen_parse_1.parseRoxygenComment)([n.lexeme]),
+    [type_1.RType.Parameter]: (n, idMap) => {
+        // get the documentation of the parent function
+        const doc = n.info.parent ? getDocumentationOf(n.info.parent, idMap) : undefined;
+        const paramName = n.lexeme;
+        if (doc && paramName) {
+            if (Array.isArray(doc)) {
+                const res = doc.filter(t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && t.value.name === paramName);
+                if (res.length === 1) {
+                    return res[0];
+                }
+                else {
+                    return res;
+                }
+            }
+            else {
+                if (doc.type === roxygen_ast_1.KnownRoxygenTags.Param && doc.value.name === paramName) {
+                    return doc;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+/**
+ * Given a normalized AST and a node ID, returns the Roxygen documentation (if any) associated with that node.
+ * Please note that this does more than {@link parseRoxygenCommentsOfNode}, as it also traverses up the AST to find documentation.
+ * Additionally, this function instruments the normalized AST to cache the parsed documentation for future queries.
+ * @param idMap   - The AST ID map to use for looking up nodes and traversing the AST.
+ * @param nodeId  - The ID of the node to get documentation for.
+ */
+function getDocumentationOf(nodeId, idMap) {
+    const node = idMap.get(nodeId);
+    if (!node) {
+        return undefined;
+    }
+    else if (node.info.doc) {
+        return node.info.doc;
+    }
+    const retriever = CommentRetriever[node.type] ?? ((c, a) => (0, roxygen_parse_1.parseRoxygenCommentsOfNode)(c, a)?.tags);
+    const doc = retriever(node, idMap);
+    if (doc) {
+        // cache the documentation for future queries
+        const expanded = expandInheritsOfTags(doc, idMap);
+        node.info.doc = expanded;
+        return expanded;
+    }
+    return doc;
+}
+function expandInheritsOfTags(tags, idMap) {
+    const expandedTags = [];
+    const tagArray = Array.isArray(tags) ? tags : [tags];
+    for (const tag of tagArray) {
+        const expanded = expandInheritOfTag(tag, tagArray, idMap);
+        if (!expanded) {
+            continue;
+        }
+        if (Array.isArray(expanded)) {
+            expandedTags.push(...expanded);
+        }
+        else {
+            expandedTags.push(expanded);
+        }
+    }
+    if (expandedTags.length === 1) {
+        return expandedTags[0];
+    }
+    return expandedTags;
+}
+function getDocumentationOfByName(name, idMap) {
+    for (const [, node] of idMap) {
+        const nodeName = node.lexeme ?? node.info.fullLexeme;
+        if (nodeName !== name) {
+            continue;
+        }
+        return getDocumentationOf(node.info.id, idMap);
+    }
+}
+function filterDocumentationForParams(doc, filter) {
+    if (!doc) {
+        return doc;
+    }
+    if (Array.isArray(doc)) {
+        return doc.filter(filter);
+    }
+    else {
+        return filter(doc) ? doc : undefined;
+    }
+}
+function expandInheritOfTag(tag, otherTags, idMap) {
+    if (tag.type === roxygen_ast_1.KnownRoxygenTags.Inherit) {
+        const inheritDoc = getDocumentationOfByName(tag.value.source, idMap);
+        return filterDocumentationForParams(inheritDoc, t => tag.value.components.includes(t.type));
+    }
+    else if (tag.type === roxygen_ast_1.KnownRoxygenTags.InheritDotParams) {
+        const inheritDoc = getDocumentationOfByName(tag.value.source, idMap);
+        return filterDocumentationForParams(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && t.value.name === '...');
+    }
+    else if (tag.type === roxygen_ast_1.KnownRoxygenTags.InheritParams) {
+        const inheritDoc = getDocumentationOfByName(tag.value, idMap);
+        const alreadyExplainedParams = new Set(otherTags.filter(t => t.type === roxygen_ast_1.KnownRoxygenTags.Param).map(t => t.value.name));
+        return filterDocumentationForParams(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && !alreadyExplainedParams.has(t.value.name));
+    }
+    return tag;
+}
+//# sourceMappingURL=documentation-provider.js.map

package/r-bridge/roxygen2/roxygen-parse.d.ts

@@ -4,6 +4,8 @@ import type { AstIdMap, ParentInformation } from '../lang-4.x/ast/model/processi
 /**
  * Parses the roxygen comments attached to a node into a RoxygenBlock AST node.
  * Will return `undefined` if there are no valid roxygen comments attached to the node.
+ * Please note that this does *not* do any clever mapping of parameters or requests.
+ * For a higher-level function that also traverses up the AST to find comments attached to parent nodes, see {@link getDocumentationOf}.
  * @param node  - The node to parse the roxygen comments for
  * @param idMap - An optional id map to traverse up the AST to find comments attached to parent nodes
  */

package/r-bridge/roxygen2/roxygen-parse.js

@@ -26,6 +26,8 @@ function prepareCommentContext(commentText) {
 /**
  * Parses the roxygen comments attached to a node into a RoxygenBlock AST node.
  * Will return `undefined` if there are no valid roxygen comments attached to the node.
+ * Please note that this does *not* do any clever mapping of parameters or requests.
+ * For a higher-level function that also traverses up the AST to find comments attached to parent nodes, see {@link getDocumentationOf}.
  * @param node  - The node to parse the roxygen comments for
  * @param idMap - An optional id map to traverse up the AST to find comments attached to parent nodes
  */

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.8.2';
+const version = '2.8.3';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */