Abstract interpretation staging

src/abstract-interpretation/domain.ts

@@ -1,4 +1,5 @@
 import { assertUnreachable, guard } from '../util/assert'
+import type { Identifier } from '../dataflow/environments/identifier'
 
 interface IntervalBound {
 	readonly value:     number,
@@ -8,25 +9,76 @@ interface IntervalBound {
 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`)
+	}
+
+	static top(): Interval {
+		return new Interval(
+			{ value: Number.NEGATIVE_INFINITY, inclusive: false },
+			{ value: Number.POSITIVE_INFINITY, inclusive: false }
+		)
 	}
 
 	toString(): string {
+		if(this.isBottom()) {
+			return '∅'
+		}
+		if(this.isSingleton()) {
+			return this.min.value.toString()
+		}
 		return `${this.min.inclusive ? '[' : '('}${this.min.value}, ${this.max.value}${this.max.inclusive ? ']' : ')'}`
 	}
+
+	equals(other: Interval): boolean {
+		return this.min.value === other.min.value && this.min.inclusive === other.min.inclusive &&
+			this.max.value === other.max.value && this.max.inclusive === other.max.inclusive
+
+	}
+
+	/** An interval is considered empty if it's of the form [T, T) or (T, T] */
+	isBottom(): boolean {
+		return this.min.value === this.max.value && !(this.min.inclusive && this.max.inclusive)
+	}
+
+	/** An interval is considered singleton if it's of the form [T, T] */
+	isSingleton(): boolean {
+		return this.min.value === this.max.value && this.min.inclusive && this.max.inclusive
+	}
+
+	/** An interval is considered top if it's of the form (-∞, ∞) */
+	isTop(): boolean {
+		return this.min.value === Number.NEGATIVE_INFINITY && this.max.value === Number.POSITIVE_INFINITY
+	}
+
+	toJSON(): object {
+		return {
+			__type: 'Interval',
+			min:    this.min,
+			max:    this.max
+		}
+	}
+
+	static revive(data: object): Interval {
+		// @ts-expect-error I'm too lazy to define the proper type for the JSON object
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+		return new Interval(data.min, data.max)
+	}
 }
 
 export class Domain {
 	private readonly _intervals: Set<Interval>
 
 	private constructor(intervals: Interval[] = []) {
-		this._intervals = new Set(unifyOverlappingIntervals(intervals))
+		this._intervals = new Set(unifyOverlappingIntervals(intervals).filter(interval => !interval.isBottom()))
 	}
 
 	static bottom(): Domain {
 		return new Domain()
 	}
 
+	static top(): Domain {
+		return new Domain([Interval.top()])
+	}
+
 	static fromIntervals(intervals: Interval[] | Set<Interval>): Domain {
 		return new Domain(Array.from(intervals))
 	}
@@ -38,26 +90,79 @@ export class Domain {
 		)])
 	}
 
+	static truthy(): Domain {
+		return Domain.fromScalar(1)
+	}
+
+	static falsy(): Domain {
+		return this.bottom()
+	}
+
+	isBottom(): boolean {
+		return this.intervals.size === 0
+	}
+
+	// FIXME: better notion of true/false in a domain
+	isTop(): boolean {
+		return this.intervals.size === 1 && Array.from(this.intervals)[0].isTop()
+	}
+
+	isTruthy(): boolean {
+		return !this.isBottom()
+	}
+
+	isFalsy(): boolean {
+		return this.isBottom()
+	}
+
 	get intervals(): Set<Interval> {
 		return this._intervals
 	}
 
-	private set intervals(intervals: Interval[]) {
-		this._intervals.clear()
-		for(const interval of intervals) {
-			this._intervals.add(interval)
+	toString(): string {
+		if(this.isBottom()) {
+			return '⊥'
+		} else if(this.isTop()) {
+			return '⊤'
+		} else {
+			return `{${Array.from(this.intervals).join(', ')}}`
 		}
 	}
 
-	addInterval(interval: Interval): void {
-		this.intervals = unifyOverlappingIntervals([...this.intervals, interval])
+	equals(other: Domain): boolean {
+		if(this.isBottom()) {
+			return other.isBottom()
+		}
+		if(this.isTop()) {
+			return other.isTop()
+		}
+		return this.intervals.size === other.intervals.size &&
+			Array.from(this.intervals).every(interval => Array.from(other.intervals).some(otherInterval => interval.equals(otherInterval)))
 	}
 
-	toString(): string {
-		return `{${Array.from(this.intervals).join(', ')}}`
+	toJSON(): object {
+		return {
+			__type:    'Domain',
+			intervals: Array.from(this.intervals)
+		}
+	}
+
+	static revive(data: object): Domain {
+		// @ts-expect-error I'm too lazy to define the proper type for the JSON object
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+		return Domain.fromIntervals(data.intervals)
 	}
 }
 
+export interface Narrowing {
+	readonly positive: Omit<AiInfo, 'narrowings'>,
+	readonly negative: Omit<AiInfo, 'narrowings'>
+}
+
+export class AiInfo {
+	constructor(readonly id: Identifier, public domain: Domain, readonly narrowings: Narrowing[] = []) { }
+}
+
 const enum CompareType {
 	/** If qual, the bound that's inclusive is the smaller one */
 	Min,
@@ -90,23 +195,40 @@ function compareIntervalsByTheirMaximum(interval1: Interval, interval2: Interval
 	return compareIntervals(CompareType.Max, interval1.max, interval2.max)
 }
 
-export function doIntervalsOverlap(interval1: Interval, interval2: Interval): boolean {
+export const enum OverlapKind {
+	Overlap = 0,
+	Touch = 1,
+}
+
+export function doIntervalsOverlap(interval1: Interval, interval2: Interval, kind: OverlapKind = OverlapKind.Overlap): boolean {
 	const diff1 = compareIntervals(CompareType.IgnoreInclusivity, interval1.max, interval2.min)
 	const diff2 = compareIntervals(CompareType.IgnoreInclusivity, interval2.max, interval1.min)
 
+	let doIntervalsOverlap = true
+	let doIntervalsTouch = true
+
 	// 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
+		doIntervalsOverlap = false
+		doIntervalsTouch = false
+	// If their bounds have the same value, they overlap if both are inclusive
+	// and touch if only one is inclusive
+	} else if(diff1 === 0) {
+		doIntervalsOverlap = interval1.max.inclusive && interval2.min.inclusive
+		doIntervalsTouch = interval1.max.inclusive !== interval2.min.inclusive
+	} else if(diff2 === 0) {
+		doIntervalsOverlap = interval2.max.inclusive && interval1.min.inclusive
+		doIntervalsTouch = interval2.max.inclusive !== interval1.min.inclusive
 	}
 
-	return true
+	switch(kind) {
+		case OverlapKind.Overlap:
+			return doIntervalsOverlap
+		case OverlapKind.Touch:
+			return doIntervalsTouch
+		default:
+			return doIntervalsOverlap && doIntervalsTouch
+	}
 }
 
 export function unifyDomains(domains: Domain[]): Domain {
@@ -123,7 +245,7 @@ export function unifyOverlappingIntervals(intervals: Interval[]): Interval[] {
 	const unifiedIntervals: Interval[] = []
 	let currentInterval = sortedIntervals[0]
 	for(const nextInterval of sortedIntervals) {
-		if(doIntervalsOverlap(currentInterval, nextInterval)) {
+		if(doIntervalsOverlap(currentInterval, nextInterval, OverlapKind.Touch | OverlapKind.Overlap)) {
 			const intervalWithEarlierStart = compareIntervalsByTheirMinimum(currentInterval, nextInterval) < 0 ? currentInterval : nextInterval
 			const intervalWithLaterEnd = compareIntervalsByTheirMaximum(currentInterval, nextInterval) > 0 ? currentInterval : nextInterval
 			currentInterval = new Interval(intervalWithEarlierStart.min, intervalWithLaterEnd.max)
@@ -166,4 +288,87 @@ export function subtractDomains(domain1: Domain, domain2: Domain): Domain {
 		}
 	}
 	return Domain.fromIntervals(intervals)
+}
+
+export const enum NarrowKind {
+	Equal = 1,
+	Smaller = 2,
+	Greater = 4
+}
+
+interface IntervalOverlap {
+	smaller:      Interval | undefined,
+	intersection: Interval | undefined,
+	larger:       Interval | undefined
+}
+
+function flipInclusiveness(intervalBound: IntervalBound): IntervalBound {
+	return { value: intervalBound.value, inclusive: !intervalBound.inclusive }
+}
+
+export function overlapIntervals(interval1: Interval, interval2: Interval): IntervalOverlap {
+	const diffMin = compareIntervalsByTheirMinimum(interval1, interval2)
+	const diffMax = compareIntervalsByTheirMaximum(interval1, interval2)
+
+	if(!doIntervalsOverlap(interval1, interval2)) {
+		if(diffMin < 0) {
+			return { smaller: interval1, intersection: undefined, larger: undefined }
+		} else if(diffMin > 0) {
+			return { smaller: undefined, intersection: undefined, larger: interval1 }
+		} else {
+			guard(false, 'Their lower bounds cannot be the same as they do not overlap') 
+		}
+	}
+
+	const intersectionStart = diffMin > 0 ? interval1.min : interval2.min
+	const intersectionEnd = diffMax < 0 ? interval1.max : interval2.max
+	const intersection = new Interval(intersectionStart, intersectionEnd)
+
+	const smallerOverhang = diffMin < 0 ? new Interval(interval1.min, flipInclusiveness(intersectionStart)) : undefined
+	const greaterOverhang = diffMax > 0 ? new Interval(flipInclusiveness(intersectionEnd), interval1.max) : undefined
+
+	return {
+		smaller:      smallerOverhang,
+		intersection: intersection,
+		larger:       greaterOverhang
+	}
+}
+
+export function narrowDomain(baseDomain: Domain, boundDomain: Domain, narrowKind: NarrowKind): Domain {
+	const isSmaller = (narrowKind & NarrowKind.Smaller) !== 0
+	const isGreater = (narrowKind & NarrowKind.Greater) !== 0
+	const isEqual = (narrowKind & NarrowKind.Equal) !== 0
+
+	guard(!(isGreater && isSmaller), 'Greater and Smaller cannot be combined')
+
+	let getNarrowedIntervals: (overlap: IntervalOverlap, bound: Interval) => (Interval | undefined)[]
+	if(isGreater) {
+		getNarrowedIntervals = ({ intersection, larger }, bound) => {
+			if(!isEqual && intersection !== undefined && compareIntervalsByTheirMinimum(intersection, bound) === 0) {
+				intersection = new Interval({ value: intersection.min.value, inclusive: false }, intersection.max)
+			}
+			return [intersection, larger]
+		}
+	} else if(isSmaller) {
+		getNarrowedIntervals = ({ smaller, intersection }, bound) => {
+			if(!isEqual && intersection !== undefined && compareIntervalsByTheirMaximum(intersection, bound) === 0) {
+				intersection = new Interval(intersection.min, { value: intersection.max.value, inclusive: false })
+			}
+			return [intersection, smaller]
+		}
+	} else {
+		guard(false, 'Either isGreater or isSmaller must be set')
+	}
+
+	const narrowedIntervals: (Interval | undefined)[] = []
+	for(const baseInterval of baseDomain.intervals) {
+		for(const boundInterval of boundDomain.intervals) {
+			const overlap = overlapIntervals(baseInterval, boundInterval)
+			console.log(`Prompt:  ${baseInterval.toString()} ${isSmaller ? '<' : ''}${isGreater ? '>' : ''}${isEqual ? '=' : ''} ${boundInterval.toString()}`)
+			console.log(`Overlap: ${(overlap.smaller ?? 'none').toString()} ${(overlap.intersection ?? 'none').toString()} ${(overlap.larger ?? 'none').toString()}`)
+			narrowedIntervals.push(...getNarrowedIntervals(overlap, boundInterval))
+		}
+	}
+
+	return Domain.fromIntervals(narrowedIntervals.filter(interval => interval !== undefined).map(interval => interval as Interval))
 }