From 73d94b677fcd82481bd4789a8161eb9d83a606f0 Mon Sep 17 00:00:00 2001 From: Ajani Bilby Date: Fri, 24 May 2024 12:42:07 +1000 Subject: [PATCH] Lift rework (#9) --- source/bnf/syntax.bnf | 4 +- source/bnf/syntax.d.ts | 10 +- source/bnf/syntax.js | 6 +- source/compiler/codegen/allocation/stack.ts | 545 ++++++++++-------- source/compiler/codegen/context.ts | 20 +- .../compiler/codegen/expression/constant.ts | 4 +- .../codegen/expression/flow-control.ts | 179 ++++++ source/compiler/codegen/expression/helper.ts | 11 +- source/compiler/codegen/expression/infix.ts | 2 +- source/compiler/codegen/expression/operand.ts | 57 +- .../codegen/expression/postfix/call.ts | 4 +- source/compiler/codegen/expression/type.ts | 76 ++- source/compiler/codegen/scope.ts | 5 +- source/compiler/codegen/variable.ts | 3 +- source/compiler/function.ts | 2 +- source/compiler/package.ts | 8 +- source/helper.ts | 22 +- source/parser.ts | 114 ++-- tests/source/codegen/allocation/stack.test.ts | 69 ++- .../syntaxes/salient.tmLanguage.json | 14 + 20 files changed, 742 insertions(+), 413 deletions(-) create mode 100644 source/compiler/codegen/expression/flow-control.ts diff --git a/source/bnf/syntax.bnf b/source/bnf/syntax.bnf index d5d9301..805fecd 100644 --- a/source/bnf/syntax.bnf +++ b/source/bnf/syntax.bnf @@ -92,13 +92,13 @@ function ::= func_head %w* ( block | ";" ) %w* ; func_arg ::= ...name %( w* ":" w* ) access ; block ::= %( "{" w* ) block_stmt* %( w* "}" w* ) ; - block_stmt ::= assign | declare | return | raise | statement ; + block_stmt ::= assign | declare | return | lift | statement ; func_call ::= access func_call_body; func_call_body ::= %( w* "(" w* ) ( expr %w* ( %( "," w* ) expr %w* )* )? %( ")" w* ) ; return ::= %"return" "_tail"? ( %w+ expr)? %( w* ";" w* ); -raise ::= %"raise" %w+ expr %( ";" w* ); # TODO rename to lift +lift ::= %"lift" %w+ expr %( ";" w* ); # drop ::= %"drop" %w+ expr %( ";" w* ); diff --git a/source/bnf/syntax.d.ts b/source/bnf/syntax.d.ts index 607ef61..fcd1306 100644 --- a/source/bnf/syntax.d.ts +++ b/source/bnf/syntax.d.ts @@ -917,7 +917,7 @@ export type Term_Block_stmt = { count: number, ref: _Shared.ReferenceRange, value: [ - (Term_Assign | Term_Declare | Term_Return | Term_Raise | Term_Statement) + (Term_Assign | Term_Declare | Term_Return | Term_Lift | Term_Statement) ] } export declare function Parse_Block_stmt (i: string, refMapping?: boolean): _Shared.ParseError | { @@ -1008,8 +1008,8 @@ export declare function Parse_Return (i: string, refMapping?: boolean): _Shared. isPartial: boolean } -export type Term_Raise = { - type: 'raise', +export type Term_Lift = { + type: 'lift', start: number, end: number, count: number, @@ -1018,8 +1018,8 @@ export type Term_Raise = { Term_Expr ] } -export declare function Parse_Raise (i: string, refMapping?: boolean): _Shared.ParseError | { - root: _Shared.SyntaxNode & Term_Raise, +export declare function Parse_Lift (i: string, refMapping?: boolean): _Shared.ParseError | { + root: _Shared.SyntaxNode & Term_Lift, reachBytes: number, reach: null | _Shared.Reference, isPartial: boolean diff --git a/source/bnf/syntax.js b/source/bnf/syntax.js index 5962671..17066fc 100644 --- a/source/bnf/syntax.js +++ b/source/bnf/syntax.js @@ -1,5 +1,5 @@ import * as _Shared from "./shared.js"; -let _rawWasm = _Shared.DecodeBase64("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"); +let _rawWasm = _Shared.DecodeBase64("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"); let _ctx = null; if (typeof window === 'undefined') { _ctx = new WebAssembly.Instance( @@ -174,8 +174,8 @@ export function Parse_Func_call_body (data, refMapping = true) { export function Parse_Return (data, refMapping = true) { return _Shared.Parse(_ctx, data, refMapping, "return"); } -export function Parse_Raise (data, refMapping = true) { - return _Shared.Parse(_ctx, data, refMapping, "raise"); +export function Parse_Lift (data, refMapping = true) { + return _Shared.Parse(_ctx, data, refMapping, "lift"); } export function Parse_Expr (data, refMapping = true) { return _Shared.Parse(_ctx, data, refMapping, "expr"); diff --git a/source/compiler/codegen/allocation/stack.ts b/source/compiler/codegen/allocation/stack.ts index 0ecc4c8..b170868 100644 --- a/source/compiler/codegen/allocation/stack.ts +++ b/source/compiler/codegen/allocation/stack.ts @@ -1,16 +1,7 @@ import { AlignUpInteger, AlignDownInteger } from "~/compiler/helper.ts"; import { AssertUnreachable, LatentValue } from "~/helper.ts"; -/** - * Used for calculating the relative stack location of variables within a function stack - * - * Before branching behaviour a stack.checkpoint must be formed - * After a branch ends you checkpoint.rewind - * Then once all branches have been resolved you checkpoint.restore - * - * This will boil up any stack values which are originally spawned in a branch, but then continue existing into the parent's stack - * This will error if any non primary branch has remaining allocations on rewind which have not been aliased to an allocation in the primary stack - */ +const DEBUG = true; class Region { head: number; @@ -20,40 +11,66 @@ class Region { this.head = start; this.tail = end; } + + clone() { + return new Region(this.head, this.tail); + } } enum StackEventType { allocation, free }; class StackEvent { - type: StackEventType; - entity: StackAllocation | StackCheckpoint; - ignore: boolean; + type: StackEventType; + alloc: StackAllocation; + + constructor(type: StackEventType, ref: StackAllocation) { + this.type = type; + this.alloc = ref; + } +} + +class StackBranch { + paths: StackScope[]; - constructor(born: StackEventType, entity: StackAllocation | StackCheckpoint) { - this.type = born; - this.entity = entity; - this.ignore = false; + constructor (paths: StackBranch['paths']) { + this.paths = paths; } } -class StackCheckpoint { - private owner: StackAllocator; - readonly previous?: StackCheckpoint; +class StackScope { + private parent: StackScope | null; + private ctx: StackAllocator; - private timeline: StackEvent[]; + private timeline: Array; + + // only used when DEBUG === true + // used to check for: + // - allocation when allocated before + // - use after free + // - free after free private local: StackAllocation[]; - private firstRewind: boolean; - constructor(owner: StackAllocator, prev?: StackCheckpoint) { - this.owner = owner; - this.previous = prev; - this.firstRewind = true; + constructor(ctx: StackScope['ctx'], parent: StackScope['parent']) { + this.ctx = ctx; + this.parent = parent; + this.timeline = []; this.local = []; } - allocate(size: number, align: number) { + isParentAllocated(alloc: StackAllocation): boolean { + if (!this.parent) return false; + + for (const a of this.local) { + if (alloc === a) return true; + } + + return this.parent.isParentAllocated(alloc); + } + + allocate(size: number, align = 1) { const alloc = new StackAllocation(this, size, align); + this.timeline.push(new StackEvent(StackEventType.allocation, alloc)); this.local.push(alloc); @@ -61,71 +78,46 @@ class StackCheckpoint { } free(alloc: StackAllocation) { - const index = this.local.findIndex(l => l === alloc); - this.timeline.push(new StackEvent(StackEventType.free, alloc)); - if (index === -1) console.warn(`Warn: Attempting to free${alloc?.tag ? ` tag[${alloc?.tag}]` : ""} non-local allocation`); - else this.local.splice(index, 1); - } - - private bind(alloc: StackAllocation) { - this.timeline.push(new StackEvent(StackEventType.allocation, alloc)); - this.local.push(alloc); - alloc._move(this); + if (!DEBUG) return; + const index = this.local.findIndex(x => x === alloc); + if (index === -1) { + if (this.isParentAllocated(alloc)) console.error(new Error(`Attempting to free a parent's allocation (tag:${alloc.tag})`)); + else console.error(new Error(`Attempting to free a non-allocated allocation (tag:${alloc.tag})`)); + } else { + this.local.splice(index, 1); + } } - hasAllocations() { - return this.local.length > 0; - } + checkpoint () { + const child = new StackScope(this.ctx, this); - getAllocationCount() { - return this.local.length; - } + this.timeline.push(child); + this.ctx.scope(child); - getAllocations() { - return this.local.map(x => x.tag || ".unknown"); + return child; } - rewind() { - if (!this.previous) throw new Error("Cannot rewind root StackCheckpoint"); - - if (this.firstRewind) { - for (const alloc of this.local) { - if (alloc.isAlias()) continue; - - this.previous.bind(alloc); - - // Ignore the allocation of this in the timeline - // As it's been pushed up - for (let i=this.timeline.length-1; 0 <= i; i--) { - if (this.timeline[i].entity === alloc) { - this.timeline[i].ignore = true; - break; - } - } - } - this.local.length = 0; - } else { - for (const alloc of this.local) { - if (!alloc.isAlias()) throw new Error("Branching allocations not resolved by prior aliasing"); - } - this.local.length = 0; + restore() { + // Free items in reverse to make splicing more efficient + for (let i=this.local.length-1; 0<=i; i--) { + const remain = this.local[i]; + this.free(remain); } + + if (this.parent) this.ctx.scope(this.parent);; } - restore() { - if (this.local.length !== 0) throw new Error("Must run rewind before restore"); + branch (n: number) { + if (n < 2) throw new Error(`Cannot branch ${n} times`); - // Merge up timelines - if (this.previous) { - for (const evt of this.timeline) { - if (evt.ignore) continue; - this.previous.timeline.push(evt); - } + const paths = new Array(); + for (let i=0; i; // Final size of the stack + private entry: StackScope; + private current: StackScope; - constructor() { - this.checkpointRef = new StackCheckpoint(this); - this.latentSize = new LatentValue(); + readonly latentSize: LatentValue; + + constructor () { + this.entry = new StackScope(this, null); + this.current = this.entry; + this.latentSize = new LatentValue(); } allocate(size: number, align = 1) { - if (!this.checkpointRef) throw new Error(`StackAllocator state error`); - return this.checkpointRef.allocate(size, align); + return this.current.allocate(size, align); + } + + free(alloc: StackAllocation) { + this.current.free(alloc); } checkpoint() { - this.checkpointRef = new StackCheckpoint(this, this.checkpointRef); - return this.checkpointRef; + return this.current.checkpoint(); } - restore(checkpoint: StackCheckpoint) { - if (this.checkpointRef != checkpoint) throw new Error(`In correct stack checkpoint restore order`); - if (!checkpoint.previous) throw new Error(`Cannot restore from a root checkpoint`); - this.checkpointRef = checkpoint.previous; + branch(n: number) { + return this.current.branch(n); } - getSize() { - this.resolve(); - return this.latentSize.get(); + scope(ctx: StackScope) { + this.current = ctx; } - getLatentSize() { - return this.latentSize; + resolve() { + // Ensure all allocs are freed + this.entry.restore(); + + const mem = new MemoryTable(); + ResolveStack(mem, this.entry); + + this.latentSize.resolve(mem.size); } +} + +export class StackAllocation { + readonly ctx: StackScope; - getAllocationCount() { - return this.checkpointRef.getAllocationCount(); + private latent: LatentValue; + private accessed: boolean; + private alias?: StackAllocation; + + align: number; + size: number; + + // for debug purposes + tag?: string; + + constructor(ctx: StackAllocation['ctx'], size: number, align: number = 1) { + this.ctx = ctx; + this.latent = new LatentValue(); + + this.accessed = false; // was this allocation ever actually used? + this.align = align; + this.size = size; } - resolve() { - if (this.checkpointRef.hasAllocations()) console.warn( - `Stack leak: ${this.checkpointRef.getAllocationCount()} stack values are still allocated after stack frame end ` - + this.checkpointRef.getAllocations() - ); - - const table: Region[] = []; - let offset = 0; - let size = 0; - - function allocate(alloc: StackAllocation): void { - // Already allocated, likely due to stack promotion - if (alloc.inUse) throw new Error("Double allocation on stack allocation"); - if (alloc.isAlias()) return; - - alloc.inUse = true; - - // short circuit - if (alloc.size == 0) return alloc.getOffset().resolve(offset); - - // Look for the first available region - for (let i=0; i chunkSize) continue; - - let start, end: number; - let placed = false; - if (paddingFront <= paddingBack) { - start = head; - end = start + alloc.size - - if (paddingFront == 0) { - region.head += alloc.size; - placed = true; - } - } else { - end = tail; - start = end - alloc.size; - - if (paddingBack == 0) { - region.tail -= alloc.size; - placed = true; - } - } + wasAccessed() { + if (this.alias) return false; + return this.accessed; + } + + isAlias() { + return !!this.alias; + } + + moveTo(other: StackAllocation) { + if (this.alias) throw new Error("Stack allocation already moved"); + + if (other.size < this.size) throw new Error(`Cannot move stack allocation size:${this.size} to size:${other.size}`); + + this.alias = other; + + // remap for any getOffset already performed + this.latent.resolveTo(other.latent); + + if (this.accessed) other.accessed = true; + } + + getOffset(): LatentValue { + if (this.alias) return this.alias.getOffset(); + + this.accessed = true; + return this.latent; + } + + free(): void { + this.ctx.free(this); + } +} - if (!placed) { - table.splice(i+1, 0, new Region(end, region.tail)); - region.tail = start; - } - alloc.getOffset().resolve(start); - return; - } - // Extend the stack to fit the new allocation - const head = AlignUpInteger(offset, alloc.align); - const padding = head-offset; - if (padding > 0) table.push(new Region(offset, head)); - alloc.getOffset().resolve(head); - offset += alloc.size + padding; - size = Math.max(size, offset); +class MemoryTable { + // only used when DEBUG === true + // check if any allocations were made, but not freed + active : number; // number of allocations + + table : Array; // denote the empty region in the stack + offset : number; // the current length of the stack (i.e. offset to the end) + size : number; // the maximum amount offset grew to + + constructor () { + this.table = [ new Region(0,0) ]; + this.active = 0; + this.offset = 0; + this.size = 0; + } + + // Extend the memory table to it matches the domain of the argument + fit(ref: MemoryTable) { + if (ref.size <= this.size) return; // no-op + + const last = this.table[this.table.length-1]; + if (last.tail === this.size) { // extend last region + last.tail = ref.size; + } else { // add new tail region + this.table.push(new Region(this.size, ref.size)); } - function free(alloc: StackAllocation): void { - if (!alloc.inUse) { - console.warn("Warn: Double free on stack allocation"); - return - } - if (alloc.isAlias()) return; + this.size = ref.size; + } - alloc.inUse = false; - if (alloc.size == 0) return; + clone () { + const out = new MemoryTable(); + out.table = this.table.map(r => r.clone()); + out.offset = this.offset; + out.size = this.size; + out.active = 0; - const head = alloc.getOffset().get(); - const tail = head + alloc.size; + return out; + } +} - if (table.length === 0) { - table.push(new Region(head, tail)); - return; +function ResolveStack(mem: MemoryTable, scope: StackScope): void { + for (const evt of scope.events()) { + if (evt instanceof StackEvent) { + // Ignore never accessed allocations + if (!evt.alloc.wasAccessed()) continue; + + switch (evt.type) { + case StackEventType.allocation: { + const offset = Allocate(mem, evt.alloc.size, evt.alloc.align); + evt.alloc.getOffset().resolve(offset); + break; + } + case StackEventType.free: { + Free(mem, evt.alloc); + break; + } + default: throw "how can TS not assert if this is unreachable?"; } - let chunkI = table.findIndex(chunk => chunk.head >= head); - if (chunkI == -1) chunkI = table.length-1; - - const prev = table[chunkI]; - const next = table[chunkI+1]; - let found = false; - if (prev.tail === head) { - prev.tail = tail; - found = true; - return; + continue; + } else if (evt instanceof StackBranch) { + for (const path of evt.paths) { + const child = mem.clone(); + ResolveStack(child, path); + mem.fit(child); } + } else if (evt instanceof StackScope) { + const child = mem.clone(); + ResolveStack(child, evt); + mem.fit(child); + } + } - if (next && tail === next.head) { - next.head = head; - found = true; + if (DEBUG && mem.active !== 0) console.warn(`Warn: Stack leak detected, ${mem.active} allocations not freed`); +} + +function Allocate(mem: MemoryTable, size: number, align: number): number { + mem.active++; + + // Double allocation aren't possible because user-facing `allocate` always makes a new object + + // short circuit + if (size == 0) return 0; + + // Look for the first available region + for (let i=0; i chunkSize) continue; + + let start, end: number; + let placed = false; + if (paddingFront <= paddingBack) { + start = head; + end = start + size + + if (paddingFront == 0) { + region.head += size; + placed = true; } + } else { + end = tail; + start = end - size; - if (found) { // attempt defrag - if (next && prev.tail == next.head) { - prev.tail = next.tail; - table.splice(chunkI+1, 1); - } - } else { // make new frag - table.splice(chunkI+1, 0, new Region(head, tail)); + if (paddingBack == 0) { + region.tail -= size; + placed = true; } } - for (const event of this.checkpointRef.events()) { - if (!(event.entity instanceof StackAllocation)) continue; - switch (event.type) { - case StackEventType.allocation: allocate(event.entity); break; - case StackEventType.free: free(event.entity); break; - default: AssertUnreachable(event.type); - } + if (!placed) { + mem.table.splice(i+1, 0, new Region(end, region.tail)); + region.tail = start; } - this.latentSize.resolve(size); + return start; } + + // Add padding to the end of the stack if necessary + const head = AlignUpInteger(mem.offset, align); + const padding = head-mem.offset; + if (padding > 0) mem.table.push(new Region(mem.offset, head)); + + // Extend the stack to fit the new allocation + mem.offset += size + padding; + mem.size = Math.max(mem.size, mem.offset); + + return head; } -export class StackAllocation { - private alias?: StackAllocation; - private owner: StackCheckpoint; - private latent: LatentValue; - readonly align: number; - readonly size: number; - inUse: boolean; +function Free(mem: MemoryTable, alloc: StackAllocation): void { + mem.active--; - // for debug purposes - tag?: string; + // Double free checks already ran in StackScope.free - constructor(owner: StackCheckpoint, size: number, align: number = 1) { - this.latent = new LatentValue(); - this.owner = owner; - this.inUse = true; - this.alias = undefined; - this.align = align; - this.size = size; - } + // short circuit + if (alloc.size == 0) return; - isAlias() { - return !!this.alias; - } + const head = alloc.getOffset().get(); + const tail = head + alloc.size; - getOffset() { - return this.alias - ? this.alias.latent - : this.latent; + if (mem.table.length === 0) { + mem.table.push(new Region(head, tail)); + return; } - _move(to: StackCheckpoint) { - this.owner = to; - } - free(): void { - if (this.alias) throw new Error("Cannot free an aliased allocation, please free the primary"); + let chunkI = mem.table.findIndex(chunk => chunk.head >= head); + if (chunkI == -1) chunkI = mem.table.length-1; - this.inUse = false; - this.owner.free(this); + const prev = mem.table[chunkI]; + const next = mem.table[chunkI+1]; + if (prev.tail === head) { + prev.tail = tail; + return; } - makeAlias(of: StackAllocation) { - // Get to the root - while (of.alias) of = of.alias; - this.alias = of; + if (next && tail === next.head) { + next.head = head; - if (this.alias.size != this.size) throw new Error("Cannot alias a stack allocation of a different size"); - this.inUse = false; + // attempt defrag + if (next && prev.tail == next.head) { + prev.tail = next.tail; + mem.table.splice(chunkI+1, 1); + } + + return; } + + mem.table.splice(chunkI+1, 0, new Region(head, tail)); } \ No newline at end of file diff --git a/source/compiler/codegen/context.ts b/source/compiler/codegen/context.ts index 745e009..95346bd 100644 --- a/source/compiler/codegen/context.ts +++ b/source/compiler/codegen/context.ts @@ -23,6 +23,8 @@ export class Context { file: File; function: Function; scope: Scope; + + exited: boolean; done: boolean; raiseType: OperandType; @@ -36,6 +38,7 @@ export class Context { this.block = block; this.file = file; + this.exited = false; this.done = false; } @@ -48,7 +51,7 @@ export class Context { case "assign": CompileAssign (this, line); break; case "statement": CompileStatement (this, line); break; case "return": CompileReturn (this, line); break; - case "raise": CompileRaise (this, line); break; + case "lift": CompileLift (this, line); break; default: AssertUnreachable(line); } @@ -76,7 +79,7 @@ export class Context { } cleanup() { - if (this.done) return; + if (this.exited) return; this.scope.cleanup(); } } @@ -206,14 +209,6 @@ function CompileAssign(ctx: Context, syntax: Syntax.Term_Assign) { } } - if (target.type instanceof IntrinsicValue) { - switch (target.base.locality) { - case BasePointerType.global: ctx.block.push(Instruction.global.get(target.base.ref)); break; - case BasePointerType.local: ctx.block.push(Instruction.local.get(target.base.ref)); break; - default: AssertUnreachable(target.base.locality); - } - } - const expr = CompileExpr(ctx, value, target.getBaseType()); Assign(ctx, target, expr, syntax.ref); } @@ -325,6 +320,7 @@ function CompileReturn(ctx: Context, syntax: Syntax.Term_Return): typeof never { ctx.scope.cleanup(true); ctx.block.push(Instruction.return()); + ctx.exited = true; ctx.done = true; return ctx.function.returns; } @@ -357,6 +353,7 @@ function CompileReturn(ctx: Context, syntax: Syntax.Term_Return): typeof never { ctx.scope.cleanup(true); ctx.block.push(Instruction.return()); + ctx.exited = true; ctx.done = true; return never; } @@ -383,12 +380,13 @@ function CompileReturn(ctx: Context, syntax: Syntax.Term_Return): typeof never { ctx.scope.cleanup(true); ctx.block.push(Instruction.return()); + ctx.exited = true; ctx.done = true; return never; } -function CompileRaise(ctx: Context, syntax: Syntax.Term_Raise) { +function CompileLift(ctx: Context, syntax: Syntax.Term_Lift) { ctx.raiseType = CompileExpr(ctx, syntax.value[0]); ctx.scope.cleanup(); ctx.done = true; diff --git a/source/compiler/codegen/expression/constant.ts b/source/compiler/codegen/expression/constant.ts index 3fc5e36..12d538b 100644 --- a/source/compiler/codegen/expression/constant.ts +++ b/source/compiler/codegen/expression/constant.ts @@ -186,7 +186,7 @@ function CompilePlainString(ctx: Context, syntax: Syntax.Term_String_plain) { return i32.value; } -function CompileTemplateString(ctx: Context, syntax: Syntax.Term_String_template) { +function CompileTemplateString(ctx: Context, syntax: Syntax.Term_String_template): never { throw new Error("Unimplemented template string compilation"); - return i32.value; + // return i32.value; } \ No newline at end of file diff --git a/source/compiler/codegen/expression/flow-control.ts b/source/compiler/codegen/expression/flow-control.ts new file mode 100644 index 0000000..9769baf --- /dev/null +++ b/source/compiler/codegen/expression/flow-control.ts @@ -0,0 +1,179 @@ +import * as colors from "https://deno.land/std@0.201.0/fmt/colors.ts"; + +import type * as Syntax from "~/bnf/syntax.d.ts"; +import { LinearType, SolidType, OperandType } from "~/compiler/codegen/expression/type.ts"; +import { IntrinsicValue, VirtualType, bool } from "~/compiler/intrinsic.ts"; +import { GetSolidType } from "~/compiler/codegen/expression/type.ts"; +import { CompileExpr } from "~/compiler/codegen/expression/index.ts"; +import { IsNamespace } from "~/compiler/file.ts"; +import { Instruction } from "~/wasm/index.ts"; +import { Context } from "~/compiler/codegen/context.ts"; +import { Panic } from "~/compiler/helper.ts"; +import { ReferenceRange, SourceView } from "~/parser.ts"; + + +export function CompileIf(ctx: Context, syntax: Syntax.Term_If, expect?: SolidType): OperandType { + const cond = CompileExpr(ctx, syntax.value[0]); + if (cond instanceof LinearType && cond.type !== bool.value) Panic( + `${colors.red("Error")}: Invalid comparison type ${cond.type.getTypeName()}\n`, + { path: ctx.file.path, name: ctx.file.name, ref: syntax.value[0].ref } + ); + + const lifter = ctx.scope.stack.allocate(0, 0); + + const brIf = CompileBranchBody(ctx, syntax.value[1], expect); + + let typeIdx = 0x40; + if (brIf.type instanceof IntrinsicValue) typeIdx = ctx.file.getModule().makeType([], [brIf.type.type.bitcode]); + else if (brIf.type instanceof VirtualType) typeIdx = 0x40; + else if (brIf.type instanceof LinearType) { + lifter.align = brIf.type.getAlignment(); + lifter.size = brIf.type.getSize(); + + if (!brIf.type.alloc) Panic( + `${colors.red("Error")}: Lifted struct somehow has no allocation\n`, + { path: ctx.file.path, name: ctx.file.name, ref: syntax.value[1].ref } + ); + + brIf.type.alloc.moveTo(lifter); + } + + const elseSyntax = syntax.value[2].value[0]; + let flowFailures: string[]; + if (elseSyntax) { + const brElse = CompileBranchBody(ctx, elseSyntax.value[0], GetSolidType(brIf.type)); + + if (brIf.type instanceof LinearType) { + if ( !(brElse.type instanceof LinearType) || brIf.type.type !== brElse.type.type ) Panic( + `${colors.red("Error")}: Type miss-match between if statement results, ${brIf.type.getTypeName()} != ${brElse.type.getTypeName()}\n`, + { path: ctx.file.path, name: ctx.file.name, ref: syntax.ref } + ); + + if (!brElse.type.alloc) Panic( + `${colors.red("Error")}: Lifted struct somehow has no allocation\n`, + { path: ctx.file.path, name: ctx.file.name, ref: elseSyntax.value[0].ref } + ); + + brElse.type.alloc.moveTo(lifter); + } else if (brIf.type != brElse.type) Panic( + `${colors.red("Error")}: Type miss-match between if statement results, ${brIf.type.getTypeName()} != ${brElse.type.getTypeName()}\n`, + { path: ctx.file.path, name: ctx.file.name, ref: syntax.ref } + ); + + + ctx.block.push(Instruction.if(typeIdx, brIf.scope.block, brElse.scope?.block)); + + ctx.exited ||= brIf.scope.exited && brElse.scope.exited; + ctx.block.push(Instruction.unreachable()); + + ResolveBranchFlow(ctx, [brIf.scope, brElse.scope], true, syntax.ref); + } else { + ctx.block.push(Instruction.if(typeIdx, brIf.scope.block)); + ResolveBranchFlow(ctx, [brIf.scope], false, syntax.ref); + } + + return brIf.type; +} + + +function CompileBranchBody(ctx: Context, syntax: Syntax.Term_Expr, expect?: SolidType) { + const stack = ctx.scope.stack.checkpoint(); + const scope = ctx.child(); + + // If there is a single block, inline it + // Otherwise compile the expression inline + const type = InlineBlock(scope, syntax) + || CompileExpr(scope, syntax, expect); + + if (IsNamespace(type)) Panic( + `${colors.red("Error")}: Unsupported namespace yielded from a branch\n`, + { path: ctx.file.path, name: ctx.file.name, ref: syntax.ref } + ); + + scope.mergeBlock(); + stack.restore(); + + return { stack, scope, type }; +} + +function InlineBlock(ctx: Context, syntax: Syntax.Term_Expr) { + // Expression only has a single arg + if (syntax.value[1].value.length !== 0) return null; + + const arg = syntax.value[0]; + + // No prefix operations + if (arg.value[0].value.length !== 0) return null; + + // No postfix operations + if (arg.value[2].value.length !== 0) return null; + + // Only a block argument + if (arg.value[1].value[0].type != "block") return null; + + // Compile each of the block_stmt in the current context + const block = arg.value[1].value[0]; + ctx.compile(block.value[0].value); + + return ctx.raiseType; +} + +function ResolveBranchFlow(parent: Context, branches: Context[], totality = false, ref: ReferenceRange) { + // If totality is true, execution must pass through at least one of these branches + // So it doesn't matter if any branch changes the state relative to the parent + // As long as all branches perform equivalent changes + + const bad = []; + + // Get list of parent variables which are changed in all branches + const override: string[] = []; + if (totality) { + outer: for (const name in branches[0].scope.vars) { + // Ignore child vars + if (!branches[0].scope.vars[name].isClone) continue; + + for (let i=1; i 0) parent.markFailure( + `${colors.red("Error")}: Variables ${bad.map(colors.cyan).join(", ")} ` + + (bad.length == 1 ? "has" : "have") + + ` an undeterminable states after branching here\n`, + ref); +} \ No newline at end of file diff --git a/source/compiler/codegen/expression/helper.ts b/source/compiler/codegen/expression/helper.ts index bfb1341..d66a1e8 100644 --- a/source/compiler/codegen/expression/helper.ts +++ b/source/compiler/codegen/expression/helper.ts @@ -1,4 +1,5 @@ import type * as Syntax from "~/bnf/syntax.d.ts"; +import { red } from "https://deno.land/std@0.201.0/fmt/colors.ts"; import { AssertUnreachable, LatentOffset } from "~/helper.ts"; import { BasePointerType, LinearType } from "~/compiler/codegen/expression/type.ts"; @@ -60,9 +61,15 @@ export function ResolveLinearType(ctx: Context, type: LinearType, ref: Reference if (strict) { const errs = type.getCompositionErrors(); if (errs) { - console.error(`Unable to compose value due to some arguments being uninitialized since:\n` + const range = ref.clone(); + for (const err of errs) { + range.span(err); + } + + console.error(`${red("Error")}: Unable to compose value due to some arguments being uninitialized since: ${errs.map(x => x.start.toString()).join(", ")}\n` + errs.map(x => SourceView(ctx.file.path, ctx.file.name, x, true)).join("") - + SourceView(ctx.file.path, ctx.file.name, ref, false) + + SourceView(ctx.file.path, ctx.file.name, ref, true) + + ` ${ctx.file.name} ${range.toString()}\n` ); ctx.file.markFailure(); diff --git a/source/compiler/codegen/expression/infix.ts b/source/compiler/codegen/expression/infix.ts index e9b2c89..5ba73f3 100644 --- a/source/compiler/codegen/expression/infix.ts +++ b/source/compiler/codegen/expression/infix.ts @@ -71,7 +71,7 @@ function CompileAs(ctx: Context, lhs: PrecedenceTree, rhs: PrecedenceTree): Oper }); const a = CompilePrecedence(ctx, lhs, goal); - if (a !== goal) Panic( + if (a instanceof LinearType ? a.type !== goal : a !== goal) Panic( `${colors.red("Error")}: Type coerce is currently unimplemented\n`, { path: ctx.file.path, name: ctx.file.name, ref: lhs.ref }); diff --git a/source/compiler/codegen/expression/operand.ts b/source/compiler/codegen/expression/operand.ts index 2c00296..246e8e5 100644 --- a/source/compiler/codegen/expression/operand.ts +++ b/source/compiler/codegen/expression/operand.ts @@ -2,18 +2,19 @@ import * as colors from "https://deno.land/std@0.201.0/fmt/colors.ts"; import type * as Syntax from "~/bnf/syntax.d.ts"; import Structure from "~/compiler/structure.ts"; -import { LinearType, SolidType, OperandType } from "~/compiler/codegen/expression/type.ts"; -import { IntrinsicValue, VirtualType, bool, never } from "~/compiler/intrinsic.ts"; import { ArrayBuilder, StructBuilder } from "~/compiler/codegen/expression/container.ts"; +import { SolidType, OperandType } from "~/compiler/codegen/expression/type.ts"; import { AssertUnreachable } from "~/helper.ts"; import { CompilePostfixes } from "~/compiler/codegen/expression/postfix/index.ts"; import { CompileConstant } from "~/compiler/codegen/expression/constant.ts"; import { CompilePrefix } from "~/compiler/codegen/expression/prefix.ts"; import { CompileExpr } from "~/compiler/codegen/expression/index.ts"; -import { IsNamespace } from "~/compiler/file.ts"; import { Instruction } from "~/wasm/index.ts"; +import { CompileIf } from "~/compiler/codegen/expression/flow-control.ts"; import { Context } from "~/compiler/codegen/context.ts"; import { Panic } from "~/compiler/helper.ts"; +import { never } from "~/compiler/intrinsic.ts"; + export function CompileArg(ctx: Context, syntax: Syntax.Term_Expr_arg, expect?: SolidType, tailCall = false): OperandType { @@ -80,59 +81,13 @@ function CompileName(ctx: Context, syntax: Syntax.Term_Name): OperandType { return variable.type; } -function CompileIf(ctx: Context, syntax: Syntax.Term_If, expect?: SolidType): OperandType { - const cond = CompileExpr(ctx, syntax.value[0]); - if (cond instanceof LinearType && cond.type !== bool.value) Panic( - `${colors.red("Error")}: Invalid comparison type ${cond.type.getTypeName()}\n`, - { path: ctx.file.path, name: ctx.file.name, ref: syntax.value[0].ref } - ); - - const scopeIf = ctx.child(); - const typeIf = CompileExpr(scopeIf, syntax.value[1], expect); - if (IsNamespace(typeIf)) Panic( - `${colors.red("Error")}: Unsupported namespace yielded from if block\n`, - { path: ctx.file.path, name: ctx.file.name, ref: syntax.ref } - ); - scopeIf.mergeBlock(); - - let typeElse: OperandType | null = null; - let scopeElse: Context | null = null; - if (syntax.value[2].value[0]) { - scopeElse = ctx.child(); - typeElse = CompileExpr(scopeElse, syntax.value[2].value[0].value[0], expect); - - if (IsNamespace(typeElse)) Panic( - `${colors.red("Error")}: Unsupported namespace yielded from else block\n`, - { path: ctx.file.path, name: ctx.file.name, ref: syntax.ref } - ); - scopeElse.mergeBlock(); - - if (typeIf != typeElse) Panic( - `${colors.red("Error")}: Type miss-match between if statement results, ${typeIf.getTypeName()} != ${typeElse.getTypeName()}\n`, - { path: ctx.file.path, name: ctx.file.name, ref: syntax.ref } - ); - - if (scopeIf.done && scopeElse.done) ctx.done = true; - } - - let typeIdx = 0x40; - if (typeIf instanceof IntrinsicValue) typeIdx = ctx.file.getModule().makeType([], [typeIf.type.bitcode]); - else if (typeIf instanceof VirtualType) typeIdx = 0x40; - else if (typeIf instanceof LinearType) Panic( - `${colors.red("Error")}: Unsupported structure raising\n`, - { path: ctx.file.path, name: ctx.file.name, ref: syntax.ref } - ); - - ctx.block.push(Instruction.if(typeIdx, scopeIf.block, scopeElse?.block)); - return typeIf; -} - function CompileBlock(ctx: Context, syntax: Syntax.Term_Block, expect?: SolidType): OperandType { const child = ctx.child(); child.compile(syntax.value[0].value); child.cleanup(); - if (child.done) ctx.done = true; + ctx.exited ||= child.exited; + ctx.done ||= child.done; ctx.block.push(Instruction.block(0x40, child.block)); return child.raiseType; diff --git a/source/compiler/codegen/expression/postfix/call.ts b/source/compiler/codegen/expression/postfix/call.ts index 1d5ba8e..9789ab3 100644 --- a/source/compiler/codegen/expression/postfix/call.ts +++ b/source/compiler/codegen/expression/postfix/call.ts @@ -35,7 +35,7 @@ export function CompileCall(ctx: Context, syntax: Syntax.Term_Expr_call, operand const stackBk = ctx.scope.register.allocate(i32.bitcode); ctx.block.push(Instruction.global.get(stackReg)); ctx.block.push(Instruction.local.tee(stackBk.ref)); - ctx.block.push(Instruction.const.i32(ctx.scope.stack.getLatentSize())); + ctx.block.push(Instruction.const.i32(ctx.scope.stack.latentSize)); ctx.block.push(Instruction.i32.add()); ctx.block.push(Instruction.global.set(stackReg)); @@ -151,7 +151,9 @@ export function CompileTailCall(ctx: Context, syntax: Syntax.Term_Expr_call, ope } if (returnType instanceof LinearType) returnType.dispose(); + ctx.exited = true; ctx.done = true; + return never; } diff --git a/source/compiler/codegen/expression/type.ts b/source/compiler/codegen/expression/type.ts index 10e2a6e..fd5b1fe 100644 --- a/source/compiler/codegen/expression/type.ts +++ b/source/compiler/codegen/expression/type.ts @@ -99,7 +99,7 @@ export class LinearType { this.consumedAt = b.consumedAt; } else { - assert(c instanceof BasePointer, "should be base pointer"); + assert(c instanceof BasePointer, `should be base pointer, not ${c}`); this.ownership = Ownership.owner; this.consumedAt = undefined; @@ -207,7 +207,6 @@ export class LinearType { dispose() { if (this.retain) return; if (!this.alloc) return; - this.alloc.free(); } // This value is not stored in a variable, and parents should retain existence after child's consumption @@ -240,6 +239,13 @@ export class LinearType { return this.type.size; } + getAlignment() { + if (this.type instanceof IntrinsicValue) return this.type.type.align; + + this.type.link(); + return this.type.align; + } + getTypeName() { if (this.type instanceof Structure) return this.type.name; @@ -260,7 +266,9 @@ export class LinearType { return false; } - + /** + * Overwrites this linear type with another + */ infuse(other: LinearType) { if (!this.like(other)) throw new Error("Cannot infuse a different type"); @@ -277,9 +285,49 @@ export class LinearType { } } + compositionallyEquivalent(other: LinearType, carry: Array<[ReferenceRange?, ReferenceRange?]> = []) { + if (this.composable != other.composable) return false; + + for (const [key, thisAttr] of this.attributes.entries()) { + const otherAttr = other.attributes.get(key); + + if (!otherAttr) return false; + else { + const ok = thisAttr.compositionallyEquivalent(otherAttr, carry);; + if (!ok) return false; + } + } + + // Check other doesn't have any attributes marked which this one does not + for (const key in other.attributes) { + if (!this.attributes.has(key)) return false; + } + + return true; + } + + infuseComposition(other: LinearType) { + this.composable = other.composable; + this.consumedAt = other.consumedAt; + + for (const [key, otherAttr] of other.attributes) { + const thisAttr = this.attributes.get(key); + + if (!thisAttr) this.attributes.set(key, otherAttr.clone()); + else thisAttr.infuseComposition(otherAttr); + + if (this.attributes.has(key)) this.attributes.delete(key); + } + + // Remove unlabled attributes + for (const key in this.attributes) { + if (!other.attributes.has(key)) this.attributes.delete(key); + } + } + clone(): LinearType { - const nx = new LinearType(this.type, this.alloc, 0); + const nx = new LinearType(this.type, this.alloc, this.base); nx.composable = this.composable; nx.consumedAt = this.consumedAt; nx.parent = this.parent; @@ -287,13 +335,23 @@ export class LinearType { nx.retain = this.retain; for (const [key, value] of this.attributes) { - if (value instanceof IntrinsicValue) { - nx.attributes.set(key, value); - } else { - nx.attributes.set(key, value.clone()); - } + nx.attributes.set(key, value.clone()); } return nx; } +} + + + + +export function GetSolidType(type: OperandType): SolidType | undefined { + if (type instanceof IntrinsicValue) return type.type; + if (type instanceof VirtualType) return undefined; + if (type instanceof LinearType) return GetSolidType(type.type); + + if (IsNamespace(type)) return undefined; + if (IsSolidType(type)) return type; + + return type; } \ No newline at end of file diff --git a/source/compiler/codegen/scope.ts b/source/compiler/codegen/scope.ts index 9c99c50..c6fa7cd 100644 --- a/source/compiler/codegen/scope.ts +++ b/source/compiler/codegen/scope.ts @@ -29,6 +29,7 @@ export class Scope { this.stack = new StackAllocator(); } + // Child vars are copy on write this.vars = {}; } @@ -82,10 +83,8 @@ export class Scope { if (readOnly) return inherited; - // Don't both cloning if the value can't be consumed in this scope - if (inherited instanceof LinearType) return inherited; - this.vars[name] = inherited.clone(); + return this.vars[name]; } return null; diff --git a/source/compiler/codegen/variable.ts b/source/compiler/codegen/variable.ts index 0160d1e..76ebee1 100644 --- a/source/compiler/codegen/variable.ts +++ b/source/compiler/codegen/variable.ts @@ -37,7 +37,8 @@ export class Variable { cleanup() { if (this.isClone) return; - if (this.type.alloc) this.type.alloc.free(); + + // Variables are allocated on the stack, so they are automatically freed by scope } // toBinary() { diff --git a/source/compiler/function.ts b/source/compiler/function.ts index f04f00b..b0f38c0 100644 --- a/source/compiler/function.ts +++ b/source/compiler/function.ts @@ -207,7 +207,7 @@ export default class Function { ctx.compile(body.value[0].value); scope.stack.resolve(); - if (!ctx.done) { + if (!ctx.exited) { console.error(`${colors.red("Error")}: Function ${colors.brightBlue(this.name)} does not return\n`+ SourceView(ctx.file.path, ctx.file.name, body.ref) ); diff --git a/source/compiler/package.ts b/source/compiler/package.ts index 7261fc2..f2a2794 100644 --- a/source/compiler/package.ts +++ b/source/compiler/package.ts @@ -6,21 +6,23 @@ import { File } from "~/compiler/file.ts" export default class Package { project: Project; files: File[]; + name: string; cwd: string; failed: boolean; - constructor(project: Project, base: string) { + constructor(project: Project, base: string, name: string = "~") { this.project = project; this.failed = false; this.files = []; + + this.name = name; this.cwd = dirname(base); } import(filePath: string) { - const name = relative(this.cwd, filePath); const data = Deno.readTextFileSync(filePath); - const file = new File(this, filePath, name, data); + const file = new File(this, filePath, `${this.name}/${relative(this.cwd, filePath)}`, data); this.files.push(file); return file; diff --git a/source/helper.ts b/source/helper.ts index 8b7dbeb..5d335f7 100644 --- a/source/helper.ts +++ b/source/helper.ts @@ -20,27 +20,39 @@ export class Box { export class LatentValue { private value: T | null; + private alias?: LatentValue; constructor() { + this.alias = undefined; this.value = null; } get (): T { + if (this.alias) return this.alias.get(); if (this.value === null) throw new Error("Attempting to read latent value before it's been resolved"); - return this.value; } - clear() { - this.value === null; + clear(): void { + if (this.alias) return this.alias.clear(); + this.value = null; } resolve(val: T, force = false) { - if (this.value !== null && !force) - throw new Error("Attempt to re-resolve already resolved latent value"); + if (this.alias) throw new Error("Attempting to resolve an aliased value"); + if (this.value !== null && !force) throw new Error("Attempting to re-resolve already resolved latent value"); this.value = val; } + + resolveTo (alias: LatentValue) { + this.clear(); + this.alias = alias; + } + + isResolved() { + return this.value !== null; + } } export class LatentOffset { diff --git a/source/parser.ts b/source/parser.ts index 34b6b9f..a84bd14 100644 --- a/source/parser.ts +++ b/source/parser.ts @@ -2,6 +2,8 @@ import * as colors from "https://deno.land/std@0.201.0/fmt/colors.ts"; import * as Instance from "~/bnf/syntax.js"; import * as Syntax from "~/bnf/syntax.d.ts"; + +/// import { ParseError, ReferenceRange, Reference, SyntaxNode } from "~/bnf/shared.js"; import { Panic } from "~/compiler/helper.ts"; @@ -47,57 +49,85 @@ function RemapRefRange(syntax: SyntaxNode) { export function SourceView(path: string, name: string, range: ReferenceRange, compact?: boolean) { - const source = ReadByteRange(path, range.start.index-200, range.end.index+200); - if (source === null) return `${name}: ${range.toString()}\n`; - - const begin = ExtractLine(source, range.start).replace(/\t/g, " "); - let body = ""; - - if (range.start.line === range.end.line) { - const margin = ` ${range.start.line} | `; - - const trimmed = begin.trim(); - const trimDiff = begin.length - trimmed.length; - - const underline = "\n" - + " ".repeat(margin.length + range.start.col - trimDiff) - + "^".repeat(Math.max(1, range.end.col - range.start.col)); - - body = margin + trimmed + underline; - } else { - const eLine = " " + range.end.line.toString(); - const sLine = range.start.line.toString().padStart(eLine.length, " "); - - const finish = ExtractLine(source, range.end).replace(/\t/g, " ");; - - body = sLine + " | " + begin + "\n" - + eLine + " | " + finish; - } - - body += compact ? "\n" : `\n ${name}: ${range.toString()}\n`; + return range.start.line == range.end.line + ? SingleLine(path, name, range, compact) + : MultiLine(path, name, range, compact); +} - return body; +function SingleLine(path: string, name: string, range: ReferenceRange, compact?: boolean) { + const offset = Math.max(0, range.start.index - 200); + const slice = ReadByteRange(path, offset, range.end.index+200); + if (slice === null) return `${name}: ${range.toString()}\n`; + + let s = slice.lastIndexOf("\n", range.start.index-offset); + if (s === -1) s = 0; + let e = slice.indexOf("\n", range.end.index-offset); + if (e === -1) e = slice.length; + + let line = slice.slice(s, e).trimEnd(); + let pad = line.length; + line = line.trimStart(); + pad -= line.length; + + const margin = ` ${range.start.line} │ `; + const underline = "\n" + + " ".repeat(margin.length + range.start.col - pad) + + "^".repeat(Math.max(1, range.end.col - range.start.col)) + + "\n"; + + const body = margin + line + underline; + return compact ? body : `${body} ${name}: ${range.toString()}\n`; } -function ExtractLine(source: string, ref: Reference) { - const begin = FindNewLine(source, ref.index, -1); - const end = FindNewLine(source, ref.index, 1); +function MultiLine(path: string, name: string, range: ReferenceRange, compact?: boolean) { + const offset = Math.max(0, range.start.index - 200); + const slice = ReadByteRange(path, offset, range.end.index+200); + if (slice === null) return `${name}: ${range.toString()}\n`; + + let s = slice.lastIndexOf("\n", range.start.index-offset); + if (s === -1) s = 0; + else s ++; + let e = slice.indexOf("\n", range.end.index-offset); + if (e === -1) e = slice.length; + + const lines = slice.slice(s, e).split("\n"); + const digits = Math.floor(Math.log10(range.end.line)) + 1; + + let maxLen = 0; + function RenderLine(line: string, lnOff: number,) { + const ln = lnOff + range.start.line; + const src = line.replaceAll("\t", " "); + maxLen = Math.max(src.length, maxLen); + return ` ${ln.toString().padStart(digits, " ")} │ ${src}\n`; + } - return source.slice(begin, end); -} + // TODO: Low priority + // This currently does not strip any padding + // So if every line in the section is indented by 4 space, that will remain + // + // Ideally it should calculate the minimum indentation in the snippet + // Then back shift based on that -function FindNewLine(source: string, index: number, step: number) { - index += step; + let body = ""; + if (lines.length <= 5) { + body += lines.map(RenderLine).join(""); + } else { + let begin = ""; + for (let i=0; i<2; i++) { + begin += RenderLine(lines[i], i); + } - while (index >= 0 && index < source.length && source[index] !== "\n") { - index += step; - } + let end = ""; + for (let i=lines.length-2; i { const b = stack.allocate(4, 1); b.tag = "B"; const c = stack.allocate(2, 1); c.tag = "C"; + const ptrA = a.getOffset(); + const ptrB = b.getOffset(); + const ptrC = c.getOffset(); + a.free(); b.free(); c.free(); stack.resolve(); - const ptrA = a.getOffset().get(); - const ptrB = b.getOffset().get(); - const ptrC = c.getOffset().get(); - assert(ptrA < ptrB); - assert(ptrA < ptrC); - assert(ptrB < ptrC); + const offA = ptrA.get(); + const offB = ptrB.get(); + const offC = ptrC.get(); + assert(offA < offB); + assert(offA < offC); + assert(offB < offC); }); Deno.test(`Region Reuse`, () => { @@ -39,6 +43,9 @@ Deno.test(`Region Reuse`, () => { c.free(); d.free(); + // Access them once so they're not omitted + a.getOffset(); b.getOffset(); c.getOffset(); d.getOffset(); + stack.resolve(); const ptrA = a.getOffset().get(); @@ -58,13 +65,15 @@ Deno.test(`Nested Stack Allocation`, () => { const check = stack.checkpoint(); const b = stack.allocate(4, 1); b.tag = "B"; b.free(); - check.rewind(); check.restore(); const c = stack.allocate(2, 1); c.tag = "C"; a.free(); c.free(); + // Access them once so they're not omitted + a.getOffset(); b.getOffset(); c.getOffset(); + stack.resolve(); const ptrA = a.getOffset().get(); @@ -81,34 +90,40 @@ Deno.test(`Branch Merging`, () => { const a = stack.allocate(1, 1); a.tag = "A"; // if { - const check = stack.checkpoint(); + const checkA = stack.checkpoint(); const b = stack.allocate(4, 1); b.tag = "B"; - const c = stack.allocate(4, 1); c.tag = "C"; - b.free(); - check.rewind(); + checkA.restore(); // } else { + const checkB = stack.checkpoint(); + const c = stack.allocate(1, 1); c.tag = "C"; const d = stack.allocate(4, 1); d.tag = "D"; - d.makeAlias(c); - check.rewind(); + const preAlias = c.getOffset(); + c.moveTo(a); + checkB.restore(); // } - check.restore(); const e = stack.allocate(2, 1); e.tag = "E"; - a.free(); - e.free(); - c.free(); + + // Access them once so they're not omitted + const ptrA = a.getOffset(); + const ptrB = b.getOffset(); + const ptrC = c.getOffset(); + const ptrE = e.getOffset(); stack.resolve(); - const ptrA = a.getOffset().get(); - const ptrB = b.getOffset().get(); - const ptrC = c.getOffset().get(); - const ptrD = d.getOffset().get(); - const ptrE = e.getOffset().get(); + const offA = ptrA.get(); + const offB = ptrB.get(); + const offC = ptrC.get(); + const offE = ptrE.get(); - assert(ptrA < ptrB); - assert(ptrB > ptrC); - assert(ptrC == ptrD); - assert(ptrC < ptrE); - assert(ptrA < ptrE); + assert(offA < offB); + assert(offB > offC); + assert(offC == offA, "Aliasing correctly moved stack pointer"); + assert(offC < offE); + assert(offA < offE); + + assert(d.getOffset().isResolved() === false, "D was never accessed so it was omitted"); + + assert(offC == preAlias.get(), "Aliasing is applied to gets before the .moveTo() was invoked"); }); \ No newline at end of file diff --git a/tools/vscode-extension/syntaxes/salient.tmLanguage.json b/tools/vscode-extension/syntaxes/salient.tmLanguage.json index cba5d02..4e1b719 100644 --- a/tools/vscode-extension/syntaxes/salient.tmLanguage.json +++ b/tools/vscode-extension/syntaxes/salient.tmLanguage.json @@ -210,6 +210,7 @@ { "include": "#declare" }, { "include": "#assign" }, { "include": "#return" }, + { "include": "#lift" }, { "include": "#expression" } ] @@ -341,6 +342,19 @@ }, + "lift": { + "begin": "\\b(lift)\\s*", + "beginCaptures": { + "1": { "name": "keyword.control.lift" } + }, + "end": "(;)", + "endCaptures": { + "1": { "name": "punctuation.terminator.statement" } + }, + "patterns": [ + { "include": "#expression" } + ] + }, "return": { "begin": "\\b(return(_tail)?)\\s*", "beginCaptures": {