feat(pbs): add Map and read-only Keyval associations
This commit is contained in:
+18
-4
@@ -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());
|
||||
|
||||
+7
-1
@@ -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);
|
||||
|
||||
+7
-1
@@ -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();
|
||||
|
||||
+12
-5
@@ -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);
|
||||
|
||||
+1
-1
@@ -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(),
|
||||
|
||||
+29
-3
@@ -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);
|
||||
|
||||
+4
@@ -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()));
|
||||
|
||||
+7
@@ -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());
|
||||
|
||||
+200
-10
@@ -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>>;
|
||||
}
|
||||
}
|
||||
|
||||
+2
@@ -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>;
|
||||
|
||||
+27
@@ -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;
|
||||
}
|
||||
+1
@@ -6,3 +6,4 @@ pub fn collectionsExample() -> int;
|
||||
pub fn linkedExample() -> int;
|
||||
pub fn setExample() -> int;
|
||||
pub fn hashingExample() -> int;
|
||||
pub fn mapsExample() -> int;
|
||||
|
||||
+23
@@ -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"), """
|
||||
|
||||
+79
@@ -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());
|
||||
}
|
||||
}
|
||||
+60
@@ -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());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user