@eagleoutice/flowr 2.9.2 → 2.9.4

package/dataflow/eval/resolve/resolve.d.ts

@@ -1,81 +1,47 @@
-import type { AstIdMap, RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { REnvironmentInformation } from '../../environments/environment';
-import type { DataflowGraph } from '../../graph/graph';
+import type { BuiltInEvalHandlerArgs } from '../../environments/built-in';
 import { type Lift, Top, type Value, type ValueNumber, type ValueVector } from '../values/r-value';
-import type { VariableResolve } from '../../../config';
-import type { ReadOnlyFlowrAnalyzerContext } from '../../../project/context/flowr-analyzer-context';
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function converts an RNode to its Value, but also recursively resolves
- * aliases and vectors (in case of a vector).
- * @param a       - Ast node to resolve
- * @param resolve - Variable resolve mode
- * @param ctx     - Analyzer context
- * @param env     - Environment to use
- * @param graph   - Dataflow Graph to use
- * @param map     - Idmap of Dataflow Graph
+ * aliases and vectors (in case of node vector).
  * @returns resolved value or top/bottom
  */
-export declare function resolveNode(resolve: VariableResolve, a: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, env?: REnvironmentInformation, graph?: DataflowGraph, map?: AstIdMap): Value;
+export declare function resolveNode({ resolve, node, ctx, blocked, environment, graph, idMap }: BuiltInEvalHandlerArgs): Value;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function resolves a vector function call `c` to a {@link ValueVector}
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve     - Variable resolve mode
- * @param node        - Node of the vector function to resolve
- * @param environment - Environment to use
- * @param ctx         - Analyzer context
- * @param graph       - Dataflow graph
- * @param idMap       - ID map of the dataflow graph
  * @returns ValueVector or Top
  */
-export declare function resolveAsVector(resolve: VariableResolve, node: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<Value[]>> | typeof Top;
+export declare function resolveAsVector({ resolve, environment, node, graph, idMap, ctx, blocked }: BuiltInEvalHandlerArgs): ValueVector | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the sequence operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueVector of ValueNumbers or Top
  */
-export declare function resolveAsSeq(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsSeq({ node: operator, environment, resolve, ctx, graph, idMap, blocked }: BuiltInEvalHandlerArgs): ValueVector<Lift<ValueNumber[]>> | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the plus operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-export declare function resolveAsPlus(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsPlus({ node: operator, environment, resolve, ctx, graph, idMap, blocked }: BuiltInEvalHandlerArgs): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
 /**
  * Helper function used by {@link resolveIdToValue}, please use that instead, if
  * you want to resolve the value of an identifier / node
  *
  * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the minus operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-export declare function resolveAsMinus(resolve: VariableResolve, operator: RNodeWithParent, ctx: ReadOnlyFlowrAnalyzerContext, environment?: REnvironmentInformation, graph?: DataflowGraph, idMap?: AstIdMap): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;
+export declare function resolveAsMinus({ node: operator, environment, resolve, ctx, graph, idMap, blocked }: BuiltInEvalHandlerArgs): ValueNumber | ValueVector<Lift<ValueNumber[]>> | typeof Top;

package/dataflow/eval/resolve/resolve.js

@@ -23,30 +23,24 @@ const identifier_1 = require("../../environments/identifier");
  * you want to resolve the value of an identifier / node
  *
  * This function converts an RNode to its Value, but also recursively resolves
- * aliases and vectors (in case of a vector).
- * @param a       - Ast node to resolve
- * @param resolve - Variable resolve mode
- * @param ctx     - Analyzer context
- * @param env     - Environment to use
- * @param graph   - Dataflow Graph to use
- * @param map     - Idmap of Dataflow Graph
+ * aliases and vectors (in case of node vector).
  * @returns resolved value or top/bottom
  */
-function resolveNode(resolve, a, ctx, env, graph, map) {
-    if (a.type === type_1.RType.String) {
-        return (0, string_constants_1.stringFrom)(a.content.str);
+function resolveNode({ resolve, node, ctx, blocked, environment, graph, idMap }) {
+    if (node.type === type_1.RType.String) {
+        return (0, string_constants_1.stringFrom)(node.content.str);
     }
-    else if (a.type === type_1.RType.Number) {
-        return (0, interval_constants_1.intervalFrom)(a.content.num, a.content.num);
+    else if (node.type === type_1.RType.Number) {
+        return (0, interval_constants_1.intervalFrom)(node.content.num, node.content.num);
     }
-    else if (a.type === type_1.RType.Logical) {
-        return a.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
+    else if (node.type === type_1.RType.Logical) {
+        return node.content.valueOf() ? logical_constants_1.ValueLogicalTrue : logical_constants_1.ValueLogicalFalse;
     }
-    else if (a.type === type_1.RType.FunctionDefinition) {
+    else if (node.type === type_1.RType.FunctionDefinition) {
         return { type: 'function-definition' };
     }
-    else if ((a.type === type_1.RType.FunctionCall || a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) && graph) {
-        const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, a.info.id)?.[0];
+    else if ((node.type === type_1.RType.FunctionCall || node.type === type_1.RType.BinaryOp || node.type === type_1.RType.UnaryOp) && graph) {
+        const origin = (0, dfg_get_origin_1.getOriginInDfg)(graph, node.info.id)?.[0];
         if (origin === undefined || origin.type !== 3 /* OriginType.BuiltInFunctionOrigin */) {
             return r_value_2.Top;
         }
@@ -54,18 +48,18 @@ function resolveNode(resolve, a, ctx, env, graph, map) {
         if ((0, built_in_1.isBuiltIn)(origin.proc)) {
             builtInName = origin.proc;
         }
-        else if (a.type === type_1.RType.FunctionCall && a.named) {
-            builtInName = (0, built_in_1.builtInId)(identifier_1.Identifier.getName(a.functionName.content));
+        else if (node.type === type_1.RType.FunctionCall && node.named) {
+            builtInName = (0, built_in_1.builtInId)(identifier_1.Identifier.getName(node.functionName.content));
         }
-        else if (a.type === type_1.RType.BinaryOp || a.type === type_1.RType.UnaryOp) {
-            builtInName = (0, built_in_1.builtInId)(a.operator);
+        else if (node.type === type_1.RType.BinaryOp || node.type === type_1.RType.UnaryOp) {
+            builtInName = (0, built_in_1.builtInId)(node.operator);
         }
         else {
             return r_value_2.Top;
         }
         if (Object.hasOwn(built_in_1.BuiltInEvalHandlerMapper, builtInName)) {
             const handler = built_in_1.BuiltInEvalHandlerMapper[builtInName];
-            return handler(resolve, a, ctx, env, graph, map);
+            return handler({ resolve, node, ctx, blocked, environment, graph, idMap });
         }
     }
     return r_value_2.Top;
@@ -76,19 +70,13 @@ function resolveNode(resolve, a, ctx, env, graph, map) {
  *
  * This function resolves a vector function call `c` to a {@link ValueVector}
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve     - Variable resolve mode
- * @param node        - Node of the vector function to resolve
- * @param environment - Environment to use
- * @param ctx         - Analyzer context
- * @param graph       - Dataflow graph
- * @param idMap       - ID map of the dataflow graph
  * @returns ValueVector or Top
  */
-function resolveAsVector(resolve, node, ctx, environment, graph, idMap) {
+function resolveAsVector({ resolve, environment, node, graph, idMap, ctx, blocked }) {
     if (node.type !== type_1.RType.FunctionCall) {
         return r_value_2.Top;
     }
-    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx };
+    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx, blocked };
     const values = node.arguments.map(arg => arg !== r_function_call_1.EmptyArgument ? (0, alias_tracking_1.resolveIdToValue)(arg.value, resolveInfo) : r_value_2.Top);
     return (0, vector_constants_1.vectorFrom)((0, vector_constants_1.flattenVectorElements)(values));
 }
@@ -98,19 +86,13 @@ function resolveAsVector(resolve, node, ctx, environment, graph, idMap) {
  *
  * This function resolves a binary sequence operator `:` to a {@link ValueVector} of {@link ValueNumber}s
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the sequence operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueVector of ValueNumbers or Top
  */
-function resolveAsSeq(resolve, operator, ctx, environment, graph, idMap) {
+function resolveAsSeq({ node: operator, environment, resolve, ctx, graph, idMap, blocked }) {
     if (operator.type !== type_1.RType.BinaryOp) {
         return r_value_2.Top;
     }
-    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx };
+    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx, blocked };
     const leftArg = (0, alias_tracking_1.resolveIdToValue)(operator.lhs, resolveInfo);
     const rightArg = (0, alias_tracking_1.resolveIdToValue)(operator.rhs, resolveInfo);
     const leftValue = (0, r_value_1.unliftRValue)(leftArg);
@@ -126,19 +108,13 @@ function resolveAsSeq(resolve, operator, ctx, environment, graph, idMap) {
  *
  * This function resolves a unary plus operator `+` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the plus operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-function resolveAsPlus(resolve, operator, ctx, environment, graph, idMap) {
+function resolveAsPlus({ node: operator, environment, resolve, ctx, graph, idMap, blocked }) {
     if (operator.type !== type_1.RType.UnaryOp) {
         return r_value_2.Top;
     }
-    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx };
+    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx, blocked };
     const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
     const argValue = (0, r_value_1.unliftRValue)(arg);
     if ((0, r_value_1.isRNumberValue)(argValue)) {
@@ -155,19 +131,13 @@ function resolveAsPlus(resolve, operator, ctx, environment, graph, idMap) {
  *
  * This function resolves a unary minus operator `-` to a {@link ValueNumber} or {@link ValueVector} of ValueNumbers
  * by recursively resolving the values of the arguments by calling {@link resolveIdToValue}
- * @param resolve  - Variable resolve mode
- * @param operator - Node of the minus operator to resolve
- * @param graph    - Dataflow graph
- * @param ctx      - Analyzer context
- * @param idMap    - Id map of the dataflow graph
- * @param environment - Environment to use
  * @returns ValueNumber, ValueVector of ValueNumbers, or Top
  */
-function resolveAsMinus(resolve, operator, ctx, environment, graph, idMap) {
+function resolveAsMinus({ node: operator, environment, resolve, ctx, graph, idMap, blocked }) {
     if (operator.type !== type_1.RType.UnaryOp) {
         return r_value_2.Top;
     }
-    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx };
+    const resolveInfo = { environment, graph, idMap, full: true, resolve, ctx, blocked };
     const arg = (0, alias_tracking_1.resolveIdToValue)(operator.operand, resolveInfo);
     const argValue = (0, r_value_1.unliftRValue)(arg);
     if ((0, r_value_1.isRNumberValue)(argValue)) {

package/dataflow/extractor.js

@@ -12,7 +12,6 @@ const process_named_call_1 = require("./internal/process/process-named-call");
 const process_value_1 = require("./internal/process/process-value");
 const named_call_handling_1 = require("./internal/process/functions/call/named-call-handling");
 const make_argument_1 = require("./internal/process/functions/call/argument/make-argument");
-const range_1 = require("../util/range");
 const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 const built_in_source_1 = require("./internal/process/functions/call/built-in/built-in-source");
 const extract_cfg_1 = require("../control-flow/extract-cfg");
@@ -21,6 +20,7 @@ const identify_link_to_last_call_relation_1 = require("../queries/catalog/call-c
 const built_in_function_definition_1 = require("./internal/process/functions/call/built-in/built-in-function-definition");
 const flowr_file_1 = require("../project/context/flowr-file");
 const identifier_1 = require("./environments/identifier");
+const range_1 = require("../util/range");
 /**
  * The best friend of {@link produceDataFlowGraph} and {@link processDataflowFor}.
  * Maps every {@link RType} in the normalized AST to a processor.
@@ -53,7 +53,7 @@ exports.processors = {
             info: info,
             content: groupStart?.content ?? '{',
             lexeme: groupStart?.lexeme ?? '{',
-            location: location ?? (0, range_1.invalidRange)(),
+            location: location ?? range_1.SourceRange.invalid(),
             ns: groupStart?.content ? undefined : 'base'
         }, (0, make_argument_1.wrapArgumentsUnnamed)(children, d.completeAst.idMap), info.id, d);
     }

package/dataflow/fn/higher-order-function.d.ts

@@ -6,5 +6,6 @@ import type { ReadOnlyFlowrAnalyzerContext } from '../../project/context/flowr-a
  * either takes a function as an argument or (may) returns a function.
  * If the return is an identity, e.g., `function(x) x`, this is not considered higher-order,
  * if no function is passed as an argument.
+ * Please note that inspecting higher order functions can be sped up (if queries multiple times) by providing an inverted graph as well!
  */
-export declare function isFunctionHigherOrder(id: NodeId, graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext): boolean;
+export declare function isFunctionHigherOrder(id: NodeId, graph: DataflowGraph, ctx: ReadOnlyFlowrAnalyzerContext, invertedGraph?: DataflowGraph): boolean;

package/dataflow/fn/higher-order-function.js

@@ -32,8 +32,8 @@ function isAnyReturnAFunction(def, graph) {
     }
     return false;
 }
-function inspectCallSitesArgumentsFns(def, graph, ctx) {
-    const callSites = graph.ingoingEdges(def.id);
+function inspectCallSitesArgumentsFns(def, graph, ctx, invertedGraph) {
+    const callSites = invertedGraph?.outgoingEdges(def.id) ?? graph.ingoingEdges(def.id);
     for (const [callerId, e] of callSites ?? []) {
         if (!edge_1.DfEdge.includesType(e, edge_1.EdgeType.Calls)) {
             continue;
@@ -59,8 +59,9 @@ function inspectCallSitesArgumentsFns(def, graph, ctx) {
  * either takes a function as an argument or (may) returns a function.
  * If the return is an identity, e.g., `function(x) x`, this is not considered higher-order,
  * if no function is passed as an argument.
+ * Please note that inspecting higher order functions can be sped up (if queries multiple times) by providing an inverted graph as well!
  */
-function isFunctionHigherOrder(id, graph, ctx) {
+function isFunctionHigherOrder(id, graph, ctx, invertedGraph) {
     const vert = graph.getVertex(id);
     if (!vert || !(0, vertex_1.isFunctionDefinitionVertex)(vert)) {
         return false;
@@ -70,6 +71,6 @@ function isFunctionHigherOrder(id, graph, ctx) {
         return true;
     }
     // 2. check whether any of the callsites passes a function
-    return inspectCallSitesArgumentsFns(vert, graph, ctx);
+    return inspectCallSitesArgumentsFns(vert, graph, ctx, invertedGraph);
 }
 //# sourceMappingURL=higher-order-function.js.map

package/dataflow/graph/graph.js

@@ -8,8 +8,6 @@ const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-fun
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const environment_1 = require("../environments/environment");
 const clone_1 = require("../environments/clone");
-const json_1 = require("../../util/json");
-const logger_1 = require("../logger");
 /**
  * Helper functions to work with {@link FunctionArgument}s.
  * @see {@link EmptyArgument} - the marker for empty arguments
@@ -171,8 +169,9 @@ class DataflowGraph {
     ingoingEdges(id) {
         const edges = new Map();
         for (const [source, outgoing] of this.edgeInformation.entries()) {
-            if (outgoing.has(id)) {
-                edges.set(source, outgoing.get(id));
+            const o = outgoing.get(id);
+            if (o) {
+                edges.set(source, o);
             }
         }
         return edges;
@@ -448,18 +447,14 @@ class DataflowGraph {
 exports.DataflowGraph = DataflowGraph;
 function mergeNodeInfos(current, next) {
     if (current.tag !== next.tag) {
-        logger_1.dataflowLogger.warn(() => `nodes to be joined for the same id should have the same tag, but ${JSON.stringify(current, json_1.jsonReplacer)} vs. ${JSON.stringify(next, json_1.jsonReplacer)} -- we are currently not handling cases in which vertices may be either! Keeping current.`);
         return current;
     }
-    if (current.tag === vertex_1.VertexType.VariableDefinition) {
-        (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
-    }
     else if (current.tag === vertex_1.VertexType.FunctionDefinition) {
-        (0, assert_1.guard)(current.scope === next.scope, 'nodes to be joined for the same id must have the same scope');
-        current.exitPoints = (0, arrays_1.uniqueArrayMerge)(current.exitPoints, next.exitPoints);
-        if (next.tag === vertex_1.VertexType.FunctionDefinition && next.mode && next.mode.length > 0) {
+        const n = next;
+        current.exitPoints = (0, arrays_1.uniqueArrayMerge)(current.exitPoints, n.exitPoints);
+        if (n.mode && n.mode.length > 0) {
             current.mode ??= [];
-            for (const m of next.mode) {
+            for (const m of n.mode) {
                 if (!current.mode.includes(m)) {
                     current.mode.push(m);
                 }

package/dataflow/internal/process/functions/call/argument/make-argument.js

@@ -5,7 +5,6 @@ exports.wrapArgumentsUnnamed = wrapArgumentsUnnamed;
 const range_1 = require("../../../../../../util/range");
 const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const voidRange = (0, range_1.rangeFrom)(-1, -1, -1, -1);
 /**
  * Converts a normalized node into an unnamed argument (wraps it with an argument node).
  */
@@ -16,7 +15,7 @@ function toUnnamedArgument(node, idMap) {
     const arg = {
         type: type_1.RType.Argument,
         lexeme: node.lexeme ?? '',
-        location: node.location ?? voidRange,
+        location: node.location ?? range_1.SourceRange.invalid(),
         info: {
             ...node.info,
             id: node.info.id + '-arg'

package/dataflow/internal/process/functions/call/built-in/built-in-register-hook.js

@@ -6,11 +6,11 @@ const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model
 const linker_1 = require("../../../../linker");
 const common_1 = require("../common");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const range_1 = require("../../../../../../util/range");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const general_1 = require("../../../../../eval/values/general");
 const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const built_in_1 = require("../../../../../environments/built-in");
+const range_1 = require("../../../../../../util/range");
 /**
  * Process a hook such as `on.exit`
  */
@@ -41,7 +41,7 @@ function processRegisterHook(name, args, rootId, data, config) {
             wrappedFunctions.add(wrapId);
             const wrapped = {
                 type: type_1.RType.FunctionDefinition,
-                location: val.location ?? name.location ?? (0, range_1.invalidRange)(),
+                location: val.location ?? name.location ?? range_1.SourceRange.invalid(),
                 parameters: [],
                 body: val,
                 lexeme: 'function',

package/dataflow/internal/process/functions/call/built-in/built-in-replacement.js

@@ -17,8 +17,8 @@ const unknown_replacement_1 = require("../../../../../graph/unknown-replacement"
 const built_in_s_seven_dispatch_1 = require("./built-in-s-seven-dispatch");
 const make_argument_1 = require("../argument/make-argument");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const range_1 = require("../../../../../../util/range");
 const graph_1 = require("../../../../../graph/graph");
+const range_1 = require("../../../../../../util/range");
 /**
  * Process a replacement function call like `<-`, `[[<-`, `$<-`, etc.
  * These are automatically created when doing assignments like `x[y] <- value` or in general `fun(x) <- value` will call `fun<- (x, value)`.
@@ -44,7 +44,7 @@ args, rootId, data, config) {
             type: type_1.RType.Symbol,
             info: uArg.info,
             lexeme: tarName,
-            location: uArg.location ?? targetArg.location ?? name.location ?? (0, range_1.invalidRange)()
+            location: uArg.location ?? targetArg.location ?? name.location ?? range_1.SourceRange.invalid()
         }, data.completeAst.idMap);
     }
     /* we assign the first argument by the last for now and maybe mark as maybe!, we can keep the symbol as we now know we have an assignment */

package/dataflow/internal/process/functions/call/built-in/built-in-s-seven-new-generic.js

@@ -10,12 +10,12 @@ const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/node
 const built_in_1 = require("../../../../../environments/built-in");
 const edge_1 = require("../../../../../graph/edge");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
-const range_1 = require("../../../../../../util/range");
 const assert_1 = require("../../../../../../util/assert");
 const identifier_1 = require("../../../../../environments/identifier");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 const r_value_1 = require("../../../../../eval/values/r-value");
 const vertex_1 = require("../../../../../graph/vertex");
+const range_1 = require("../../../../../../util/range");
 /**
  * Process an S7 new generic dispatch call like `new_generic` or `setGeneric`.
  */
@@ -72,7 +72,7 @@ function processS7NewGeneric(name, args, rootId, data, config) {
 // 'function([dispatch_args],...) S7_dispatch()'; returns the value id
 function makeS7DispatchFDef(name, names, rootId, args, idMap) {
     const argNameId = rootId + '-s7-new-generic-fun-arg-name';
-    const r = name.location ?? (0, range_1.invalidRange)();
+    const r = name.location ?? range_1.SourceRange.invalid();
     const argName = {
         type: type_1.RType.Symbol,
         lexeme: 'fun',

package/dataflow/internal/process/functions/call/built-in/built-in-s-three-dispatch.js

@@ -87,7 +87,7 @@ function processS3Dispatch(name, args, rootId, data, config) {
         info: generic.info,
         content: accessedIdentifiers[0],
         lexeme: accessedIdentifiers[0],
-        location: generic.location ?? (0, range_1.invalidRange)()
+        location: generic.location ?? range_1.SourceRange.invalid()
     };
     (0, common_1.patchFunctionCall)({
         nextGraph: dfGeneric.graph,

package/documentation/doc-util/doc-search.js

@@ -6,8 +6,8 @@ const doc_code_1 = require("./doc-code");
 const time_1 = require("../../util/text/time");
 const flowr_search_printer_1 = require("../../search/flowr-search-printer");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
-const dfg_1 = require("../../util/mermaid/dfg");
 const flowr_analyzer_builder_1 = require("../../project/flowr-analyzer-builder");
+const range_1 = require("../../util/range");
 /**
  * Visualizes a search and its results in markdown format.
  */
@@ -47,7 +47,7 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify(search, null, 2))}
 ${collapseResult ? ' <details> <summary style="color:gray">Show Results</summary>' : ''}
 
 The query returns the following vetices (all references to \`x\` in the code):
-${result.getElements().map(({ node }) => `<b>${node.info.id} ('${(0, node_id_1.recoverContent)(node.info.id, dataflow.graph)}')</b> at L${(0, dfg_1.formatRange)(node.location)}`).join(', ')}
+${result.getElements().map(({ node }) => `<b>${node.info.id} ('${(0, node_id_1.recoverContent)(node.info.id, dataflow.graph)}')</b> at L${range_1.SourceRange.format(node.location)}`).join(', ')}
 
 ${metaInfo}
 

package/linter/linter-executor.js

@@ -34,9 +34,8 @@ async function executeLintingRule(ruleName, input, lintingRuleConfig) {
         };
     }
     catch (e) {
-        const msg = typeof e === 'string' ? e : e instanceof Error ? e.message : JSON.stringify(e);
         return {
-            error: msg
+            error: e
         };
     }
 }

package/linter/linter-format.d.ts

@@ -7,7 +7,7 @@ import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/
 import type { LintingRuleConfig, LintingRuleMetadata, LintingRuleNames, LintingRuleResult } from './linter-rules';
 import type { AsyncOrSync, DeepPartial, DeepReadonly } from 'ts-essentials';
 import type { LintingRuleTag } from './linter-tags';
-import type { SourceRange } from '../util/range';
+import type { SourceLocation } from '../util/range';
 import type { DataflowInformation } from '../dataflow/info';
 import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
 import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
@@ -78,7 +78,7 @@ interface BaseQuickFix {
     /**
      * The range of the text that should be replaced.
      */
-    readonly range: SourceRange;
+    readonly loc: SourceLocation;
 }
 export interface LintQuickFixReplacement extends BaseQuickFix {
     readonly type: 'replace';
@@ -114,7 +114,8 @@ export interface ConfiguredLintingRule<Name extends LintingRuleNames = LintingRu
  * For when a linting rule throws an error during execution
  */
 export interface LintingResultsError {
-    readonly error: string;
+    /** the error thrown */
+    readonly error: unknown;
 }
 export interface LintingResultsSuccess<Name extends LintingRuleNames> {
     results: LintingRuleResult<Name>[];
@@ -124,20 +125,45 @@ export interface LintingResultsSuccess<Name extends LintingRuleNames> {
     };
 }
 /**
- * Checks whether the given linting results represent an error.
- * @see {@link isLintingResultsSuccess}
+ * The results of executing a linting rule.
+ * @see {@link LintingResults.isError} and {@link LintingResults.isSuccess} to differentiate between success and error results.
  */
-export declare function isLintingResultsError<Name extends LintingRuleNames>(o: LintingResults<Name>): o is LintingResultsError;
+export type LintingResults<Name extends LintingRuleNames> = LintingResultsSuccess<Name> | LintingResultsError;
 /**
- * Checks whether the given linting results represent a successful linting result.
- * @see {@link isLintingResultsError}
+ * Helper functions for working with {@link LintingResults}.
  */
-export declare function isLintingResultsSuccess<Name extends LintingRuleNames>(o: LintingResults<Name>): o is LintingResultsSuccess<Name>;
-export type LintingResults<Name extends LintingRuleNames> = LintingResultsSuccess<Name> | LintingResultsError;
+export declare const LintingResults: {
+    /**
+     * Checks whether the given linting results represent an error.
+     * @see {@link LintingResultsError}
+     * @see {@link LintingResults.isSuccess}
+     */
+    readonly isError: <Name extends LintingRuleNames>(this: void, o: LintingResults<Name>) => o is LintingResultsError;
+    /**
+     * Checks whether the given linting results represent a successful execution.
+     * @see {@link LintingResultsSuccess}
+     * @see {@link LintingResults.isError}
+     * @see {@link LintingResults.unpackSuccess}
+     */
+    readonly isSuccess: <Name extends LintingRuleNames>(this: void, o: LintingResults<Name>) => o is LintingResultsSuccess<Name>;
+    /**
+     * Unpacks the given linting results, throwing an error if they represent an error.
+     */
+    readonly unpackSuccess: <Name extends LintingRuleNames>(this: void, o: LintingResults<Name>) => LintingResultsSuccess<Name>;
+    /**
+     * Gets all involved node IDs from the given linting results.
+     * If the results represent an error, an empty set is returned.
+     */
+    readonly allInvolvedIds: <L extends LintingRuleNames>(this: void, res: LintingResults<L> | undefined) => Set<NodeId>;
+    /**
+     * Stringifies the error contained in the given linting results error.
+     */
+    readonly stringifyError: (this: void, { error }: LintingResultsError) => string;
+};
 export declare enum LintingResultCertainty {
     /**
      * The linting rule cannot say for sure whether the result is correct or not.
-     * This linting certainty should be used for linting results whose calculations are based on estimations involving unknown side-effects, reflection, etc.
+     * This linting certainty should be used for linting results whose calculations are based on estimations involving unknown side effects, reflection, etc.
      */
     Uncertain = "uncertain",
     /**