@eagleoutice/flowr 1.3.14 → 1.4.2

package/core/print/parse-printer.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseToQuads = void 0;
 const quads_1 = require("../../util/quads");
-const internal_1 = require("../../r-bridge/lang-4.x/ast/parser/xml/internal");
+const r_bridge_1 = require("../../r-bridge");
+const format_1 = require("../../r-bridge/lang-4.x/ast/parser/json/format");
+const parser_1 = require("../../r-bridge/lang-4.x/ast/parser/json/parser");
 function filterObject(obj, keys) {
     if (typeof obj !== 'object') {
         return obj;
@@ -20,10 +22,10 @@ function filterObject(obj, keys) {
             .map(([k, v]) => [k, filterObject(v, keys)]));
     }
 }
-async function parseToQuads(code, config, parseConfig) {
-    const obj = await (0, internal_1.xlm2jsonObject)(parseConfig, code);
+function parseToQuads(code, config) {
+    const obj = (0, parser_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(code));
     // recursively filter so that if the object contains one of the keys 'a', 'b' or 'c', all other keys are ignored
-    return (0, quads_1.serialize2quads)(filterObject(obj, new Set([parseConfig.attributeName, parseConfig.childrenName, parseConfig.contentName])), config);
+    return (0, quads_1.serialize2quads)(filterObject(obj, new Set([r_bridge_1.attributesKey, r_bridge_1.childrenKey, r_bridge_1.contentKey])), config);
 }
 exports.parseToQuads = parseToQuads;
 //# sourceMappingURL=parse-printer.js.map

package/core/print/print.d.ts

@@ -1,4 +1,4 @@
-import { StepFunction } from '../steps';
+import type { StepFunction } from '../steps';
 /**
  * Defines the output format of a step that you are interested in.
  */

package/core/print/slice-diff-ansi.d.ts

@@ -1,2 +1,2 @@
-import { NodeId, NormalizedAst } from '../../r-bridge';
+import type { NodeId, NormalizedAst } from '../../r-bridge';
 export declare function sliceDiffAnsi(slice: Set<NodeId>, normalized: NormalizedAst, criteriaIds: Set<NodeId>, originalCode: string): string;

package/core/slicer.d.ts

@@ -1,7 +1,8 @@
-import { LAST_PER_FILE_STEP, LAST_STEP, StepRequired, STEPS_PER_SLICE, StepName, StepResult } from './steps';
-import { SlicingCriteria } from '../slicing';
-import { SteppingSlicerInput } from './input';
-import { StepResults } from './output';
+import type { LAST_PER_FILE_STEP, StepRequired, StepName, StepResult } from './steps';
+import { LAST_STEP, STEPS_PER_SLICE } from './steps';
+import type { SlicingCriteria } from '../slicing';
+import type { SteppingSlicerInput } from './input';
+import type { StepResults } from './output';
 /**
  * This is ultimately the root of flowR's static slicing procedure.
  * It clearly defines the steps that are to be executed and splits them into two stages.

package/core/slicer.js

@@ -162,11 +162,11 @@ class SteppingSlicer {
                 break;
             case 1:
                 step = guardStep('normalize');
-                result = await (0, steps_1.executeSingleSubStep)(step, this.results.parse, await this.shell.tokenMap(), this.hooks, this.getId);
+                result = (0, steps_1.executeSingleSubStep)(step, this.results.parse, this.hooks, this.getId);
                 break;
             case 2:
                 step = guardStep('dataflow');
-                result = (0, steps_1.executeSingleSubStep)(step, this.results.normalize);
+                result = (0, steps_1.executeSingleSubStep)(step, this.request, this.results.normalize);
                 break;
             case 3:
                 (0, assert_1.guard)(this.criterion !== undefined, 'Cannot decode criteria without a criterion');

package/core/steps.d.ts

@@ -12,14 +12,15 @@
  *
  * @module
  */
-import { MergeableRecord } from '../util/objects';
-import { normalize, retrieveXmlFromRCode } from '../r-bridge';
-import { produceDataFlowGraph } from '../dataflow';
+import type { MergeableRecord } from '../util/objects';
+import { retrieveParseDataFromRCode } from '../r-bridge';
 import { reconstructToCode, staticSlicing } from '../slicing';
-import { internalPrinter, IStepPrinter, StepOutputFormat } from './print/print';
+import type { IStepPrinter } from './print/print';
+import { internalPrinter, StepOutputFormat } from './print/print';
 import { normalizedAstToJson, normalizedAstToQuads, printNormalizedAstToMermaid, printNormalizedAstToMermaidUrl } from './print/normalize-printer';
-import { dataflowGraphToJson, dataflowGraphToMermaid, dataflowGraphToMermaidUrl, dataflowGraphToQuads } from './print/dataflow-printer';
 import { parseToQuads } from './print/parse-printer';
+import { dataflowGraphToJson, dataflowGraphToMermaid, dataflowGraphToMermaidUrl, dataflowGraphToQuads } from './print/dataflow-printer';
+import { normalize } from '../r-bridge/lang-4.x/ast/parser/json/parser';
 /**
  * This represents close a function that we know completely nothing about.
  * Nevertheless, this is the basis of what a step processor should look like.
@@ -47,7 +48,7 @@ export interface IStep<Fn extends StepFunction> extends MergeableRecord {
 export declare const STEPS_PER_FILE: {
     readonly parse: {
         description: string;
-        processor: typeof retrieveXmlFromRCode;
+        processor: typeof retrieveParseDataFromRCode;
         required: "once-per-file";
         printer: {
             0: typeof internalPrinter;
@@ -69,7 +70,7 @@ export declare const STEPS_PER_FILE: {
     };
     readonly dataflow: {
         description: string;
-        processor: typeof produceDataFlowGraph;
+        processor: (r: import("../r-bridge").RParseRequest, a: import("../r-bridge").NormalizedAst<import("../r-bridge").ParentInformation>) => import("../dataflow/internal/info").DataflowInformation;
         required: "once-per-file";
         printer: {
             0: typeof internalPrinter;
@@ -117,7 +118,7 @@ export declare const STEPS: {
     };
     readonly parse: {
         description: string;
-        processor: typeof retrieveXmlFromRCode;
+        processor: typeof retrieveParseDataFromRCode;
         required: "once-per-file";
         printer: {
             0: typeof internalPrinter;
@@ -139,7 +140,7 @@ export declare const STEPS: {
     };
     readonly dataflow: {
         description: string;
-        processor: typeof produceDataFlowGraph;
+        processor: (r: import("../r-bridge").RParseRequest, a: import("../r-bridge").NormalizedAst<import("../r-bridge").ParentInformation>) => import("../dataflow/internal/info").DataflowInformation;
         required: "once-per-file";
         printer: {
             0: typeof internalPrinter;

package/core/steps.js

@@ -21,12 +21,13 @@ const slicing_1 = require("../slicing");
 const print_1 = require("./print/print");
 const normalize_printer_1 = require("./print/normalize-printer");
 const assert_1 = require("../util/assert");
-const dataflow_printer_1 = require("./print/dataflow-printer");
 const parse_printer_1 = require("./print/parse-printer");
+const dataflow_printer_1 = require("./print/dataflow-printer");
+const parser_1 = require("../r-bridge/lang-4.x/ast/parser/json/parser");
 exports.STEPS_PER_FILE = {
     'parse': {
         description: 'Parse the given R code into an AST',
-        processor: r_bridge_1.retrieveXmlFromRCode,
+        processor: r_bridge_1.retrieveParseDataFromRCode,
         required: 'once-per-file',
         printer: {
             [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
@@ -36,7 +37,7 @@ exports.STEPS_PER_FILE = {
     },
     'normalize': {
         description: 'Normalize the AST to flowR\'s AST (first step of the normalization)',
-        processor: r_bridge_1.normalize,
+        processor: parser_1.normalize,
         required: 'once-per-file',
         printer: {
             [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
@@ -48,7 +49,7 @@ exports.STEPS_PER_FILE = {
     },
     'dataflow': {
         description: 'Construct the dataflow graph',
-        processor: dataflow_1.produceDataFlowGraph,
+        processor: (r, a) => (0, dataflow_1.produceDataFlowGraph)(r, a),
         required: 'once-per-file',
         printer: {
             [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,

package/dataflow/environments/append.d.ts

@@ -1,4 +1,4 @@
-import { REnvironmentInformation } from './environment';
+import type { REnvironmentInformation } from './environment';
 /**
  * Adds all writes of `next` to `base` (i.e., the operations of `next` *might* happen).
  */

package/dataflow/environments/environment.d.ts

@@ -4,10 +4,10 @@
  *
  * @module
  */
-import { NodeId } from '../../r-bridge';
-import { DataflowGraph, DataflowGraphEdgeAttribute } from '../graph';
-import { DataflowScopeName } from './scopes';
-import { GenericDifferenceInformation } from '../../util/diff';
+import type { NodeId } from '../../r-bridge';
+import type { DataflowGraph, DataflowGraphEdgeAttribute } from '../graph';
+import type { DataflowScopeName } from './scopes';
+import type { GenericDifferenceInformation } from '../../util/diff';
 /** identifiers are branded to avoid confusion with other string-like types */
 export type Identifier = string & {
     __brand?: 'identifier';

package/dataflow/environments/environment.js

@@ -77,6 +77,14 @@ exports.DefaultEnvironmentMemory = new Map([
                 definedAt: exports.BuiltIn,
                 name: 'print',
                 nodeId: exports.BuiltIn
+            }]],
+    ['source', [{
+                kind: 'built-in-function',
+                scope: scopes_1.GlobalScope,
+                used: 'always',
+                definedAt: exports.BuiltIn,
+                name: 'source',
+                nodeId: exports.BuiltIn
             }]]
 ]);
 function initializeCleanEnvironments() {

package/dataflow/environments/overwrite.d.ts

@@ -1,4 +1,4 @@
-import { REnvironmentInformation, IEnvironment } from './environment';
+import type { REnvironmentInformation, IEnvironment } from './environment';
 export declare function overwriteIEnvironmentWith(base: IEnvironment | undefined, next: IEnvironment | undefined, includeParent?: boolean): IEnvironment;
 export declare function overwriteEnvironments(base: REnvironmentInformation, next: REnvironmentInformation | undefined): REnvironmentInformation;
 export declare function overwriteEnvironments(base: REnvironmentInformation | undefined, next: REnvironmentInformation): REnvironmentInformation;

package/dataflow/environments/register.d.ts

@@ -1,5 +1,5 @@
-import { IdentifierDefinition, REnvironmentInformation } from './environment';
-import { DataflowScopeName } from './scopes';
+import type { IdentifierDefinition, REnvironmentInformation } from './environment';
+import type { DataflowScopeName } from './scopes';
 /**
  * Insert the given `definition` --- defined within the given scope --- into the passed along `environments` will take care of propagation.
  * Does not modify the passed along `environments` in-place! It returns the new reference.

package/dataflow/environments/register.js

@@ -10,6 +10,7 @@ const assert_1 = require("../../util/assert");
  */
 function define(definition, withinScope, environments) {
     let newEnvironments = environments;
+    (0, assert_1.guard)(withinScope === definition.scope, 'Mismatching scopes');
     if (withinScope === scopes_1.LocalScope) {
         newEnvironments = (0, environment_1.cloneEnvironments)(environments, false);
         newEnvironments.current.memory.set(definition.name, [definition]);

package/dataflow/environments/resolve-by-name.d.ts

@@ -1,5 +1,5 @@
-import { Identifier, IdentifierDefinition, REnvironmentInformation } from './environment';
-import { DataflowScopeName } from './scopes';
+import type { Identifier, IdentifierDefinition, REnvironmentInformation } from './environment';
+import type { DataflowScopeName } from './scopes';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  *

package/dataflow/environments/scoping.d.ts

@@ -1,4 +1,4 @@
-import { REnvironmentInformation } from './environment';
+import type { REnvironmentInformation } from './environment';
 /** Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone) */
 export declare function pushLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;
 export declare function popLocalEnvironment(base: REnvironmentInformation): REnvironmentInformation;

package/dataflow/extractor.d.ts

@@ -1,6 +1,6 @@
-import { NormalizedAst, ParentInformation, RBinaryOp } from '../r-bridge';
-import { DataflowInformation } from './internal/info';
-import { DataflowProcessorInformation } from './processor';
-import { DataflowScopeName } from './environments';
-export declare function produceDataFlowGraph<OtherInfo>(ast: NormalizedAst<OtherInfo & ParentInformation>, initialScope?: DataflowScopeName): DataflowInformation;
+import type { NormalizedAst, ParentInformation, RBinaryOp, RParseRequest } from '../r-bridge';
+import type { DataflowInformation } from './internal/info';
+import type { DataflowProcessorInformation } from './processor';
+import type { DataflowScopeName } from './environments';
+export declare function produceDataFlowGraph<OtherInfo>(request: RParseRequest, ast: NormalizedAst<OtherInfo & ParentInformation>, initialScope?: DataflowScopeName): DataflowInformation;
 export declare function processBinaryOp<OtherInfo>(node: RBinaryOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/extractor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processBinaryOp = exports.produceDataFlowGraph = void 0;
+const r_bridge_1 = require("../r-bridge");
 const processor_1 = require("./processor");
 const uninteresting_leaf_1 = require("./internal/process/uninteresting-leaf");
 const symbol_1 = require("./internal/process/symbol");
@@ -44,8 +45,15 @@ const processors = {
     ["RArgument" /* RType.Argument */]: argument_1.processFunctionArgument,
     ["RExpressionList" /* RType.ExpressionList */]: expression_list_1.processExpressionList,
 };
-function produceDataFlowGraph(ast, initialScope = scopes_1.LocalScope) {
-    return (0, processor_1.processDataflowFor)(ast.ast, { completeAst: ast, activeScope: initialScope, environments: (0, environments_1.initializeCleanEnvironments)(), processors: processors });
+function produceDataFlowGraph(request, ast, initialScope = scopes_1.LocalScope) {
+    return (0, processor_1.processDataflowFor)(ast.ast, {
+        completeAst: ast,
+        activeScope: initialScope,
+        environments: (0, environments_1.initializeCleanEnvironments)(),
+        processors: processors,
+        currentRequest: request,
+        referenceChain: [(0, r_bridge_1.requestFingerprint)(request)]
+    });
 }
 exports.produceDataFlowGraph = produceDataFlowGraph;
 function processBinaryOp(node, data) {

package/dataflow/graph/diff.d.ts

@@ -1,6 +1,6 @@
-import { NodeId } from '../../r-bridge';
-import { DataflowGraph, FunctionArgument, OutgoingEdges } from './graph';
-import { GenericDifferenceInformation, DifferenceReport } from '../../util/diff';
+import type { NodeId } from '../../r-bridge';
+import type { DataflowGraph, FunctionArgument, OutgoingEdges } from './graph';
+import type { GenericDifferenceInformation, DifferenceReport } from '../../util/diff';
 export interface NamedGraph {
     name: string;
     graph: DataflowGraph;

package/dataflow/graph/graph.d.ts

@@ -1,10 +1,11 @@
-import { NodeId, NoInfo, RNodeWithParent } from '../../r-bridge';
-import { IdentifierDefinition, IdentifierReference } from '../environments';
-import { BiMap } from '../../util/bimap';
-import { DataflowGraphEdge, DataflowGraphEdgeAttribute, EdgeType } from './edge';
-import { DataflowInformation } from '../internal/info';
-import { DataflowGraphVertexArgument, DataflowGraphVertexInfo } from './vertex';
-import { DifferenceReport } from '../../util/diff';
+import type { NodeId, NoInfo, RNodeWithParent } from '../../r-bridge';
+import type { IdentifierDefinition, IdentifierReference } from '../environments';
+import type { BiMap } from '../../util/bimap';
+import type { DataflowGraphEdge, DataflowGraphEdgeAttribute } from './edge';
+import { EdgeType } from './edge';
+import type { DataflowInformation } from '../internal/info';
+import type { DataflowGraphVertexArgument, DataflowGraphVertexInfo } from './vertex';
+import type { DifferenceReport } from '../../util/diff';
 /** Used to get an entry point for every id, after that it allows reference-chasing of the graph */
 export type DataflowMap<OtherInfo = NoInfo> = BiMap<NodeId, RNodeWithParent<OtherInfo>>;
 export type DataflowFunctionFlowInformation = Omit<DataflowInformation, 'graph'> & {

package/dataflow/graph/quads.d.ts

@@ -1,5 +1,5 @@
-import { QuadSerializationConfiguration } from '../../util/quads';
-import { DataflowGraph } from './graph';
+import type { QuadSerializationConfiguration } from '../../util/quads';
+import type { DataflowGraph } from './graph';
 /**
  * @see cfg2quads
  * @see serialize2quads

package/dataflow/graph/vertex.d.ts

@@ -1,8 +1,8 @@
-import { MergeableRecord } from '../../util/objects';
-import { NodeId } from '../../r-bridge';
-import { DataflowScopeName, REnvironmentInformation } from '../environments';
-import { DataflowGraphEdgeAttribute } from './edge';
-import { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
+import type { MergeableRecord } from '../../util/objects';
+import type { NodeId } from '../../r-bridge';
+import type { DataflowScopeName, REnvironmentInformation } from '../environments';
+import type { DataflowGraphEdgeAttribute } from './edge';
+import type { DataflowFunctionFlowInformation, FunctionArgument } from './graph';
 export type DataflowGraphVertices = Map<NodeId, DataflowGraphVertexInfo>;
 /**
  * Arguments required to construct a vertex in the dataflow graph.

package/dataflow/internal/info.d.ts

@@ -1,6 +1,6 @@
 import { DataflowGraph } from '../graph';
-import { REnvironmentInformation, IdentifierReference, DataflowScopeName } from '../environments';
-import { DataflowProcessorInformation } from '../processor';
+import type { REnvironmentInformation, IdentifierReference, DataflowScopeName } from '../environments';
+import type { DataflowProcessorInformation } from '../processor';
 /**
  * Continuously updated during the dataflow analysis to hold the current state.
  */

package/dataflow/internal/linker.d.ts

@@ -1,7 +1,7 @@
-import { DataflowGraph, DataflowGraphVertexInfo, FunctionArgument } from '../graph';
-import { DataflowScopeName, IdentifierReference, REnvironmentInformation } from '../environments';
+import type { DataflowGraph, DataflowGraphVertexInfo, FunctionArgument } from '../graph';
+import type { DataflowScopeName, IdentifierReference, REnvironmentInformation } from '../environments';
 import { DefaultMap } from '../../util/defaultmap';
-import { DecoratedAstMap, NodeId, ParentInformation, RParameter } from '../../r-bridge';
+import type { DecoratedAstMap, NodeId, ParentInformation, RParameter } from '../../r-bridge';
 export declare function linkIngoingVariablesInSameScope(graph: DataflowGraph, references: IdentifierReference[]): void;
 export type NameIdMap = DefaultMap<string, IdentifierReference[]>;
 export declare function produceNameSharedIdMap(references: IdentifierReference[]): NameIdMap;

package/dataflow/internal/process/access.d.ts

@@ -1,4 +1,4 @@
-import { ParentInformation, RAccess } from '../../../r-bridge';
-import { DataflowInformation } from '../info';
-import { DataflowProcessorInformation } from '../../processor';
+import type { ParentInformation, RAccess } from '../../../r-bridge';
+import type { DataflowInformation } from '../info';
+import type { DataflowProcessorInformation } from '../../processor';
 export declare function processAccess<OtherInfo>(node: RAccess<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/expression-list.d.ts

@@ -2,7 +2,7 @@
  * Processes a list of expressions joining their dataflow graphs accordingly.
  * @module
  */
-import { DataflowInformation } from '../info';
-import { ParentInformation, RExpressionList } from '../../../r-bridge';
-import { DataflowProcessorInformation } from '../../processor';
+import type { DataflowInformation } from '../info';
+import type { ParentInformation, RExpressionList } from '../../../r-bridge';
+import type { DataflowProcessorInformation } from '../../processor';
 export declare function processExpressionList<OtherInfo>(exprList: RExpressionList<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/expression-list.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processExpressionList = void 0;
-/**
- * Processes a list of expressions joining their dataflow graphs accordingly.
- * @module
- */
 const info_1 = require("../info");
 const r_bridge_1 = require("../../../r-bridge");
 const processor_1 = require("../../processor");

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

@@ -1,8 +1,8 @@
-import { DataflowInformation } from '../../info';
-import { DataflowProcessorInformation } from '../../../processor';
-import { ParentInformation, RArgument, RNode } from '../../../../r-bridge';
+import type { DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../../processor';
+import type { ParentInformation, RArgument, RNode } from '../../../../r-bridge';
 import { DataflowGraph } from '../../../graph';
-import { IdentifierReference } from '../../../environments';
+import type { IdentifierReference } from '../../../environments';
 export declare const UnnamedArgumentPrefix = "unnamed-argument-";
 export declare function linkReadsForArgument<OtherInfo>(root: RNode<OtherInfo & ParentInformation>, ingoingRefs: IdentifierReference[], graph: DataflowGraph): void;
 export declare function processFunctionArgument<OtherInfo>(argument: RArgument<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/exit-points.d.ts

@@ -1,2 +1,2 @@
-import { NodeId, ParentInformation, RFunctionDefinition } from '../../../../r-bridge';
+import type { NodeId, ParentInformation, RFunctionDefinition } from '../../../../r-bridge';
 export declare function retrieveExitPointsOfFunctionDefinition<OtherInfo>(functionDefinition: RFunctionDefinition<OtherInfo & ParentInformation>): NodeId[];

package/dataflow/internal/process/functions/function-call.d.ts

@@ -1,5 +1,5 @@
-import { DataflowInformation } from '../../info';
-import { DataflowProcessorInformation } from '../../../processor';
-import { ParentInformation, RFunctionCall } from '../../../../r-bridge';
+import type { DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../../processor';
+import type { ParentInformation, RFunctionCall } from '../../../../r-bridge';
 export declare const UnnamedFunctionCallPrefix = "unnamed-function-call-";
 export declare function processFunctionCall<OtherInfo>(functionCall: RFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/function-call.js

@@ -7,6 +7,7 @@ const assert_1 = require("../../../../util/assert");
 const index_1 = require("../../../index");
 const linker_1 = require("../../linker");
 const scopes_1 = require("../../../environments/scopes");
+const source_1 = require("./source");
 exports.UnnamedFunctionCallPrefix = 'unnamed-function-call-';
 function processFunctionCall(functionCall, data) {
     const named = functionCall.flavor === 'named';
@@ -86,7 +87,7 @@ function processFunctionCall(functionCall, data) {
         // push the called function to the ids:
         inIds.push(...functionName.in, ...functionName.unknownReferences);
     }
-    return {
+    let info = {
         unknownReferences: [],
         in: inIds,
         out: functionName.out, // we do not keep argument out as it has been linked by the function
@@ -94,6 +95,11 @@ function processFunctionCall(functionCall, data) {
         environments: finalEnv,
         scope: data.activeScope
     };
+    // parse a source call and analyze the referenced code
+    if ((0, source_1.isSourceCall)(functionCallName, data.activeScope, finalEnv)) {
+        info = (0, source_1.processSourceCall)(functionCall, data, info);
+    }
+    return info;
 }
 exports.processFunctionCall = processFunctionCall;
 //# sourceMappingURL=function-call.js.map

package/dataflow/internal/process/functions/function-definition.d.ts

@@ -1,4 +1,4 @@
-import { DataflowInformation } from '../../info';
-import { DataflowProcessorInformation } from '../../../processor';
-import { ParentInformation, RFunctionDefinition } from '../../../../r-bridge';
+import type { DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../../processor';
+import type { ParentInformation, RFunctionDefinition } from '../../../../r-bridge';
 export declare function processFunctionDefinition<OtherInfo>(functionDefinition: RFunctionDefinition<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

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

@@ -1,4 +1,4 @@
-import { DataflowInformation } from '../../info';
-import { DataflowProcessorInformation } from '../../../processor';
-import { ParentInformation, RParameter } from '../../../../r-bridge';
+import type { DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../../processor';
+import type { ParentInformation, RParameter } from '../../../../r-bridge';
 export declare function processFunctionParameter<OtherInfo>(parameter: RParameter<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/source.d.ts

@@ -0,0 +1,8 @@
+import type { IdGenerator, NoInfo, RParseRequest, RParseRequestProvider, ParentInformation, RFunctionCall } from '../../../../r-bridge';
+import { type DataflowProcessorInformation } from '../../../processor';
+import { type DataflowScopeName, type Identifier, type REnvironmentInformation } from '../../../environments';
+import type { DataflowInformation } from '../../info';
+export declare function setSourceProvider(provider: RParseRequestProvider): void;
+export declare function isSourceCall(name: Identifier, scope: DataflowScopeName, environments: REnvironmentInformation): boolean;
+export declare function processSourceCall<OtherInfo>(functionCall: RFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, information: DataflowInformation): DataflowInformation;
+export declare function sourceRequest<OtherInfo>(request: RParseRequest, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, information: DataflowInformation, getId: IdGenerator<NoInfo>): DataflowInformation;

package/dataflow/internal/process/functions/source.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceRequest = exports.processSourceCall = exports.isSourceCall = exports.setSourceProvider = void 0;
+const r_bridge_1 = require("../../../../r-bridge");
+const shell_executor_1 = require("../../../../r-bridge/shell-executor");
+const core_1 = require("../../../../core");
+const processor_1 = require("../../../processor");
+const environments_1 = require("../../../environments");
+const index_1 = require("../../../index");
+const config_1 = require("../../../../config");
+let sourceProvider = (0, r_bridge_1.requestProviderFromFile)();
+function setSourceProvider(provider) {
+    sourceProvider = provider;
+}
+exports.setSourceProvider = setSourceProvider;
+function isSourceCall(name, scope, environments) {
+    const definitions = (0, environments_1.resolveByName)(name, scope, environments);
+    if (definitions === undefined) {
+        return false;
+    }
+    // fail if there are multiple definitions because then we must treat the complete import as a maybe because it might do something different
+    if (definitions.length !== 1) {
+        return false;
+    }
+    const def = definitions[0];
+    return def.name == 'source' && def.kind == 'built-in-function';
+}
+exports.isSourceCall = isSourceCall;
+function processSourceCall(functionCall, data, information) {
+    const sourceFile = functionCall.arguments[0];
+    if ((0, config_1.getConfig)().ignoreSourceCalls) {
+        index_1.dataflowLogger.info(`Skipping source call ${JSON.stringify(sourceFile)} (disabled in config file)`);
+        return information;
+    }
+    if (sourceFile?.value?.type == "RString" /* RType.String */) {
+        const path = (0, r_bridge_1.removeRQuotes)(sourceFile.lexeme);
+        const request = sourceProvider.createRequest(path);
+        // check if the sourced file has already been dataflow analyzed, and if so, skip it
+        if (data.referenceChain.includes((0, r_bridge_1.requestFingerprint)(request))) {
+            index_1.dataflowLogger.info(`Found loop in dataflow analysis for ${JSON.stringify(request)}: ${JSON.stringify(data.referenceChain)}, skipping further dataflow analysis`);
+            return information;
+        }
+        return sourceRequest(request, data, information, (0, r_bridge_1.sourcedDeterministicCountingIdGenerator)(path, functionCall.location));
+    }
+    else {
+        index_1.dataflowLogger.info(`Non-constant argument ${JSON.stringify(sourceFile)} for source is currently not supported, skipping`);
+        return information;
+    }
+}
+exports.processSourceCall = processSourceCall;
+function sourceRequest(request, data, information, getId) {
+    const executor = new shell_executor_1.RShellExecutor();
+    // parse, normalize and dataflow the sourced file
+    let normalized;
+    let dataflow;
+    try {
+        const parsed = (0, core_1.executeSingleSubStep)('parse', request, executor);
+        normalized = (0, core_1.executeSingleSubStep)('normalize', parsed, undefined, getId);
+        dataflow = (0, processor_1.processDataflowFor)(normalized.ast, {
+            ...data,
+            currentRequest: request,
+            environments: information.environments,
+            referenceChain: [...data.referenceChain, (0, r_bridge_1.requestFingerprint)(request)]
+        });
+    }
+    catch (e) {
+        index_1.dataflowLogger.warn(`Failed to analyze sourced file ${JSON.stringify(request)}, skipping: ${e.message}`);
+        return information;
+    }
+    // update our graph with the sourced file's information
+    const newInformation = { ...information };
+    newInformation.environments = (0, environments_1.overwriteEnvironments)(information.environments, dataflow.environments);
+    newInformation.graph.mergeWith(dataflow.graph);
+    // this can be improved, see issue #628
+    for (const [k, v] of normalized.idMap) {
+        data.completeAst.idMap.set(k, v);
+    }
+    return newInformation;
+}
+exports.sourceRequest = sourceRequest;
+//# sourceMappingURL=source.js.map

package/dataflow/internal/process/if-then-else.d.ts

@@ -1,4 +1,4 @@
-import { DataflowInformation } from '../info';
-import { DataflowProcessorInformation } from '../../processor';
-import { ParentInformation, RIfThenElse } from '../../../r-bridge';
+import type { DataflowInformation } from '../info';
+import type { DataflowProcessorInformation } from '../../processor';
+import type { ParentInformation, RIfThenElse } from '../../../r-bridge';
 export declare function processIfThenElse<OtherInfo>(ifThen: RIfThenElse<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/loops/for-loop.d.ts

@@ -1,4 +1,4 @@
-import { DataflowInformation } from '../../info';
-import { DataflowProcessorInformation } from '../../../processor';
-import { ParentInformation, RForLoop } from '../../../../r-bridge';
+import type { DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../../processor';
+import type { ParentInformation, RForLoop } from '../../../../r-bridge';
 export declare function processForLoop<OtherInfo>(loop: RForLoop<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/loops/repeat-loop.d.ts

@@ -1,4 +1,4 @@
-import { DataflowInformation } from '../../info';
-import { DataflowProcessorInformation } from '../../../processor';
-import { ParentInformation, RRepeatLoop } from '../../../../r-bridge';
+import type { DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../../processor';
+import type { ParentInformation, RRepeatLoop } from '../../../../r-bridge';
 export declare function processRepeatLoop<OtherInfo>(loop: RRepeatLoop<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/loops/while-loop.d.ts

@@ -1,4 +1,4 @@
-import { DataflowInformation } from '../../info';
-import { DataflowProcessorInformation } from '../../../processor';
-import { ParentInformation, RWhileLoop } from '../../../../r-bridge';
+import type { DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../../processor';
+import type { ParentInformation, RWhileLoop } from '../../../../r-bridge';
 export declare function processWhileLoop<OtherInfo>(loop: RWhileLoop<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/operators/assignment.d.ts

@@ -1,4 +1,4 @@
-import { ParentInformation, RAssignmentOp } from '../../../../r-bridge';
-import { DataflowInformation } from '../../info';
-import { DataflowProcessorInformation } from '../../../processor';
+import type { ParentInformation, RAssignmentOp } from '../../../../r-bridge';
+import type { DataflowInformation } from '../../info';
+import type { DataflowProcessorInformation } from '../../../processor';
 export declare function processAssignment<OtherInfo>(op: RAssignmentOp<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;