Basic Structure for the Abstract Interpretation

src/abstract-interpretation/domain.ts

@@ -0,0 +1,169 @@
+import {assertUnreachable, guard} from '../util/assert'
+
+interface IntervalBound {
+	readonly value:     number,
+	readonly inclusive: boolean
+}
+
+export class Interval {
+	constructor(readonly min: IntervalBound, readonly max: IntervalBound) {
+		guard(min.value <= max.value, () => `The interval ${this.toString()} has a minimum that is greater than its maximum`)
+		guard(min.value !== max.value || (min.inclusive === max.inclusive), `The bound ${min.value} cannot be in- and exclusive at the same time`)
+	}
+
+	toString(): string {
+		return `${this.min.inclusive ? '[' : '('}${this.min.value}, ${this.max.value}${this.max.inclusive ? ']' : ')'}`
+	}
+}
+
+export class Domain {
+	private readonly _intervals: Set<Interval>
+
+	private constructor(intervals: Interval[] = []) {
+		this._intervals = new Set(unifyOverlappingIntervals(intervals))
+	}
+
+	static bottom(): Domain {
+		return new Domain()
+	}
+
+	static fromIntervals(intervals: Interval[] | Set<Interval>): Domain {
+		return new Domain(Array.from(intervals))
+	}
+
+	static fromScalar(n: number): Domain {
+		return new Domain([new Interval(
+			{value: n, inclusive: true},
+			{value: n, inclusive: true}
+		)])
+	}
+
+	get intervals(): Set<Interval> {
+		return this._intervals
+	}
+
+	private set intervals(intervals: Interval[]) {
+		this._intervals.clear()
+		for(const interval of intervals) {
+			this._intervals.add(interval)
+		}
+	}
+
+	addInterval(interval: Interval): void {
+		this.intervals = unifyOverlappingIntervals([...this.intervals, interval])
+	}
+
+	toString(): string {
+		return `{${Array.from(this.intervals).join(', ')}}`
+	}
+}
+
+const enum CompareType {
+	/** If qual, the bound that's inclusive is the smaller one */
+	Min,
+	/** If equal, the bound that's inclusive is the greater one */
+	Max,
+	/** Equality is only based on the "raw" values */
+	IgnoreInclusivity
+}
+
+function compareIntervals(compareType: CompareType, interval1: IntervalBound, interval2: IntervalBound): number {
+	const diff = interval1.value - interval2.value
+	if(diff !== 0 || compareType === CompareType.IgnoreInclusivity) {
+		return diff
+	}
+	switch(compareType) {
+		case CompareType.Min:
+			return Number(!interval1.inclusive) - Number(!interval2.inclusive)
+		case CompareType.Max:
+			return Number(interval1.inclusive) - Number(interval2.inclusive)
+		default:
+			assertUnreachable(compareType)
+	}
+}
+
+function compareIntervalsByTheirMinimum(interval1: Interval, interval2: Interval): number {
+	return compareIntervals(CompareType.Min, interval1.min, interval2.min)
+}
+
+function compareIntervalsByTheirMaximum(interval1: Interval, interval2: Interval): number {
+	return compareIntervals(CompareType.Max, interval1.max, interval2.max)
+}
+
+export function doIntervalsOverlap(interval1: Interval, interval2: Interval): boolean {
+	const diff1 = compareIntervals(CompareType.IgnoreInclusivity, interval1.max, interval2.min)
+	const diff2 = compareIntervals(CompareType.IgnoreInclusivity, interval2.max, interval1.min)
+
+	// If one interval ends before the other starts, they don't overlap
+	if(diff1 < 0 || diff2 < 0) {
+		return false
+	}
+	// If their end and start are equal, they only overlap if both are inclusive
+	if(diff1 === 0) {
+		return interval1.max.inclusive && interval2.min.inclusive
+	}
+	if(diff2 === 0) {
+		return interval2.max.inclusive && interval1.min.inclusive
+	}
+
+	return true
+}
+
+export function unifyDomains(domains: Domain[]): Domain {
+	const unifiedIntervals = unifyOverlappingIntervals(domains.flatMap(domain => Array.from(domain.intervals)))
+	return Domain.fromIntervals(unifiedIntervals)
+}
+
+export function unifyOverlappingIntervals(intervals: Interval[]): Interval[] {
+	if(intervals.length === 0) {
+		return []
+	}
+	const sortedIntervals = intervals.sort(compareIntervalsByTheirMinimum)
+
+	const unifiedIntervals: Interval[] = []
+	let currentInterval = sortedIntervals[0]
+	for(const nextInterval of sortedIntervals) {
+		if(doIntervalsOverlap(currentInterval, nextInterval)) {
+			const intervalWithEarlierStart = compareIntervalsByTheirMinimum(currentInterval, nextInterval) < 0 ? currentInterval : nextInterval
+			const intervalWithLaterEnd = compareIntervalsByTheirMaximum(currentInterval, nextInterval) > 0 ? currentInterval : nextInterval
+			currentInterval = new Interval(intervalWithEarlierStart.min, intervalWithLaterEnd.max)
+		} else {
+			unifiedIntervals.push(currentInterval)
+			currentInterval = nextInterval
+		}
+	}
+	unifiedIntervals.push(currentInterval)
+	return unifiedIntervals
+}
+
+export function addDomains(domain1: Domain, domain2: Domain): Domain {
+	const intervals = new Set<Interval>()
+	for(const interval1 of domain1.intervals) {
+		for(const interval2 of domain2.intervals) {
+			intervals.add(new Interval({
+				value:     interval1.min.value + interval2.min.value,
+				inclusive: interval1.min.inclusive && interval2.min.inclusive
+			}, {
+				value:     interval1.max.value + interval2.max.value,
+				inclusive: interval1.max.inclusive && interval2.max.inclusive
+			}))
+		}
+	}
+	return Domain.fromIntervals(intervals)
+}
+
+export function subtractDomains(domain1: Domain, domain2: Domain): Domain {
+	const intervals = new Set<Interval>()
+	for(const interval1 of domain1.intervals) {
+		for(const interval2 of domain2.intervals) {
+			intervals.add(new Interval({
+				value:     interval1.min.value - interval2.max.value,
+				inclusive: interval1.min.inclusive && interval2.max.inclusive
+			}, {
+				value:     interval1.max.value - interval2.min.value,
+				inclusive: interval1.max.inclusive && interval2.min.inclusive
+			}))
+		}
+	}
+	return Domain.fromIntervals(intervals)
+}

src/abstract-interpretation/handler/binop/binop.ts

@@ -0,0 +1,42 @@
+import {Handler} from '../handler'
+import {aiLogger, AINode} from '../../processor'
+import {BinaryOperatorFlavor, ParentInformation, RBinaryOp} from '../../../r-bridge'
+import {guard} from '../../../util/assert'
+import {operators} from './operators'
+
+export type BinOpOperators = {
+	[key in BinaryOperatorFlavor]: (lhs: AINode, rhs: AINode, node: RBinaryOp<ParentInformation>) => AINode
+}
+
+export class BinOp implements Handler<AINode> {
+	lhs: AINode | undefined
+	rhs: AINode | undefined
+
+	constructor(readonly node: RBinaryOp<ParentInformation>) {}
+
+	getName(): string {
+		return `Bin Op (${this.node.flavor})`
+	}
+
+	enter(): void {
+		aiLogger.trace(`Entered ${this.getName()}`)
+	}
+
+	exit(): AINode {
+		aiLogger.trace(`Exited ${this.getName()}`)
+		guard(this.lhs !== undefined, `No LHS found for assignment ${this.node.info.id}`)
+		guard(this.rhs !== undefined, `No RHS found for assignment ${this.node.info.id}`)
+		return operators[this.node.flavor](this.lhs, this.rhs, this.node)
+	}
+
+	next(node: AINode): void {
+		aiLogger.trace(`${this.getName()} received`)
+		if(this.lhs === undefined) {
+			this.lhs = node
+		} else if(this.rhs === undefined) {
+			this.rhs = node
+		} else {
+			guard(false, `BinOp ${this.node.info.id} already has both LHS and RHS`)
+		}
+	}
+}

src/abstract-interpretation/handler/binop/operators.ts

@@ -0,0 +1,40 @@
+import {guard} from '../../../util/assert'
+import {BinOpOperators} from './binop'
+import {addDomains, subtractDomains} from '../../domain'
+
+export const operators: BinOpOperators = {
+	'assignment': (lhs, rhs, node) => {
+		return {
+			id:      lhs.id,
+			domain:  rhs.domain,
+			astNode: node.lhs,
+		}
+	},
+	'arithmetic': (lhs, rhs, node) => {
+		switch(node.operator) {
+			case '+':
+				return {
+					id:      lhs.id,
+					domain:  addDomains(lhs.domain, rhs.domain),
+					astNode: node,
+				}
+			case '-':
+				return {
+					id:      lhs.id,
+					domain:  subtractDomains(lhs.domain, rhs.domain),
+					astNode: node,
+				}
+			default:
+				guard(false, `Unknown binary operator ${node.operator}`)
+		}
+	},
+	'logical': () => {
+		guard(false, 'Not implemented yet')
+	},
+	'model formula': () => {
+		guard(false, 'Not implemented yet')
+	},
+	'comparison': () => {
+		guard(false, 'Not implemented yet')
+	},
+}

src/abstract-interpretation/handler/handler.ts

@@ -0,0 +1,6 @@
+export interface Handler<ValueType> {
+	getName: () => string,
+	enter:   () => void
+	exit:    () => ValueType
+	next:    (value: ValueType) => void
+}

src/abstract-interpretation/processor.ts

@@ -0,0 +1,83 @@
+import {DataflowInformation} from '../dataflow/internal/info'
+import {NodeId, NormalizedAst, ParentInformation, RNodeWithParent, 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'
+import {Handler} from './handler/handler'
+import {BinOp} from './handler/binop/binop'
+import {Domain, unifyDomains} from './domain'
+import {log} from '../util/log'
+
+export const aiLogger = log.getSubLogger({name: 'abstract-interpretation'})
+
+export interface AINode {
+	readonly id:      NodeId
+	readonly domain:  Domain
+	readonly astNode: RNodeWithParent<ParentInformation>
+}
+
+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
+	}
+}
+
+function getDomainOfDfgChild(node: NodeId, dfg: DataflowInformation, nodeMap: Map<NodeId, AINode>): 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: Domain[] = []
+	for(const id of ids) {
+		const domain = nodeMap.get(id)?.domain
+		guard(domain !== undefined, `No domain found for ID ${id}`)
+		domains.push(domain)
+	}
+	return unifyDomains(domains)
+}
+
+export function runAbstractInterpretation(ast: NormalizedAst, dfg: DataflowInformation): DataflowInformation {
+	const cfg = extractCFG(ast)
+	const operationStack = new Stack<Handler<AINode>>()
+	const nodeMap = new Map<NodeId, AINode>()
+	visitCfg(cfg, (node, _) => {
+		const astNode = ast.idMap.get(node.id)
+		if(astNode?.type === RType.BinaryOp) {
+			operationStack.push(new BinOp(astNode)).enter()
+		} else if(astNode?.type === RType.Symbol) {
+			operationStack.peek()?.next({
+				id:      astNode.info.id,
+				domain:  getDomainOfDfgChild(node.id, dfg, nodeMap),
+				astNode: astNode,
+			})
+		} else if(astNode?.type === RType.Number){
+			const num = astNode.content.num
+			operationStack.peek()?.next({
+				id:      astNode.info.id,
+				domain:  Domain.fromScalar(num),
+				astNode: astNode,
+			})
+		} else if(node.type === CfgVertexType.EndMarker) {
+			const operation = operationStack.pop()
+			if(operation === undefined) {
+				return
+			}
+			const operationResult = operation.exit()
+			guard(!nodeMap.has(operationResult.id), `Domain for ID ${operationResult.id} already exists`)
+			nodeMap.set(operationResult.id, operationResult)
+			operationStack.peek()?.next(operationResult)
+		} else {
+			aiLogger.warn(`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) {