@eagleoutice/flowr 2.9.13 → 2.9.14

package/documentation/wiki-dataflow-graph.js

@@ -38,11 +38,12 @@ const flowr_analyzer_builder_1 = require("../project/flowr-analyzer-builder");
 const flowr_analyzer_context_1 = require("../project/context/flowr-analyzer-context");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
 const flowr_analyzer_1 = require("../project/flowr-analyzer");
-const built_in_1 = require("../dataflow/environments/built-in");
 const dfg_1 = require("../util/mermaid/dfg");
 const r_number_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-number");
 const model_1 = require("../r-bridge/lang-4.x/ast/model/model");
 const range_1 = require("../util/range");
+const df_helper_1 = require("../dataflow/graph/df-helper");
+const built_in_proc_name_1 = require("../dataflow/environments/built-in-proc-name");
 async function subExplanation(parser, { description, code, expectedSubgraph }) {
     expectedSubgraph = await (0, doc_dfg_1.verifyExpectedSubgraph)(parser, code, expectedSubgraph);
     const marks = [];
@@ -170,7 +171,7 @@ ${(0, doc_structure_1.block)({
                 content: `
 	If you want to obtain the locations where a variable is defined, or read, or re-defined, refrain from tracking these details manually in the dataflow graph
 	as there are some edge-cases that require special attention.
-	In general, the ${ctx.link(dfg_get_origin_1.getOriginInDfg)} function explained below in [working with the dataflow graph](${doc_files_1.FlowrWikiBaseRef}/Dataflow%20Graph#working-with-the-dataflow-graph) will help you to get the information you need.
+	In general, the ${ctx.link(dfg_get_origin_1.getOriginInDfg)} (which is also available as ${ctx.linkO(df_helper_1.Dataflow, 'origin')}) function explained below in [working with the dataflow graph](${doc_files_1.FlowrWikiBaseRef}/Dataflow%20Graph#working-with-the-dataflow-graph) will help you to get the information you need.
 	`
             })}
 
@@ -196,8 +197,8 @@ ${ctx.hierarchy('FunctionArgument')}
 
 There is another element of potential interest to you, the \`origin\` property which records how flowR created the respective function call.
 These origins may hold the name of any processor that is part of the ${ctx.link('BuiltInProcName')} enumeration to signal that the respective processor (cf. ${ctx.link('BuiltInProcessorMapper')}) was responsible for creating the vertex.
-The entry \`${built_in_1.BuiltInProcName.Function}\` signals that flowR used a processor for a user-defined function defined within the source code, \`${built_in_1.BuiltInProcName.Unnamed}\` signals that the function as an anonymous function definition.
-However, in general, flowR may use any fitting handler as an origin (see the ${ctx.link('BuiltInProcName')} enum for a *complete* list). For example, within a access definition, flowR will correspondingly redefine the meaning of \`:=\` to that of the \`${built_in_1.BuiltInProcName.TableAssignment}\`. 
+The entry \`${built_in_proc_name_1.BuiltInProcName.Function}\` signals that flowR used a processor for a user-defined function defined within the source code, \`${built_in_proc_name_1.BuiltInProcName.Unnamed}\` signals that the function as an anonymous function definition.
+However, in general, flowR may use any fitting handler as an origin (see the ${ctx.link('BuiltInProcName')} enum for a *complete* list). For example, within a access definition, flowR will correspondingly redefine the meaning of \`:=\` to that of the \`${built_in_proc_name_1.BuiltInProcName.TableAssignment}\`. 
 
 ${(0, doc_structure_1.details)('Example: Simple Function Call (unresolved)', await (async () => {
                 const code = 'foo(x,3,y=3,)';
@@ -367,7 +368,7 @@ ${(0, doc_structure_1.block)({
                 content: `Now you might be asking yourself how to differentiate anonymous and named functions and what you have to keep in mind when working with them?
 
 Unnamed functions have an array of signatures which you can use to identify them. 
-But in short: the \`origin\` attribute of the ${ctx.link('DataflowGraphVertexFunctionCall')} is \`${built_in_1.BuiltInProcName.Unnamed}\`.
+But in short: the \`origin\` attribute of the ${ctx.link('DataflowGraphVertexFunctionCall')} is \`${built_in_proc_name_1.BuiltInProcName.Unnamed}\`.
 Please be aware that unnamed functions still have a \`name\` property to give it a unique identifier that can be used for debugging and reference.
 This name _always_ starts with \`${unnamed_call_handling_1.UnnamedFunctionCallPrefix}\`.
 
@@ -1052,7 +1053,8 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(treeSitter, 'alias <- unknown\nalias(
 ${(0, doc_structure_1.section)('Working with the Dataflow Graph', 2, 'dfg-working')}
 
 The ${ctx.link('DataflowInformation')} is the core result of _flowR_ and summarizes a lot of information.
-Depending on what you are interested in, there exists a plethora of functions and queries to help you out, answering the most important questions:
+Depending on what you are interested in, there exists a plethora of functions and queries to help you out, answering the most important questions.
+Generally, we recommend you check out the ${ctx.link(df_helper_1.Dataflow, undefined, { type: 'variable' })} helper object!
 
 * The **${ctx.linkPage('wiki/Query API')}** provides many functions to query the dataflow graph for specific information (dependencies, calls, slices, clusters, ...)
 * The **${ctx.linkPage('wiki/Search API')}** allows you to search for specific vertices or edges in the dataflow graph or the original program
@@ -1064,9 +1066,9 @@ Depending on what you are interested in, there exists a plethora of functions an
 
 FlowR also provides various helper objects (with the same name as the corresponding type) to help you work with the dataflow graph:
 
-* ${ctx.link('DfEdge', undefined, { type: 'variable' })} to get helpful functions wrt. edges (see [below](#dfg-resolving-values))
-* ${ctx.link('Identifier', undefined, { type: 'variable' })} to get helpful functions wrt. identifiers
-* ${ctx.link('FunctionArgument', undefined, { type: 'variable' })} to get helpful functions wrt. function arguments
+* ${ctx.link(edge_1.DfEdge, undefined, { type: 'variable' })} to get helpful functions wrt. edges (see [below](#dfg-resolving-values))
+* ${ctx.link(identifier_1.Identifier, undefined, { type: 'variable' })} to get helpful functions wrt. identifiers
+* ${ctx.link(graph_1.FunctionArgument, undefined, { type: 'variable' })} to get helpful functions wrt. function arguments
 
 Some of these functions have been explained in their respective wiki pages. However, some are part of the ${ctx.linkPage('wiki/Dataflow Graph', 'Dataflow Graph API')} and so we explain them here.
 If you are interested in which features we support and which features are still to be worked on, please refer to our ${ctx.linkPage('wiki/Capabilities', 'capabilities')} page.
@@ -1107,14 +1109,14 @@ ${await (async () => {
                 }
                 throw new Error('Could not find edge');
             })()}&mdash;which is usually not very helpful.
-You can use ${ctx.link('DfEdge::splitTypes')} to get the individual bitmasks of all included types, and 
-${ctx.link('DfEdge::includesType')} to check whether a specific type (or one of a collection of types) is included in the edge.
+You can use ${ctx.linkO(edge_1.DfEdge, 'splitTypes')} to get the individual bitmasks of all included types, and 
+${ctx.linkO(edge_1.DfEdge, 'includesType')} to check whether a specific type (or one of a collection of types) is included in the edge.
 
 ${(0, doc_structure_1.section)('Handling Origins', 3, 'dfg-handling-origins')}
 
 If you are writing another analysis on top of the dataflow graph, you probably want to know all definitions that serve as the source of a read, all functions
 that are called by an invocation, and more.
-For this, the ${ctx.link(dfg_get_origin_1.getOriginInDfg)} function provides you with a collection of ${ctx.link('Origin')} objects:
+For this, the ${ctx.link(dfg_get_origin_1.getOriginInDfg)} (this is also accessible with ${ctx.linkO(df_helper_1.Dataflow, 'origin')}) function provides you with a collection of ${ctx.link('Origin')} objects:
 
 ${ctx.hierarchy('Origin', { openTop: true })}
 

package/documentation/wiki-interface.js

@@ -18,8 +18,8 @@ const flowr_main_options_1 = require("../cli/flowr-main-options");
 const doc_issue_1 = require("./doc-util/doc-issue");
 const doc_structure_1 = require("./doc-util/doc-structure");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
-const built_in_1 = require("../dataflow/environments/built-in");
 const doc_writing_code_1 = require("./data/interface/doc-writing-code");
+const built_in_proc_name_1 = require("../dataflow/environments/built-in-proc-name");
 async function explainServer(parser) {
     (0, doc_data_server_messages_1.documentAllServerMessages)();
     return `
@@ -236,7 +236,7 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
             environment: {
                 overwriteBuiltIns: {
                     definitions: [
-                        { type: 'function', names: ['foo'], processor: built_in_1.BuiltInProcName.Assignment, config: {} }
+                        { type: 'function', names: ['foo'], processor: built_in_proc_name_1.BuiltInProcName.Assignment, config: {} }
                     ]
                 }
             }
@@ -290,7 +290,7 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
   | Type            | Description                                                                                                                                                                                                                                                                                              | Example                                                                                                    |
   | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
   | \`constant\`    | Additionally allows for a \`value\` this should resolve to.                                                                                                                                                                                                                                                | \`{ type: 'constant', names: ['NULL', 'NA'],  value: null }\`                                                |
-  | \`function\`    | Is a rather flexible way to define and bind built-in functions. For the time, we do not have extensive documentation to cover all the cases, so please either consult the sources with the \`default-builtin-config.ts\` or open a [new issue](${doc_issue_1.NewIssueUrl}). | \`{ type: 'function', names: ['next'], processor: '${built_in_1.BuiltInProcName.Default}', config: { cfg: ExitPointType.Next } }\` |
+  | \`function\`    | Is a rather flexible way to define and bind built-in functions. For the time, we do not have extensive documentation to cover all the cases, so please either consult the sources with the \`default-builtin-config.ts\` or open a [new issue](${doc_issue_1.NewIssueUrl}). | \`{ type: 'function', names: ['next'], processor: '${built_in_proc_name_1.BuiltInProcName.Default}', config: { cfg: ExitPointType.Next } }\` |
   | \`replacement\` | A comfortable way to specify replacement functions like \`$<-\` or \`names<-\`. \`suffixes\` describes the... suffixes to attach automatically. | \`{ type: 'replacement', suffixes: ['<-', '<<-'], names: ['[', '[['] }\` |
 
 

package/documentation/wiki-linter.js

@@ -122,6 +122,7 @@ df[6, "value"]
 `, tagTypes);
     rule(knownParser, 'dead-code', 'DeadCodeConfig', 'DEAD_CODE', 'lint-dead-code', 'if(TRUE) 1 else 2', tagTypes);
     rule(knownParser, 'useless-loop', 'UselessLoopConfig', 'USELESS_LOOP', 'lint-useless-loop', 'for(i in c(1)) { print(i) }', tagTypes);
+    rule(knownParser, 'stop-call', 'StopWithCallConfig', 'STOP_WITH_CALL_ARG', 'lint-stop-call', 'stop(42)', tagTypes);
     function rule(parser, name, configType, ruleType, testfile, example, types) {
         const rule = linter_rules_1.LintingRules[name];
         const tags = rule.info.tags.toSorted((a, b) => {

package/documentation/wiki-normalized-ast.js

@@ -16,6 +16,7 @@ const roxygen_parse_1 = require("../r-bridge/roxygen2/roxygen-parse");
 const r_binary_op_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-binary-op");
 const model_1 = require("../r-bridge/lang-4.x/ast/model/model");
 const r_project_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-project");
+const r_expression_list_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-expression-list");
 async function quickNormalizedAstMultipleFiles() {
     const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
         .setEngine('tree-sitter')
@@ -95,8 +96,8 @@ ${await (0, doc_normalized_ast_1.printNormalizedAstForCode)(treeSitter, 'x <- 2
 > 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 of the normalization is the root ${ctx.link('RProject')} node, which is present in every normalized AST
-and provides the ${ctx.link('RExpressionList')} nodes for each file in the project.
+Indicative of the normalization is the root ${ctx.link(r_project_1.RProject)} node, which is present in every normalized AST
+and provides the ${ctx.link(r_expression_list_1.RExpressionList)} nodes for each file in the project.
 In general, we provide node types for:
 
 1. literals (e.g., numbers and strings)
@@ -112,7 +113,7 @@ In general, we provide node types for:
 Every node is a link, which directly refers to the implementation in the source code.
 Grayed-out parts are used for structuring the AST, grouping together related nodes.
 
-${(0, doc_code_1.codeBlock)('mermaid', ctx.mermaid('RNode'))}
+${(0, doc_code_1.codeBlock)('mermaid', ctx.mermaid(model_1.RNode))}
 
 </details>
 
@@ -123,7 +124,7 @@ Most notably, the \`info\` field holds the \`id\` of the node, which is used to
 
 In summary, we have the following types:
 
-${(0, doc_structure_1.details)('Normalized AST Node Types', ctx.hierarchy('RNode', { collapseFromNesting: Number.MAX_VALUE, ignoredTypes: ['Info', 'LogLevel'] }))}
+${(0, doc_structure_1.details)('Normalized AST Node Types', ctx.hierarchy(model_1.RNode, { collapseFromNesting: Number.MAX_VALUE, ignoredTypes: ['Info', 'LogLevel'] }))}
 
 The following segments intend to give you an overview of how to work with the normalized AST:
 

package/documentation/wiki-query.js

@@ -29,7 +29,6 @@ const vertex_1 = require("../dataflow/graph/vertex");
 const control_flow_query_executor_1 = require("../queries/catalog/control-flow-query/control-flow-query-executor");
 const doc_cfg_1 = require("./doc-util/doc-cfg");
 const df_shape_query_executor_1 = require("../queries/catalog/df-shape-query/df-shape-query-executor");
-const _00_slice_1 = require("../core/steps/all/static-slicing/00-slice");
 const doc_repl_1 = require("./doc-util/doc-repl");
 const inspect_higher_order_query_executor_1 = require("../queries/catalog/inspect-higher-order-query/inspect-higher-order-query-executor");
 const doc_escape_1 = require("./doc-util/doc-escape");
@@ -39,6 +38,8 @@ const call_graph_query_executor_1 = require("../queries/catalog/call-graph-query
 const inspect_recursion_query_executor_1 = require("../queries/catalog/inspect-recursion-query/inspect-recursion-query-executor");
 const does_call_query_executor_1 = require("../queries/catalog/does-call-query/does-call-query-executor");
 const inspect_exception_query_executor_1 = require("../queries/catalog/inspect-exceptions-query/inspect-exception-query-executor");
+const slice_direction_1 = require("../util/slice-direction");
+const provenance_query_executor_1 = require("../queries/catalog/provenance-query/provenance-query-executor");
 (0, doc_query_1.registerQueryDocumentation)('call-context', {
     name: 'Call-Context Query',
     type: 'active',
@@ -554,7 +555,7 @@ To specify a variable of interest, you have to present flowR with a [slicing cri
 
 To exemplify the capabilities, consider the following code:
 ${(0, doc_code_1.codeBlock)('r', exampleCode)}
-If you are interested in the parts required for the use of \`x\` in the last line, you can use the following query:
+If you are interested in the parts required for the use of \`x\` in the last line and \`z\`, you can use the following query:
 
 ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
                 type: 'static-slice',
@@ -575,7 +576,7 @@ Likewise, if you want the forward slice for the first use of \`x\`, you can do i
 ${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
                 type: 'static-slice',
                 criteria: ['1@x'],
-                direction: _00_slice_1.SliceDirection.Forward
+                direction: slice_direction_1.SliceDirection.Forward
             }], { showCode: false, shorthand: (0, doc_query_1.sliceQueryShorthand)(['1@x'], (0, doc_escape_1.escapeNewline)(exampleCode), true) })}
 
 You can disable [magic comments](${doc_files_1.FlowrWikiBaseRef}/Interface#slice-magic-comments) using the \`noMagicComments\` flag.
@@ -583,6 +584,30 @@ This query replaces the old [\`request-slice\`](${doc_files_1.FlowrWikiBaseRef}/
 		`;
     }
 });
+(0, doc_query_1.registerQueryDocumentation)('provenance', {
+    name: 'Provenance Query',
+    type: 'active',
+    shortDescription: 'Calculate the provenance of a given variable, optionally restricted to its enveloping fdef',
+    functionName: provenance_query_executor_1.executeProvenanceQuery.name,
+    functionFile: '../queries/catalog/provenance-query/provenance-query-executor.ts',
+    buildExplanation: async (shell) => {
+        const exampleCode = 'x <- 1\ny <- 2\nz <- 3\nx';
+        const criterion = '4@x';
+        return `
+Given a [slicing criterion](${doc_files_1.FlowrWikiBaseRef}/Terminology#slicing-criterion), flowR will return the provenance
+of the given program element (i.e., all related vertices in a non-interprocedural and non-context sensitive backward slice).
+
+To exemplify the capabilities, consider the following code:
+${(0, doc_code_1.codeBlock)('r', exampleCode)}
+If you are interested in the provenance of the \`x\` in the last line you can use:
+
+${await (0, doc_query_1.showQuery)(shell, exampleCode, [{
+                type: 'provenance',
+                criterion
+            }], { showCode: false, shorthand: (0, doc_query_1.sliceQueryShorthand)([criterion], (0, doc_escape_1.escapeNewline)(exampleCode)) })}
+`;
+    }
+});
 (0, doc_query_1.registerQueryDocumentation)('dependencies', {
     name: 'Dependencies Query',
     type: 'active',

package/linter/linter-rules.d.ts

@@ -277,10 +277,33 @@ export declare const LintingRules: {
             readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
             readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell, import("./linter-tags").LintingRuleTag.Readability];
             readonly defaultConfig: {
-                readonly loopyFunctions: Set<import("../dataflow/environments/built-in").BuiltInProcName>;
+                readonly loopyFunctions: Set<import("../dataflow/environments/built-in-proc-name").BuiltInProcName>;
             };
         };
     };
+    readonly 'stop-call': {
+        readonly createSearch: () => import("../search/flowr-search-builder").FlowrSearchBuilder<"get", ["filter"], import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
+        readonly processSearchResult: (elements: import("../search/flowr-search").FlowrSearchElements<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../search/flowr-search").FlowrSearchElement<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, _config: import("../util/objects").MergeableRecord, { dataflow, analyzer }: {
+            normalize: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            dataflow: import("../dataflow/info").DataflowInformation;
+            cfg: import("../control-flow/control-flow-graph").ControlFlowInformation;
+            analyzer: import("../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
+        }) => {
+            results: import("ts-essentials").Writable<import("./rules/stop-with-call-arg").StopWithCallResult>[];
+            '.meta': import("./rules/stop-with-call-arg").StopWithCallMetadata;
+        };
+        readonly prettyPrint: {
+            readonly query: (result: import("./rules/stop-with-call-arg").StopWithCallResult) => string;
+            readonly full: (result: import("./rules/stop-with-call-arg").StopWithCallResult) => string;
+        };
+        readonly info: {
+            readonly name: "Stop without call.=False argument";
+            readonly tags: readonly [import("./linter-tags").LintingRuleTag.Smell];
+            readonly certainty: import("./linter-format").LintingRuleCertainty.BestEffort;
+            readonly description: "Checks whether stop calls without call. argument set to FALSE are used.";
+            readonly defaultConfig: {};
+        };
+    };
 };
 export type LintingRuleNames = keyof typeof LintingRules;
 export type LintingRuleMetadata<Name extends LintingRuleNames> = typeof LintingRules[Name] extends LintingRule<infer _Result, infer Metadata, infer _Config, infer _Info, infer _Elements> ? Metadata : never;

package/linter/linter-rules.js

@@ -11,6 +11,7 @@ const naming_convention_1 = require("./rules/naming-convention");
 const dataframe_access_validation_1 = require("./rules/dataframe-access-validation");
 const useless_loop_1 = require("./rules/useless-loop");
 const network_functions_1 = require("./rules/network-functions");
+const stop_with_call_arg_1 = require("./rules/stop-with-call-arg");
 /**
  * The registry of currently supported linting rules.
  * A linting rule can be executed on a dataflow pipeline result using {@link executeLintingRule}.
@@ -25,6 +26,7 @@ exports.LintingRules = {
     'network-functions': network_functions_1.NETWORK_FUNCTIONS,
     'dataframe-access-validation': dataframe_access_validation_1.DATA_FRAME_ACCESS_VALIDATION,
     'dead-code': dead_code_1.DEAD_CODE,
-    'useless-loop': useless_loop_1.USELESS_LOOP
+    'useless-loop': useless_loop_1.USELESS_LOOP,
+    'stop-call': stop_with_call_arg_1.STOP_WITH_CALL_ARG
 };
 //# sourceMappingURL=linter-rules.js.map

package/linter/rules/seeded-randomness.js

@@ -19,7 +19,7 @@ const vertex_1 = require("../../dataflow/graph/vertex");
 const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const r_value_1 = require("../../dataflow/eval/values/r-value");
 const info_1 = require("../../dataflow/info");
-const built_in_1 = require("../../dataflow/environments/built-in");
+const built_in_proc_name_1 = require("../../dataflow/environments/built-in-proc-name");
 exports.SEEDED_RANDOMNESS = {
     createSearch: (config) => flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.FunctionCall)
         .with(search_enrichers_1.Enrichment.CallTargets, { onlyBuiltin: true })
@@ -140,7 +140,7 @@ exports.SEEDED_RANDOMNESS = {
     }
 };
 function getDefaultAssignments() {
-    return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && (b.processor === built_in_1.BuiltInProcName.Assignment || b.processor === built_in_1.BuiltInProcName.AssignmentLike));
+    return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && (b.processor === built_in_proc_name_1.BuiltInProcName.Assignment || b.processor === built_in_proc_name_1.BuiltInProcName.AssignmentLike));
 }
 function isConstantArgument(graph, call, argIndex, ctx) {
     const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.FunctionArgument.getReference);

package/linter/rules/stop-with-call-arg.d.ts

@@ -0,0 +1,35 @@
+import { type LintingResult, LintingRuleCertainty } from '../linter-format';
+import { SourceLocation } from '../../util/range';
+import type { MergeableRecord } from '../../util/objects';
+import { LintingRuleTag } from '../linter-tags';
+import type { Writable } from 'ts-essentials';
+export interface StopWithCallResult extends LintingResult {
+    readonly loc: SourceLocation;
+}
+export type StopWithCallConfig = MergeableRecord;
+export interface StopWithCallMetadata extends MergeableRecord {
+    consideredNodes: number;
+}
+export declare const STOP_WITH_CALL_ARG: {
+    readonly createSearch: () => import("../../search/flowr-search-builder").FlowrSearchBuilder<"get", ["filter"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, Promise<import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, [] | import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>>;
+    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, _config: MergeableRecord, { dataflow, analyzer }: {
+        normalize: import("../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        dataflow: import("../../dataflow/info").DataflowInformation;
+        cfg: import("../../control-flow/control-flow-graph").ControlFlowInformation;
+        analyzer: import("../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider;
+    }) => {
+        results: Writable<StopWithCallResult>[];
+        '.meta': StopWithCallMetadata;
+    };
+    readonly prettyPrint: {
+        readonly query: (result: StopWithCallResult) => string;
+        readonly full: (result: StopWithCallResult) => string;
+    };
+    readonly info: {
+        readonly name: "Stop without call.=False argument";
+        readonly tags: readonly [LintingRuleTag.Smell];
+        readonly certainty: LintingRuleCertainty.BestEffort;
+        readonly description: "Checks whether stop calls without call. argument set to FALSE are used.";
+        readonly defaultConfig: {};
+    };
+};

package/linter/rules/stop-with-call-arg.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STOP_WITH_CALL_ARG = 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 alias_tracking_1 = require("../../dataflow/eval/resolve/alias-tracking");
+const dfg_get_origin_1 = require("../../dataflow/origin/dfg-get-origin");
+const linker_1 = require("../../dataflow/internal/linker");
+const general_1 = require("../../dataflow/eval/values/general");
+exports.STOP_WITH_CALL_ARG = {
+    createSearch: () => flowr_search_builder_1.Q.var('stop').filter(vertex_1.VertexType.FunctionCall),
+    processSearchResult: (elements, _config, { dataflow, analyzer }) => {
+        const meta = {
+            consideredNodes: 0
+        };
+        return {
+            results: elements.getElements()
+                .filter(element => {
+                //only built-in functions
+                const origins = (0, dfg_get_origin_1.getOriginInDfg)(dataflow.graph, element.node.info.id);
+                if ((0, assert_1.isNotUndefined)(origins)) {
+                    const builtIn = origins.every(e => e.type === 3 /* OriginType.BuiltInFunctionOrigin */);
+                    if (!builtIn) {
+                        return false;
+                    }
+                }
+                const fCall = dataflow.graph.getVertex(element.node.info.id);
+                //filter out function calls with argument "call." set to false
+                const stopParamMap = {
+                    '...': '...',
+                    'call.': 'call.',
+                    'domain': 'domain'
+                };
+                const mapping = (0, linker_1.pMatch)(fCall.args, stopParamMap);
+                const mappedToStop = mapping.get('call.') ?? [];
+                for (const argId of mappedToStop) {
+                    const res = (0, alias_tracking_1.resolveIdToValue)(argId, { graph: dataflow.graph, environment: fCall.environment, ctx: analyzer.inspectContext() });
+                    const values = (0, general_1.valueSetGuard)(res);
+                    if (values?.type === 'set' && values.elements.length !== 0) {
+                        if (values.elements[0].type === 'logical') {
+                            return values.elements[0].value;
+                        }
+                    }
+                }
+                return true;
+            })
+                .map(element => ({
+                certainty: linter_format_1.LintingResultCertainty.Uncertain,
+                involvedId: element.node.info.id,
+                loc: range_1.SourceLocation.fromNode(element.node)
+            }))
+                .filter(element => (0, assert_1.isNotUndefined)(element.loc)),
+            '.meta': 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)} does call stop without setting call. to FALSE`,
+    },
+    info: {
+        name: 'Stop without call.=False argument',
+        tags: [linter_tags_1.LintingRuleTag.Smell],
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
+        description: 'Checks whether stop calls without call. argument set to FALSE are used.',
+        defaultConfig: {}
+    }
+};
+//# sourceMappingURL=stop-with-call-arg.js.map

package/linter/rules/useless-loop.d.ts

@@ -1,8 +1,8 @@
-import type { BuiltInProcName } from '../../dataflow/environments/built-in';
 import type { MergeableRecord } from '../../util/objects';
 import { SourceLocation } from '../../util/range';
 import { type LintingResult, LintingResultCertainty, LintingRuleCertainty } from '../linter-format';
 import { LintingRuleTag } from '../linter-tags';
+import type { BuiltInProcName } from '../../dataflow/environments/built-in-proc-name';
 export interface UselessLoopResult extends LintingResult {
     name: string;
     loc: SourceLocation;

package/package.json

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

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

@@ -9,7 +9,7 @@ import type { CfgSimplificationPassName } from '../../control-flow/cfg-simplific
 import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
 import type { CfgKind } from '../cfg-kind';
 import type { FlowrAnalyzerContext } from '../context/flowr-analyzer-context';
-import type { CallGraph } from '../../dataflow/graph/call-graph';
+import { CallGraph } from '../../dataflow/graph/call-graph';
 interface FlowrAnalyzerCacheOptions<Parser extends KnownParser> {
     parser: Parser;
     context: FlowrAnalyzerContext;

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

@@ -141,7 +141,7 @@ class FlowrAnalyzerCache extends flowr_cache_1.FlowrCache {
      */
     async callGraph(force) {
         if (!this.callGraphCache || force) {
-            this.callGraphCache = (0, call_graph_1.computeCallGraph)((await this.dataflow(force)).graph);
+            this.callGraphCache = call_graph_1.CallGraph.compute((await this.dataflow(force)).graph);
         }
         return this.callGraphCache;
     }

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

@@ -56,6 +56,9 @@ export declare class FlowrAnalyzerBuilder {
      * @param config - The new configuration.
      */
     setConfig(config: FlowrConfig): this;
+    /**
+     * Set a specific value in the configuration used by the resulting analyzer.
+     */
     configure<K extends AutocompletablePaths<FlowrConfig>>(key: K, value: PathValue<FlowrConfig, K>): this;
     /**
      * Set the parser instance used by the analyzer.

package/project/flowr-analyzer.d.ts

@@ -15,8 +15,8 @@ import type { RAnalysisRequest } from './context/flowr-analyzer-files-context';
 import type { RParseRequest, RParseRequestFromFile } from '../r-bridge/retriever';
 import { fileProtocol } from '../r-bridge/retriever';
 import type { FlowrFileProvider } from './context/flowr-file';
-import type { CallGraph } from '../dataflow/graph/call-graph';
 import type { Tree } from 'web-tree-sitter';
+import type { CallGraph } from '../dataflow/graph/call-graph';
 /**
  * Extends the {@link ReadonlyFlowrAnalysisProvider} with methods that allow modifying the analyzer state.
  */

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identifyLinkToNestedRelation = identifyLinkToNestedRelation;
-const call_graph_1 = require("../../../dataflow/graph/call-graph");
 const vertex_1 = require("../../../dataflow/graph/vertex");
 const identifier_1 = require("../../../dataflow/environments/identifier");
+const call_graph_1 = require("../../../dataflow/graph/call-graph");
 /**
  * **Please refer to {@link identifyLinkToRelation}.**
  *
@@ -19,7 +19,7 @@ async function identifyLinkToNestedRelation(from, analyzer, { callName, ignoreIf
     const test = callName instanceof RegExp ? (t) => callName.test(t) : callName;
     const found = [];
     const cg = await analyzer.callGraph();
-    const subCg = (0, call_graph_1.getSubCallGraph)(cg, new Set([from]));
+    const subCg = call_graph_1.CallGraph.computeSubCallGraph(cg, new Set([from]));
     for (const [, t] of subCg.vertices(true)) {
         if (!(0, vertex_1.isFunctionCallVertex)(t)) {
             continue;

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

@@ -2,7 +2,7 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import { executeCallGraphQuery } from './call-graph-query-executor';
 import Joi from 'joi';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { CallGraph } from '../../../dataflow/graph/call-graph';
+import { CallGraph } from '../../../dataflow/graph/call-graph';
 /**
  * Computes the Call Graph of the analyzed project.
  */

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

@@ -7,14 +7,14 @@ exports.CallGraphQueryDefinition = void 0;
 const call_graph_query_executor_1 = require("./call-graph-query-executor");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
-const dfg_1 = require("../../../util/mermaid/dfg");
 const joi_1 = __importDefault(require("joi"));
+const call_graph_1 = require("../../../dataflow/graph/call-graph");
 exports.CallGraphQueryDefinition = {
     executor: call_graph_query_executor_1.executeCallGraphQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('call-graph', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(`   ╰ [Call Graph](${(0, dfg_1.graphToMermaidUrl)(out.graph)})`);
+        result.push(`   ╰ [Call Graph](${call_graph_1.CallGraph.visualize.mermaid.url(out.graph)})`);
         return true;
     },
     schema: joi_1.default.object({

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

@@ -7,8 +7,8 @@ exports.ClusterQueryDefinition = void 0;
 const ansi_1 = require("../../../util/text/ansi");
 const joi_1 = __importDefault(require("joi"));
 const cluster_query_executor_1 = require("./cluster-query-executor");
-const dfg_1 = require("../../../util/mermaid/dfg");
 const query_print_1 = require("../../query-print");
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
 exports.ClusterQueryDefinition = {
     executor: cluster_query_executor_1.executeDataflowClusterQuery,
     asciiSummarizer: async (formatter, analyzer, queryResults, result) => {
@@ -19,7 +19,7 @@ exports.ClusterQueryDefinition = {
             const unknownSideEffects = cluster.hasUnknownSideEffects ? '(has unknown side effect)' : '';
             let suffix = '';
             if (formatter === ansi_1.markdownFormatter) {
-                suffix = `([marked](${(0, dfg_1.graphToMermaidUrl)((await analyzer.dataflow()).graph, false, new Set(cluster.members))}))`;
+                suffix = `([marked](${df_helper_1.Dataflow.visualize.mermaid.url((await analyzer.dataflow()).graph, false, new Set(cluster.members))}))`;
             }
             result.push(`      ╰ ${unknownSideEffects} {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, cluster.members)}} ${suffix}`);
         }

package/queries/catalog/dataflow-lens-query/dataflow-lens-query-format.js

@@ -7,14 +7,14 @@ exports.DataflowLensQueryDefinition = void 0;
 const dataflow_lens_query_executor_1 = require("./dataflow-lens-query-executor");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
-const dfg_1 = require("../../../util/mermaid/dfg");
 const joi_1 = __importDefault(require("joi"));
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
 exports.DataflowLensQueryDefinition = {
     executor: dataflow_lens_query_executor_1.executeDataflowLensQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('dataflow-lens', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(`   ╰ [Simplified Graph](${(0, dfg_1.graphToMermaidUrl)(out.simplifiedGraph, false, undefined, true)})`);
+        result.push(`   ╰ [Simplified Graph](${df_helper_1.Dataflow.visualize.mermaid.url(out.simplifiedGraph, false, undefined, true)})`);
         return true;
     },
     schema: joi_1.default.object({

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

@@ -7,14 +7,14 @@ exports.DataflowQueryDefinition = void 0;
 const dataflow_query_executor_1 = require("./dataflow-query-executor");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
-const dfg_1 = require("../../../util/mermaid/dfg");
 const joi_1 = __importDefault(require("joi"));
+const df_helper_1 = require("../../../dataflow/graph/df-helper");
 exports.DataflowQueryDefinition = {
     executor: dataflow_query_executor_1.executeDataflowQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
         result.push(`Query: ${(0, ansi_1.bold)('dataflow', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
-        result.push(`   ╰ [Dataflow Graph](${(0, dfg_1.graphToMermaidUrl)(out.graph)})`);
+        result.push(`   ╰ [Dataflow Graph](${df_helper_1.Dataflow.visualize.mermaid.url(out.graph)})`);
         return true;
     },
     schema: joi_1.default.object({

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

@@ -39,14 +39,13 @@ async function executeDfShapeQuery({ analyzer }, queries) {
             continue;
         }
         try {
-            const nodeId = (0, parse_1.slicingCriterionToId)(query.criterion, ast.idMap);
+            const nodeId = parse_1.SingleSlicingCriterion.parse(query.criterion, ast.idMap);
             const node = ast.idMap.get(nodeId);
             const value = inference.getAbstractValue(node?.info.id);
             result.set(query.criterion, value);
         }
         catch (e) {
             console.error(e instanceof Error ? e.message : e);
-            continue;
         }
     }
     return {

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

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeDoesCallQuery = executeDoesCallQuery;
 const log_1 = require("../../../util/log");
 const node_id_1 = require("../../../r-bridge/lang-4.x/ast/model/processing/node-id");
-const parse_1 = require("../../../slicing/criterion/parse");
 const identifier_1 = require("../../../dataflow/environments/identifier");
+const parse_1 = require("../../../slicing/criterion/parse");
 /**
  * Execute does call queries on the given analyzer.
  */
@@ -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 = (0, parse_1.tryResolveSliceCriterionToId)(query.call, idMap);
+        const nodeId = parse_1.SingleSlicingCriterion.tryParse(query.call, idMap);
         if (!nodeId) {
             results[id] = false;
             continue;