@eagleoutice/flowr 2.6.0 → 2.6.2

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

@@ -17,6 +17,9 @@ const built_in_access_1 = require("./built-in-access");
 const built_in_1 = require("../../../../../environments/built-in");
 const identifier_1 = require("../../../../../environments/identifier");
 const unknown_replacement_1 = require("../../../../../graph/unknown-replacement");
+/**
+ *
+ */
 function processReplacementFunction(name, 
 /** The last one has to be the value */
 args, rootId, data, config) {
@@ -97,7 +100,6 @@ args, rootId, data, config) {
  * a[[1]]$b
  * # results in index with index 1 as identifier with a sub-index with lexeme b as identifier
  * ```
- *
  * @param operation - Operation of replacement function e.g. '$\<-', '[\<-', '[[\<-'
  * @param args      - Arguments of the replacement function
  * @returns Accessed indices construct

package/dataflow/internal/process/functions/call/built-in/built-in-rm.d.ts

@@ -1,7 +1,10 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
 import type { DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/**
+ *
+ */
 export declare function processRm<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -6,6 +6,9 @@ const r_function_call_1 = require("../../../../../../r-bridge/lang-4.x/ast/model
 const logger_1 = require("../../../../../logger");
 const remove_1 = require("../../../../../environments/remove");
 const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+/**
+ *
+ */
 function processRm(name, args, rootId, data) {
     if (args.length === 0) {
         logger_1.dataflowLogger.warn('empty rm, skipping');

package/dataflow/internal/process/functions/call/built-in/built-in-source.d.ts

@@ -1,15 +1,23 @@
 import { type DataflowProcessorInformation } from '../../../../../processor';
-import type { DataflowInformation } from '../../../../../info';
-import type { FlowrLaxSourcingOptions } from '../../../../../../config';
-import { InferWorkingDirectory } from '../../../../../../config';
-import type { RParseRequest, RParseRequestProvider } from '../../../../../../r-bridge/retriever';
-import type { IdGenerator, ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type DataflowInformation } from '../../../../../info';
+import { type FlowrLaxSourcingOptions, InferWorkingDirectory } from '../../../../../../config';
+import { type RParseRequest, type RParseRequestProvider } from '../../../../../../r-bridge/retriever';
+import { type IdGenerator, type ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { NoInfo } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
+/**
+ * Returns the current (global) source provider
+ */
 export declare function getSourceProvider(): RParseRequestProvider;
+/**
+ * Sets the current (global) source provider
+ */
 export declare function setSourceProvider(provider: RParseRequestProvider): void;
+/**
+ * Infers working directories based on the given option and reference chain
+ */
 export declare function inferWdFromScript(option: InferWorkingDirectory, referenceChain: readonly RParseRequest[]): string[];
 /**
  * Tries to find sourced by a source request and returns the first path that exists
@@ -20,11 +28,20 @@ export declare function inferWdFromScript(option: InferWorkingDirectory, referen
 export declare function findSource(resolveSource: FlowrLaxSourcingOptions | undefined, seed: string, data: {
     referenceChain: readonly RParseRequest[];
 }): string[] | undefined;
+/**
+ * Processes a named function call (i.e., not an anonymous function)
+ */
 export declare function processSourceCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     /** should this produce an explicit source function call in the graph? */
     includeFunctionCall?: boolean;
     /** should this function call be followed, even when the configuration disables it? */
     forceFollow?: boolean;
 }): DataflowInformation;
+/**
+ * Processes a source request with the given dataflow processor information and existing dataflow information
+ */
 export declare function sourceRequest<OtherInfo>(rootId: NodeId, request: RParseRequest, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, information: DataflowInformation, getId: IdGenerator<NoInfo>): DataflowInformation;
+/**
+ * Processes a standalone source file (i.e., not from a source function call)
+ */
 export declare function standaloneSourceFile<OtherInfo>(inputRequest: RParseRequest, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, uniqueSourceId: string, information: DataflowInformation): DataflowInformation;

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

@@ -31,12 +31,21 @@ const r_value_1 = require("../../../../../eval/values/r-value");
 const unknown_side_effect_1 = require("../../../../../graph/unknown-side-effect");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
 let sourceProvider = (0, retriever_1.requestProviderFromFile)();
+/**
+ * Returns the current (global) source provider
+ */
 function getSourceProvider() {
     return sourceProvider;
 }
+/**
+ * Sets the current (global) source provider
+ */
 function setSourceProvider(provider) {
     sourceProvider = provider;
 }
+/**
+ * Infers working directories based on the given option and reference chain
+ */
 function inferWdFromScript(option, referenceChain) {
     switch (option) {
         case config_1.InferWorkingDirectory.MainScript:
@@ -124,6 +133,9 @@ function findSource(resolveSource, seed, data) {
     }
     return found;
 }
+/**
+ * Processes a named function call (i.e., not an anonymous function)
+ */
 function processSourceCall(name, args, rootId, data, config) {
     if (args.length !== 1) {
         logger_1.dataflowLogger.warn(`Expected exactly one argument for source currently, but got ${args.length} instead, skipping`);
@@ -169,6 +181,9 @@ function processSourceCall(name, args, rootId, data, config) {
     (0, unknown_side_effect_1.handleUnknownSideEffect)(information.graph, information.environment, rootId);
     return information;
 }
+/**
+ * Processes a source request with the given dataflow processor information and existing dataflow information
+ */
 function sourceRequest(rootId, request, data, information, getId) {
     if (request.request === 'file') {
         /* check if the file exists and if not, fail */
@@ -185,7 +200,8 @@ function sourceRequest(rootId, request, data, information, getId) {
         const file = request.request === 'file' ? request.content : undefined;
         const parsed = (!data.parser.async ? data.parser : new shell_executor_1.RShellExecutor()).parse(request);
         normalized = (typeof parsed !== 'string' ?
-            (0, parser_1.normalizeTreeSitter)({ parsed }, getId, data.flowrConfig, file) : (0, parser_1.normalize)({ parsed }, getId, file));
+            (0, parser_1.normalizeTreeSitter)({ parsed }, getId, data.flowrConfig, file)
+            : (0, parser_1.normalize)({ parsed }, getId, file));
         dataflow = (0, processor_1.processDataflowFor)(normalized.ast, {
             ...data,
             currentRequest: request,
@@ -223,6 +239,9 @@ function sourceRequest(rootId, request, data, information, getId) {
         exitPoints: dataflow.exitPoints
     };
 }
+/**
+ * Processes a standalone source file (i.e., not from a source function call)
+ */
 function standaloneSourceFile(inputRequest, data, uniqueSourceId, information) {
     const path = inputRequest.request === 'file' ? inputRequest.content : '-inline-';
     /* this way we can still pass content */

package/dataflow/internal/process/functions/call/built-in/built-in-special-bin-op.d.ts

@@ -5,6 +5,9 @@ import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { ForceArguments } from '../common';
+/**
+ *
+ */
 export declare function processSpecialBinOp<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: {
     lazy: boolean;
     evalRhsWhen: boolean;

package/dataflow/internal/process/functions/call/built-in/built-in-special-bin-op.js

@@ -4,6 +4,9 @@ exports.processSpecialBinOp = processSpecialBinOp;
 const known_call_handling_1 = require("../known-call-handling");
 const logger_1 = require("../../../../../logger");
 const edge_1 = require("../../../../../graph/edge");
+/**
+ *
+ */
 function processSpecialBinOp(name, args, rootId, data, config) {
     if (!config.lazy) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'builtin:special-bin-op' }).information;

package/dataflow/internal/process/functions/call/built-in/built-in-vector.d.ts

@@ -1,4 +1,4 @@
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';

package/dataflow/internal/process/functions/call/built-in/built-in-while-loop.d.ts

@@ -1,7 +1,10 @@
 import type { DataflowProcessorInformation } from '../../../../../processor';
-import type { DataflowInformation } from '../../../../../info';
+import { type DataflowInformation } from '../../../../../info';
 import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/**
+ *
+ */
 export declare function processWhileLoop<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -13,6 +13,9 @@ const edge_1 = require("../../../../../graph/edge");
 const identifier_1 = require("../../../../../environments/identifier");
 const general_1 = require("../../../../../eval/values/general");
 const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
+/**
+ *
+ */
 function processWhileLoop(name, args, rootId, data) {
     if (args.length !== 2 || args[1] === r_function_call_1.EmptyArgument) {
         logger_1.dataflowLogger.warn(`While-Loop ${name.content} does not have 2 arguments, skipping`);

package/dataflow/internal/process/functions/call/common.d.ts

@@ -1,13 +1,13 @@
-import type { DataflowInformation } from '../../../../info';
-import type { DataflowProcessorInformation } from '../../../../processor';
+import { type DataflowInformation } from '../../../../info';
+import { type DataflowProcessorInformation } from '../../../../processor';
 import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
 import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RFunctionArgument } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { type RFunctionArgument } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { DataflowGraph, FunctionArgument } from '../../../../graph/graph';
 import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { REnvironmentInformation } from '../../../../environments/environment';
-import type { IdentifierReference } from '../../../../environments/identifier';
-import type { DataflowGraphVertexAstLink, FunctionOriginInformation } from '../../../../graph/vertex';
+import { type IdentifierReference } from '../../../../environments/identifier';
+import { type DataflowGraphVertexAstLink, type FunctionOriginInformation } from '../../../../graph/vertex';
 import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 export interface ForceArguments {
     /** which of the arguments should be forced? this may be all, e.g., if the function itself is unknown on encounter */
@@ -29,6 +29,9 @@ export interface ProcessAllArgumentResult {
     readonly remainingReadInArgs: IdentifierReference[];
     readonly processedArguments: (DataflowInformation | undefined)[];
 }
+/**
+ *
+ */
 export declare function processAllArguments<OtherInfo>({ functionName, args, data, finalGraph, functionRootId, forceArgs, patchData }: ProcessAllArgumentInput<OtherInfo>): ProcessAllArgumentResult;
 export interface PatchFunctionCallInput<OtherInfo> {
     readonly nextGraph: DataflowGraph;
@@ -39,4 +42,7 @@ export interface PatchFunctionCallInput<OtherInfo> {
     readonly origin: FunctionOriginInformation;
     readonly link?: DataflowGraphVertexAstLink;
 }
+/**
+ *
+ */
 export declare function patchFunctionCall<OtherInfo>({ nextGraph, rootId, name, data, argumentProcessResult, origin, link }: PatchFunctionCallInput<OtherInfo>): void;

package/dataflow/internal/process/functions/call/common.js

@@ -43,6 +43,9 @@ function forceVertexArgumentValueReferences(rootId, value, graph, env) {
         }
     }
 }
+/**
+ *
+ */
 function processAllArguments({ functionName, args, data, finalGraph, functionRootId, forceArgs = [], patchData = d => d }) {
     let finalEnv = functionName.environment;
     // arg env contains the environments with other args defined
@@ -104,6 +107,9 @@ function processAllArguments({ functionName, args, data, finalGraph, functionRoo
     }
     return { finalEnv, callArgs, remainingReadInArgs, processedArguments };
 }
+/**
+ *
+ */
 function patchFunctionCall({ nextGraph, rootId, name, data, argumentProcessResult, origin, link }) {
     nextGraph.addVertex({
         tag: vertex_1.VertexType.FunctionCall,

package/dataflow/internal/process/functions/call/default-call-handling.d.ts

@@ -2,4 +2,7 @@ import type { DataflowInformation } from '../../../../info';
 import type { DataflowProcessorInformation } from '../../../../processor';
 import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RFunctionCall } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+/**
+ *
+ */
 export declare function processFunctionCall<OtherInfo>(functionCall: RFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/default-call-handling.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFunctionCall = processFunctionCall;
 const named_call_handling_1 = require("./named-call-handling");
 const unnamed_call_handling_1 = require("./unnamed-call-handling");
+/**
+ *
+ */
 function processFunctionCall(functionCall, data) {
     if (functionCall.named) {
         return (0, named_call_handling_1.processNamedCall)(functionCall.functionName, functionCall.arguments, functionCall.info.id, data);

package/dataflow/internal/process/functions/call/known-call-handling.d.ts

@@ -1,14 +1,14 @@
-import type { DataflowProcessorInformation } from '../../../../processor';
-import type { DataflowInformation } from '../../../../info';
-import type { ForceArguments } from './common';
+import { type DataflowProcessorInformation } from '../../../../processor';
+import { type DataflowInformation } from '../../../../info';
+import { type ForceArguments } from './common';
 import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RFunctionArgument } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { RNode } from '../../../../../r-bridge/lang-4.x/ast/model/model';
-import type { IdentifierReference } from '../../../../environments/identifier';
+import { type IdentifierReference } from '../../../../environments/identifier';
 import { DataflowGraph } from '../../../../graph/graph';
-import type { ContainerIndicesCollection, FunctionOriginInformation } from '../../../../graph/vertex';
+import { type ContainerIndicesCollection, type FunctionOriginInformation } from '../../../../graph/vertex';
 export interface ProcessKnownFunctionCallInput<OtherInfo> extends ForceArguments {
     readonly name: RSymbol<OtherInfo & ParentInformation>;
     readonly args: readonly (RNode<OtherInfo & ParentInformation> | RFunctionArgument<OtherInfo & ParentInformation>)[];
@@ -29,5 +29,12 @@ export interface ProcessKnownFunctionCallResult {
     readonly processedArguments: readonly (DataflowInformation | undefined)[];
     readonly fnRef: IdentifierReference;
 }
+/**
+ * Marks the given arguments as being involved in R's non-standard evaluation.
+ */
 export declare function markNonStandardEvaluationEdges(markAsNSE: readonly number[], callArgs: readonly (DataflowInformation | undefined)[], finalGraph: DataflowGraph, rootId: NodeId): void;
+/**
+ * The main processor for function calls for which we know the target but need not
+ * add any specific handling.
+ */
 export declare function processKnownFunctionCall<OtherInfo>({ name, args, rootId, data, reverseOrder, markAsNSE, forceArgs, patchData, hasUnknownSideEffect, origin }: ProcessKnownFunctionCallInput<OtherInfo>, indicesCollection?: ContainerIndicesCollection): ProcessKnownFunctionCallResult;

package/dataflow/internal/process/functions/call/known-call-handling.js

@@ -11,6 +11,9 @@ const logger_1 = require("../../../../logger");
 const vertex_1 = require("../../../../graph/vertex");
 const log_1 = require("../../../../../util/log");
 const unknown_side_effect_1 = require("../../../../graph/unknown-side-effect");
+/**
+ * Marks the given arguments as being involved in R's non-standard evaluation.
+ */
 function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId) {
     for (const nse of markAsNSE) {
         if (nse < callArgs.length) {
@@ -24,6 +27,10 @@ function markNonStandardEvaluationEdges(markAsNSE, callArgs, finalGraph, rootId)
         }
     }
 }
+/**
+ * The main processor for function calls for which we know the target but need not
+ * add any specific handling.
+ */
 function processKnownFunctionCall({ name, args, rootId, data, reverseOrder = false, markAsNSE = undefined, forceArgs, patchData = d => d, hasUnknownSideEffect, origin }, indicesCollection = undefined) {
     const functionName = (0, processor_1.processDataflowFor)(name, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);

package/dataflow/internal/process/functions/call/named-call-handling.d.ts

@@ -1,9 +1,15 @@
 import type { DataflowProcessorInformation } from '../../../../processor';
-import type { DataflowInformation } from '../../../../info';
+import { type DataflowInformation } from '../../../../info';
 import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RFunctionArgument } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RSymbol } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { NodeId } from '../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { DataflowGraph } from '../../../../graph/graph';
+/**
+ * Marks the given function call node as only calling built-in functions.
+ */
 export declare function markAsOnlyBuiltIn(graph: DataflowGraph, rootId: NodeId): void;
+/**
+ * Processes a named function call within the dataflow analysis.
+ */
 export declare function processNamedCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/named-call-handling.js

@@ -28,6 +28,9 @@ function processDefaultFunctionProcessor(information, name, args, rootId, data)
     const call = (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, forceArgs: (resolve?.length ?? 0) > 0 ? undefined : 'all', origin: 'default' });
     return mergeInformation(information, call.information);
 }
+/**
+ * Marks the given function call node as only calling built-in functions.
+ */
 function markAsOnlyBuiltIn(graph, rootId) {
     const v = graph.getVertex(rootId);
     if (v?.tag === vertex_1.VertexType.FunctionCall) {
@@ -35,6 +38,9 @@ function markAsOnlyBuiltIn(graph, rootId) {
         v.environment = undefined;
     }
 }
+/**
+ * Processes a named function call within the dataflow analysis.
+ */
 function processNamedCall(name, args, rootId, data) {
     const resolved = (0, resolve_by_name_1.resolveByName)(name.content, data.environment, identifier_1.ReferenceType.Function) ?? [];
     let defaultProcessor = resolved.length === 0;

package/dataflow/internal/process/functions/call/unnamed-call-handling.d.ts

@@ -1,7 +1,10 @@
-import type { DataflowProcessorInformation } from '../../../../processor';
+import { type DataflowProcessorInformation } from '../../../../processor';
 import type { DataflowInformation } from '../../../../info';
 import type { RUnnamedFunctionCall } from '../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 export declare const UnnamedFunctionCallPrefix = "unnamed-function-call-";
 export declare const UnnamedFunctionCallOrigin = "unnamed";
+/**
+ *
+ */
 export declare function processUnnamedFunctionCall<OtherInfo>(functionCall: RUnnamedFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/unnamed-call-handling.js

@@ -13,6 +13,9 @@ const logger_1 = require("../../../../logger");
 const identifier_1 = require("../../../../environments/identifier");
 exports.UnnamedFunctionCallPrefix = 'unnamed-function-call-';
 exports.UnnamedFunctionCallOrigin = 'unnamed';
+/**
+ *
+ */
 function processUnnamedFunctionCall(functionCall, data) {
     const calledFunction = (0, processor_1.processDataflowFor)(functionCall.calledFunction, data);
     const finalGraph = new graph_1.DataflowGraph(data.completeAst.idMap);

package/dataflow/internal/process/functions/process-argument.d.ts

@@ -1,9 +1,15 @@
-import type { DataflowProcessorInformation } from '../../../processor';
-import type { DataflowInformation } from '../../../info';
+import { type DataflowProcessorInformation } from '../../../processor';
+import { type DataflowInformation } from '../../../info';
 import type { ParentInformation } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RNode } from '../../../../r-bridge/lang-4.x/ast/model/model';
 import type { IdentifierReference } from '../../../environments/identifier';
 import { DataflowGraph } from '../../../graph/graph';
 import type { RArgument } from '../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
+/**
+ * Links all reads that occur before the argument to the argument root node.
+ */
 export declare function linkReadsForArgument<OtherInfo>(root: RNode<OtherInfo & ParentInformation>, ingoingRefs: readonly IdentifierReference[], graph: DataflowGraph): void;
+/**
+ * Processes the dataflow information for a function argument.
+ */
 export declare function processFunctionArgument<OtherInfo>(argument: RArgument<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -8,6 +8,9 @@ const graph_1 = require("../../../graph/graph");
 const type_1 = require("../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../graph/edge");
 const vertex_1 = require("../../../graph/vertex");
+/**
+ * Links all reads that occur before the argument to the argument root node.
+ */
 function linkReadsForArgument(root, ingoingRefs, graph) {
     const allIdsBeforeArguments = new Set((0, collect_1.collectAllIds)(root, n => n.type === type_1.RType.Argument && n.info.id !== root.info.id));
     const ingoingBeforeArgs = ingoingRefs.filter(r => allIdsBeforeArguments.has(r.nodeId));
@@ -16,6 +19,9 @@ function linkReadsForArgument(root, ingoingRefs, graph) {
         graph.addEdge(root.info.id, ref, edge_1.EdgeType.Reads);
     }
 }
+/**
+ * Processes the dataflow information for a function argument.
+ */
 function processFunctionArgument(argument, data) {
     const name = argument.name === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.name, data);
     const value = argument.value === undefined ? undefined : (0, processor_1.processDataflowFor)(argument.value, data);

package/dataflow/internal/process/functions/process-parameter.d.ts

@@ -1,5 +1,8 @@
-import type { DataflowInformation } from '../../../info';
-import type { DataflowProcessorInformation } from '../../../processor';
+import { type DataflowInformation } from '../../../info';
+import { type DataflowProcessorInformation } from '../../../processor';
 import type { RParameter } from '../../../../r-bridge/lang-4.x/ast/model/nodes/r-parameter';
 import type { ParentInformation } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ *
+ */
 export declare function processFunctionParameter<OtherInfo>(parameter: RParameter<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/process-parameter.js

@@ -7,6 +7,9 @@ const identifier_1 = require("../../../environments/identifier");
 const define_1 = require("../../../environments/define");
 const type_1 = require("../../../../r-bridge/lang-4.x/ast/model/type");
 const edge_1 = require("../../../graph/edge");
+/**
+ *
+ */
 function processFunctionParameter(parameter, data) {
     const name = (0, processor_1.processDataflowFor)(parameter.name, data);
     const defaultValue = parameter.defaultValue === undefined ? undefined : (0, processor_1.processDataflowFor)(parameter.defaultValue, data);

package/dataflow/internal/process/process-symbol.d.ts

@@ -2,4 +2,7 @@ import { type DataflowInformation } from '../../info';
 import type { DataflowProcessorInformation } from '../../processor';
 import type { RSymbol } from '../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import type { ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ *
+ */
 export declare function processSymbol<OtherInfo>(symbol: RSymbol<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo>): DataflowInformation;

package/dataflow/internal/process/process-symbol.js

@@ -6,6 +6,9 @@ const convert_values_1 = require("../../../r-bridge/lang-4.x/convert-values");
 const graph_1 = require("../../graph/graph");
 const vertex_1 = require("../../graph/vertex");
 const identifier_1 = require("../../environments/identifier");
+/**
+ *
+ */
 function processSymbol(symbol, data) {
     if (symbol.content === convert_values_1.RNull || symbol.content === convert_values_1.RNa) {
         return (0, process_value_1.processValue)(symbol, data);

package/dataflow/internal/process/process-uninteresting-leaf.d.ts

@@ -1,4 +1,7 @@
 import { type DataflowInformation } from '../../info';
 import type { DataflowProcessorInformation } from '../../processor';
 import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ *
+ */
 export declare function processUninterestingLeaf<OtherInfo>(leaf: RNodeWithParent, info: DataflowProcessorInformation<OtherInfo>): DataflowInformation;

package/dataflow/internal/process/process-uninteresting-leaf.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processUninterestingLeaf = processUninterestingLeaf;
 const info_1 = require("../../info");
+/**
+ *
+ */
 function processUninterestingLeaf(leaf, info) {
     return (0, info_1.initializeCleanDataflowInformation)(leaf.info.id, info);
 }

package/dataflow/internal/process/process-value.d.ts

@@ -1,4 +1,7 @@
 import { type DataflowInformation } from '../../info';
 import type { DataflowProcessorInformation } from '../../processor';
 import type { RNodeWithParent } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ *
+ */
 export declare function processValue<OtherInfo>({ info: { id } }: RNodeWithParent, data: DataflowProcessorInformation<OtherInfo>): DataflowInformation;

package/dataflow/internal/process/process-value.js

@@ -4,6 +4,9 @@ exports.processValue = processValue;
 const graph_1 = require("../../graph/graph");
 const vertex_1 = require("../../graph/vertex");
 const identifier_1 = require("../../environments/identifier");
+/**
+ *
+ */
 function processValue({ info: { id } }, data) {
     return {
         unknownReferences: [],

package/dataflow/origin/dfg-get-origin.d.ts

@@ -10,7 +10,6 @@ export declare const enum OriginType {
 /**
  * An origin that indicates that the definition is read, written, or simply a constant.
  * These origins only reference the 'direct' dependencies. There is no transitivity.
- *
  * @example
  * ```r
  * x <- 2
@@ -28,7 +27,6 @@ export interface SimpleOrigin {
 /**
  * Determines the (transitive) origin of a function call (i.e., all anonymous function definitions within the program that
  * can be called).
- *
  * @example
  * ```r
  * f <- function(x) {

package/dataflow/origin/dfg-get-symbol-refs.d.ts

@@ -5,15 +5,13 @@ import type { DataflowGraph } from '../graph/graph';
  *
  * For example, for the following code
  * ```ts
- *   y <- 5
- *   f <- function() {
- *     y <- 8
- *     print(y)
- *   }
+ * y <- 5
+ * f <- function() {
+ * y <- 8
+ * print(y)
+ * }
  * ```
- *
  * @example getAllRefsToSymbol('3\@y') returns ['3\@y', '4\@y']
- *
  * @param graph  - Dataflow Graph
  * @param nodeId - NodeId of Symbol to resolve
  * @returns List including the Definitions and Refereneces to that definition

package/dataflow/origin/dfg-get-symbol-refs.js

@@ -9,15 +9,13 @@ const dfg_get_origin_1 = require("./dfg-get-origin");
  *
  * For example, for the following code
  * ```ts
- *   y <- 5
- *   f <- function() {
- *     y <- 8
- *     print(y)
- *   }
+ * y <- 5
+ * f <- function() {
+ * y <- 8
+ * print(y)
+ * }
  * ```
- *
  * @example getAllRefsToSymbol('3\@y') returns ['3\@y', '4\@y']
- *
  * @param graph  - Dataflow Graph
  * @param nodeId - NodeId of Symbol to resolve
  * @returns List including the Definitions and Refereneces to that definition
@@ -32,7 +30,7 @@ function getAllRefsToSymbol(graph, nodeId) {
     if (definitiveOrigins.length === 0) {
         return undefined;
     }
-    // Gather all the references 
+    // Gather all the references
     const res = new Set();
     for (const origin of definitiveOrigins) {
         res.add(origin.id);

package/dataflow/processor.d.ts

@@ -64,7 +64,6 @@ export type DataflowProcessors<OtherInfo> = {
  * <p>
  * Now this method can be called recursively within the other processors to parse the dataflow for nodes that you cannot narrow down
  * in type or context.
- *
  * @param current - The current node to start processing from
  * @param data    - The initial (/current) information to be passed down
  */