@eagleoutice/flowr 2.10.4 → 2.10.5

package/queries/catalog/input-sources-query/input-source-functions.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionsFunctions = exports.LangFunctions = exports.FfiFunctions = exports.SystemFunctions = exports.PureFunctions = void 0;
+exports.PureFunctions = [
+    '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',
+    'rownames', 'colnames',
+    'list.files', 'tolower', 'toupper', 'printf',
+    '<-', '->', '=', '<<-', '->>', 'assign', 'get',
+    '[', '[[', '$', 'length<-', 'dim<-', 'names<-', 'colnames<-', 'rownames<-',
+    'as.character', 'as.numeric', 'as.logical', 'as.raw', 'as.list', 'as.data.frame', 'as.matrix', 'as.array',
+    'identity', 'invisible', 'return', 'force', 'missing',
+    'print', 'cat', 'message', 'warning', 'stop',
+    'format', 'sprintf', 'formatC',
+    'is.na', 'is.null', 'is.numeric', 'is.character',
+    'which', 'match', 'order', 'sort', 'unique', 'duplicated', 'na.omit',
+    'grep', 'grepl', 'sub', 'gsub', 'regexpr', 'gregexpr', 'regexec', 'regmatches',
+    'as.integer', 'as.double', 'as.complex',
+    'trimws', 'seq_len', 'seq_along', 'rep.int',
+    'pmin', 'pmax', 'cumsum', 'cumprod', 'cummax', 'cummin', 'diff', 'signif',
+    'table', 'prop.table', 'xtabs',
+    'rbind', 'cbind', 't', 'crossprod', 'tcrossprod',
+    'colSums', 'rowSums', 'colMeans', 'rowMeans',
+    'solve', 'det', 'eigen',
+    'is.factor', 'is.logical', 'is.vector', 'is.matrix', 'is.data.frame',
+];
+exports.SystemFunctions = ['system', 'system2', 'pipe', 'shell', 'shell.exec'];
+exports.FfiFunctions = ['.C', '.Call', '.Fortran', '.External', 'dyn.load', 'sourceCpp', 'getNativeSymbolInfo'];
+exports.LangFunctions = [
+    'substitute', 'quote', 'enquote', 'bquote',
+    'call', 'as.call', 'expression', 'as.expression', // 'str2lang', 'str2expression',
+    'as.name', 'as.symbol', 'alist', 'as.language', 'evalq',
+    'expr', 'exprs', 'enexpr', 'enexprs', 'inject',
+    'quo', 'quos', 'enquo', 'enquos', 'enquo0', 'enquos0',
+    'sym', 'syms', 'ensym', 'ensyms'
+];
+exports.OptionsFunctions = ['options', 'getOption', 'Sys.getenv'];
+//# sourceMappingURL=input-source-functions.js.map

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

@@ -1,5 +1,5 @@
 import type { BasicQueryData } from '../../base-query-format';
-import type { InputSourcesQuery, InputSourcesQueryResult } from './input-sources-query-format';
+import { type InputSourcesQuery, type InputSourcesQueryResult } from './input-sources-query-format';
 /**
  * Execute an input sources query
  */

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

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeInputSourcesQuery = executeInputSourcesQuery;
+const input_sources_query_format_1 = require("./input-sources-query-format");
 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");
+const flowr_search_executor_1 = require("../../../search/flowr-search-executor");
+const record_1 = require("../../../util/record");
 /**
  * Execute an input sources query
  */
@@ -18,6 +18,7 @@ async function executeInputSourcesQuery({ analyzer }, queries) {
     const results = {};
     const nast = await analyzer.normalize();
     const df = await analyzer.dataflow();
+    const defaultConfig = await resolveSearches(analyzer, input_sources_query_format_1.DefaultInputClassifierConfig);
     for (const query of queries) {
         const key = query.criterion;
         if (results[key]) {
@@ -27,56 +28,8 @@ async function executeInputSourcesQuery({ analyzer }, queries) {
         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, {
-            fullDfg: df.graph,
-            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',
-                'rownames', 'colnames',
-                'list.files', 'tolower', 'toupper', 'printf',
-                '<-', '->', '=', '<<-', '->>', 'assign', 'get',
-                '[', '[[', '$', 'length<-', 'dim<-', 'names<-', 'colnames<-', 'rownames<-',
-                'as.character', 'as.numeric', 'as.logical', 'as.raw', 'as.list', 'as.data.frame', 'as.matrix', 'as.array',
-                'identity', 'invisible', 'return', 'force', 'missing',
-                'print', 'cat', 'message', 'warning', 'stop',
-                'format', 'sprintf', 'formatC',
-                'is.na', 'is.null', 'is.numeric', 'is.character',
-                'which', 'match', 'order', 'sort', 'unique', 'duplicated', 'na.omit',
-                'grep', 'grepl', 'sub', 'gsub', 'regexpr', 'gregexpr', 'regexec', 'regmatches',
-                'as.integer', 'as.double', 'as.complex',
-                'trimws', 'seq_len', 'seq_along', 'rep.int',
-                'pmin', 'pmax', 'cumsum', 'cumprod', 'cummax', 'cummin', 'diff', 'signif',
-                'table', 'prop.table', 'xtabs',
-                'rbind', 'cbind', 't', 'crossprod', 'tcrossprod',
-                'colSums', 'rowSums', 'colMeans', 'rowMeans',
-                'solve', 'det', 'eigen',
-                'is.factor', 'is.logical', 'is.vector', 'is.matrix', 'is.data.frame',
-            ],
-            readFileFns: query.config?.readFileFns ?? read_functions_1.ReadFunctions.map(f => f.name),
-            systemFns: query.config?.systemFns ?? ['system', 'system2', 'pipe', 'shell', 'shell.exec'],
-            ffiFns: query.config?.ffiFns ?? ['.C', '.Call', '.Fortran', '.External', 'dyn.load', 'sourceCpp', 'getNativeSymbolInfo'],
-            langFns: query.config?.langFns ?? [
-                'substitute', 'quote', 'bquote', 'enquote',
-                'enexpr', 'enexprs', 'enquo', 'enquos',
-                'expression', 'call', 'as.call', 'as.expression',
-                'as.name', 'as.symbol', 'alist', 'as.language', 'evalq',
-                'expr', 'quo', 'enexpr', 'ensym', 'ensyms'
-            ],
-            optionsFns: query.config?.optionsFns ?? ['options', 'getOption', 'Sys.getenv']
-        });
+        const config = { ...defaultConfig, ...(await resolveSearches(analyzer, query?.config ?? {})) };
+        results[key] = (0, simple_input_classifier_1.classifyInput)(criterionId, provenance, config, df.graph);
     }
     return {
         '.meta': {
@@ -85,4 +38,17 @@ async function executeInputSourcesQuery({ analyzer }, queries) {
         results
     };
 }
+async function resolveSearches(analyzer, config) {
+    const result = {};
+    for (const [key, value] of record_1.Record.entries(config)) {
+        if (value === undefined || Array.isArray(value)) {
+            result[key] = value;
+        }
+        else {
+            const searchResult = await (0, flowr_search_executor_1.runSearch)(value, analyzer);
+            result[key] = searchResult.getElements().map(element => element.node.info.id);
+        }
+    }
+    return result;
+}
 //# sourceMappingURL=input-sources-query-executor.js.map

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

@@ -3,7 +3,7 @@ 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 InputClassifierConfig, type 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';
@@ -21,6 +21,7 @@ export interface InputSourcesQuery extends BaseQueryFormat {
     readonly criterion: SlicingCriterion;
     readonly config?: InputSourcesQueryConfig;
 }
+export declare const DefaultInputClassifierConfig: InputClassifierConfig;
 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>;

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

@@ -3,13 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputSourcesDefinition = void 0;
+exports.InputSourcesDefinition = exports.DefaultInputClassifierConfig = void 0;
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
+const simple_input_classifier_1 = require("./simple-input-classifier");
 const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
 const input_sources_query_executor_1 = require("./input-sources-query-executor");
 const range_1 = require("../../../util/range");
+const flowr_search_builder_1 = require("../../../search/flowr-search-builder");
+const read_functions_1 = require("../dependencies-query/function-info/read-functions");
+const input_source_functions_1 = require("./input-source-functions");
+exports.DefaultInputClassifierConfig = {
+    [simple_input_classifier_1.InputTraceType.Pure]: input_source_functions_1.PureFunctions,
+    [simple_input_classifier_1.InputType.File]: read_functions_1.ReadFunctions.map(readFunction => readFunction.name),
+    [simple_input_classifier_1.InputType.Network]: flowr_search_builder_1.Q.fromQuery({ type: 'linter', rules: ['network-functions'] }),
+    [simple_input_classifier_1.InputType.Random]: flowr_search_builder_1.Q.fromQuery({ type: 'linter', rules: ['seeded-randomness'] }),
+    [simple_input_classifier_1.InputType.System]: input_source_functions_1.SystemFunctions,
+    [simple_input_classifier_1.InputType.Ffi]: input_source_functions_1.FfiFunctions,
+    [simple_input_classifier_1.InputType.Lang]: input_source_functions_1.LangFunctions,
+    [simple_input_classifier_1.InputType.Options]: input_source_functions_1.OptionsFunctions
+};
 function inputSourcesQueryLineParser(output, line, _config) {
     const criterion = (0, slice_query_parser_1.sliceCriteriaParser)(line[0]);
     if (!criterion || criterion.length !== 1) {
@@ -29,10 +43,11 @@ exports.InputSourcesDefinition = {
         const nast = (await analyzer.normalize()).idMap;
         for (const [key, sources] of Object.entries(out.results)) {
             result.push(`   ╰ Input Sources for ${key}`);
-            for (const { id, trace, types } of sources) {
+            for (const { id, trace, types, value } of sources) {
                 const kNode = nast.get(id);
                 const kLoc = kNode ? range_1.SourceLocation.format(range_1.SourceLocation.fromNode(kNode)) : 'unknown location';
-                result.push(`           ╰ ${kLoc} (id: ${id}), type: ${JSON.stringify(types)}, trace: ${trace}`);
+                const valueStr = value !== undefined ? `, value: ${JSON.stringify(value)}` : '';
+                result.push(`           ╰ ${kLoc} (id: ${id}), type: ${JSON.stringify(types)}, trace: ${trace}${valueStr}`);
             }
         }
         return true;
@@ -42,14 +57,14 @@ exports.InputSourcesDefinition = {
         type: joi_1.default.string().valid('input-sources').required().description('The type of the query.'),
         criterion: joi_1.default.string().required().description('The slicing criterion to use.'),
         config: joi_1.default.object({
-            pureFns: joi_1.default.array().items(joi_1.default.string()).optional().description('Deterministic/pure functions: functions that preserve constantness of their inputs (e.g., arithmetic, parse).'),
-            networkFns: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that fetch data from the network (e.g., download.file, url connections).'),
-            randomFns: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that produce randomness (e.g., runif, rnorm).'),
-            readFileFns: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that read from the filesystem and produce data (e.g., read.csv, readRDS).'),
-            systemFns: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that execute system commands (e.g., system, system2, shell, pipe).'),
-            ffiFns: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that call native code via the R FFI (.C, .Call, .Fortran, .External, dyn.load).'),
-            langFns: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that produce language objects (e.g., substitute, quote, bquote, expression).'),
-            optionsFns: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that access or set global options (e.g., options, getOption).'),
+            [simple_input_classifier_1.InputTraceType.Pure]: joi_1.default.array().items(joi_1.default.string()).optional().description('Deterministic/pure functions: functions that preserve constantness of their inputs (e.g., arithmetic, parse).'),
+            [simple_input_classifier_1.InputType.File]: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that read from the filesystem and produce data (e.g., read.csv, readRDS).'),
+            [simple_input_classifier_1.InputType.Network]: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that fetch data from the network (e.g., download.file, url connections).'),
+            [simple_input_classifier_1.InputType.Random]: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that produce randomness (e.g., runif, rnorm).'),
+            [simple_input_classifier_1.InputType.System]: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that execute system commands (e.g., system, system2, shell, pipe).'),
+            [simple_input_classifier_1.InputType.Ffi]: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that call native code via the R FFI (.C, .Call, .Fortran, .External, dyn.load).'),
+            [simple_input_classifier_1.InputType.Lang]: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that produce language objects (e.g., substitute, quote, bquote, expression).'),
+            [simple_input_classifier_1.InputType.Options]: joi_1.default.array().items(joi_1.default.string()).optional().description('Functions that access or set global options (e.g., options, getOption).'),
         }).optional()
     }).description('Input Sources query definition'),
     flattenInvolvedNodes: (queryResults) => {

package/queries/catalog/input-sources-query/simple-input-classifier.d.ts

@@ -2,6 +2,7 @@ import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/nod
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
 import type { MergeableRecord } from '../../../util/objects';
 import { Identifier } from '../../../dataflow/environments/identifier';
+import type { FlowrSearchLike } from '../../../search/flowr-search-builder';
 /**
  * Lattice flattening until we have a taint engine :)
  * Please note that the classifier considers this basis with a set-lift,
@@ -25,7 +26,7 @@ export declare enum InputType {
     Random = "rand",
     /** Calls to system/system2 and similar */
     System = "system",
-    /** Calls to .C / Fortran interfaces */
+    /** Calls to .C / Fortran interfaces (foreign function interfaces) */
     Ffi = "ffi",
     /** Language objects (quote/substitute/etc.) */
     Lang = "lang",
@@ -48,6 +49,12 @@ export declare enum InputTraceType {
     /** Not fully known origin */
     Unknown = "unknown"
 }
+/**
+ * Scalar R constant values representable in TypeScript.
+ * `null` corresponds to R's `NULL`.
+ * NA values are not included (they have no direct TS equivalent).
+ */
+export type ConstantValue = string | number | boolean | null;
 /**
  * Object attached to an input source
  * @see {@link InputSources}
@@ -58,6 +65,8 @@ export interface InputSource extends MergeableRecord {
     trace: InputTraceType;
     /** if the trace is affected by control dependencies, they are classified too, this is a duplicate free array */
     cds?: InputType[];
+    /** the concrete scalar value when the source is a constant or a pure alias of one */
+    value?: ConstantValue;
 }
 /**
  * Map of input sources, keyed by the node id of the input source. Each input source is classified with an {@link InputSource} object.
@@ -67,54 +76,22 @@ export type InputSources = InputSource[];
  * This is either an {@link NodeId|id} of a known functions all of that category (e.g., you can issue a dependencies query before and then pass all
  * identified ids to this query here).
  */
-export type InputClassifierFunctionIdentifier = Identifier | NodeId;
+export type InputClassifierFunctionIdentifiers = readonly (Identifier | NodeId)[];
 /**
- * For the specifications of `pureFns` etc. please have a look at {@link InputClassifierFunctionIdentifier}.
+ * For the specifications of `pure` etc. please have a look at {@link InputClassifierFunctionIdentifiers}.
  */
-export interface InputClassifierConfig extends MergeableRecord {
+export interface InputClassifierConfig<Functions extends InputClassifierFunctionIdentifiers | FlowrSearchLike = readonly Identifier[] | FlowrSearchLike> extends Partial<Record<InputType, Functions>> {
     /**
      * Functions which are considered to be pure (i.e., deterministic, trusted, safe, idempotent on the lub of the input types)
      */
-    pureFns: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that read from the network
-     */
-    networkFns: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that produce a random value
-     * Note: may need to check with respect to seeded randomness
-     */
-    randomFns: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that read from the file system
-     */
-    readFileFns: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that call system utilities (system/system2)
-     */
-    systemFns?: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that call native code via .C/.Fortran interfaces
-     */
-    ffiFns?: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that produce language objects such as quote/substitute
-     */
-    langFns?: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * Functions that access or set global options
-     */
-    optionsFns?: readonly InputClassifierFunctionIdentifier[];
-    /**
-     * For the scope escape analysis, pass on the full, non-reduced DFG here
-     */
-    fullDfg?: DataflowGraph;
+    [InputTraceType.Pure]?: Functions;
 }
 /**
  * Takes the given id which is expected to either be:
  * - a function call - in this case all arguments are considered to be inputs (additionally to all read edges from the function call in the dataflow graph)
- * - anything else - in that case the node itself is considered as an "input" - please note that in these scenarios the *return* value will only contain one mapping - that for the id you pased in.
+ * - anything else - in that case the node itself is considered as an "input" - please note that in these scenarios the *return* value will only contain one mapping - that for the id you passed in.
  *
- * This method traces the dependencies in the dataflow graph using the specification of functions passed in
+ * This method traces the dependencies in the dataflow graph using the specification of functions passed in.
+ * For the scope escape analysis, pass on the full, non-reduced DFG as `fullDfg`.
  */
-export declare function classifyInput(id: NodeId, dfg: DataflowGraph, config: InputClassifierConfig): InputSources;
+export declare function classifyInput(id: NodeId, dfg: DataflowGraph, config: InputClassifierConfig<InputClassifierFunctionIdentifiers>, fullDfg?: DataflowGraph): InputSources;