feat(pbs): add array-backed Stack and circular Queue

This commit is contained in:
2026-10-27 09:37:10 +00:00
parent 01a1968689
commit 0016d92ac3
34 changed files with 5274 additions and 9 deletions
@@ -44,7 +44,7 @@ class PbsListCursorTest {
if(name.startsWith("gc"))module=PbsStructuredValuesTest.withTestSafepoint(module);
new BytecodePreloadVerifierService().verify(module);
Files.createDirectories(directory());Files.write(directory().resolve("pbs-"+collection+"-"+name+".pbx"),module.serialize());
if(!name.startsWith("gc") || collection.equals("map")) {
if(!name.startsWith("gc") || java.util.Set.of("map","stack","queue").contains(collection)) {
var optimized=new OptimizeIRVMService().optimize(new LowerToIRVMService().lower(backend));
var optimizedModule=new BytecodeEmitter().emit(optimized.coherentEmissionPlan());
if(name.startsWith("gc"))optimizedModule=PbsStructuredValuesTest.withTestSafepoint(optimizedModule);
@@ -0,0 +1,222 @@
package p.studio.compiler.backend.irvm;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.Files;
import java.nio.file.Path;
import static org.junit.jupiter.api.Assertions.*;
class PbsStackQueueTest {
private static void compile(String type,String name,String source) throws Exception {
PbsListCursorTest.compileCollection(type,name,source);
}
private static void probe(String type,String name,String body) throws Exception {
compile(type,name,"declare service Probe{fn main()->int{"+body+"}}");
}
private static String insert(String type) {return type.equals("stack")?"push":"enqueue";}
private static String remove(String type) {return type.equals("stack")?"pop":"dequeue";}
@Test void fullApiZeroDefaultAndPreciseGrowth() throws Exception {
for (String type:java.util.List.of("stack","queue")) {
probe(type,"basic","""
let normal:TYPE<int>=new TYPE();if normal.capacity()!=(16 as long){return 0;}
let n:int=0;let values:TYPE<int>=new TYPE<>(n);let alias=values;
if values.isEmpty()==false or values.size()!=(0 as long) or values.capacity()!=(0 as long){return 0;}
if values.peek().hasSome() or values.REMOVE().hasSome(){return 0;}
values.clear();values.INSERT(0);if values.peek().hasNone(){return 0;}
if values.capacity()!=(1 as long){return 0;}values.INSERT(1);
if values.capacity()!=(2 as long){return 0;}values.INSERT(2);
if values.capacity()!=(3 as long){return 0;}values.INSERT(3);
if values.capacity()!=(5 as long){return 0;}values.INSERT(4);values.INSERT(5);
if values.capacity()!=(8 as long) or alias.size()!=(6 as long){return 0;}
let sum:int=0;for i:int from 0 until 6{let expected:int=ORDER;if (alias.peek() else -1)!=expected{return 0;}if (values.REMOVE() else -1)!=expected{return 0;}sum=sum+expected;}
if sum!=15 or values.REMOVE().hasSome() or values.peek().hasSome(){return 0;}
if values.capacity()!=(8 as long) or values.isEmpty()==false{return 0;}
values.INSERT(20);values.INSERT(22);values.clear();values.clear();
if values.size()!=(0 as long) or values.capacity()!=(8 as long){return 0;}
values.INSERT(42);return values.REMOVE() else 0;
""".replace("ORDER",type.equals("stack")?"5-i":"i").replace("TYPE",type).replace("INSERT",insert(type)).replace("REMOVE",remove(type)));
probe(type,"capacity","""
let cap:long=3;let values=new TYPE<int>(cap);
for i:int from 0 until 3{values.INSERT(i);}if values.capacity()!=cap{return 0;}
values.INSERT(3);if values.capacity()!=(5 as long){return 0;}
let maybe:optional (TYPE<int>)=some(new TYPE());if let owner=maybe{owner.INSERT(42);return owner.REMOVE() else 0;}return 0;
""".replace("TYPE",type).replace("INSERT",insert(type)).replace("REMOVE",remove(type)));
probe(type,"arithmetic","""
let maximum:long=4294967295;
if _grownCapacity(maximum-(1 as long),maximum)!=maximum{return 0;}
if _grownCapacity(0,42)!=(42 as long){return 0;}
if _ringIndex(maximum-(1 as long),maximum-(1 as long),maximum)!=maximum-(2 as long){return 0;}
return 42;
""");
probe(type,"fault-negative","let x=new "+type+"<int>(-1);return 0;");
probe(type,"fault-too-large","let n:long=4294967296;let x=new "+type+"<int>(n);return 0;");
probe(type,"fault-required","let maximum:long=4294967295;let x:long=_grownCapacity(maximum,maximum+1);return 0;");
}
}
@Test void circularQueueWrapsGrowsAndNormalizesAcrossRepeatedCycles() throws Exception {
probe("queue","wrap","""
let q=new queue<int>(4);for i:int from 0 until 4{q.enqueue(i);}
if (q.dequeue() else -1)!=0 or (q.dequeue() else -1)!=1{return 0;}
q.enqueue(4);q.enqueue(5);if q.capacity()!=(4 as long){return 0;}
let snapshot=q.cursor();q.enqueue(6);if q.capacity()!=(6 as long){return 0;}
for i:int from 2 until 7{if (q.dequeue() else -1)!=i{return 0;}}
for i:int from 2 until 6{if (snapshot.current() else -1)!=i{return 0;}snapshot.next();}
if (snapshot.current() else -1)!=5 or snapshot.hasNext(){return 0;}
for cycle:int from 0 until 20{
for i:int from 0 until 6{q.enqueue(cycle*10+i);}
for i:int from 0 until 6{if (q.dequeue() else -1)!=cycle*10+i{return 0;}}
if q.isEmpty()==false{return 0;}
}
for i:int from 0 until 6{q.enqueue(i);}q.dequeue();q.dequeue();q.enqueue(20);q.enqueue(22);
q.clear();q.enqueue(42);if q.capacity()!=(6 as long){return 0;}return q.dequeue() else 0;
""");
}
@Test void snapshotsKeepAllStatesOrderDuplicatesAndSharedPayloadMutation() throws Exception {
for (String type:java.util.List.of("stack","queue")) {
probe(type,"cursor-empty","""
let values=new TYPE<int>(0);let c=values.cursor();values.INSERT(42);
for i:int from 0 until 3{if c.current().hasSome() or c.hasNext(){return 0;}c.next();}return 42;
""".replace("TYPE",type).replace("INSERT",insert(type)));
probe(type,"cursor-single","""
let values=new TYPE<int>();values.INSERT(42);let c=values.cursor();values.REMOVE();values.clear();
for i:int from 0 until 3{if c.hasNext() or (c.current() else 0)!=42{return 0;}c.next();}return 42;
""".replace("TYPE",type).replace("INSERT",insert(type)).replace("REMOVE",remove(type)));
compile(type,"snapshot","""
declare struct Item(pub mut value:int);
declare service Probe{fn main()->int{
let values=new TYPE<Item>(2);let first=new Item(20);let last=new Item(22);
values.INSERT(first);values.INSERT(last);values.INSERT(first);let c=values.cursor();
values.REMOVE();values.INSERT(new Item(0));values.clear();first.value=21;
if c.hasNext()==false{return 0;}if let a=c.current(){if a.value!=21{return 0;}}else{return 0;}
c.next();if let b=c.current(){if b.value!=22{return 0;}}else{return 0;}
if c.hasNext()==false{return 0;}c.next();c.next();if c.hasNext(){return 0;}
if let a=c.current(){return a.value*2;}return 0;
}}
""".replace("TYPE",type).replace("INSERT",insert(type)).replace("REMOVE",remove(type)));
probe(type,"cursor-order","""
let values=new TYPE<int>(0);values.INSERT(20);values.INSERT(22);let c=values.cursor();
if (c.current() else 0)!=FIRST{return 0;}if c.hasNext()==false{return 0;}
c.next();if (c.current() else 0)!=LAST or c.hasNext(){return 0;}return 42;
""".replace("TYPE",type).replace("INSERT",insert(type)).replace("FIRST",type.equals("stack")?"22":"20").replace("LAST",type.equals("stack")?"20":"22"));
}
}
@Test void completeGroupsOptionalFieldsFunctionsAndContractsSurviveGrowthAndRemoval() throws Exception {
for (String type:java.util.List.of("stack","queue")) {
probe(type,"groups","""
let groups=new TYPE<(a:int,b:int)>(0);groups.INSERT((a:20,b:22));let c=groups.cursor();
groups.INSERT((a:1,b:2));
if let removed=groups.REMOVE(){if removed.a!=EXPECTED_A or removed.b!=EXPECTED_B{return 0;}}else{return 0;}
groups.clear();
if let group=c.current(){return group.a+group.b;}return 0;
""".replace("TYPE",type).replace("INSERT",insert(type)).replace("REMOVE",remove(type))
.replace("EXPECTED_A",type.equals("stack")?"1":"20").replace("EXPECTED_B",type.equals("stack")?"2":"22"));
compile(type,"references","""
declare struct Item(pub value:optional int);
declare contract Read{fn read()->int;}
implements Read for Item using item{fn read()->int{return item.value else 0;}}
fn answer()->int{return 42;}
declare service Probe{fn main()->int{
let flags=new TYPE<bool>(0);flags.INSERT(false);if flags.peek().hasNone() or (flags.REMOVE() else true){return 0;}
let items=new TYPE<Item>(0);items.INSERT(new Item(none));if let item=items.REMOVE(){if item.value.hasSome(){return 0;}}else{return 0;}
let reads=new TYPE<Read>(0);reads.INSERT(new Item(some(42)) as Read);let c=reads.cursor();reads.clear();
let functions=new TYPE<Fn()->int>(0);functions.INSERT(answer);if let f=functions.REMOVE(){if f()!=42{return 0;}}else{return 0;}
let arrays=new TYPE<array<int>>(0);let a:array<int>=[42];arrays.INSERT(a);a[0]=20;
if let shared=arrays.REMOVE(){if (shared[0] else 0)!=20{return 0;}}else{return 0;}
if let r=c.current(){return r.read();}return 0;
}}
""".replace("TYPE",type).replace("INSERT",insert(type)).replace("REMOVE",remove(type)));
compile(type,"native","""
[BuiltinType(name="vec2",version=1)]declare builtin type Vec2(pub x:float,pub y:float){}
fn nativeProbe()->int{
let values=new TYPE<Vec2>(0);values.INSERT(new Vec2(20.0,22.0));let c=values.cursor();
values.INSERT(new Vec2(1.0,2.0));
if let removed=values.REMOVE(){if removed.x!=EXPECTED_X or removed.y!=EXPECTED_Y{return 0;}}else{return 0;}
values.clear();
if let v=c.current(){return (v.x+v.y) as int;}return 0;
}
declare service Probe{fn main()->int{return nativeProbe();}}
""".replace("TYPE",type).replace("INSERT",insert(type)).replace("REMOVE",remove(type))
.replace("EXPECTED_X",type.equals("stack")?"1.0":"20.0").replace("EXPECTED_Y",type.equals("stack")?"2.0":"22.0"));
compile(type,"evaluation","""
declare struct Effects(pub mut trace:int,pub values:TYPE<int>){
fn receiver()->TYPE<int>{this.trace=this.trace*10+1;return this.values;}
fn value()->int{this.trace=this.trace*10+2;return 42;}
fn capacity()->int{this.trace=this.trace*10+3;return 0;}
}
fn insertNamed(values:TYPE<int>,value:int){values.INSERT(value);}
declare service Probe{fn main()->int{
let e=new Effects(0,new TYPE<int>());e.receiver().INSERT(e.value());if e.trace!=12{return 0;}
e.trace=0;insertNamed apply (value:e.value(),values:e.receiver());if e.trace!=21{return 0;}
e.trace=0;let created=new TYPE<int>(e.capacity());if e.trace!=3 or created.capacity()!=(0 as long){return 0;}
e.trace=0;let found=e.receiver().peek();if e.trace!=1{return 0;}return found else 0;
}}
""".replace("TYPE",type).replace("INSERT",insert(type)));
}
}
@Test void operationFixturesMarkPreparationAndAllVisibleWrites() throws Exception {
for (String type:java.util.List.of("stack","queue")) {
for (String operation:java.util.List.of("insert","growth","zero","remove","clear","peek","cursor","empty")) {
String statement=switch(operation){case "insert","growth","zero"->"values."+insert(type)+"(42);";case "remove","empty"->"let old=values."+remove(type)+"();";case "clear"->"values.clear();";case "peek"->"let old=values.peek();";default->"let c=values.cursor();";};
String setup=switch(operation){case "zero","empty"->"let values=new "+type+"<int>(0);";case "growth"->"let values=new "+type+"<int>(4);for i:int from 0 until 4{values."+insert(type)+"(i);}";default->"let values=new "+type+"<int>(8);for i:int from 0 until 4{values."+insert(type)+"(i);}";};
compile(type,"refusal-"+operation,"""
fn mutationMarker(){let marker:int=314160;}
fn completedMarker(){let marker:int=314161;}
fn perform(values:TYPE<int>){OPERATION}
declare service Probe{fn main()->int{SETUP mutationMarker();perform(values);completedMarker();return 42;}}
""".replace("TYPE",type).replace("OPERATION",statement).replace("SETUP",setup));
}
}
compile("queue","refusal-wrapped","""
fn mutationMarker(){let marker:int=314160;}fn completedMarker(){let marker:int=314161;}
fn perform(values:queue<int>){values.enqueue(42);}
declare service Probe{fn main()->int{let values=new queue<int>(4);for i:int from 0 until 4{values.enqueue(i);}values.dequeue();values.dequeue();values.enqueue(4);values.enqueue(5);mutationMarker();perform(values);completedMarker();return 42;}}
""");
String sdk=PbsSetTest.sdk();
for(String type:java.util.List.of("stack","queue")) {
int offset=sdk.indexOf(type.equals("stack")?"[SdkStack]":"[SdkQueue]");
int end=sdk.indexOf(type.equals("stack")?"// Valid only for nonempty backing":"declare contract Cursor<T>",offset);
String injected=sdk.substring(0,offset)+sdk.substring(offset,end).replace("this.storage = target;","this.storage = target;let testOnlyQuotaProbe=new array<int>(1000000);")+sdk.substring(end);
PbsListCursorTest.compileCollection(type,"injected-growth","declare service Probe{fn main()->int{let values=new "+type+"<int>(2);values."+insert(type)+"(20);values."+insert(type)+"(22);values."+insert(type)+"(42);return 42;}}",injected);
}
}
@Test void realGcFixturesObserveRemovalClearReplacedBackingAndSnapshotRelease() throws Exception {
for (String type:java.util.List.of("stack","queue")) {
compile(type,"gc-snapshot","""
declare struct Item(pub value:int);declare struct Garbage();fn collect(){let marker:int=314159;}
fn make()->Cursor<Item>{let values=new TYPE<Item>(0);for i:int from 0 until 1200{values.INSERT(new Item(i));}return values.cursor();}
fn use(){let c=make();collect();for i:int from 0 until 1199{c.next();}collect();for i:int from 0 until 1200{c.next();}collect();}
declare service Probe{fn main()->int{use();for i:int from 0 until 1200{let x=new Garbage();}collect();return 42;}}
""".replace("TYPE",type).replace("INSERT",insert(type)));
compile(type,"gc-collection","""
declare struct Item(pub value:int);declare struct Garbage();fn collect(){let marker:int=314159;}
fn pressure(){for i:int from 0 until 1200{let x=new Garbage();}}
fn make()->TYPE<Item>{let values=new TYPE<Item>(0);for i:int from 0 until 64{values.INSERT(new Item(i));}return values;}
fn discard(values:TYPE<Item>){for i:int from 0 until 3{values.REMOVE();}}
fn use(){let values=make();pressure();collect();discard(values);pressure();collect();values.clear();pressure();collect();values.INSERT(new Item(42));pressure();collect();}
declare service Probe{fn main()->int{use();pressure();collect();return 42;}}
""".replace("TYPE",type).replace("INSERT",insert(type)).replace("REMOVE",remove(type)));
}
}
@Test void aliasesAndReexportsUseInstalledSdkAuthority(@TempDir Path root) throws Exception {
Files.createDirectories(root.resolve("src/facade"));
Files.writeString(root.resolve("prometeu.json"),"{\"name\":\"app\",\"version\":\"1.0.0\",\"language\":\"pbs\",\"stdlib\":\"1\",\"target\":\"Game\",\"dependencies\":[]}");
Files.writeString(root.resolve("src/mod.barrel"),"pub fn frame()->void;");
Files.writeString(root.resolve("src/facade/mod.barrel"),"pub struct Lifo<T>;pub struct Fifo<T>;pub contract Walk<T>;");
Files.writeString(root.resolve("src/facade/main.pbs"),"import {stack as Lifo,queue as Fifo,Cursor as Walk} from @sdk:collections;");
Files.writeString(root.resolve("src/main.pbs"),"""
import {Lifo,Fifo,Walk} from @app:facade;
[Frame]fn frame()->void{
let s:Lifo<int>=new Lifo(0);let q:Fifo<int>=new Fifo<>(0);
s.push(20);s.push(22);q.enqueue(20);q.enqueue(22);
let a:Walk<int>=s.cursor();let b:Walk<int>=q.cursor();s.clear();q.clear();
if (a.current() else 0)!=22 or (b.current() else 0)!=20{let failure=1/0;}
a.next();b.next();if (a.current() else 0)!=20 or (b.current() else 0)!=22{let failure=1/0;}
}
""");
var compiled=p.studio.compiler.workspaces.BuilderPipelineService.INSTANCE.compile(
p.studio.compiler.models.BuilderPipelineContext.fromConfig(new p.studio.compiler.messages.BuilderPipelineConfig(false,root.toString())),
p.studio.utilities.logs.LogAggregator.stdout());
assertFalse(compiled.diagnostics().stream().anyMatch(d->d.isError()),compiled.diagnostics().toString());
Files.write(Path.of(System.getProperty("pbs.registryConformanceDirectory")).resolve("pbs-stack-queue-imports.pbx"),compiled.bytecodeBytes());
}
}