Basic Structure for the Abstract Interpretation

src/abstract-interpretation/processor.ts

@@ -0,0 +1,196 @@
+import {DataflowInformation} from '../dataflow/internal/info'
+import {NodeId, NormalizedAst, ParentInformation, RAssignmentOp, RBinaryOp, RType} from '../r-bridge'
+import {CfgVertexType, extractCFG} from '../util/cfg/cfg'
+import {visitCfg} from '../util/cfg/visitor'
+import {guard} from '../util/assert'
+import {DataflowGraphVertexInfo, EdgeType, OutgoingEdges} from '../dataflow'
+
+const constraintMap = new Map<NodeId, Constraints>()
+
+class Stack<ElementType> {
+	private backingStore: ElementType[] = []
+
+	size(): number { return this.backingStore.length }
+	peek(): ElementType | undefined { return this.backingStore[this.size() - 1] }
+	pop(): ElementType | undefined { return this.backingStore.pop() }
+	push(item: ElementType): ElementType {
+		this.backingStore.push(item)
+		return item
+	}
+}
+
+interface IHandler<ValueType> {
+	name:  string,
+	enter: () => void
+	exit:  () => ValueType
+	next:  (value: ValueType) => void
+}
+
+interface Interval {
+	min:          number,
+	max:          number,
+	minInclusive: boolean,
+	maxInclusive: boolean
+}
+
+type Domain = Set<Interval>
+
+interface Constraints {
+	node:     NodeId,
+	domain:   Domain,
+	debugMsg: string
+}
+
+function compareIntervals(interval1: Interval, interval2: Interval): number {
+	const diff = interval1.min - interval2.min
+	if(diff !== 0) {
+		return diff
+	}
+	return Number(!interval1.minInclusive) - Number(!interval2.minInclusive)
+}
+
+function unifyDomains(domains: Domain[]): Domain {
+	const allIntervals = new Array<Interval>()
+	domains.forEach(domain => allIntervals.push(...domain))
+	allIntervals.sort(compareIntervals)
+	if(!allIntervals.length) {
+		return new Set<Interval>()
+	}
+
+	const resultingDomain = new Set<Interval>()
+	let currentInterval = allIntervals[0]
+	allIntervals.forEach(interval => {
+		if(interval.min < currentInterval.max) {
+			if(interval.max > currentInterval.max) {
+				currentInterval.max = interval.max
+				currentInterval.maxInclusive = interval.maxInclusive
+			}
+		} else {
+			resultingDomain.add(currentInterval)
+			currentInterval = interval
+		}
+	})
+	resultingDomain.add(currentInterval)
+	return resultingDomain
+}
+
+function intervalFromNumber(n: number): Domain {
+	return new Set([{min: n, minInclusive: true, max: n, maxInclusive: true}])
+}
+
+function getIntervalsOfDfgChild(node: NodeId, dfg: DataflowInformation): Domain {
+	const dfgNode: [DataflowGraphVertexInfo, OutgoingEdges] | undefined = dfg.graph.get(node)
+	guard(dfgNode !== undefined, `No DFG-Node found with ID ${node}`)
+	const [_, children] = dfgNode
+	const ids = Array.from(children.entries())
+		.filter(([_, edge]) => edge.types.has(EdgeType.Reads))
+		.map(([id, _]) => id)
+	const domains = new Array<Domain>()
+	for(const id of ids) {
+		const constraint = constraintMap.get(id)
+		guard(constraint !== undefined, `No constraint found for ID ${id}`)
+		domains.push(constraint.domain)
+	}
+	return unifyDomains(domains)
+}
+
+class Assignment implements IHandler<Constraints> {
+	private lhs:           NodeId | undefined
+	private rhs:           NodeId | undefined
+	private readonly node: RAssignmentOp<ParentInformation>
+	name = 'Assignment'
+
+	constructor(node: RAssignmentOp<ParentInformation>) {
+		this.node = node
+	}
+
+	enter(): void {
+		console.log(`Entered ${this.name} ${this.node.info.id}`)
+	}
+
+	exit(): Constraints {
+		console.log(`Exited ${this.name} ${this.node.info.id}`)
+		return {
+			node:     this.lhs as NodeId,
+			domain:   new Set(), // TODO: check interval of the assignments source
+			debugMsg: this.name
+		}
+	}
+
+	next(constraint: Constraints): void {
+		if(this.lhs === undefined) {
+			this.lhs = constraint.node
+		} else if(this.rhs === undefined){
+			this.rhs = constraint.node
+		}
+		console.log(`${this.name} received ${constraint.debugMsg}`)
+	}
+}
+
+class BinOp implements IHandler<Constraints> {
+	private readonly node: RBinaryOp<ParentInformation>
+
+	constructor(node: RBinaryOp<ParentInformation>) {
+		this.node = node
+	}
+
+	name = 'Bin Op'
+
+	enter(): void {
+		console.log(`Entered ${this.name}`)
+	}
+
+	exit(): Constraints {
+		console.log(`Exited ${this.name}`)
+		return {
+			node:     this.node.info.id,
+			domain:   new Set(), // TODO: Check the operands constraints and see how the operation affects those
+			debugMsg: this.name
+		}
+	}
+
+	next(value: Constraints): void {
+		console.log(`${this.name} received ${value.debugMsg}`)
+	}
+}
+
+export function runAbstractInterpretation(ast: NormalizedAst, dfg: DataflowInformation): DataflowInformation {
+	const cfg = extractCFG(ast)
+	const operationStack = new Stack<IHandler<Constraints>>()
+	visitCfg(cfg, (node, _) => {
+		const astNode = ast.idMap.get(node.id)
+		// TODO: avoid if-else
+		if(astNode?.type === RType.BinaryOp) {
+			switch(astNode.flavor) {
+				case 'assignment': operationStack.push(new Assignment(astNode as RAssignmentOp<ParentInformation>)).enter(); break
+				case 'arithmetic': operationStack.push(new BinOp(astNode)).enter(); break
+				default: guard(false, `Unknown binary op ${astNode.flavor}`)
+			}
+		} else if(astNode?.type === RType.Symbol) {
+			operationStack.peek()?.next({
+				node:     astNode.info.id,
+				domain:   getIntervalsOfDfgChild(node.id, dfg),
+				debugMsg: 'Symbol'
+			})
+		} else if(astNode?.type === RType.Number){
+			const num = astNode.content.num
+			operationStack.peek()?.next({
+				node:     astNode.info.id,
+				domain:   intervalFromNumber(num),
+				debugMsg: 'Number'
+			})
+		} else if(node.type === CfgVertexType.EndMarker) {
+			const operation = operationStack.pop()
+			if(operation === undefined) {
+				return
+			}
+			const operationResult = operation.exit()
+			guard(!constraintMap.has(operationResult.node), `No constraint for the given ID ${operationResult.node}`)
+			constraintMap.set(operationResult.node, operationResult)
+			operationStack.peek()?.next(operationResult)
+		} else {
+			guard(false, `Unknown node type ${node.type}`)
+		}
+	})
+	return dfg
+}

src/benchmark/slicer.ts

@@ -82,6 +82,7 @@ export class BenchmarkSlicer {
 	private loadedXml:      string | undefined
 	private tokenMap:       Record<string, string> | undefined
 	private dataflow:       DataflowInformation | undefined
+	private ai:             DataflowInformation | undefined
 	private normalizedAst:  NormalizedAst | undefined
 	private totalStopwatch: IStoppableStopwatch
 	private finished = false
@@ -133,6 +134,7 @@ export class BenchmarkSlicer {
 		this.loadedXml = await this.measureCommonStep('parse', 'retrieve AST from R code')
 		this.normalizedAst = await this.measureCommonStep('normalize', 'normalize R AST')
 		this.dataflow = await this.measureCommonStep('dataflow', 'produce dataflow information')
+		this.ai = await this.measureCommonStep('ai', 'run abstract interpretation')
 
 		this.stepper.switchToSliceStage()
 

src/benchmark/stats/stats.ts

@@ -2,7 +2,7 @@ import { SingleSlicingCriterion, SlicingCriteria } from '../../slicing'
 import { NodeId, RParseRequestFromFile, RParseRequestFromText } from '../../r-bridge'
 import { ReconstructionResult } from '../../slicing'
 
-export const CommonSlicerMeasurements = ['initialize R session', 'inject home path', 'ensure installation of xmlparsedata', 'retrieve token map', 'retrieve AST from R code', 'normalize R AST', 'produce dataflow information', 'close R session', 'total'] as const
+export const CommonSlicerMeasurements = ['initialize R session', 'inject home path', 'ensure installation of xmlparsedata', 'retrieve token map', 'retrieve AST from R code', 'normalize R AST', 'produce dataflow information', 'run abstract interpretation', 'close R session', 'total'] as const
 export type CommonSlicerMeasurements = typeof CommonSlicerMeasurements[number]
 
 export const PerSliceMeasurements = ['static slicing', 'reconstruct code', 'total'] as const

src/cli/repl/commands/cfg.ts

@@ -1,7 +1,7 @@
 import { ReplCommand } from './main'
 import { SteppingSlicer } from '../../../core'
 import { requestFromInput, RShell } from '../../../r-bridge'
-import { extractCFG } from '../../../util/cfg'
+import { extractCFG } from '../../../util/cfg/cfg'
 import { cfgToMermaid, cfgToMermaidUrl } from '../../../util/mermaid'
 
 async function controlflow(shell: RShell, remainingLine: string) {

src/cli/repl/server/connection.ts

@@ -20,12 +20,12 @@ import {
 } from './messages/repl'
 import { replProcessAnswer } from '../core'
 import { ansiFormatter, voidFormatter } from '../../../statistics'
-import { cfg2quads, ControlFlowInformation, extractCFG } from '../../../util/cfg'
-import { defaultQuadIdGenerator, QuadSerializationConfiguration } from '../../../util/quads'
 import { deepMergeObject } from '../../../util/objects'
 import { LogLevel } from '../../../util/log'
+import { cfg2quads, ControlFlowInformation, extractCFG } from '../../../util/cfg/cfg'
 import { StepOutputFormat } from '../../../core/print/print'
 import { DataflowInformation } from '../../../dataflow/internal/info'
+import { defaultQuadIdGenerator, QuadSerializationConfiguration } from '../../../util/quads'
 
 /**
  * Each connection handles a single client, answering to its requests.
@@ -137,6 +137,7 @@ export class FlowRServerConnection {
 					parse:     await printStepResult('parse', results.parse as string, StepOutputFormat.RdfQuads, config(), parseConfig),
 					normalize: await printStepResult('normalize', results.normalize as NormalizedAst, StepOutputFormat.RdfQuads, config()),
 					dataflow:  await printStepResult('dataflow', results.dataflow as DataflowInformation, StepOutputFormat.RdfQuads, config()),
+					ai:        ''
 				}
 			})
 		} else {

src/cli/repl/server/messages/analysis.ts

@@ -1,7 +1,7 @@
 import { IdMessageBase, MessageDefinition } from './messages'
 import { LAST_PER_FILE_STEP, StepResults } from '../../../../core'
 import Joi from 'joi'
-import { ControlFlowInformation } from '../../../../util/cfg'
+import { ControlFlowInformation } from '../../../../util/cfg/cfg'
 
 /**
  * Send by the client to request an analysis of a given file.

src/cli/statistics-helper-app.ts

@@ -7,14 +7,14 @@ import {
 import { log } from '../util/log'
 import { processCommandLineArgs } from './common'
 import { jsonReplacer } from '../util/json'
-import { extractCFG } from '../util/cfg'
-import { create } from 'tar'
 import fs from 'fs'
 import { guard } from '../util/assert'
 import { retrieveArchiveName } from './common/features'
 import { printStepResult } from '../core'
 import { StepOutputFormat } from '../core/print/print'
 import { date2string } from '../util/time'
+import { create } from 'tar'
+import { extractCFG } from '../util/cfg/cfg'
 
 // apps should never depend on other apps when forking (otherwise, they are "run" on load :/)
 

src/core/input.ts

@@ -29,7 +29,7 @@ interface BaseSteppingSlicerInput<InterestedIn extends StepName | undefined> ext
 	autoSelectIf?:   AutoSelectPredicate
 }
 
-interface NormalizeSteppingSlicerInput<InterestedIn extends 'dataflow' | 'normalize'> extends BaseSteppingSlicerInput<InterestedIn> {
+interface NormalizeSteppingSlicerInput<InterestedIn extends 'ai' | 'dataflow' | 'normalize'> extends BaseSteppingSlicerInput<InterestedIn> {
 	stepOfInterest: InterestedIn
 }
 

src/core/output.ts

@@ -14,7 +14,7 @@ type StepResultsHelper<InterestedIn extends StepName> = {
 	'parse':       Out<'parse'>
 	'normalize':   StepResultsHelper<'parse'> & Out<'normalize'>
 	'dataflow':    StepResultsHelper<'normalize'> & Out<'dataflow'>
-	'slice':       StepResultsHelper<'dataflow'> & Out<'slice'>
+	'ai':          StepResultsHelper<'dataflow'> & Out<'ai'>
+	'slice':       StepResultsHelper<'ai'> & Out<'slice'>
 	'reconstruct': StepResultsHelper<'slice'> & Out<'reconstruct'>
 }[InterestedIn]
-

src/core/slicer.ts

@@ -209,11 +209,15 @@ export class SteppingSlicer<InterestedIn extends StepName | undefined = typeof L
 				result = executeSingleSubStep(step, this.results.normalize as NormalizedAst)
 				break
 			case 3:
+				step = guardStep('ai')
+				result = executeSingleSubStep(step, this.results.normalize as NormalizedAst, this.results.dataflow as DataflowInformation)
+				break
+			case 4:
 				guard(this.criterion !== undefined, 'Cannot decode criteria without a criterion')
 				step = guardStep('slice')
-				result = executeSingleSubStep(step, (this.results.dataflow as DataflowInformation).graph, this.results.normalize as NormalizedAst, this.criterion)
+				result = executeSingleSubStep(step, (this.results.ai as DataflowInformation).graph, this.results.normalize as NormalizedAst, this.criterion)
 				break
-			case 4:
+			case 5:
 				step = guardStep('reconstruct')
 				result = executeSingleSubStep(step, this.results.normalize as NormalizedAst<NoInfo>, (this.results.slice as SliceResult).result)
 				break

src/core/steps.ts

@@ -28,13 +28,14 @@ import {
 	printNormalizedAstToMermaidUrl
 } from './print/normalize-printer'
 import { guard } from '../util/assert'
+import { parseToQuads } from './print/parse-printer'
 import {
 	dataflowGraphToJson,
 	dataflowGraphToMermaid,
 	dataflowGraphToMermaidUrl,
 	dataflowGraphToQuads
 } from './print/dataflow-printer'
-import { parseToQuads } from './print/parse-printer'
+import { runAbstractInterpretation } from '../abstract-interpretation/processor'
 
 /**
  * This represents close a function that we know completely nothing about.
@@ -102,7 +103,15 @@ export const STEPS_PER_FILE = {
 			[StepOutputFormat.Mermaid]:    dataflowGraphToMermaid,
 			[StepOutputFormat.MermaidUrl]: dataflowGraphToMermaidUrl
 		}
-	} satisfies IStep<typeof produceDataFlowGraph>
+	} satisfies IStep<typeof produceDataFlowGraph>,
+	'ai': {
+		description: 'Run abstract interpretation',
+		processor:   runAbstractInterpretation,
+		required:    'once-per-file',
+		printer:     {
+			[StepOutputFormat.Internal]: internalPrinter
+		}
+	} satisfies IStep<typeof runAbstractInterpretation>
 } as const
 
 export const STEPS_PER_SLICE = {
@@ -125,7 +134,7 @@ export const STEPS_PER_SLICE = {
 } as const
 
 export const STEPS = { ...STEPS_PER_FILE, ...STEPS_PER_SLICE } as const
-export const LAST_PER_FILE_STEP = 'dataflow' as const
+export const LAST_PER_FILE_STEP = 'ai' as const
 export const LAST_STEP = 'reconstruct' as const
 
 export type StepName = keyof typeof STEPS