feat(pbs): add Map and read-only Keyval associations
Test / Tests and coverage
Intrepid/Prometeu/Studio/pipeline/pr-master This commit looks good

This commit is contained in:
2026-10-26 20:37:06 +00:00
parent 8105604f92
commit 01a1968689
41 changed files with 4072 additions and 42 deletions
@@ -245,8 +245,8 @@ public final class PbsGenericInstantiation {
return null;
}
if (PbsSdkCollections.isCollection(template) && PbsSdkCollections.directOptional(arguments.getFirst())) {
error(PbsSdkCollections.isSet(template)?"SET_OPTIONAL_ELEMENT":PbsSdkCollections.isLinked(template) ? "LINKED_OPTIONAL_ELEMENT" : "LIST_OPTIONAL_ELEMENT",
"SDK " + name(template) + "<T> does not permit a directly optional element", site);
error(PbsSdkCollections.isMap(template)?"MAP_OPTIONAL_KEY":PbsSdkCollections.isSet(template)?"SET_OPTIONAL_ELEMENT":PbsSdkCollections.isLinked(template) ? "LINKED_OPTIONAL_ELEMENT" : "LIST_OPTIONAL_ELEMENT",
"SDK " + name(template) + " does not permit a directly optional " + (PbsSdkCollections.isMap(template)?"key":"element"), site);
return null;
}
var application = PbsAst.TypeRef.applied(name(template), arguments, template.span());
@@ -548,6 +548,8 @@ public final class PbsGenericInstantiation {
for(var member:a.target().pathSegments())target=new PbsAst.MemberExpr(target,member,a.target().span());
}
var expected = target == null ? locals.get(a.target().rootName()) : infer(target);
if(target instanceof PbsAst.IndexExpr && expected!=null && expected.kind()==PbsAst.TypeRefKind.OPTIONAL)
expected=expected.inner();
return new PbsAst.AssignStatement(a.target(), a.operator(), expression(a.value(), expected), a.span());
}
return super.statement(s);
@@ -555,6 +557,13 @@ public final class PbsGenericInstantiation {
@Override public PbsAst.Expression expression(PbsAst.Expression e, PbsAst.TypeRef expected) {
if (e != null) { budget.visit(e.span(), chain.size()); budget.store(e.span(), 64); }
if(e instanceof PbsAst.IndexExpr index) {
var receiver=expression(index.receiver(),null);
var owner=types.declaration(infer(receiver));
var origin=PbsContractTypes.applicationOrigin(owner);
var key=origin!=null&&PbsSdkCollections.isMap(origin.declaration())?origin.arguments().getFirst():null;
return new PbsAst.IndexExpr(receiver,expression(index.index(),key),index.span());
}
if(symbolicProbe&&e instanceof PbsAst.MemberExpr member) {
var receiver=infer(member.receiver());
if(receiver!=null)requiredShapes.add(receiver.name());
@@ -647,11 +656,12 @@ public final class PbsGenericInstantiation {
else { error("CONTEXT", "Construction of "+n.typeName()+" requires explicit arguments or an expected application", n.span()); return n; }
}
var concreteType = type(applied);
if(PbsSdkCollections.isSet(s)&&n.arguments().isEmpty()&&!symbolicProbe) {
if((PbsSdkCollections.isSet(s)||PbsSdkCollections.isMap(s))&&n.arguments().isEmpty()&&!symbolicProbe) {
var owner=types.declaration(concreteType);
var origin=PbsContractTypes.applicationOrigin(owner);
if(origin!=null&&!PbsSdkCollections.hasDefaultIdentity(origin.arguments().getFirst(),types))
error("SET_IDENTITY_REQUIRED","This Set element type requires an explicit Identity<T> strategy",n.span());
error(PbsSdkCollections.isMap(s)?"MAP_IDENTITY_REQUIRED":"SET_IDENTITY_REQUIRED",
"This collection key/element type requires an explicit Identity strategy",n.span());
}
if (symbolicProbe) requiredShapes.add(concreteType.name());
var constructor = PbsSdkCollections.isCollection(s) && n.ctorName() == null ? "make" : n.ctorName();
@@ -677,6 +687,10 @@ public final class PbsGenericInstantiation {
case PbsAst.NewExpr n -> n.explicitType() != null ? n.explicitType() : PbsAst.TypeRef.simple(n.typeName(), n.span());
case PbsAst.IndexExpr i -> {
var receiver=infer(i.receiver());
var declaration=types.declaration(receiver);
var origin=PbsContractTypes.applicationOrigin(declaration);
if(origin!=null&&PbsSdkCollections.hasIndexer(origin.declaration()))
yield PbsAst.TypeRef.optional(origin.arguments().get(PbsSdkCollections.isMap(origin.declaration())?1:0),i.span());
yield receiver!=null && receiver.kind()==PbsAst.TypeRefKind.ARRAY ? PbsAst.TypeRef.optional(receiver.inner(),i.span()) : null;
}
case PbsAst.GroupExpr g -> infer(g.expression());
@@ -170,7 +170,7 @@ final class PbsGenericTemplateValidator {
context.error("CONTEXT", "Generic construction requires an expected application or explicit type arguments", n.span());
if (d instanceof PbsAst.StructDecl s) {
var env = bindings(s, result);
var constructor = PbsSdkCollections.isIndexedCollection(s) && n.ctorName()==null ? "make" : n.ctorName();
var constructor = PbsSdkCollections.isCollection(s) && n.ctorName()==null ? "make" : n.ctorName();
var expectedParameters = constructor == null ? map(s.fields(), f -> new PbsAst.Parameter(f.name(), PbsTypeSubstitution.substitute(f.typeRef(), env), f.span()))
: s.ctors().stream().filter(c -> c.name().equals(constructor) && c.parameters().size()==n.arguments().size()).findFirst().map(c ->
map(c.parameters(), p -> new PbsAst.Parameter(p.name(), PbsTypeSubstitution.substitute(p.typeRef(), env), p.span()))).orElse(ReadOnlyList.empty());
@@ -209,6 +209,12 @@ final class PbsGenericTemplateValidator {
case PbsAst.UnaryExpr u -> { var value = infer(u.expression(), null); if (containsParameter(value)) capability(u.span()); yield value; }
case PbsAst.IndexExpr i -> {
var receiver = infer(i.receiver(), null);
var declaration=context.declaration(receiver);
if(declaration instanceof PbsAst.StructDecl s&&PbsSdkCollections.hasIndexer(s)) {
var method=s.methods().stream().filter(m->m.name().equals("_at")).findFirst().orElse(null);
if(method!=null&&PbsSdkCollections.isMap(s))infer(i.index(),PbsTypeSubstitution.substitute(method.parameters().getFirst().typeRef(),bindings(s,receiver)));
if(method!=null)yield PbsTypeSubstitution.substitute(method.returnType(),bindings(s,receiver));
}
yield receiver != null && receiver.kind() == PbsAst.TypeRefKind.ARRAY ? PbsAst.TypeRef.optional(receiver.inner(), i.span()) : null;
}
case PbsAst.GroupExpr g -> infer(g.expression(), expected);
@@ -18,8 +18,14 @@ public final class PbsSdkCollections {
public static boolean isSet(PbsAst.TopDecl declaration) {
return declaration instanceof PbsAst.StructDecl s && attribute(s.attributes(), "SdkSet") != null;
}
public static boolean isMap(PbsAst.TopDecl declaration) {
return declaration instanceof PbsAst.StructDecl s && attribute(s.attributes(), "SdkMap") != null;
}
public static boolean hasIndexer(PbsAst.TopDecl declaration) {
return isIndexedCollection(declaration) || isMap(declaration);
}
public static boolean isCollection(PbsAst.TopDecl declaration) {
return isIndexedCollection(declaration)||isSet(declaration);
return hasIndexer(declaration)||isSet(declaration);
}
public static boolean hasDefaultIdentity(PbsAst.TypeRef type,PbsContractTypes types) {
while(type!=null&&type.kind()==PbsAst.TypeRefKind.GROUP)type=type.inner();
@@ -572,7 +572,7 @@ final class PbsExecutableBodyLowerer {
var receiverType = PbsRuntimeTypes.unwrap(expressionType(member.receiver(), context));
if (receiverType != null && receiverType.kind() == PbsAst.TypeRefKind.OPTIONAL
&& (member.memberName().equals("hasSome") || member.memberName().equals("hasNone"))) {
lowerExpression(member.receiver(), context);
lowerExpected(member.receiver(), receiverType, context);
int slot = save(1, callExpr.span(), context);
optionalPresence(slot, receiverType, callExpr.span(), context);
if (member.memberName().equals("hasNone")) {
@@ -1170,7 +1170,7 @@ final class PbsExecutableBodyLowerer {
var array = PbsRuntimeTypes.unwrap(expressionType(index.receiver(), c));
if(array==null)return null;
var declaration=c.types().structs.get(array.name());
return p.studio.compiler.pbs.PbsSdkCollections.isIndexedCollection(declaration)
return p.studio.compiler.pbs.PbsSdkCollections.hasIndexer(declaration)
? declaration.methods().stream().filter(m->m.name().equals("_at")).findFirst().orElseThrow().returnType()
: PbsAst.TypeRef.optional(array.inner(),index.span());
}
@@ -1238,6 +1238,11 @@ final class PbsExecutableBodyLowerer {
var struct = c.types().structs.get(owner.name());
var service = c.types().services.get(owner.name());
var methods = struct != null ? struct.methods() : service != null ? service.methods() : ReadOnlyList.<PbsAst.FunctionDecl>empty();
var applicable=methods.stream().filter(candidate -> candidate.name().equals(member.memberName())
&& parametersMatch(candidate.parameters(),call.arguments(),c)).toList();
// A chained receiver has its own result type; the outer call's expected
// bool (for example hasSome) cannot erase a uniquely resolved optional.
if(applicable.size()==1)return PbsTypeSubstitution.replaceSelf(applicable.getFirst().returnType(),owner.name());
for (var candidate : methods) if (candidate.name().equals(member.memberName()) && parametersMatch(candidate.parameters(),call.arguments(),c)
&& returnMatches(candidate.returnType(),owner.name(),c)) return PbsTypeSubstitution.replaceSelf(candidate.returnType(),owner.name());
var method=c.types().signatures.get(owner.name()+"."+member.memberName()+"#"+call.arguments().size());
@@ -1692,12 +1697,14 @@ final class PbsExecutableBodyLowerer {
private boolean lowerCollectionIndex(PbsAst.IndexExpr index, PbsAst.Expression value, PbsAst.TypeRef type, PbsExecutableLoweringContext c) {
var declaration=type==null?null:c.types().structs.get(type.name());
if(!p.studio.compiler.pbs.PbsSdkCollections.isIndexedCollection(declaration))return false;
if(!p.studio.compiler.pbs.PbsSdkCollections.hasIndexer(declaration))return false;
var name=value==null?"_at":"_put";
var method=declaration.methods().stream().filter(m->m.name().equals(name)).findFirst().orElseThrow();
lowerExpected(index.receiver(),type,c);
lowerArrayIndex(index.index(),c);
int pops=2;
var key=method.parameters().getFirst().typeRef();
if(p.studio.compiler.pbs.PbsSdkCollections.isMap(declaration))lowerExpected(index.index(),key,c);
else lowerArrayIndex(index.index(),c);
int pops=1+c.types().slots(key);
if(value!=null) {
var element=method.parameters().get(1).typeRef();
lowerExpected(value,element,c);pops+=c.types().slots(element);
@@ -685,7 +685,7 @@ final class PbsDeclarationParser {
final String targetSurface) {
for (final var attribute : attributes) {
if ("Doc".equals(attribute.name()) || attribute.trustedSdkOrigin() &&
java.util.Set.of("SdkList", "SdkLinked", "SdkSet").contains(attribute.name()) && "struct declarations".equals(targetSurface)) {
java.util.Set.of("SdkList", "SdkLinked", "SdkSet", "SdkMap").contains(attribute.name()) && "struct declarations".equals(targetSurface)) {
continue;
}
p.studio.compiler.source.diagnostics.Diagnostics.error(context.diagnostics(),
@@ -41,7 +41,7 @@ public final class PbsEditorialSupportService {
final Integer previousTokenIndex = context.previousSignificantTokenIndexAt(offset);
if (previousTokenIndex != null && context.token(previousTokenIndex).kind() == PbsTokenKind.DOT) {
final TypeView receiverType = context.resolveReceiverTypeBeforeDot(previousTokenIndex, scopeState);
return context.memberCompletions(receiverType);
return context.memberCompletions(receiverType, context.receiverExpressionBefore(previousTokenIndex) instanceof PbsAst.ThisExpr);
}
return context.generalCompletions(scopeState);
}
@@ -72,6 +72,7 @@ public final class PbsEditorialSupportService {
final Integer previousTokenIndex = context.previousSignificantTokenIndex(tokenIndex);
if (previousTokenIndex != null && context.token(previousTokenIndex).kind() == PbsTokenKind.DOT) {
final TypeView receiverType = context.resolveReceiverTypeBeforeDot(previousTokenIndex, scopeState);
if(!context.visibleMember(receiverType,token.lexeme(),context.receiverExpressionBefore(previousTokenIndex) instanceof PbsAst.ThisExpr))return Optional.empty();
return context.resolveMemberHover(receiverType, token.lexeme());
}
return context.resolveSymbolHover(token.lexeme(), tokenIndex, scopeState);
@@ -753,13 +754,29 @@ public final class PbsEditorialSupportService {
}
private List<PbsEditorialCompletionCandidate> memberCompletions(final TypeView receiverType) {
return memberCompletions(receiverType, false);
}
private boolean visibleMember(TypeView receiverType,String name,boolean ownFields) {
if(receiverType==null||receiverType.kind()==Kind.UNKNOWN)return false;
if(receiverType.kind()!=Kind.STRUCT)return true;
if(model.isSdkPrivateMember(receiverType,name))return false;
var symbolic=symbolicStruct(receiverType);
if(symbolic!=null) {
var field=symbolic.fields().stream().filter(f->f.name().equals(name)).findFirst();
if(field.isPresent())return ownFields||field.get().isPublic();
}
var owner=model.structs.get(receiverType.name());
var field=owner==null?null:owner.fields().get(name);
return field==null||ownFields||field.isPublic();
}
private List<PbsEditorialCompletionCandidate> memberCompletions(final TypeView receiverType, boolean ownFields) {
if (receiverType == null) {
return List.of();
}
final Map<String, PbsEditorialCompletionCandidate> completions = new LinkedHashMap<>();
var symbolic = symbolicStruct(receiverType);
if (symbolic != null) {
for (var field : symbolic.fields()) if(!p.studio.compiler.pbs.PbsSdkCollections.isCollection(symbolic)||field.isPublic()) completions.put(field.name(), new PbsEditorialCompletionCandidate(
for (var field : symbolic.fields()) if(ownFields||field.isPublic()) completions.put(field.name(), new PbsEditorialCompletionCandidate(
field.name(), PbsEditorialSymbolKind.FIELD, field.typeRef().surface(), symbolic.name()));
for (var method : symbolic.methods()) if(p.studio.compiler.pbs.PbsSdkCollections.attribute(method.attributes(),"SdkPrivate")==null) completions.put(method.name(), new PbsEditorialCompletionCandidate(
method.name(), PbsEditorialSymbolKind.METHOD, signatureFromFunction(method.name(), method.parameters(),
@@ -778,7 +795,7 @@ public final class PbsEditorialSupportService {
final StructInfo structInfo = model.structs.get(receiverType.name());
if (structInfo != null) {
for (final var field : structInfo.fields().entrySet()) {
if(model.isSdkCollection(receiverType)&&!field.getValue().isPublic())continue;
if(!ownFields&&!field.getValue().isPublic())continue;
completions.put(field.getKey(), new PbsEditorialCompletionCandidate(
field.getKey(),
PbsEditorialSymbolKind.FIELD,
@@ -959,6 +976,7 @@ public final class PbsEditorialSupportService {
final Integer previousTokenIndex = previousSignificantTokenIndex(tokenIndex);
if (previousTokenIndex != null && token(previousTokenIndex).kind() == PbsTokenKind.DOT) {
final TypeView receiverType = resolveReceiverTypeBeforeDot(previousTokenIndex, scopeState);
if(!visibleMember(receiverType,token.lexeme(),receiverExpressionBefore(previousTokenIndex) instanceof PbsAst.ThisExpr))return List.of();
return resolveMemberDefinition(receiverType, token.lexeme());
}
return resolveSymbolDefinition(token.lexeme(), tokenIndex, scopeState, offset);
@@ -1305,6 +1323,7 @@ public final class PbsEditorialSupportService {
private List<PbsEditorialSignature> resolveMemberSignatures(
final TypeView receiverType,
final String memberName) {
if(!visibleMember(receiverType,memberName,false))return List.of();
return resolveMemberHover(receiverType, memberName)
.map(PbsEditorialResolvedSymbol::signatures)
.orElse(List.of());
@@ -1749,6 +1768,13 @@ public final class PbsEditorialSupportService {
return new CallSite(CallSiteKind.MEMBER, calleeToken.lexeme(), activeParameter, maybeDotIndex);
}
if (maybeDotIndex != null && token(maybeDotIndex).kind() == PbsTokenKind.NEW) {
// Contextual construction records the application on the whole
// NewExpr span rather than on an explicit angular type suffix.
for(var resolution:genericResolutions.entrySet())
if(resolution.getKey().getStart()==token(maybeDotIndex).start()
&& resolution.getKey().getEnd()>=calleeToken.end()
&& concreteSymbols.get(resolution.getValue()) instanceof PbsAst.StructDecl)
return new CallSite(CallSiteKind.CONSTRUCTOR,resolution.getValue(),activeParameter,-1);
return new CallSite(CallSiteKind.CONSTRUCTOR, calleeToken.lexeme(), activeParameter, -1);
}
return new CallSite(CallSiteKind.FUNCTION, calleeToken.lexeme(), activeParameter, -1);
@@ -202,6 +202,10 @@ final class PbsFlowSemanticSupport {
return type != null && p.studio.compiler.pbs.PbsSdkCollections.isIndexedCollection(contractTypes.declaration(
type.sourceType() == null ? PbsAst.TypeRef.simple(type.name(), Span.none()) : type.sourceType()));
}
boolean isSdkMap(TypeView type) {
return type != null && p.studio.compiler.pbs.PbsSdkCollections.isMap(contractTypes.declaration(
type.sourceType() == null ? PbsAst.TypeRef.simple(type.name(), Span.none()) : type.sourceType()));
}
boolean isSdkCollection(TypeView type) {
return type != null && p.studio.compiler.pbs.PbsSdkCollections.isCollection(contractTypes.declaration(
type.sourceType() == null ? PbsAst.TypeRef.simple(type.name(), Span.none()) : type.sourceType()));
@@ -52,6 +52,13 @@ final class PbsFlowStructuralExpressionAnalyzer {
}
if (expression instanceof PbsAst.IndexExpr index) {
final var receiver = analyzeValueExpression(index.receiver(), context, null).type();
if (model.isSdkMap(receiver)) {
var read=model.structs.get(receiver.name()).methods().get("_at").getFirst();
var key=analyzeValueExpression(index.index(),context,read.inputTypes().getFirst()).type();
if(!typeOps.compatible(key,read.inputTypes().getFirst())) Diagnostics.error(diagnostics,
"E_SEM_MAP_KEY_TYPE", "Map key does not match its declared key type", index.index().span());
return ExprResult.type(read.outputType());
}
checkArrayIndex(index.index(), context);
if (model.isSdkIndexedCollection(receiver)) {
return ExprResult.type(model.structs.get(receiver.name()).methods().get("_at").getFirst().outputType());
@@ -320,19 +320,19 @@ fn _collectionHash<T>(value: T) -> long { return 0; }
[IdentityPrimitive(name = "defaultEquals")]
fn _collectionEquals<T>(left: T, right: T) -> bool { return false; }
fn _setBucket(hash: long, capacity: long) -> long {
fn _hashBucket(hash: long, capacity: long) -> long {
let bucket: long = hash % capacity;
if bucket < (0 as long) { bucket = bucket + capacity; }
return bucket;
}
fn _setNextSize(length: long) -> long {
fn _hashNextSize(length: long) -> long {
let maximum: long = 9223372036854775807;
_bounds(length, maximum);
return length + 1;
}
fn _setCapacity(capacity: long, required: long) -> long {
fn _hashCapacity(capacity: long, required: long) -> long {
let maximum: long = 4294967295;
if capacity == (0 as long) { return 8; }
if capacity < maximum && required > capacity * (3 as long) / (4 as long) {
@@ -385,7 +385,7 @@ declare struct set<T>(buckets: optional array<_SetNode<T>>, length: long, strate
[SdkPrivate]
fn _find(hash: long, value: T) -> bool {
if let buckets = this.buckets {
let current: optional _SetNode<T> = buckets[_setBucket(hash, buckets.length)];
let current: optional _SetNode<T> = buckets[_hashBucket(hash, buckets.length)];
while current.hasSome() {
if let node = current {
if node.hash == hash && this._equals(node.value, value) { return true; }
@@ -404,7 +404,7 @@ declare struct set<T>(buckets: optional array<_SetNode<T>>, length: long, strate
let current: optional _SetNode<T> = buckets[index];
while current.hasSome() {
if let node = current {
let bucket: long = _setBucket(node.hash, capacity);
let bucket: long = _hashBucket(node.hash, capacity);
let copied = new _SetNode<T>(node.hash, node.value, target[bucket]);
target[bucket] = copied;
current = node.next;
@@ -426,20 +426,20 @@ declare struct set<T>(buckets: optional array<_SetNode<T>>, length: long, strate
this._begin();
let hash: long = this._hash(value);
if this._find(hash, value) { this.busy = false; return false; }
let required: long = _setNextSize(this.length);
let required: long = _hashNextSize(this.length);
let capacity: long = 0;
if let buckets = this.buckets { capacity = buckets.length; }
let nextCapacity: long = _setCapacity(capacity, required);
let nextCapacity: long = _hashCapacity(capacity, required);
if nextCapacity != capacity {
let target = this._rehash(nextCapacity);
let bucket: long = _setBucket(hash, nextCapacity);
let bucket: long = _hashBucket(hash, nextCapacity);
let inserted = new _SetNode<T>(hash, value, target[bucket]);
target[bucket] = inserted;
let published: optional array<_SetNode<T>> = some(target);
this.buckets = published;
} else {
if let buckets = this.buckets {
let bucket: long = _setBucket(hash, capacity);
let bucket: long = _hashBucket(hash, capacity);
let inserted = new _SetNode<T>(hash, value, buckets[bucket]);
buckets[bucket] = inserted;
}
@@ -452,7 +452,7 @@ declare struct set<T>(buckets: optional array<_SetNode<T>>, length: long, strate
this._begin();
let hash: long = this._hash(value);
if let buckets = this.buckets {
let bucket: long = _setBucket(hash, buckets.length);
let bucket: long = _hashBucket(hash, buckets.length);
let previous: optional _SetNode<T> = none;
let current: optional _SetNode<T> = buckets[bucket];
while current.hasSome() {
@@ -500,3 +500,193 @@ declare struct set<T>(buckets: optional array<_SetNode<T>>, length: long, strate
return new _SnapshotCursor<T>(head) as Cursor<T>;
}
}
// An association is independent of mutable Map nodes. Only payload aliases are shared.
declare struct keyval<K, V>(storedKey: K, storedValue: V) {
ctor make(key: K, value: V) { this.storedKey = key; this.storedValue = value; }
fn key() -> K { return this.storedKey; }
fn value() -> V { return this.storedValue; }
}
declare struct _MapNode<K, V>(pub hash: long, pub key: K, pub mut value: V, pub mut next: optional _MapNode<K, V>) {
ctor make(hash: long, key: K, value: V, next: optional _MapNode<K, V>) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
[SdkMap]
declare struct map<K, V>(buckets: optional array<_MapNode<K, V>>, length: long, strategy: optional Identity<K>, busy: bool) {
ctor make() {
this.buckets = none;
this.length = 0;
this.strategy = none;
this.busy = false;
}
ctor make(identity: Identity<K>) {
this.buckets = none;
this.length = 0;
this.strategy = some(identity);
this.busy = false;
}
fn size() -> long { return this.length; }
fn isEmpty() -> bool { return this.length == (0 as long); }
[SdkPrivate]
fn _check() { if this.busy { _fail(); } }
[SdkPrivate]
fn _begin() { this._check(); this.busy = true; }
[SdkPrivate]
fn _hash(key: K) -> long {
if let identity = this.strategy { return identity.hash(key); }
return _collectionHash<K>(key);
}
[SdkPrivate]
fn _equals(left: K, right: K) -> bool {
if let identity = this.strategy { return identity.equals(left, right); }
return _collectionEquals<K>(left, right);
}
[SdkPrivate]
fn _find(hash: long, key: K) -> optional _MapNode<K, V> {
if let buckets = this.buckets {
let current: optional _MapNode<K, V> = buckets[_hashBucket(hash, buckets.length)];
while current.hasSome() {
if let node = current {
if node.hash == hash && this._equals(node.key, key) { return some(node); }
current = node.next;
}
}
}
return none;
}
[SdkPrivate]
fn _at(key: K) -> optional V {
this._begin();
let hash: long = this._hash(key);
let retrieved: optional V = none;
if let node = this._find(hash, key) { retrieved = some(node.value); }
this.busy = false;
return retrieved;
}
[SdkPrivate]
fn _put(key: K, value: V) { let discarded: optional V = this._associate(key, value, false); }
fn containsKey(key: K) -> bool {
this._begin();
let hash: long = this._hash(key);
let found: bool = this._find(hash, key).hasSome();
this.busy = false;
return found;
}
[SdkPrivate]
fn _rehash(capacity: long) -> array<_MapNode<K, V>> {
let target: array<_MapNode<K, V>> = new array<>(capacity);
if let buckets = this.buckets {
let index: long = 0;
while index < buckets.length {
let current: optional _MapNode<K, V> = buckets[index];
while current.hasSome() {
if let node = current {
let bucket: long = _hashBucket(node.hash, capacity);
let copied = new _MapNode<K, V>(node.hash, node.key, node.value, target[bucket]);
target[bucket] = copied;
current = node.next;
}
}
index = index + 1;
}
}
return target;
}
[SdkPrivate]
fn _associate(key: K, value: V, returnPrevious: bool) -> optional V {
this._begin();
let hash: long = this._hash(key);
if let node = this._find(hash, key) {
let previous: optional V = none;
if returnPrevious { previous = some(node.value); }
node.value = value;
this.busy = false;
return previous;
}
// Typed absence can materialize a carrier; prepare it before publishing nodes.
let absent: optional V = none;
let required: long = _hashNextSize(this.length);
let capacity: long = 0;
if let buckets = this.buckets { capacity = buckets.length; }
let nextCapacity: long = _hashCapacity(capacity, required);
if nextCapacity != capacity {
let target = this._rehash(nextCapacity);
let bucket: long = _hashBucket(hash, nextCapacity);
let inserted = new _MapNode<K, V>(hash, key, value, target[bucket]);
target[bucket] = inserted;
let published: optional array<_MapNode<K, V>> = some(target);
this.buckets = published;
} else {
if let buckets = this.buckets {
let bucket: long = _hashBucket(hash, capacity);
let inserted = new _MapNode<K, V>(hash, key, value, buckets[bucket]);
buckets[bucket] = inserted;
}
}
this.length = required;
this.busy = false;
return absent;
}
fn put(entry: keyval<K, V>) -> optional V {
return this._associate(entry.key(), entry.value(), true);
}
fn remove(key: K) -> optional V {
this._begin();
let hash: long = this._hash(key);
if let buckets = this.buckets {
let bucket: long = _hashBucket(hash, buckets.length);
let previous: optional _MapNode<K, V> = none;
let current: optional _MapNode<K, V> = buckets[bucket];
while current.hasSome() {
if let node = current {
if node.hash == hash && this._equals(node.key, key) {
let retrieved: optional V = some(node.value);
let next: optional _MapNode<K, V> = node.next;
let length: long = this.length - 1;
if let predecessor = previous { predecessor.next = next; }
else {
if let successor = next { buckets[bucket] = successor; }
else { buckets.clear(bucket); }
}
this.length = length;
this.busy = false;
return retrieved;
}
previous = current;
current = node.next;
}
}
}
this.busy = false;
return none;
}
fn clear() {
this._check();
this.buckets = none;
this.length = 0;
}
fn cursor() -> Cursor<keyval<K, V>> {
let head: optional _SnapshotNode<keyval<K, V>> = none;
if let buckets = this.buckets {
let index: long = 0;
while index < buckets.length {
let current: optional _MapNode<K, V> = buckets[index];
while current.hasSome() {
if let node = current {
let captured = new keyval<K, V>(node.key, node.value);
head = some(new _SnapshotNode<keyval<K, V>>(captured, head));
current = node.next;
}
}
index = index + 1;
}
}
return new _SnapshotCursor<keyval<K, V>>(head) as Cursor<keyval<K, V>>;
}
}
@@ -3,3 +3,5 @@ pub contract Cursor<T>;
pub struct linked<T>;
pub struct set<T>;
pub contract Identity<T>;
pub struct map<K, V>;
pub struct keyval<K, V>;
@@ -0,0 +1,27 @@
import {map, keyval} from @sdk:collections;
fn mapsExample() -> int {
let scores = new map<str, optional int>();
scores["left"] = some(20);
let previous = scores.put(new keyval<str, optional int>("right", some(22)));
if previous.hasSome() { return 0; }
scores["empty"] = none;
if scores.containsKey("empty") == false { return 0; }
if let empty = scores["empty"] {
if empty.hasSome() { return 0; }
} else { return 0; }
if scores["missing"].hasSome() { return 0; }
let captured = scores.cursor();
scores["left"] = some(0);
scores.clear();
let total: int = 0;
while true {
if let entry = captured.current() {
if let value = entry.value() { total = total + value; }
} else { break; }
if captured.hasNext() { captured.next(); }
else { break; }
}
return total;
}
@@ -6,3 +6,4 @@ pub fn collectionsExample() -> int;
pub fn linkedExample() -> int;
pub fn setExample() -> int;
pub fn hashingExample() -> int;
pub fn mapsExample() -> int;
@@ -124,6 +124,29 @@ class PbsGateUSdkInterfaceConformanceTest {
assertTrue(copied.hasErrors());
}
@Test
void mapExportsUseOriginCheckedKeyTypingAndPrivateAssociations() throws IOException {
var positive=compileWorkspaceModule(tempDir.resolve("map-positive"),"""
import {map as Maps,keyval as Entry} from @sdk:collections;
[Frame] fn frame()->void{
let m:Maps<str,optional int>=new Maps();m["a"]=none;
let previous=m.put(new Entry<str,optional int>("a",some(42)));
if let value=m["a"]{if (value else 0)!=42{let failure=1/0;}}else{let failure=1/0;}
}
""","pub fn frame()->void;",1,null);
assertFalse(positive.diagnostics().hasErrors(),positive.diagnostics().toString());
for(var entry:java.util.Map.of(
"optional","let m=new map<optional int,int>();",
"key","let m=new map<str,int>();m[0]=42;",
"private","let m=new map<int,int>();let exposed=m.buckets;",
"association","let e=new keyval<int,int>(20,22);e.storedKey=0;",
"capacity","let m=new map<int,int>(8);").entrySet()){
var negative=compileWorkspaceModule(tempDir.resolve("map-negative-"+entry.getKey()),
"import {map,keyval} from @sdk:collections;[Frame]fn frame()->void{"+entry.getValue()+"}","pub fn frame()->void;",1,null);
assertTrue(negative.diagnostics().hasErrors(),entry.getKey());
}
}
@Test
void removedInputObjectsExplainTheirMigration() throws IOException {
final var result = compileWorkspaceModule(tempDir.resolve("removed-input"), """
@@ -0,0 +1,79 @@
package p.studio.compiler.pbs;
import org.junit.jupiter.api.Test;
import p.studio.compiler.models.SourceKind;
import p.studio.compiler.source.diagnostics.DiagnosticSink;
import p.studio.compiler.source.identifiers.FileId;
import java.nio.charset.StandardCharsets;
import static org.junit.jupiter.api.Assertions.*;
class PbsMapKeyvalTest {
private DiagnosticSink compile(String source)throws Exception {
String sdk;
try(var stream=getClass().getResourceAsStream("/game/stdlib/1/sdk/collections/main.pbs")){
assertNotNull(stream);sdk=new String(stream.readAllBytes(),StandardCharsets.UTF_8);
}
var diagnostics=DiagnosticSink.empty();
new PbsFrontendCompiler().compileFile(new FileId(0),sdk+"\n"+source,diagnostics,SourceKind.SDK_INTERFACE);
return diagnostics;
}
private void accepts(String source)throws Exception {
var diagnostics=compile(source);assertFalse(diagnostics.hasErrors(),()->diagnostics.stream().map(d->d.getCode()+":"+d.getMessage()).toList().toString());
}
private void rejects(String source,String code)throws Exception {
var diagnostics=compile(source);assertTrue(diagnostics.stream().anyMatch(d->d.getCode().contains(code)),()->diagnostics.stream().map(d->d.getCode()+":"+d.getMessage()).toList().toString());
}
@Test void keyAndValueApplicationsHaveIndependentRules()throws Exception {
accepts("""
fn main()->optional int {
let a:map<str,optional int>=new map<>();a["a"]=none;
let b:map<str,optional int>=new map();b["a"]=some(42);
let entry:keyval<str,optional int>=new keyval("a",none);
let prior:optional (optional int)=b.put(entry);
let detached=new keyval<optional int,optional int>(none,some(42));
return detached.value();
}
""");
rejects("fn main(){let m=new map<optional int,int>();}","MAP_OPTIONAL_KEY");
rejects("fn main(){let m=new map<(optional int),int>();}","MAP_OPTIONAL_KEY");
rejects("""
declare service Policy {}
implements Identity<optional int> for Policy using p {
fn hash(v:optional int)->long{return 0;}fn equals(a:optional int,b:optional int)->bool{return true;}
}
fn main(){let m=new map<optional int,int>(Policy);}
""","MAP_OPTIONAL_KEY");
rejects("fn main(){let m=new map();}","GENERIC_CONTEXT");
rejects("fn main(){let k=new keyval(1,2);}","GENERIC_CONTEXT");
rejects("fn main(){let m:map<int,long>=new map<int,int>();}","GENERIC_TYPE_MISMATCH");
rejects("fn main(){let m=new map<str,int>();m[0]=42;}","MAP_KEY_TYPE");
rejects("fn main(){let m=new map<str,int>();m[\"a\"]=false;}","ASSIGN_TYPE_MISMATCH");
}
@Test void strategiesAreNominalAndNeverRequiredForValues()throws Exception {
accepts("""
declare struct Box<T>(value:T){fn get()->T{return this.value;}}
fn main(){let m=new map<Box<int>,Box<int>>();m[new Box(20)]=new Box(22);}
""");
accepts("""
declare service Policy {}
implements Identity<(a:int,b:int)> for Policy using p {
fn hash(v:(a:int,b:int))->long{return 0;}
fn equals(a:(a:int,b:int),b:(a:int,b:int))->bool{return a.a==b.a&&a.b==b.b;}
}
fn main(){let m=new map<(a:int,b:int),optional int>(Policy);m[(a:20,b:22)]=none;}
""");
accepts("fn main(){let m=new map<int,(a:int,b:int)>();m[1]=(a:20,b:22);}");
rejects("fn main(){let m=new map<(a:int,b:int),int>();}","MAP_IDENTITY_REQUIRED");
rejects("fn main(){let k=new keyval<int,int>(20,22);k.storedKey=42;}","ACCESS_DENIED");
rejects("fn main(){let k=new keyval<int,int>(20,22);let hidden=k.storedValue;}","ACCESS_DENIED");
rejects("fn main(){let m=new map<int,int>();m._at(0);}","PRIVATE");
var source="declare struct map<K,V>(pub key:K,pub value:V);fn main(){let m=new map<optional int,optional int>(none,none);}";
var diagnostics=DiagnosticSink.empty();new PbsFrontendCompiler().compileFile(new FileId(0),source,diagnostics);
assertFalse(diagnostics.hasErrors(),diagnostics.toString());
}
@Test void reservedMapBindingCannotBeForgedByProjectCode() {
var diagnostics=DiagnosticSink.empty();new PbsFrontendCompiler().compileFile(new FileId(0),
"[SdkMap] declare struct map<K,V>(key:K,value:V);",diagnostics);
assertTrue(diagnostics.hasErrors());
}
}
@@ -0,0 +1,60 @@
package p.studio.compiler.pbs.semantics;
import org.junit.jupiter.api.Test;
import p.studio.compiler.pbs.ast.PbsAst;
import p.studio.compiler.pbs.lexer.PbsLexer;
import p.studio.compiler.pbs.parser.PbsParser;
import p.studio.compiler.source.diagnostics.DiagnosticSink;
import p.studio.compiler.source.identifiers.FileId;
import p.studio.utilities.structures.ReadOnlyList;
import java.nio.charset.StandardCharsets;
import java.util.Set;
import java.util.stream.Collectors;
import static org.junit.jupiter.api.Assertions.*;
class PbsMapKeyvalEditorialTest {
@Test void concretePublicApiAndIndexResultsRetainSdkOrigins()throws Exception {
var diagnostics=DiagnosticSink.empty();var sdkId=new FileId(1);String sdk;
try(var stream=getClass().getResourceAsStream("/game/stdlib/1/sdk/collections/main.pbs")){
assertNotNull(stream);sdk=new String(stream.readAllBytes(),StandardCharsets.UTF_8);
}
var library=PbsParser.parse(PbsLexer.lex(sdk,sdkId,diagnostics),sdkId,diagnostics,PbsParser.ParseMode.INTERFACE_MODULE);
var source="""
import {map as Maps,keyval as Entry,Cursor} from @sdk:collections;
fn sample(values:Maps<str,optional int>,entry:Entry<str,optional int>)->optional (optional int){
let created:Maps<str,optional int>=new Maps();
let association:Entry<str,optional int>=new Entry("a",none);
values.put(entry);entry.key();entry.value();return values["a"];
}
""";
var id=new FileId(2);var ast=PbsParser.parse(PbsLexer.lex(source,id,diagnostics),id,diagnostics);
var declarations=new java.util.ArrayList<PbsAst.TopDecl>(library.topDecls().stream().toList());
for(var binding:java.util.Map.of("map","Maps","keyval","Entry").entrySet()){
var origin=library.topDecls().stream().filter(d->d instanceof PbsAst.StructDecl s&&s.name().equals(binding.getKey())).findFirst().orElseThrow();
declarations.add(new PbsAst.TypeBindingDecl(binding.getValue(),origin,ast.span()));
}
var supplemental=ReadOnlyList.wrap(declarations);var service=new PbsEditorialSupportService();
assertFalse(diagnostics.hasErrors(),diagnostics.toString());
int put=source.indexOf("values.put")+7;
var methods=service.completion(source,ast,supplemental,put);
assertEquals(Set.of("containsKey","put","remove","clear","size","isEmpty","cursor"),methods.stream().map(c->c.label()).collect(Collectors.toSet()));
var hover=service.hover(source,ast,supplemental,put).orElseThrow();
assertTrue(hover.signatures().getFirst().label().contains("optional int"),hover.toString());
assertEquals(sdkId,service.definition(source,ast,supplemental,put).getFirst().span().getFileId());
int key=source.indexOf("entry.key")+6;
assertEquals(Set.of("key","value"),service.completion(source,ast,supplemental,key).stream().map(c->c.label()).collect(Collectors.toSet()));
assertTrue(service.hover(source,ast,supplemental,key).orElseThrow().signatures().getFirst().label().contains("str"));
int construction=source.indexOf("new Maps(")+9;
var ctors=service.signatureHelp(source,ast,supplemental,construction).orElseThrow().signatures();
assertEquals(2,ctors.size());assertTrue(ctors.stream().noneMatch(s->s.label().contains("buckets")||s.label().contains("$generic$")));
var entryCtor=service.signatureHelp(source,ast,supplemental,source.indexOf("new Entry(")+10).orElseThrow();
assertTrue(entryCtor.signatures().getFirst().label().contains("key: str"),entryCtor.toString());
assertTrue(service.rename(source,ast,supplemental,source.indexOf("values:Maps"),"scores").allowed());
assertTrue(service.references(source,ast,supplemental,source.indexOf("values:Maps")).size()>=3);
String invalid=source.replace("entry.key();","entry.storedKey;entry.key();");
var invalidAst=PbsParser.parse(PbsLexer.lex(invalid,id,diagnostics),id,diagnostics);
int hidden=invalid.indexOf("entry.storedKey")+6;
assertTrue(service.hover(invalid,invalidAst,supplemental,hidden).isEmpty());
assertTrue(service.definition(invalid,invalidAst,supplemental,hidden).isEmpty());
}
}