@eagleoutice/flowr 2.6.0 → 2.6.1

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeHigherOrderQuery = executeHigherOrderQuery;
+const parse_1 = require("../../../slicing/criterion/parse");
+const vertex_1 = require("../../../dataflow/graph/vertex");
+const higher_order_function_1 = require("../../../dataflow/fn/higher-order-function");
+async function executeHigherOrderQuery({ analyzer }, queries) {
+    const start = Date.now();
+    let filters = undefined;
+    // filter will remain undefined if at least one of the queries wants all functions
+    for (const q of queries) {
+        if (q.filter === undefined) {
+            filters = undefined;
+            break;
+        }
+        else {
+            filters ??= [];
+            filters = filters.concat(filters);
+        }
+    }
+    const ast = await analyzer.normalize();
+    const filterFor = new Set();
+    if (filters) {
+        for (const f of filters) {
+            const i = (0, parse_1.tryResolveSliceCriterionToId)(f, ast.idMap);
+            if (i !== undefined) {
+                filterFor.add(i);
+            }
+        }
+    }
+    const graph = (await analyzer.dataflow()).graph;
+    const fns = graph.vertices(true)
+        .filter(([, v]) => (0, vertex_1.isFunctionDefinitionVertex)(v) && (filterFor.size === 0 || filterFor.has(v.id)));
+    const result = {};
+    for (const [id,] of fns) {
+        result[id] = (0, higher_order_function_1.isHigherOrder)(id, graph);
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        higherOrder: result
+    };
+}
+//# sourceMappingURL=inspect-higher-order-query-executor.js.map

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-format.d.ts

@@ -0,0 +1,22 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import { executeHigherOrderQuery } from './inspect-higher-order-query-executor';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+/**
+ * Either returns all function definitions alongside whether they are higher-order functions,
+ * or just those matching the filters.
+ */
+export interface InspectHigherOrderQuery extends BaseQueryFormat {
+    readonly type: 'inspect-higher-order';
+    readonly filter?: SingleSlicingCriterion[];
+}
+export interface InspectHigherOrderQueryResult extends BaseQueryResult {
+    readonly higherOrder: Record<NodeId, boolean>;
+}
+export declare const InspectHigherOrderQueryDefinition: {
+    readonly executor: typeof executeHigherOrderQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, processed: import("../../../project/flowr-analyzer").FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+};

package/queries/catalog/inspect-higher-order-query/inspect-higher-order-query-format.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InspectHigherOrderQueryDefinition = void 0;
+const ansi_1 = require("../../../util/text/ansi");
+const joi_1 = __importDefault(require("joi"));
+const inspect_higher_order_query_executor_1 = require("./inspect-higher-order-query-executor");
+const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const dfg_1 = require("../../../util/mermaid/dfg");
+exports.InspectHigherOrderQueryDefinition = {
+    executor: inspect_higher_order_query_executor_1.executeHigherOrderQuery,
+    asciiSummarizer: async (formatter, processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('inspect-higher-order', formatter)} (${out['.meta'].timing.toFixed(0)}ms)`);
+        for (const [r, v] of Object.entries(out.higherOrder)) {
+            const loc = (await processed.normalize()).idMap.get((0, node_id_1.normalizeIdToNumberIfPossible)(r))?.location ?? undefined;
+            result.push(`  - Function ${(0, ansi_1.bold)(r, formatter)} (${(0, dfg_1.formatRange)(loc)}) is ${v ? '' : 'not '}a higher-order function`);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('inspect-higher-order').required().description('The type of the query.'),
+        filter: joi_1.default.array().items(joi_1.default.string().required()).optional().description('If given, only function definitions that match one of the given slicing criteria are considered. Each criterion can be either `line:column`, `line@variable-name`, or `$id`, where the latter directly specifies the node id of the function definition to be considered.')
+    }).description('Either returns all function definitions alongside whether they are higher-order functions, or just those matching the filters.'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return Object.keys(out.higherOrder).filter(id => out.higherOrder[id]);
+    }
+};
+//# sourceMappingURL=inspect-higher-order-query-format.js.map

package/queries/query.d.ts

@@ -25,11 +25,13 @@ import type { ControlFlowQuery } from './catalog/control-flow-query/control-flow
 import type { DfShapeQuery } from './catalog/df-shape-query/df-shape-query-format';
 import type { AsyncOrSync } from 'ts-essentials';
 import type { FlowrConfigOptions } from '../config';
+import type { InspectHigherOrderQuery } from './catalog/inspect-higher-order-query/inspect-higher-order-query-format';
 import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
 /**
  * These are all queries that can be executed from within flowR
+ * {@link SynchronousQuery} are queries that can be executed synchronously, i.e., they do not return a Promise.
  */
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectHigherOrderQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -57,7 +59,7 @@ export declare const SupportedQueries: {
     };
     readonly config: {
         readonly executor: typeof import("./catalog/config-query/config-query-executor").executeConfigQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => true;
         readonly completer: (partialLine: readonly string[], config: FlowrConfigOptions) => string[];
         readonly fromLine: (line: readonly string[], _config: FlowrConfigOptions) => [ConfigQuery];
         readonly schema: Joi.ObjectSchema<any>;
@@ -141,6 +143,12 @@ export declare const SupportedQueries: {
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
+    readonly 'inspect-higher-order': {
+        readonly executor: typeof import("./catalog/inspect-higher-order-query/inspect-higher-order-query-executor").executeHigherOrderQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, processed: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    };
     readonly 'resolve-value': {
         readonly executor: typeof import("./catalog/resolve-value-query/resolve-value-query-executor").executeResolveValueQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;

package/queries/query.js

@@ -32,6 +32,7 @@ const origin_query_format_1 = require("./catalog/origin-query/origin-query-forma
 const linter_query_format_1 = require("./catalog/linter-query/linter-query-format");
 const control_flow_query_format_1 = require("./catalog/control-flow-query/control-flow-query-format");
 const df_shape_query_format_1 = require("./catalog/df-shape-query/df-shape-query-format");
+const inspect_higher_order_query_format_1 = require("./catalog/inspect-higher-order-query/inspect-higher-order-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
@@ -48,6 +49,7 @@ exports.SupportedQueries = {
     'location-map': location_map_query_format_1.LocationMapQueryDefinition,
     'search': search_query_format_1.SearchQueryDefinition,
     'happens-before': happens_before_query_format_1.HappensBeforeQueryDefinition,
+    'inspect-higher-order': inspect_higher_order_query_format_1.InspectHigherOrderQueryDefinition,
     'resolve-value': resolve_value_query_format_1.ResolveValueQueryDefinition,
     'project': project_query_format_1.ProjectQueryDefinition,
     'origin': origin_query_format_1.OriginQueryDefinition,

package/r-bridge/parser.d.ts

@@ -8,6 +8,13 @@ interface ParserContent<T> {
     parse(request: RParseRequest): T;
     close(): void;
 }
+export interface TreeSitterInformation {
+    name: TreeSitterExecutor['name'];
+}
+export interface RShellInformation {
+    name: RShell['name'];
+    rVersion: string;
+}
 export type SyncParser<T> = ParserContent<Awaited<T>> & {
     readonly async?: false;
 };

package/search/search-executor/search-enrichers.js

@@ -12,6 +12,7 @@ const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const cfg_simplification_1 = require("../../control-flow/cfg-simplification");
 const call_context_query_executor_1 = require("../../queries/catalog/call-context-query/call-context-query-executor");
+const cfg_kind_1 = require("../../project/cfg-kind");
 /**
  * An enumeration that stores the names of the available enrichments that can be applied to a set of search elements.
  * See {@link FlowrSearchBuilder.with} for more information on how to apply enrichments.
@@ -113,7 +114,7 @@ exports.Enrichments = {
             }
             const content = {
                 ...prev,
-                cfg: await data.controlflow(args.simplificationPasses, true),
+                cfg: await data.controlflow(args.simplificationPasses, cfg_kind_1.CfgKind.WithDataflow),
             };
             if (args.checkReachable) {
                 content.reachableNodes = (0, cfg_simplification_1.cfgFindAllReachable)(content.cfg);

package/util/r-value.d.ts

@@ -20,4 +20,4 @@ export declare function unliftRValue(value: ValueString): RStringValue | undefin
 export declare function unliftRValue(value: ValueNumber | ValueInterval): RNumberValue | undefined;
 export declare function unliftRValue(value: ValueLogical): RLogicalValue | undefined;
 export declare function unliftRValue(value: ValueVector): (RStringValue | RNumberValue | RLogicalValue)[] | undefined;
-export declare function unliftRValue(value: Value): RStringValue | RNumberValue | boolean | (RStringValue | RNumberValue | RLogicalValue)[] | undefined;
+export declare function unliftRValue(value: Value): RStringValue | RNumberValue | 'fn-def' | boolean | ('fn-def' | RStringValue | RNumberValue | RLogicalValue)[] | undefined;

package/util/r-value.js

@@ -106,6 +106,8 @@ function unliftRValue(value) {
         case 'missing': {
             return undefined;
         }
+        case 'function-definition':
+            return 'fn-def';
         default:
             (0, assert_1.assertUnreachable)(type);
     }

package/util/version.d.ts

@@ -1,2 +1,19 @@
 import { SemVer } from 'semver';
+import type { KnownParser } from '../r-bridge/parser';
+import type { ReplOutput } from '../cli/repl/commands/repl-main';
+import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
 export declare function flowrVersion(): SemVer;
+type Version = `${number}.${number}.${number}`;
+/**
+ * Describes the version of flowR and the used R interpreter.
+ */
+export interface VersionInformation {
+    /** The version of flowR */
+    flowr: Version;
+    /** The version of R identified by the underlying {@link RShell} */
+    r: Version | 'unknown' | 'none';
+    engine: string;
+}
+export declare function retrieveVersionInformation(input: KnownParser | FlowrAnalysisProvider): Promise<VersionInformation>;
+export declare function printVersionInformation(output: ReplOutput, input: KnownParser | FlowrAnalysisProvider): Promise<void>;
+export {};

package/util/version.js

@@ -1,10 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
+exports.retrieveVersionInformation = retrieveVersionInformation;
+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.6.0';
+const version = '2.6.1';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }
+const versionRegex = /^\d+\.\d+\.\d+/m;
+async function retrieveVersionInformation(input) {
+    const flowr = flowrVersion().toString();
+    let r;
+    let name;
+    if ('name' in input) {
+        r = await input.rVersion();
+        name = input.name;
+    }
+    else {
+        const parserInformation = await input.parserInformation();
+        r = parserInformation.name === 'r-shell' ? parserInformation.rVersion : 'unknown';
+        name = parserInformation.name;
+    }
+    (0, assert_1.guard)(versionRegex.test(flowr), `flowR version ${flowr} does not match the expected format!`);
+    (0, assert_1.guard)(r === 'unknown' || r === 'none' || versionRegex.test(r), `R version ${r} does not match the expected format!`);
+    return { flowr: flowr, r: r, engine: name };
+}
+async function printVersionInformation(output, input) {
+    const { flowr, r, engine } = await retrieveVersionInformation(input);
+    output.stdout(`Engine: ${engine}`);
+    output.stdout(` flowR: ${flowr}`);
+    output.stdout(` R: ${r}`);
+}
 //# sourceMappingURL=version.js.map