perf: try to improve cfg construction and union

Author: EagleoutIce

src/control-flow/extract-cfg.ts

@@ -78,6 +78,8 @@ function dataflowCfgFolds(dataflowGraph: DataflowGraph): FoldFunctions<ParentInf
  * @param ast             - the normalized AST
  * @param graph           - additional dataflow facts to consider by the control flow extraction
  * @param simplifications - a list of simplification passes to apply to the control flow graph
+ *
+ * @see {@link extractSimpleCfg} - for a simplified version of this function
  */
 export function extractCFG<Info=ParentInformation>(
 	ast:    NormalizedAst<Info>,
@@ -87,6 +89,13 @@ export function extractCFG<Info=ParentInformation>(
 	return simplifyControlFlowInformation(foldAst(ast.ast, graph ? dataflowCfgFolds(graph) : cfgFolds), simplifications);
 }
 
+/**
+ * Simplified version of {@link extractCFG} that is much quicker, but much simpler!
+ */
+export function extractSimpleCfg<Info=ParentInformation>(ast: NormalizedAst<Info>) {
+	return foldAst(ast.ast, cfgFolds);
+}
+
 function cfgLeaf(type: CfgVertexType.Expression | CfgVertexType.Statement): (leaf: RNodeWithParent) => ControlFlowInformation {
 	return (leaf: RNodeWithParent) => {
 		const graph = new ControlFlowGraph();
@@ -318,9 +327,10 @@ function cfgFunctionCall(call: RFunctionCall<ParentInformation>, name: ControlFl
 			continue;
 		}
 		graph.merge(arg.graph);
-		info.breaks.push(...arg.breaks);
-		info.nexts.push(...arg.nexts);
-		info.returns.push(...arg.returns);
+		info.breaks = info.breaks.concat(arg.breaks);
+		info.nexts = info.nexts.concat(arg.nexts);
+		info.returns = info.returns.concat(arg.returns);
+
 		for(const entry of arg.entryPoints) {
 			for(const exit of lastArgExits) {
 				graph.addEdge(entry, exit, { label: CfgEdgeType.Fd });
@@ -389,9 +399,10 @@ function cfgArgumentOrParameter(node: RNodeWithParent, name: ControlFlowInformat
 
 	if(name) {
 		graph.merge(name.graph);
-		info.breaks.push(...name.breaks);
-		info.nexts.push(...name.nexts);
-		info.returns.push(...name.returns);
+		info.breaks = info.breaks.concat(name.breaks);
+		info.nexts = info.nexts.concat(name.nexts);
+		info.returns = info.returns.concat(name.returns);
+
 		for(const entry of name.entryPoints) {
 			graph.addEdge(entry, node.info.id, { label: CfgEdgeType.Fd });
 		}
@@ -406,9 +417,10 @@ function cfgArgumentOrParameter(node: RNodeWithParent, name: ControlFlowInformat
 
 	if(value) {
 		graph.merge(value.graph);
-		info.breaks.push(...value.breaks);
-		info.nexts.push(...value.nexts);
-		info.returns.push(...value.returns);
+		info.breaks = info.breaks.concat(value.breaks);
+		info.nexts = info.nexts.concat(value.nexts);
+		info.returns = info.returns.concat(value.returns);
+
 		for(const exitPoint of currentExitPoint) {
 			for(const entry of value.entryPoints) {
 				graph.addEdge(entry, exitPoint, { label: CfgEdgeType.Fd });
@@ -476,9 +488,9 @@ function cfgAccess(access: RAccess<ParentInformation>, name: ControlFlowInformat
 			}
 		}
 		result.exitPoints = accessor.exitPoints;
-		result.breaks.push(...accessor.breaks);
-		result.nexts.push(...accessor.nexts);
-		result.returns.push(...accessor.returns);
+		result.breaks = result.breaks.concat(accessor.breaks);
+		result.nexts = result.nexts.concat(accessor.nexts);
+		result.returns = result.returns.concat(accessor.returns);
 	}
 	for(const exitPoint of result.exitPoints) {
 		graph.addEdge(access.info.id + '-exit', exitPoint, { label: CfgEdgeType.Fd });
@@ -518,9 +530,9 @@ function cfgExprList(node: RExpressionList<ParentInformation>, _grouping: unknow
 			}
 		}
 		result.graph.merge(expression.graph);
-		result.breaks.push(...expression.breaks);
-		result.nexts.push(...expression.nexts);
-		result.returns.push(...expression.returns);
+		result.breaks = result.breaks.concat(expression.breaks);
+		result.nexts = result.nexts.concat(expression.nexts);
+		result.returns = result.returns.concat(expression.returns);
 		result.exitPoints = expression.exitPoints;
 	}
 

src/control-flow/simple-visitor.ts

@@ -22,7 +22,7 @@ export function visitCfgInReverseOrder(
 	visitor: (node: NodeId) => boolean | void
 ): void {
 	const visited = new Set<NodeId>();
-	const queue = [...startNodes];
+	let queue = [...startNodes];
 	while(queue.length > 0) {
 		const current = queue.pop() as NodeId;
 		if(visited.has(current)) {
@@ -34,7 +34,7 @@ export function visitCfgInReverseOrder(
 		}
 		const get = graph.getVertex(current);
 		if(get?.type === CfgVertexType.Block) {
-			queue.push(...get.elems.toReversed().map(e => e.id));
+			queue = queue.concat(get.elems.toReversed().map(e => e.id));
 		}
 		const incoming = graph.outgoing(current) ?? [];
 		for(const [from] of incoming) {
@@ -60,7 +60,7 @@ export function visitCfgInOrder(
 	visitor: (node: NodeId) => boolean | void
 ): void {
 	const visited = new Set<NodeId>();
-	const queue = [...startNodes];
+	let queue = [...startNodes];
 	while(queue.length > 0) {
 		const current = queue.shift() as NodeId;
 		if(visited.has(current)) {
@@ -72,7 +72,7 @@ export function visitCfgInOrder(
 		}
 		const get = graph.getVertex(current);
 		if(get?.type === CfgVertexType.Block) {
-			queue.push(...get.elems.map(e => e.id));
+			queue = queue.concat(get.elems.map(e => e.id));
 		}
 		const outgoing = graph.ingoing(current) ?? [];
 		for(const [to] of outgoing) {

src/dataflow/environments/resolve-by-name.ts

@@ -120,7 +120,7 @@ const AliasHandler = {
 } as const satisfies Record<VertexType, AliasHandler>;
 
 function getUseAlias(sourceId: NodeId, dataflow: DataflowGraph, environment: REnvironmentInformation): NodeId[] | undefined {
-	const definitions: NodeId[] = [];
+	let definitions: NodeId[] = [];
 
 	// Source is Symbol -> resolve definitions of symbol
 	const identifier = recoverName(sourceId, dataflow.idMap);
@@ -140,7 +140,7 @@ function getUseAlias(sourceId: NodeId, dataflow: DataflowGraph, environment: REn
 			if(def.value === undefined) {
 				return undefined;
 			}
-			definitions.push(...def.value);
+			definitions = definitions.concat(def.value);
 		} else if(def.type === ReferenceType.Constant || def.type === ReferenceType.BuiltInConstant) {
 			definitions.push(def.nodeId);
 		} else {

src/dataflow/extractor.ts

@@ -17,7 +17,7 @@ import type { RParseRequest, RParseRequests } from '../r-bridge/retriever';
 import { initializeCleanEnvironments } from './environments/environment';
 import { standaloneSourceFile } from './internal/process/functions/call/built-in/built-in-source';
 import type { DataflowGraph } from './graph/graph';
-import { extractCFG } from '../control-flow/extract-cfg';
+import { extractSimpleCfg } from '../control-flow/extract-cfg';
 import { EdgeType } from './graph/edge';
 import {
 	identifyLinkToLastCallRelation
@@ -73,7 +73,7 @@ function resolveLinkToSideEffects(ast: NormalizedAst, graph: DataflowGraph) {
 		if(typeof s !== 'object') {
 			continue;
 		}
-		cfg ??= extractCFG(ast).graph;
+		cfg ??= extractSimpleCfg(ast).graph;
 		/* this has to change whenever we add a new link to relations because we currently offer no abstraction for the type */
 		const potentials = identifyLinkToLastCallRelation(s.id, cfg, graph, s.linkTo);
 		for(const pot of potentials) {

src/dataflow/graph/graph.ts

@@ -381,7 +381,7 @@ export class DataflowGraph<
 			}
 		}
 
-		this.sourced.push(...otherGraph.sourced);
+		this._sourced = this._sourced.concat(otherGraph.sourced);
 
 		for(const unknown of otherGraph.unknownSideEffects) {
 			this._unknownSideEffects.add(unknown);

src/dataflow/internal/linker.ts

@@ -22,7 +22,6 @@ import { VertexType } from '../graph/vertex';
 import { resolveByName } from '../environments/resolve-by-name';
 import type { BuiltIn } from '../environments/built-in';
 import { isBuiltIn } from '../environments/built-in';
-import { slicerLogger } from '../../slicing/static/static-slicer';
 import type { REnvironmentInformation } from '../environments/environment';
 import { findByPrefixIfUnique } from '../../util/prefix';
 
@@ -298,7 +297,6 @@ export function getAllLinkedFunctionDefinitions(
 
 		const currentInfo = dataflowGraph.get(currentId, true);
 		if(currentInfo === undefined) {
-			slicerLogger.trace('skipping unknown link');
 			continue;
 		}
 		visited.add(currentId);
@@ -308,7 +306,7 @@ export function getAllLinkedFunctionDefinitions(
 		const returnEdges = outgoingEdges.filter(([_, e]) => edgeIncludesType(e.types, EdgeType.Returns));
 		if(returnEdges.length > 0) {
 			// only traverse return edges and do not follow `calls` etc. as this indicates that we have a function call which returns a result, and not the function calls itself
-			potential.push(...returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
+			potential = potential.concat(...returnEdges.map(([target]) => target).filter(id => !visited.has(id)));
 			continue;
 		}
 

src/dataflow/internal/process/functions/call/built-in/built-in-expression-list.ts

@@ -127,7 +127,7 @@ export function processExpressionList<OtherInfo>(
 	const remainingRead = new Map<string, IdentifierReference[]>();
 
 	const nextGraph = new DataflowGraph(data.completeAst.idMap);
-	const out = [];
+	let out: IdentifierReference[] = [];
 	const exitPoints: ExitPoint[] = [];
 
 	let expressionCounter = 0;
@@ -157,7 +157,7 @@ export function processExpressionList<OtherInfo>(
 
 		addNonDefaultExitPoints(exitPoints, processed.exitPoints);
 
-		out.push(...processed.out);
+		out = out.concat(processed.out);
 
 		expensiveTrace(dataflowLogger, () => `expression ${expressionCounter} of ${expressions.length} has ${processed.unknownReferences.length} unknown nodes`);
 

src/dataflow/internal/process/functions/call/built-in/built-in-quote.ts

@@ -20,16 +20,16 @@ export function processQuote<OtherInfo>(
 	const startEnv = data.environment;
 	const { information, processedArguments, fnRef } = processKnownFunctionCall({ name, args, rootId, data, forceArgs: config.forceArgs, origin: 'builtin:quote' });
 
-	const inRefs: IdentifierReference[] = [fnRef];
-	const outRefs: IdentifierReference[] = [];
-	const unknownRefs: IdentifierReference[] = [];
+	let inRefs: IdentifierReference[] = [fnRef];
+	let outRefs: IdentifierReference[] = [];
+	let unknownRefs: IdentifierReference[] = [];
 
 	for(let i = 0; i < args.length; i++) {
 		const processedArg = processedArguments[i];
 		if(processedArg && i !== config?.quoteArgumentsWithIndex) {
-			inRefs.push(...processedArg.in);
-			outRefs.push(...processedArg.out);
-			unknownRefs.push(...processedArg.unknownReferences);
+			inRefs = inRefs.concat(processedArg.in);
+			outRefs = outRefs.concat(processedArg.out);
+			unknownRefs = unknownRefs.concat(processedArg.unknownReferences);
 		} else if(processedArg) {
 			information.graph.addEdge(rootId, processedArg.entryPoint, EdgeType.NonStandardEvaluation);
 			/* nse actually affects _everything_ within that argument! */

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

@@ -31,7 +31,7 @@ export function processVector<OtherInfo>(
 		return fnCall.information;
 	}
 
-	const vectorArgs: ContainerIndex[] = [];
+	let vectorArgs: ContainerIndex[] = [];
 	let argIndex = 1;
 	for(const arg of args) {
 		// Skip invalid argument types
@@ -61,7 +61,7 @@ export function processVector<OtherInfo>(
 						nodeId:     index.nodeId,
 					};
 				}) ?? [];
-			vectorArgs.push(...flattenedIndices);
+			vectorArgs = vectorArgs.concat(flattenedIndices);
 		}
 	}
 

src/dataflow/internal/process/functions/call/unnamed-call-handling.ts

@@ -52,14 +52,15 @@ export function processUnnamedFunctionCall<OtherInfo>(functionCall: RUnnamedFunc
 		origin:      ['unnamed']
 	});
 
-	const inIds = remainingReadInArgs;
+	let inIds = remainingReadInArgs;
 	inIds.push({ nodeId: functionRootId, name: functionCallName, controlDependencies: data.controlDependencies, type: ReferenceType.Function });
 
 	if(functionCall.calledFunction.type === RType.FunctionDefinition) {
 		linkArgumentsOnCall(callArgs, functionCall.calledFunction.parameters, finalGraph);
 	}
 	// push the called function to the ids:
-	inIds.push(...calledFunction.in, ...calledFunction.unknownReferences);
+
+	inIds = inIds.concat(calledFunction.in, calledFunction.unknownReferences);
 
 	return {
 		unknownReferences: [],

src/queries/catalog/call-context-query/call-context-query-executor.ts

@@ -104,7 +104,7 @@ function retrieveAllCallAliases(nodeId: NodeId, graph: DataflowGraph): Map<strin
 
 	const visited = new Set<NodeId>();
 	/* we store the current call name */
-	const queue: (readonly [string, NodeId])[] = [[recoverContent(nodeId, graph) ?? '', nodeId]];
+	let queue: (readonly [string, NodeId])[] = [[recoverContent(nodeId, graph) ?? '', nodeId]];
 
 	while(queue.length > 0) {
 		const [str, id] = queue.shift() as [string, NodeId];
@@ -132,7 +132,7 @@ function retrieveAllCallAliases(nodeId: NodeId, graph: DataflowGraph): Map<strin
 				.filter(([,{ types }]) => edgeIncludesType(types, EdgeType.Reads | EdgeType.DefinedBy | EdgeType.DefinedByOnCall))
 				.map(([t]) => [recoverContent(t, graph) ?? '', t] as const);
 			/** only follow defined-by and reads */
-			queue.push(...x);
+			queue = queue.concat(x);
 			continue;
 		}
 

src/queries/catalog/call-context-query/identify-link-to-last-call-relation.ts

@@ -127,16 +127,17 @@ export function identifyLinkToLastCallRelation(
 		if(node === from) {
 			return;
 		}
-		const vertex = graph.get(node);
+		const vertex = graph.get(node, true);
 		if(vertex === undefined || vertex[0].tag !== VertexType.FunctionCall) {
 			return;
 		}
-		if(callName.test(vertex[0].name)) {
-			const act = cascadeIf ? cascadeIf(vertex[0], from, graph) : CascadeAction.Stop;
+		const [fst] = vertex;
+		if(callName.test(fst.name)) {
+			const act = cascadeIf ? cascadeIf(fst, from, graph) : CascadeAction.Stop;
 			if(act === CascadeAction.Skip) {
 				return;
 			}
-			const tar = satisfiesCallTargets(vertex[0].id, graph, CallTargets.MustIncludeGlobal);
+			const tar = satisfiesCallTargets(fst.id, graph, CallTargets.MustIncludeGlobal);
 			if(tar === 'no') {
 				return act === CascadeAction.Stop;
 			}

src/queries/catalog/dependencies-query/dependencies-query-executor.ts

@@ -334,9 +334,9 @@ function getArgumentValue(
 }
 
 function getFunctionsToCheck(customFunctions: readonly FunctionInfo[] | undefined, ignoreDefaultFunctions: boolean, defaultFunctions: readonly FunctionInfo[]): FunctionInfo[] {
-	const functions: FunctionInfo[] = ignoreDefaultFunctions ? [] : [...defaultFunctions];
+	let functions: FunctionInfo[] = ignoreDefaultFunctions ? [] : [...defaultFunctions];
 	if(customFunctions) {
-		functions.push(...customFunctions);
+		functions = functions.concat(customFunctions);
 	}
 	return functions;
 }