@eagleoutice/flowr 2.9.14 → 2.10.2

package/linter/rules/roxygen-arguments.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROXYGEN_ARGS = void 0;
+const linter_format_1 = require("../linter-format");
+const range_1 = require("../../util/range");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const linter_tags_1 = require("../linter-tags");
+const assert_1 = require("../../util/assert");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const roxygen_ast_1 = require("../../r-bridge/roxygen2/roxygen-ast");
+const r_function_definition_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-definition");
+const documentation_provider_1 = require("../../r-bridge/roxygen2/documentation-provider");
+function getDocumentation(id, idMap) {
+    const comment = (0, documentation_provider_1.getDocumentationOf)(id, idMap);
+    if (comment === undefined) {
+        return undefined;
+    }
+    return Array.isArray(comment) ? comment : [comment];
+}
+function calculateArgumentDiff(inheritedParams, functionParam, roxygenParam) {
+    //match documented against existing params
+    let underDocumented = new Set(functionParam);
+    const notOverDocumented = underDocumented.has('...');
+    let overDocumented = new Set(roxygenParam);
+    const commonParams = underDocumented.intersection(overDocumented);
+    underDocumented = underDocumented.difference(commonParams);
+    overDocumented = overDocumented.difference(commonParams);
+    //case: '...', overdocumentation not possible
+    if (notOverDocumented) {
+        //if still remaining overdocumented parameters, "..." doesn't need to be documented
+        if (overDocumented.size > 0) {
+            underDocumented.delete('...');
+        }
+        //can't be overdocumented
+        overDocumented.clear();
+    }
+    //inherited params removed from list of overdocumented params
+    overDocumented = overDocumented.difference(new Set(inheritedParams));
+    return underDocumented.size === 0 && overDocumented.size === 0 ? false : { under: Array.from(underDocumented), over: Array.from(overDocumented) };
+}
+exports.ROXYGEN_ARGS = {
+    createSearch: () => flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.FunctionDefinition),
+    processSearchResult: (elements, _config, { normalize }) => {
+        return {
+            results: elements.getElements()
+                .map(element => ({
+                element,
+                underDocumented: [],
+                overDocumented: []
+            }))
+                .filter(({ element: { node }, underDocumented, overDocumented }) => {
+                const comments = getDocumentation(node.info.id, normalize.idMap);
+                if (!comments) {
+                    return false;
+                }
+                const parameters = getParameters(node);
+                //get parameter names
+                const functionParamNames = parameters.map(p => p.name.content.toString());
+                const inheritedParams = comments.filter(tag => (tag?.inherited && tag.type === roxygen_ast_1.KnownRoxygenTags.Param)).map(tag => (tag.value.name));
+                const roxygenParamNames = comments
+                    .filter(tag => tag.type === roxygen_ast_1.KnownRoxygenTags.Param)
+                    .map(tag => tag.value.name);
+                if (functionParamNames === null || roxygenParamNames == null) {
+                    return false;
+                }
+                const result = calculateArgumentDiff(inheritedParams, functionParamNames, roxygenParamNames);
+                if (result === false) {
+                    return false;
+                }
+                underDocumented.push(...result.under);
+                overDocumented.push(...result.over);
+                return true;
+            })
+                .map(({ element, overDocumented, underDocumented }) => ({
+                certainty: linter_format_1.LintingResultCertainty.Uncertain,
+                involvedId: element.node.info.id,
+                loc: range_1.SourceLocation.fromNode(element.node),
+                underDocumented: underDocumented,
+                overDocumented: overDocumented
+            }))
+                .filter(element => (0, assert_1.isNotUndefined)(element.loc)),
+            '.meta': {}
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Code at ${range_1.SourceLocation.format(result.loc)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Code at ${range_1.SourceLocation.format(result.loc)} has undocumented parameters: ${result.underDocumented?.join()} and overdocumented parameters: ${result.overDocumented?.join()}`
+    },
+    info: {
+        name: 'Roxygen Arguments',
+        tags: [linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.Documentation, linter_tags_1.LintingRuleTag.Style],
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
+        description: 'Checks whether a function has undocumented or overdocumented parameters',
+        defaultConfig: {}
+    }
+};
+function getParameters(node) {
+    return r_function_definition_1.RFunctionDefinition.is(node) ? node.parameters : [];
+}
+//# sourceMappingURL=roxygen-arguments.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.9.14",
+  "version": "2.10.2",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -165,8 +165,8 @@
     }
   },
   "devDependencies": {
-    "@commitlint/cli": "^19.7.1",
-    "@commitlint/config-angular": "^19.7.1",
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-angular": "^20.5.0",
     "@eagleoutice/eslint-config-flowr": "^1.0.36",
     "@eslint/eslintrc": "^3.3.3",
     "@eslint/js": "^9.39.2",
@@ -175,7 +175,6 @@
     "@types/command-line-usage": "^5.0.4",
     "@types/commonmark": "^0.27.10",
     "@types/dagre": "^0.7.53",
-    "@types/n-readlines": "^1.0.6",
     "@types/n3": "^1.26.0",
     "@types/object-hash": "^3.0.6",
     "@types/object-path": "^0.11.4",
@@ -191,11 +190,11 @@
     "npm-run-all": "^4.1.5",
     "release-it": "^19.2.3",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.27.7",
-    "typedoc-plugin-missing-exports": "^3.1.0",
-    "typedoc-theme-hierarchy": "^5.0.4",
+    "typedoc": "^0.28.17",
+    "typedoc-plugin-missing-exports": "^4.1.2",
+    "typedoc-theme-hierarchy": "^6.0.0",
     "typedoc-umlclass": "^0.10.2",
-    "typescript": "^5.7.3",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
   "dependencies": {
@@ -210,7 +209,7 @@
     "gray-matter": "^4.0.3",
     "joi": "^18.0.1",
     "lz-string": "^1.5.0",
-    "n-readlines": "^1.0.3",
+    "n-readlines": "^3.4.1",
     "n3": "^1.26.0",
     "object-hash": "^3.0.0",
     "object-path": "^0.11.8",

package/project/context/flowr-analyzer-context.d.ts

@@ -35,17 +35,12 @@ export interface ReadOnlyFlowrAnalyzerContext {
      * The configuration options used by the analyzer.
      */
     readonly config: FlowrConfig;
-    /**
-     * Run all resolution steps that can be done before the main analysis run.
-     */
-    readonly resolvePreAnalysis: () => void;
 }
 /**
  * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
  * Have a look at the attributes and layers listed below (e.g., {@link files} and {@link deps})
  * to get an idea of the capabilities provided by this context.
- * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods alongside the
- * {@link resolvePreAnalysis} method that conducts all the steps that can be done before the main analysis run.
+ * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods.
  * In general, you do not have to worry about these details, as the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer} take care of them.
  *
  * To inspect, e.g., the loading order, you can do so via {@link files.loadingOrder.getLoadingOrder}. To get information on a specific library, use
@@ -71,8 +66,6 @@ export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContex
     addRequests(requests: readonly RAnalysisRequest[]): void;
     addFile(f: string | FlowrFileProvider | RParseRequestFromFile): void;
     addFiles(f: (string | FlowrFileProvider | RParseRequestFromFile)[]): void;
-    /** this conducts all the step that can be done before the main analysis run */
-    resolvePreAnalysis(): void;
     /**
      * Get a read-only version of this context.
      * This is useful if you want to pass the context to a place where you do not want it to be modified or just to reduce

package/project/context/flowr-analyzer-context.js

@@ -18,8 +18,7 @@ const flowr_analyzer_meta_context_1 = require("./flowr-analyzer-meta-context");
  * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
  * Have a look at the attributes and layers listed below (e.g., {@link files} and {@link deps})
  * to get an idea of the capabilities provided by this context.
- * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods alongside the
- * {@link resolvePreAnalysis} method that conducts all the steps that can be done before the main analysis run.
+ * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods.
  * In general, you do not have to worry about these details, as the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer} take care of them.
  *
  * To inspect, e.g., the loading order, you can do so via {@link files.loadingOrder.getLoadingOrder}. To get information on a specific library, use
@@ -63,11 +62,6 @@ class FlowrAnalyzerContext {
     addFiles(f) {
         this.files.addFiles(f);
     }
-    /** this conducts all the step that can be done before the main analysis run */
-    resolvePreAnalysis() {
-        this.files.computeLoadingOrder();
-        this.deps.resolveStaticDependencies();
-    }
     /**
      * Get a read-only version of this context.
      * This is useful if you want to pass the context to a place where you do not want it to be modified or just to reduce

package/project/context/flowr-analyzer-environment-context.d.ts

@@ -28,6 +28,10 @@ export interface ReadOnlyFlowrAnalyzerEnvironmentContext {
      * Create a new {@link REnvironmentInformation|environment} with an empty built-in environment as base.
      */
     makeCleanEnvWithEmptyBuiltIns(): REnvironmentInformation;
+    /**
+     * A completely empty {@link REnvironmentInformation|environment}.
+     */
+    makeEmptyEnv(): REnvironmentInformation;
 }
 /**
  * This context is responsible for providing the built-in environment.
@@ -44,4 +48,5 @@ export declare class FlowrAnalyzerEnvironmentContext implements ReadOnlyFlowrAna
     makeCleanEnv(): REnvironmentInformation;
     getCleanEnvFingerprint(): Fingerprint;
     makeCleanEnvWithEmptyBuiltIns(): REnvironmentInformation;
+    makeEmptyEnv(): REnvironmentInformation;
 }

package/project/context/flowr-analyzer-environment-context.js

@@ -45,6 +45,12 @@ class FlowrAnalyzerEnvironmentContext {
             level: 0
         };
     }
+    makeEmptyEnv() {
+        return {
+            current: new environment_1.Environment(undefined, true),
+            level: 0
+        };
+    }
 }
 exports.FlowrAnalyzerEnvironmentContext = FlowrAnalyzerEnvironmentContext;
 //# sourceMappingURL=flowr-analyzer-environment-context.js.map

package/project/context/flowr-analyzer-files-context.d.ts

@@ -56,6 +56,11 @@ export interface ReadOnlyFlowrAnalyzerFilesContext {
      * @returns An array of all files.
      */
     getAllFiles(): FlowrFileProvider[];
+    /**
+     * Check if the context has a cached file with the given path.
+     * @param path - The path to the file.
+     */
+    hasCached(path: string): boolean;
     /**
      * Check if the context has a file with the given path.
      * Please note, that this may also check the file system, depending on the configuration
@@ -130,6 +135,7 @@ export declare class FlowrAnalyzerFilesContext extends AbstractFlowrAnalyzerCont
     addFile(file: string | FlowrFileProvider | RParseRequestFromFile, roles?: readonly FileRole[]): FlowrFileProvider<{
         toString(): string;
     }>;
+    hasCached(path: string): boolean;
     hasFile(path: string): boolean;
     exists(p: string, ignoreCase: boolean): string | undefined;
     private fileLoadPlugins;

package/project/context/flowr-analyzer-files-context.js

@@ -120,9 +120,11 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
         }
         return f;
     }
+    hasCached(path) {
+        return this.files.has(path);
+    }
     hasFile(path) {
-        return this.files.has(path)
-            || (this.ctx.config.project.resolveUnknownPathsOnDisk && fs_1.default.existsSync(path));
+        return this.hasCached(path) || (this.ctx.config.project.resolveUnknownPathsOnDisk && fs_1.default.existsSync(path));
     }
     exists(p, ignoreCase) {
         try {

package/project/flowr-analyzer-builder.js

@@ -157,10 +157,7 @@ class FlowrAnalyzerBuilder {
             context,
             ...(this.input ?? {})
         });
-        const analyzer = new flowr_analyzer_1.FlowrAnalyzer(this.parser, context, cache);
-        // we do it here to save time later if the analyzer is to be duplicated
-        context.resolvePreAnalysis();
-        return analyzer;
+        return new flowr_analyzer_1.FlowrAnalyzer(this.parser, context, cache);
     }
 }
 exports.FlowrAnalyzerBuilder = FlowrAnalyzerBuilder;

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

@@ -2,7 +2,7 @@ import type { CallContextQuery, CallContextQueryResult, CallNameTypes, LinkTo }
 import type { BasicQueryData } from '../../base-query-format';
 export type PromotedCallTest = (t: string) => boolean;
 /**
- *
+ * Convert a name to a predicate that checks whether an input conforms to this name.
  */
 export declare function promoteCallName(callName: CallNameTypes, exact?: boolean): PromotedCallTest;
 export type PromotedLinkTo<LT = LinkTo> = Omit<LT, 'callName'> & {

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

@@ -44,19 +44,24 @@ function isSubCallQuery(query) {
     return 'linkTo' in query && query.linkTo !== undefined;
 }
 /**
- *
+ * Convert a name to a predicate that checks whether an input conforms to this name.
  */
 function promoteCallName(callName, exact = false) {
     if (Array.isArray(callName)) {
         const s = new Set(callName);
         return (t) => s.has(t);
     }
-    else if (exact) {
-        const s = new Set([typeof callName === 'string' ? callName : callName.source]);
-        return (t) => s.has(t);
+    else if (typeof callName === 'string') {
+        if (exact) {
+            return (t) => t === callName;
+        }
+        else {
+            const r = new RegExp(callName);
+            return (t) => r.test(t);
+        }
     }
     else {
-        const r = new RegExp(callName);
+        const r = new RegExp(exact ? '^' + callName.source + '$' : callName.source);
         return (t) => r.test(t);
     }
 }

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

@@ -24,7 +24,7 @@ export interface DefaultCallContextQueryFormat<RegexType extends CallNameTypes>
     readonly type: 'call-context';
     /** Regex regarding the function name, please note that strings will be interpreted as regular expressions too! */
     readonly callName: RegexType;
-    /** Should we automatically add the `^` and `$` anchors to the regex to make it an exact match? */
+    /** Should we automatically add the `^` and `$` anchors to the regex to make it an exact match, we now also allow '.' etc. to have their conventional meaning if you pass in the regex as a string? */
     readonly callNameExact?: boolean;
     /** kind may be a step or anything that you attach to the call, this can be used to group calls together (e.g., linking `ggplot` to `visualize`). Defaults to `.` */
     readonly kind?: string;

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

@@ -7,6 +7,7 @@ exports.LibraryFunctions = [
     { package: 'base', name: 'loadNamespace', argIdx: 0, argName: 'package', resolveValue: true },
     { package: 'base', name: 'attachNamespace', argIdx: 0, argName: 'ns', resolveValue: true },
     { package: 'base', name: 'attach', argIdx: 0, argName: 'what', resolveValue: true },
+    { package: 'base', name: 'use', argIdx: 0, argName: 'package', resolveValue: 'library' },
     { package: 'groundhog', name: 'groundhog.library', argIdx: 0, argName: 'pkg', resolveValue: true },
     { package: 'pacman', name: 'p_load', argIdx: 'unnamed', resolveValue: 'library' },
     { package: 'pacman', name: 'p_load_gh', argIdx: 'unnamed', resolveValue: 'library' },
@@ -15,5 +16,6 @@ exports.LibraryFunctions = [
     { package: 'librarian', name: 'shelf', argIdx: 'unnamed', resolveValue: true },
     { package: 'devtools', name: 'load_all', argIdx: 0, argName: 'path', resolveValue: true, defaultValue: '.' },
     { package: 'devtools', name: 'load_code', argIdx: 0, argName: 'path', resolveValue: true, defaultValue: '.' },
+    { package: 'import', name: 'from', argIdx: 0, argName: 'package', resolveValue: true }
 ];
 //# sourceMappingURL=library-functions.js.map

package/queries/catalog/df-shape-query/df-shape-query-executor.js

@@ -39,7 +39,7 @@ async function executeDfShapeQuery({ analyzer }, queries) {
             continue;
         }
         try {
-            const nodeId = parse_1.SingleSlicingCriterion.parse(query.criterion, ast.idMap);
+            const nodeId = parse_1.SlicingCriterion.parse(query.criterion, ast.idMap);
             const node = ast.idMap.get(nodeId);
             const value = inference.getAbstractValue(node?.info.id);
             result.set(query.criterion, value);

package/queries/catalog/df-shape-query/df-shape-query-format.d.ts

@@ -3,17 +3,17 @@ import type { DataFrameDomain } from '../../../abstract-interpretation/data-fram
 import type { StateAbstractDomain } from '../../../abstract-interpretation/domains/state-abstract-domain';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfig } from '../../../config';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { ParsedQueryLine } from '../../query';
 import { executeDfShapeQuery } from './df-shape-query-executor';
 /** Infer the shape of data frames using abstract interpretation. */
 export interface DfShapeQuery extends BaseQueryFormat {
     readonly type: 'df-shape';
-    readonly criterion?: SingleSlicingCriterion;
+    readonly criterion?: SlicingCriterion;
 }
 export interface DfShapeQueryResult extends BaseQueryResult {
-    domains: StateAbstractDomain<DataFrameDomain> | Map<SingleSlicingCriterion, DataFrameDomain | undefined>;
+    domains: StateAbstractDomain<DataFrameDomain> | Map<SlicingCriterion, DataFrameDomain | undefined>;
 }
 declare function dfShapeQueryLineParser(_output: ReplOutput, line: readonly string[], _config: FlowrConfig): ParsedQueryLine<'df-shape'>;
 export declare const DfShapeQueryDefinition: {

package/queries/catalog/df-shape-query/df-shape-query-format.js

@@ -5,11 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfShapeQueryDefinition = void 0;
 const joi_1 = __importDefault(require("joi"));
+const abstract_domain_1 = require("../../../abstract-interpretation/domains/abstract-domain");
+const lattice_1 = require("../../../abstract-interpretation/domains/lattice");
 const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const df_shape_query_executor_1 = require("./df-shape-query-executor");
-const abstract_domain_1 = require("../../../abstract-interpretation/domains/abstract-domain");
 function dfShapeQueryLineParser(_output, line, _config) {
     const criterion = (0, slice_query_parser_1.sliceCriterionParser)(line[0]);
     return {
@@ -26,6 +27,10 @@ exports.DfShapeQueryDefinition = {
         const out = queryResults;
         const domains = out.domains instanceof abstract_domain_1.AbstractDomain ? out.domains.value : out.domains;
         result.push(`Query: ${(0, ansi_1.bold)('df-shape', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        if (domains === lattice_1.Bottom) {
+            result.push(`   ╰ state: ${lattice_1.BottomSymbol}`);
+            return true;
+        }
         result.push(...domains.entries().take(20).map(([key, domain]) => {
             return `   ╰ ${key}: ${domain?.toString()}`;
         }));
@@ -37,7 +42,7 @@ exports.DfShapeQueryDefinition = {
     jsonFormatter: (queryResults) => {
         const { domains, ...out } = queryResults;
         const state = domains instanceof abstract_domain_1.AbstractDomain ? domains.value : domains;
-        const json = Object.fromEntries(state.entries().map(([key, domain]) => [key, domain?.toJson() ?? null]));
+        const json = state === lattice_1.Bottom ? state.description : Object.fromEntries(state.entries().map(([key, domain]) => [key, domain?.toJson() ?? null]));
         const result = { domains: json, ...out };
         return result;
     },

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

@@ -19,7 +19,7 @@ async function executeDoesCallQuery({ analyzer }, queries) {
             log_1.log.warn(`Duplicate query id '${id}' in does-call queries, SKIP.`);
             continue;
         }
-        const nodeId = parse_1.SingleSlicingCriterion.tryParse(query.call, idMap);
+        const nodeId = parse_1.SlicingCriterion.tryParse(query.call, idMap);
         if (!nodeId) {
             results[id] = false;
             continue;

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

@@ -3,7 +3,7 @@ import Joi from 'joi';
 import type { ParsedQueryLine } from '../../query';
 import { executeDoesCallQuery } from './does-call-query-executor';
 import { type NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
 import type { FlowrConfig } from '../../../config';
 interface CallsIdConstraint {
@@ -30,7 +30,7 @@ export type CallsConstraint = CallsIdConstraint | CallsWithNameConstraint | Call
 export interface DoesCallQuery extends BaseQueryFormat {
     readonly type: 'does-call';
     readonly queryId?: string;
-    readonly call: SingleSlicingCriterion;
+    readonly call: SlicingCriterion;
     readonly calls: CallsConstraint;
 }
 export interface FindAllCallsResult {

package/queries/catalog/files-query/files-query-executor.js

@@ -6,7 +6,6 @@ exports.executeFileQuery = executeFileQuery;
  */
 function executeFileQuery({ analyzer }, queries) {
     const start = Date.now();
-    analyzer.inspectContext().resolvePreAnalysis();
     const base = analyzer.inspectContext().files.getAllFiles();
     let files = [];
     const foundFingerprints = new Set();

package/queries/catalog/happens-before-query/happens-before-query-executor.js

@@ -22,8 +22,8 @@ async function executeHappensBefore({ analyzer }, queries) {
             log_1.log.warn('Duplicate happens-before query', query, 'ignoring');
         }
         try {
-            const resolvedA = parse_1.SingleSlicingCriterion.parse(a, ast.idMap);
-            const resolvedB = parse_1.SingleSlicingCriterion.parse(b, ast.idMap);
+            const resolvedA = parse_1.SlicingCriterion.parse(a, ast.idMap);
+            const resolvedB = parse_1.SlicingCriterion.parse(b, ast.idMap);
             results[fingerprint] = (0, happens_before_1.happensBefore)(cfg.graph, resolvedA, resolvedB);
         }
         catch (e) {

package/queries/catalog/happens-before-query/happens-before-query-format.d.ts

@@ -1,12 +1,12 @@
 import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import Joi from 'joi';
 import { executeHappensBefore } from './happens-before-query-executor';
-import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
 import type { Ternary } from '../../../util/logic';
 export interface HappensBeforeQuery extends BaseQueryFormat {
     readonly type: 'happens-before';
-    readonly a: SingleSlicingCriterion;
-    readonly b: SingleSlicingCriterion;
+    readonly a: SlicingCriterion;
+    readonly b: SlicingCriterion;
 }
 export interface HappensBeforeQueryResult extends BaseQueryResult {
     readonly results: Record<string, Ternary>;

package/queries/catalog/input-sources-query/input-sources-query-executor.d.ts

@@ -0,0 +1,6 @@
+import type { BasicQueryData } from '../../base-query-format';
+import type { InputSourcesQuery, InputSourcesQueryResult } from './input-sources-query-format';
+/**
+ * Execute an input sources query
+ */
+export declare function executeInputSourcesQuery({ analyzer }: BasicQueryData, queries: readonly InputSourcesQuery[]): Promise<InputSourcesQueryResult>;

package/queries/catalog/input-sources-query/input-sources-query-executor.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeInputSourcesQuery = executeInputSourcesQuery;
+const log_1 = require("../../../util/log");
+const parse_1 = require("../../../slicing/criterion/parse");
+const r_function_definition_1 = require("../../../r-bridge/lang-4.x/ast/model/nodes/r-function-definition");
+const model_1 = require("../../../r-bridge/lang-4.x/ast/model/model");
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
+const simple_input_classifier_1 = require("./simple-input-classifier");
+const network_functions_1 = require("../../../linter/rules/network-functions");
+const seeded_randomness_1 = require("../../../linter/rules/seeded-randomness");
+const read_functions_1 = require("../dependencies-query/function-info/read-functions");
+/**
+ * Execute an input sources query
+ */
+async function executeInputSourcesQuery({ analyzer }, queries) {
+    const start = Date.now();
+    const results = {};
+    const nast = await analyzer.normalize();
+    const df = await analyzer.dataflow();
+    for (const query of queries) {
+        const key = query.criterion;
+        if (results[key]) {
+            log_1.log.warn(`Duplicate key for input-sources query: ${key}, skipping...`);
+        }
+        const criterionId = parse_1.SlicingCriterion.tryParse(key, nast.idMap) ?? key;
+        const provenanceNode = nast.idMap.get(criterionId);
+        const fdef = r_function_definition_1.RFunctionDefinition.rootFunctionDefinition(provenanceNode, nast.idMap);
+        const provenance = df_helper_1.Dataflow.provenanceGraph(criterionId, df.graph, fdef ? model_1.RNode.collectAllIds(fdef) : undefined);
+        results[key] = (0, simple_input_classifier_1.classifyInput)(criterionId, provenance, {
+            networkFns: query.config?.networkFns ?? network_functions_1.NETWORK_FUNCTIONS.info.defaultConfig.fns,
+            randomFns: query.config?.randomFns ?? seeded_randomness_1.SEEDED_RANDOMNESS.info.defaultConfig.randomnessConsumers,
+            pureFns: query.config?.pureFns ?? ['paste', 'paste0', 'parse', '+', '-', '*',
+                '/', '^', '%%', '%/%', '&', '|', '!', '&&', '||',
+                '<', '>', '<=', '>=', '==', '!=', ':',
+                'abs', 'sign', 'sqrt', 'exp', 'log', 'log10', 'log2',
+                'sin', 'cos', 'tan', 'asin', 'acos', 'atan',
+                'length', 'nchar', 'dim', 'nrow', 'ncol',
+                'c', 'list', 'data.frame',
+                'ifelse', 'switch', 'factor', 'as.factor',
+                'round', 'floor', 'ceiling', 'trunc',
+                'substr', 'substring', 'strsplit',
+                'min', 'max', 'range', 'sum', 'prod', 'mean', 'median', 'var', 'sd',
+                'head', 'tail', 'seq', 'rep',
+                'apply', 'lapply', 'sapply', 'vapply', 'tapply',
+                'matrix', 'array', 'substitute', 'quote', 'bquote', 'enquote', 'enexpr', 'enexprs', 'enquo', 'enquos',
+                'expression', 'call', 'as.call', 'as.expression',
+                'rownames', 'colnames',
+                'list.files', 'tolower', 'toupper', 'printf',
+                '<-', '->', '=', '<<-', '->>', 'assign', 'get',
+                '[', '[[', '$', 'length<-', 'dim<-', 'names<-', 'colnames<-', 'rownames<-',
+                'as.character', 'as.numeric', 'as.logical', 'as.list', 'as.data.frame', 'as.matrix', 'as.array',
+                'identity', 'invisible', 'return', 'force', 'missing',
+                'print', 'cat', 'message', 'warning', 'stop'
+            ],
+            readFileFns: query.config?.readFileFns ?? read_functions_1.ReadFunctions.map(f => f.name)
+        });
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        results
+    };
+}
+//# sourceMappingURL=input-sources-query-executor.js.map

package/queries/catalog/input-sources-query/input-sources-query-format.d.ts

@@ -0,0 +1,36 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { SlicingCriterion } from '../../../slicing/criterion/parse';
+import type { ParsedQueryLine } from '../../query';
+import Joi from 'joi';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { InputClassifierConfig, InputSources } from './simple-input-classifier';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { FlowrConfig } from '../../../config';
+import { executeInputSourcesQuery } from './input-sources-query-executor';
+export type InputSourcesQueryConfig = InputClassifierConfig;
+/**
+ * Calculates provenance for all inputs and their transformations
+ * based on the `provenance` of a given function.
+ */
+export interface InputSourcesQuery extends BaseQueryFormat {
+    readonly type: 'input-sources';
+    /**
+     * This takes a criterion (or a numerical id works too)
+     * {@link SlicingCriterion.fromId}
+     */
+    readonly criterion: SlicingCriterion;
+    readonly config?: InputSourcesQueryConfig;
+}
+export interface InputSourcesQueryResult extends BaseQueryResult {
+    /** For each query key, a list of classified input sources (each with id and all traces) */
+    results: Record<string, InputSources>;
+}
+declare function inputSourcesQueryLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfig): ParsedQueryLine<'input-sources'>;
+export declare const InputSourcesDefinition: {
+    readonly executor: typeof executeInputSourcesQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly fromLine: typeof inputSourcesQueryLineParser;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+};
+export {};