feat(pbs): add mutable lists and stable snapshot cursors
Implement SDK list<T> and Cursor<T> with trusted compiler bindings and generic storage publication across IR and PBX. Pin the runtime provider and include specs, conformance coverage, installed examples, and DSC-0090 lessons.
This commit is contained in:
+45
-5
@@ -237,6 +237,10 @@ public final class PbsGenericInstantiation {
|
||||
error("ARITY", name(template)+" requires "+parameters(template).size()+" explicit type argument(s)", site);
|
||||
return null;
|
||||
}
|
||||
if (PbsSdkCollections.isList(template) && PbsSdkCollections.directOptional(arguments.getFirst())) {
|
||||
error("LIST_OPTIONAL_ELEMENT", "SDK list<T> does not permit a directly optional element", site);
|
||||
return null;
|
||||
}
|
||||
var application = PbsAst.TypeRef.applied(name(template), arguments, template.span());
|
||||
var applicationKey = template instanceof PbsAst.FunctionDecl ? PbsContractTypes.nominal(template)+"["+
|
||||
arguments.stream().map(types::key).map(k -> k.length()+":"+k).collect(Collectors.joining())+"]" : types.key(application);
|
||||
@@ -357,6 +361,7 @@ public final class PbsGenericInstantiation {
|
||||
current = probe.concrete.values().stream().flatMap(Collection::stream).toList();
|
||||
}
|
||||
var supplemental = new ArrayList<PbsAst.TopDecl>(witnesses);
|
||||
if(request!=null)probe.addShapeImplementations(request,supplemental);
|
||||
var visible = new ArrayList<PbsAst.TopDecl>(source.visible().asList());
|
||||
visible.addAll(source.ast().topDecls().asList());
|
||||
var shapeKeys = new HashSet<String>();
|
||||
@@ -374,11 +379,12 @@ public final class PbsGenericInstantiation {
|
||||
while (!probe.pending.isEmpty()) {
|
||||
var dependency = probe.pending.removeFirst();
|
||||
if (dependency == request) continue;
|
||||
var fullShape = dependency.template() instanceof PbsAst.FunctionDecl || probe.requiredShapes.contains(dependency.name());
|
||||
var fullShape = dependency.template() instanceof PbsAst.FunctionDecl || dependency.template() instanceof PbsAst.ContractDecl || probe.requiredShapes.contains(dependency.name());
|
||||
var shape = fullShape ? probe.concreteDeclaration(dependency, probe.shapeRewriter(
|
||||
probe.environment(dependency.template(), dependency.arguments()), PbsAst.TypeRef.simple(dependency.name(), dependency.template().span())))
|
||||
: probe.anchors.get(dependency.name());
|
||||
if (shape != null) { supplemental.add(shape); probe.types.index(shape); }
|
||||
probe.addShapeImplementations(dependency,supplemental);
|
||||
}
|
||||
for (var bindings : probe.argumentBindings.values()) for (var binding : bindings.entrySet())
|
||||
supplemental.add(new PbsAst.TypeBindingDecl(binding.getKey(), binding.getValue(), template.span()));
|
||||
@@ -394,6 +400,20 @@ public final class PbsGenericInstantiation {
|
||||
}
|
||||
}
|
||||
|
||||
private void addShapeImplementations(Request request,List<PbsAst.TopDecl> output) {
|
||||
if(!(request.template() instanceof PbsAst.StructDecl template))return;
|
||||
for(var rule:rules)if(!rule.typeParameters().isEmpty() && types.declaration(rule.ownerType())==template) {
|
||||
var bindings=new LinkedHashMap<String,PbsAst.TypeRef>();
|
||||
for(int i=0;i<rule.ownerType().arguments().size();i++)
|
||||
bindings.put(rule.ownerType().arguments().get(i).name(),request.arguments().get(i));
|
||||
var owner=PbsAst.TypeRef.simple(request.name(),template.span());
|
||||
var rewrite=shapeRewriter(bindings,owner);
|
||||
rewrite.implicitLocals=Map.of(rule.binderName(),owner);
|
||||
output.add(new PbsAst.ImplementsDecl(ReadOnlyList.empty(),rewrite.type(rule.contractType()),owner,
|
||||
rule.binderName(),PbsAstRewriter.map(rule.methods(),rewrite::function),rule.span()));
|
||||
}
|
||||
}
|
||||
|
||||
private ConcreteRewriter shapeRewriter(Map<String, PbsAst.TypeRef> bindings, PbsAst.TypeRef owner) {
|
||||
return new ConcreteRewriter(bindings, owner, List.of()) {
|
||||
@Override public PbsAst.FunctionDecl function(PbsAst.FunctionDecl f) {
|
||||
@@ -496,6 +516,21 @@ public final class PbsGenericInstantiation {
|
||||
locals.put(l.name(), expected == null ? infer(value) : expected);
|
||||
return new PbsAst.LetStatement(l.isConst(), l.name(), l.nameSpan(), expected, value, l.span());
|
||||
}
|
||||
if(s instanceof PbsAst.IfStatement i && i.bindingName()!=null) {
|
||||
var condition=expression(i.condition());
|
||||
var optional=infer(condition);
|
||||
var previous=locals;locals=new HashMap<>(locals);
|
||||
PbsAst.Block thenBlock;
|
||||
try {
|
||||
if(optional!=null && optional.kind()==PbsAst.TypeRefKind.OPTIONAL) {
|
||||
locals.put(i.bindingName(),optional.inner());
|
||||
if(symbolicProbe && optional.inner().name()!=null)requiredShapes.add(optional.inner().name());
|
||||
}
|
||||
thenBlock=block(i.thenBlock());
|
||||
} finally {locals=previous;}
|
||||
return new PbsAst.IfStatement(condition,thenBlock,
|
||||
i.elseIf()==null?null:(PbsAst.IfStatement)statement(i.elseIf()),block(i.elseBlock()),i.span(),i.bindingName(),i.bindingSpan());
|
||||
}
|
||||
if (s instanceof PbsAst.ReturnStatement r) return new PbsAst.ReturnStatement(expression(r.value(), result), r.span());
|
||||
if (s instanceof PbsAst.AssignStatement a) {
|
||||
var target = a.target().expression();
|
||||
@@ -596,11 +631,12 @@ public final class PbsGenericInstantiation {
|
||||
}
|
||||
var concreteType = type(applied);
|
||||
if (symbolicProbe) requiredShapes.add(concreteType.name());
|
||||
var fields = constructorParameters(concreteType, n.ctorName());
|
||||
var constructor = PbsSdkCollections.isList(s) && n.ctorName() == null ? "make" : n.ctorName();
|
||||
var fields = constructorParameters(concreteType, constructor, n.arguments().size());
|
||||
var arguments = new ArrayList<PbsAst.Expression>();
|
||||
for (int i = 0; i < n.arguments().size(); i++) arguments.add(expression(n.arguments().get(i),
|
||||
fields.size() == n.arguments().size() ? fields.get(i).typeRef() : null));
|
||||
return new PbsAst.NewExpr(concreteType.name(), n.ctorName(), ReadOnlyList.wrap(arguments), null, false, n.span());
|
||||
return new PbsAst.NewExpr(concreteType.name(), constructor, ReadOnlyList.wrap(arguments), null, false, n.span());
|
||||
}
|
||||
}
|
||||
return super.expression(e, expected);
|
||||
@@ -611,6 +647,10 @@ public final class PbsGenericInstantiation {
|
||||
case PbsAst.IdentifierExpr i -> locals.get(i.name());
|
||||
case PbsAst.ThisExpr t -> self;
|
||||
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());
|
||||
yield receiver!=null && receiver.kind()==PbsAst.TypeRefKind.ARRAY ? PbsAst.TypeRef.optional(receiver.inner(),i.span()) : null;
|
||||
}
|
||||
case PbsAst.GroupExpr g -> infer(g.expression());
|
||||
case PbsAst.CallExpr c -> { var callables = callableSignatures(c.callee()); yield callables.size() == 1 ? callables.getFirst().returnType() : null; }
|
||||
case PbsAst.MemberExpr m -> {
|
||||
@@ -669,14 +709,14 @@ public final class PbsGenericInstantiation {
|
||||
private PbsAst.FunctionSignature signature(PbsAst.FunctionDecl f) {
|
||||
return new PbsAst.FunctionSignature(f.name(), f.parameters(), f.returnKind(), f.returnType(), f.resultErrorType(), f.attributes(), f.span());
|
||||
}
|
||||
private ReadOnlyList<PbsAst.Parameter> constructorParameters(PbsAst.TypeRef owner, String constructor) {
|
||||
private ReadOnlyList<PbsAst.Parameter> constructorParameters(PbsAst.TypeRef owner, String constructor, int arity) {
|
||||
var d = types.declaration(owner);
|
||||
var origin = PbsContractTypes.applicationOrigin(d);
|
||||
if (origin != null) d = origin.declaration();
|
||||
if (!(d instanceof PbsAst.StructDecl s)) return ReadOnlyList.empty();
|
||||
var rewrite = origin == null ? this : new ConcreteRewriter(environment(s, origin.arguments()), owner, chain);
|
||||
if (constructor == null) return map(s.fields(), f -> new PbsAst.Parameter(f.name(), rewrite.type(f.typeRef()), f.span()));
|
||||
var candidates = s.ctors().stream().filter(c -> c.name().equals(constructor)).toList();
|
||||
var candidates = s.ctors().stream().filter(c -> c.name().equals(constructor) && c.parameters().size() == arity).toList();
|
||||
return candidates.size() == 1 ? map(candidates.getFirst().parameters(), rewrite::parameter) : ReadOnlyList.empty();
|
||||
}
|
||||
}
|
||||
|
||||
+6
-2
@@ -93,6 +93,9 @@ final class PbsGenericTemplateValidator {
|
||||
} else if (s instanceof PbsAst.ReturnStatement r) checkCompatible(infer(r.value(), result), result, r.span());
|
||||
else if (s instanceof PbsAst.AssignStatement a) {
|
||||
var target = a.target().expression() == null ? locals.get(a.target().rootName()) : infer(a.target().expression(), null);
|
||||
// Indexed writes accept the element, while indexed reads are optional.
|
||||
if(a.target().expression() instanceof PbsAst.IndexExpr && target!=null && target.kind()==PbsAst.TypeRefKind.OPTIONAL)
|
||||
target=target.inner();
|
||||
checkCompatible(infer(a.value(), target), target, a.span());
|
||||
if (a.operator() != PbsAst.AssignOperator.ASSIGN && symbolic(target)) capability(a.span());
|
||||
}
|
||||
@@ -150,8 +153,9 @@ 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 expectedParameters = n.ctorName() == 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(n.ctorName())).findFirst().map(c ->
|
||||
var constructor = PbsSdkCollections.isList(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());
|
||||
checkArguments(n.arguments(), List.of(new Callable(expectedParameters, result)), n.span());
|
||||
}
|
||||
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
package p.studio.compiler.pbs;
|
||||
|
||||
import p.studio.compiler.pbs.ast.PbsAst;
|
||||
import p.studio.utilities.structures.ReadOnlyList;
|
||||
|
||||
/** Reserved SDK bindings retain parser-established origin through specialization. */
|
||||
public final class PbsSdkCollections {
|
||||
private PbsSdkCollections() {}
|
||||
public static boolean isList(PbsAst.TopDecl declaration) {
|
||||
return declaration instanceof PbsAst.StructDecl s && attribute(s.attributes(), "SdkList") != null;
|
||||
}
|
||||
public static PbsAst.Attribute attribute(ReadOnlyList<PbsAst.Attribute> attributes, String name) {
|
||||
return attributes.stream().filter(a -> a.trustedSdkOrigin() && a.name().equals(name)).findFirst().orElse(null);
|
||||
}
|
||||
public static String argument(PbsAst.Attribute attribute, String name) {
|
||||
var value=attribute.arguments().stream().filter(a -> a.name().equals(name))
|
||||
.map(PbsAst.AttributeArgument::value).findFirst().orElse(null);
|
||||
if (!(value instanceof PbsAst.AttributeStringValue s)) throw new IllegalArgumentException("Missing SDK binding argument: "+name);
|
||||
var text=s.value();
|
||||
return text.startsWith("\"") ? text.substring(1,text.length()-1) : text;
|
||||
}
|
||||
public static boolean directOptional(PbsAst.TypeRef type) {
|
||||
while(type!=null && type.kind()==PbsAst.TypeRefKind.GROUP)type=type.inner();
|
||||
return type!=null && type.kind()==PbsAst.TypeRefKind.OPTIONAL;
|
||||
}
|
||||
}
|
||||
+5
-1
@@ -70,7 +70,11 @@ public final class PbsAst {
|
||||
public record Attribute(
|
||||
String name,
|
||||
ReadOnlyList<AttributeArgument> arguments,
|
||||
Span span) {
|
||||
Span span,
|
||||
boolean trustedSdkOrigin) {
|
||||
public Attribute(String name, ReadOnlyList<AttributeArgument> arguments, Span span) {
|
||||
this(name,arguments,span,false);
|
||||
}
|
||||
}
|
||||
|
||||
public record AttributeArgument(
|
||||
|
||||
+149
-6
@@ -60,7 +60,11 @@ final class PbsExecutableBodyLowerer {
|
||||
}
|
||||
var binding = functionDecl.attributes().stream().filter(a -> "IntrinsicCall".equals(a.name())).findFirst();
|
||||
final boolean terminated;
|
||||
if (binding.isPresent()) {
|
||||
var storageBinding = p.studio.compiler.pbs.PbsSdkCollections.attribute(functionDecl.attributes(), "StoragePrimitive");
|
||||
if (storageBinding != null) {
|
||||
lowerStoragePrimitive(functionDecl,storageBinding,context);
|
||||
terminated = true;
|
||||
} else if (binding.isPresent()) {
|
||||
var attribute = binding.get();
|
||||
var name = attribute.arguments().stream().filter(a -> "name".equals(a.name()))
|
||||
.map(a -> ((PbsAst.AttributeStringValue) a.value()).value()).findFirst().orElseThrow();
|
||||
@@ -664,6 +668,19 @@ final class PbsExecutableBodyLowerer {
|
||||
offset+=width;
|
||||
}
|
||||
}
|
||||
var nativeFields=receiverType==null?null:context.types().fields.get(receiverType.name());
|
||||
if(nativeFields!=null) {
|
||||
lowerExpected(memberExpr.receiver(),receiverType,context);
|
||||
int slot=save(context.types().slots(receiverType),memberExpr.span(),context),offset=0;
|
||||
for(var field:nativeFields) {
|
||||
int width=context.types().slots(field.typeRef());
|
||||
if(field.name().equals(memberExpr.memberName())) {
|
||||
emitLoadLocalSlots(slot+offset,width,memberExpr.span(),context);return;
|
||||
}
|
||||
offset+=width;
|
||||
}
|
||||
reportUnsupportedLowering("Unknown native field",memberExpr.span(),context);return;
|
||||
}
|
||||
var struct = receiverType == null ? null : context.types().structs.get(receiverType.name());
|
||||
if (struct != null) {
|
||||
for (int i=0;i<struct.fields().size();i++) if (struct.fields().get(i).name().equals(memberExpr.memberName())) {
|
||||
@@ -1066,6 +1083,7 @@ final class PbsExecutableBodyLowerer {
|
||||
if (!(argument instanceof PbsAst.TupleExpr tuple) || tuple.items().isEmpty() || tuple.items().getFirst().label() == null) {
|
||||
lowerCallExpression(call, c); return;
|
||||
}
|
||||
if(lowerNamedStructApply(apply,tuple,c))return;
|
||||
var signature = c.types().signatures.get(PbsRuntimeTypes.path(call.callee())+"#"+call.arguments().size());
|
||||
if(signature == null) { reportUnsupportedLowering("Named application requires a resolved signature", apply.span(), c); return; }
|
||||
var slots = new java.util.HashMap<String,Integer>();
|
||||
@@ -1087,6 +1105,41 @@ final class PbsExecutableBodyLowerer {
|
||||
callsiteEmitter.emitCallsite(call,c);
|
||||
}
|
||||
|
||||
private boolean lowerNamedStructApply(PbsAst.ApplyExpr apply,PbsAst.TupleExpr tuple,PbsExecutableLoweringContext c) {
|
||||
if(!(apply.callee() instanceof PbsAst.MemberExpr member))return false;
|
||||
var owner=PbsRuntimeTypes.unwrap(expressionType(member.receiver(),c));
|
||||
var declaration=owner==null?null:c.types().structs.get(owner.name());
|
||||
if(declaration==null)return false;
|
||||
var methods=declaration.methods().stream().filter(m->m.name().equals(member.memberName())&&m.parameters().size()==tuple.items().size()).toList();
|
||||
if(methods.size()!=1)return false;
|
||||
var method=methods.getFirst();
|
||||
boolean listIndex=p.studio.compiler.pbs.PbsSdkCollections.isList(declaration)&&java.util.Set.of("insert","clearAt","removeAt","resize","reserve").contains(member.memberName());
|
||||
var receiverName=c.nextLabel("named_receiver");
|
||||
lowerExpected(member.receiver(),owner,c);
|
||||
int receiver=c.declareLocalSlots(receiverName,1);c.localTypes.put(receiverName,owner);
|
||||
emitStoreLocalSlots(receiver,1,member.span(),c);
|
||||
var values=new java.util.HashMap<String,String>();
|
||||
for(var item:tuple.items()) {
|
||||
int ordinal=-1;
|
||||
for(int i=0;i<method.parameters().size();i++)if(method.parameters().get(i).name().equals(item.label()))ordinal=i;
|
||||
if(ordinal<0||values.containsKey(item.label())){reportUnsupportedLowering("Unknown or duplicate named argument",item.span(),c);return true;}
|
||||
var type=PbsTypeSubstitution.replaceSelf(method.parameters().get(ordinal).typeRef(),owner.name());
|
||||
if(listIndex&&ordinal==0)lowerArrayIndex(item.expression(),c);else lowerExpected(item.expression(),type,c);
|
||||
var name=c.nextLabel("named_argument");int slot=c.declareLocalSlots(name,c.types().slots(type));
|
||||
c.localTypes.put(name,type);emitStoreLocalSlots(slot,c.types().slots(type),item.span(),c);values.put(item.label(),name);
|
||||
}
|
||||
var arguments=new java.util.ArrayList<PbsAst.Expression>();
|
||||
for(var parameter:method.parameters()) {
|
||||
var name=values.get(parameter.name());
|
||||
if(name==null){reportUnsupportedLowering("Missing named argument",apply.span(),c);return true;}
|
||||
arguments.add(new PbsAst.IdentifierExpr(name,apply.span()));
|
||||
}
|
||||
var callee=new PbsAst.MemberExpr(new PbsAst.IdentifierExpr(receiverName,member.span()),member.memberName(),member.span());
|
||||
if(!lowerStructuredCall(new PbsAst.CallExpr(callee,ReadOnlyList.wrap(arguments),apply.span()),c))
|
||||
reportUnsupportedLowering("Named method requires its exact signature",apply.span(),c);
|
||||
return true;
|
||||
}
|
||||
|
||||
private void lowerExpected(PbsAst.Expression expression, PbsAst.TypeRef expected, PbsExecutableLoweringContext context) {
|
||||
var previous = context.expectedType;
|
||||
context.expectedType = expected;
|
||||
@@ -1109,7 +1162,14 @@ final class PbsExecutableBodyLowerer {
|
||||
if (e instanceof PbsAst.ThisExpr) return c.localTypes.getOrDefault("this", c.serviceOwner == null ? null : PbsRuntimeTypes.type(c.serviceOwner));
|
||||
if (e instanceof PbsAst.SomeExpr some) return PbsAst.TypeRef.optional(expressionType(some.value(), c), some.span());
|
||||
if (e instanceof PbsAst.ElseExpr fallback) {var opt = PbsRuntimeTypes.unwrap(expressionType(fallback.optionalExpression(), c)); return opt == null ? null : opt.inner();}
|
||||
if (e instanceof PbsAst.IndexExpr index) {var array = PbsRuntimeTypes.unwrap(expressionType(index.receiver(), c)); return array == null ? null : PbsAst.TypeRef.optional(array.inner(), index.span());}
|
||||
if (e instanceof PbsAst.IndexExpr index) {
|
||||
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.isList(declaration)
|
||||
? declaration.methods().stream().filter(m->m.name().equals("_at")).findFirst().orElseThrow().returnType()
|
||||
: PbsAst.TypeRef.optional(array.inner(),index.span());
|
||||
}
|
||||
if (e instanceof PbsAst.MemberExpr member) {
|
||||
var serviceType = expressionType(member.receiver(), c);
|
||||
var service = serviceType == null ? null : c.types().services.get(serviceType.name());
|
||||
@@ -1123,6 +1183,8 @@ final class PbsExecutableBodyLowerer {
|
||||
for (var field : receiver.fields()) if (field.label().equals(member.memberName())) return field.typeRef();
|
||||
var struct = receiver == null ? null : c.types().structs.get(receiver.name());
|
||||
if (struct != null) for (var field : struct.fields()) if (field.name().equals(member.memberName())) return field.typeRef();
|
||||
var builtinFields=receiver==null?null:c.types().fields.get(receiver.name());
|
||||
if(builtinFields!=null)for(var field:builtinFields)if(field.name().equals(member.memberName()))return field.typeRef();
|
||||
}
|
||||
if (e instanceof PbsAst.IdentifierExpr i) {
|
||||
if(c.types().services.containsKey(i.name()))return PbsRuntimeTypes.type(i.name());
|
||||
@@ -1551,6 +1613,78 @@ final class PbsExecutableBodyLowerer {
|
||||
span);
|
||||
}
|
||||
|
||||
private void lowerStoragePrimitive(PbsAst.FunctionDecl function, PbsAst.Attribute binding, PbsExecutableLoweringContext c) {
|
||||
var operation=p.studio.compiler.pbs.PbsSdkCollections.argument(binding,"name");
|
||||
var span=function.span();
|
||||
switch(operation) {
|
||||
case "indexGuard" -> {
|
||||
emitLoadLocalSlots(0,2,span,c);
|
||||
registry(INDEX_GUARD,null,0,2,0,span,c);
|
||||
}
|
||||
case "checkLength" -> {
|
||||
emitGetLocal(0,span,c);
|
||||
registry(ARRAY_CHECK_LENGTH,c.types().arrayStorage(),0,1,0,span,c);
|
||||
}
|
||||
case "copy" -> {
|
||||
emitLoadLocalSlots(0,5,span,c);
|
||||
registry(ARRAY_COPY,c.types().arrayStorage(),0,5,0,span,c);
|
||||
}
|
||||
case "publish" -> {
|
||||
var parameters=function.parameters();
|
||||
var optional=PbsRuntimeTypes.unwrap(parameters.get(7).typeRef());
|
||||
var payload=optional.inner();
|
||||
var owner=parameters.get(8).typeRef();
|
||||
var declaration=c.types().structs.get(owner.name());
|
||||
var firstName=p.studio.compiler.pbs.PbsSdkCollections.argument(binding,"first");
|
||||
var secondName=p.studio.compiler.pbs.PbsSdkCollections.argument(binding,"second");
|
||||
int first=-1,second=-1;
|
||||
for(int i=0;i<declaration.fields().size();i++) {
|
||||
if(declaration.fields().get(i).name().equals(firstName))first=i;
|
||||
if(declaration.fields().get(i).name().equals(secondName))second=i;
|
||||
}
|
||||
if(first<0||second<0)throw new IllegalArgumentException("Unresolved SDK storage fields");
|
||||
emitLoadLocalSlots(0,7,span,c);
|
||||
optionalPresence(7,optional,span,c);
|
||||
var absent=c.nextLabel("empty_storage_fill");var ready=c.nextLabel("storage_fill_ready");
|
||||
emitJump(IRBackendExecutableFunction.InstructionKind.JMP_IF_FALSE,absent,span,c);
|
||||
unwrapOptional(7,optional,span,c);
|
||||
packStorage(payload,span,c);
|
||||
registry(DYN_PACK,c.types().registryType(payload),0,storageWidth(payload,c),2,span,c);
|
||||
emitJump(IRBackendExecutableFunction.InstructionKind.JMP,ready,span,c);
|
||||
emitLabel(absent,span,c);emitDefault(c.types().dynamic(),2,span,c);
|
||||
emitLabel(ready,span,c);
|
||||
int offset=8,pops=9;
|
||||
for(int i=8;i<parameters.size();i++) {
|
||||
var type=parameters.get(i).typeRef();int width=c.types().slots(type);
|
||||
emitLoadLocalSlots(offset,width,span,c);packStorage(type,span,c);
|
||||
offset+=width;pops+=storageWidth(type,c);
|
||||
}
|
||||
c.instructions().add(new IRBackendExecutableFunction.Instruction(IRBackendExecutableFunction.InstructionKind.REGISTRY,
|
||||
null,"",null,null,null,"","",pops,0,span,
|
||||
new IRRegistryInstruction(STORAGE_PUBLISH,c.types().arrayStorage(),c.types().registryType(owner),null,first,second)));
|
||||
}
|
||||
default -> throw new IllegalArgumentException("Unknown private storage binding: "+operation);
|
||||
}
|
||||
c.instructions().add(new IRBackendExecutableFunction.Instruction(IRBackendExecutableFunction.InstructionKind.RET,"",null,null,span));
|
||||
}
|
||||
|
||||
private boolean lowerListIndex(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.isList(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;
|
||||
if(value!=null) {
|
||||
var element=method.parameters().get(1).typeRef();
|
||||
lowerExpected(value,element,c);pops+=c.types().slots(element);
|
||||
}
|
||||
emitStructuredFunction(type.name()+"."+name,receiverParameters(type.name(),method.parameters()),
|
||||
method.returnType(),pops,c.types().slots(method.returnType()),index.span(),c);
|
||||
return true;
|
||||
}
|
||||
|
||||
private void registry(IRRegistryInstruction.Kind kind, IRRegistry.TypeRef type, int field, int pops, int pushes, Span span, PbsExecutableLoweringContext c) {
|
||||
c.instructions().add(new IRBackendExecutableFunction.Instruction(IRBackendExecutableFunction.InstructionKind.REGISTRY,
|
||||
null, "", null, null, null, "", "", pops, pushes, span,
|
||||
@@ -1589,6 +1723,7 @@ final class PbsExecutableBodyLowerer {
|
||||
}
|
||||
private void lowerArrayWrite(PbsAst.IndexExpr index,PbsAst.Expression value,PbsExecutableLoweringContext c) {
|
||||
var type=PbsRuntimeTypes.unwrap(expressionType(index.receiver(),c));
|
||||
if(lowerListIndex(index,value,type,c))return;
|
||||
lowerExpected(index.receiver(),type,c);
|
||||
lowerArrayIndex(index.index(),c);
|
||||
lowerExpected(value,type.inner(),c);
|
||||
@@ -1598,6 +1733,7 @@ final class PbsExecutableBodyLowerer {
|
||||
}
|
||||
private void lowerArrayRead(PbsAst.IndexExpr index,PbsExecutableLoweringContext c) {
|
||||
var type=PbsRuntimeTypes.unwrap(expressionType(index.receiver(),c));
|
||||
if(lowerListIndex(index,null,type,c))return;
|
||||
var optional=PbsAst.TypeRef.optional(type.inner(),index.span());
|
||||
lowerExpected(index.receiver(),type,c);
|
||||
lowerArrayIndex(index.index(),c);
|
||||
@@ -1703,10 +1839,11 @@ final class PbsExecutableBodyLowerer {
|
||||
}
|
||||
private void lowerStructNew(PbsAst.NewExpr expr,PbsExecutableLoweringContext c) {
|
||||
var declaration=c.types().structs.get(expr.typeName());var ref=c.types().registryType(PbsRuntimeTypes.type(expr.typeName()));
|
||||
boolean list=p.studio.compiler.pbs.PbsSdkCollections.isList(declaration);
|
||||
if(expr.ctorName()!=null) {
|
||||
var ctor=declaration.ctors().stream().filter(f->f.name().equals(expr.ctorName()) && parametersMatch(f.parameters(),expr.arguments(),c)).findFirst().orElseThrow();
|
||||
var ctor=declaration.ctors().stream().filter(f->f.name().equals(expr.ctorName()) && parametersMatch(f.parameters(),expr.arguments(),c,list)).findFirst().orElseThrow();
|
||||
var arguments=new java.util.ArrayList<Integer>();
|
||||
for(int i=0;i<expr.arguments().size();i++){var type=PbsTypeSubstitution.replaceSelf(ctor.parameters().get(i).typeRef(),expr.typeName());lowerExpected(expr.arguments().get(i),type,c);arguments.add(save(c.types().slots(type),expr.span(),c));}
|
||||
for(int i=0;i<expr.arguments().size();i++){var type=PbsTypeSubstitution.replaceSelf(ctor.parameters().get(i).typeRef(),expr.typeName());if(list)lowerArrayIndex(expr.arguments().get(i),c);else lowerExpected(expr.arguments().get(i),type,c);arguments.add(save(c.types().slots(type),expr.span(),c));}
|
||||
registry(STRUCT_NEW,ref,0,0,1,expr.span(),c);int instance=save(1,expr.span(),c);emitGetLocal(instance,expr.span(),c);
|
||||
for(int i=0;i<arguments.size();i++)emitLoadLocalSlots(arguments.get(i),c.types().slots(ctor.parameters().get(i).typeRef()),expr.span(),c);
|
||||
emitStructuredFunction(expr.typeName()+".$ctor."+expr.ctorName(),receiverParameters(expr.typeName(),ctor.parameters()),PbsAst.TypeRef.unit(expr.span()),1+ctor.parameters().stream().mapToInt(p->c.types().slots(p.typeRef())).sum(),0,expr.span(),c);
|
||||
@@ -1779,10 +1916,11 @@ final class PbsExecutableBodyLowerer {
|
||||
emitStructuredFunction(owner.name()+"."+method.name(),method.parameters().stream().map(PbsAst.Parameter::typeRef).toList(),PbsTypeSubstitution.replaceSelf(method.returnType(),owner.name()),pops,c.types().slots(method.returnType()),call.span(),c);return true;
|
||||
}
|
||||
var struct=c.types().structs.get(owner.name());if(struct==null)return false;
|
||||
var method=struct.methods().stream().filter(m->m.name().equals(member.memberName())&¶metersMatch(m.parameters(),call.arguments(),c) && returnMatches(m.returnType(),owner.name(),c)).findFirst().orElse(null);
|
||||
boolean listIndex=p.studio.compiler.pbs.PbsSdkCollections.isList(struct) && java.util.Set.of("insert","clearAt","removeAt","resize","reserve").contains(member.memberName());
|
||||
var method=struct.methods().stream().filter(m->m.name().equals(member.memberName())&¶metersMatch(m.parameters(),call.arguments(),c,listIndex) && returnMatches(m.returnType(),owner.name(),c)).findFirst().orElse(null);
|
||||
if(method==null)return false;
|
||||
lowerExpected(member.receiver(),owner,c);int pops=1;
|
||||
for(int i=0;i<call.arguments().size();i++){var type=PbsTypeSubstitution.replaceSelf(method.parameters().get(i).typeRef(),owner.name());lowerExpected(call.arguments().get(i),type,c);pops+=c.types().slots(type);}
|
||||
for(int i=0;i<call.arguments().size();i++){var type=PbsTypeSubstitution.replaceSelf(method.parameters().get(i).typeRef(),owner.name());if(listIndex&&i==0)lowerArrayIndex(call.arguments().get(i),c);else lowerExpected(call.arguments().get(i),type,c);pops+=c.types().slots(type);}
|
||||
emitStructuredFunction(owner.name()+"."+method.name(),receiverParameters(owner.name(),method.parameters()),PbsTypeSubstitution.replaceSelf(method.returnType(),owner.name()),pops,c.types().slots(method.returnType()),call.span(),c);return true;
|
||||
}
|
||||
private java.util.List<PbsAst.TypeRef> receiverParameters(String owner, ReadOnlyList<PbsAst.Parameter> parameters) {
|
||||
@@ -1807,6 +1945,10 @@ final class PbsExecutableBodyLowerer {
|
||||
|
||||
private boolean parametersMatch(ReadOnlyList<PbsAst.Parameter> parameters,
|
||||
ReadOnlyList<PbsAst.Expression> arguments, PbsExecutableLoweringContext c) {
|
||||
return parametersMatch(parameters,arguments,c,false);
|
||||
}
|
||||
private boolean parametersMatch(ReadOnlyList<PbsAst.Parameter> parameters,
|
||||
ReadOnlyList<PbsAst.Expression> arguments, PbsExecutableLoweringContext c, boolean listIndex) {
|
||||
if (parameters.size() != arguments.size()) return false;
|
||||
for (int i = 0; i < parameters.size(); i++) {
|
||||
var actual = PbsRuntimeTypes.unwrap(expressionType(arguments.get(i), c));
|
||||
@@ -1817,6 +1959,7 @@ final class PbsExecutableBodyLowerer {
|
||||
|| arguments.get(i) instanceof PbsAst.NoneExpr
|
||||
|| arguments.get(i) instanceof PbsAst.NewExpr allocation
|
||||
&& allocation.typeName().equals("array") && allocation.explicitType() == null) continue;
|
||||
if (listIndex && i==0 && "int".equals(c.types().canonical(actual)) && "long".equals(c.types().canonical(expected))) continue;
|
||||
if (c.types().shapeKey(actual).equals(c.types().shapeKey(expected))) continue;
|
||||
if (arguments.get(i) instanceof PbsAst.IntLiteralExpr && "long".equals(c.types().canonical(expected))) continue;
|
||||
if (c.types().isContract(expected) && c.types().contractTypes.implementers(expected).contains(actual.name())) continue;
|
||||
|
||||
+1
@@ -69,6 +69,7 @@ final class PbsRuntimeTypes {
|
||||
for (var declaration : declarations) if (declaration instanceof PbsAst.TypeBindingDecl binding) {
|
||||
aliases.put(binding.name(), p.studio.compiler.pbs.PbsGenericInstantiation.name(binding.declaration()));
|
||||
if (binding.declaration() instanceof PbsAst.StructDecl s) structs.put(binding.name(), s);
|
||||
if (binding.declaration() instanceof PbsAst.BuiltinTypeDecl b) fields.put(binding.name(), b.fields());
|
||||
if (binding.declaration() instanceof PbsAst.ServiceDecl s) services.put(binding.name(), s);
|
||||
if (binding.declaration() instanceof PbsAst.ContractDecl c) contracts.put(binding.name(), c);
|
||||
}
|
||||
|
||||
+1
-1
@@ -51,7 +51,7 @@ final class PbsAttributeParser {
|
||||
return new PbsAst.Attribute(
|
||||
name.lexeme(),
|
||||
ReadOnlyList.wrap(arguments),
|
||||
context.span(leftBracket.start(), end));
|
||||
context.span(leftBracket.start(), end), context.parseMode() == PbsParser.ParseMode.INTERFACE_MODULE);
|
||||
}
|
||||
|
||||
private void parseAttributeArguments(final ArrayList<PbsAst.AttributeArgument> arguments) {
|
||||
|
||||
+4
-2
@@ -684,7 +684,8 @@ final class PbsDeclarationParser {
|
||||
final ReadOnlyList<PbsAst.Attribute> attributes,
|
||||
final String targetSurface) {
|
||||
for (final var attribute : attributes) {
|
||||
if ("Doc".equals(attribute.name())) {
|
||||
if ("Doc".equals(attribute.name()) || attribute.trustedSdkOrigin() &&
|
||||
"SdkList".equals(attribute.name()) && "struct declarations".equals(targetSurface)) {
|
||||
continue;
|
||||
}
|
||||
p.studio.compiler.source.diagnostics.Diagnostics.error(context.diagnostics(),
|
||||
@@ -722,7 +723,8 @@ final class PbsDeclarationParser {
|
||||
PbsAst.LifecycleMarker marker = PbsAst.LifecycleMarker.NONE;
|
||||
for (final var attribute : attributes) {
|
||||
final PbsAst.LifecycleMarker nextMarker;
|
||||
if ("Doc".equals(attribute.name())) {
|
||||
if ("Doc".equals(attribute.name()) || attribute.trustedSdkOrigin() &&
|
||||
java.util.Set.of("StoragePrimitive","SdkPrivate").contains(attribute.name())) {
|
||||
continue;
|
||||
}
|
||||
if (!isOrdinaryMode()) {
|
||||
|
||||
-18
@@ -65,12 +65,6 @@ public final class PbsDeclarationSemanticsValidator {
|
||||
final var rules = new PbsDeclarationRuleValidator(nameTable, declarationDiagnostics);
|
||||
if (topDecl instanceof PbsAst.FunctionDecl functionDecl) {
|
||||
validateDocAttributes(functionDecl.attributes(), "function declarations", declarationDiagnostics);
|
||||
if (interfaceModule) {
|
||||
reportInterfaceNonDeclarativeDecl(
|
||||
functionDecl.span(),
|
||||
"Top-level functions are not allowed in interface modules",
|
||||
declarationDiagnostics);
|
||||
}
|
||||
validateCallable(
|
||||
PbsCallableScope.topLevelFunctions(),
|
||||
functionDecl.name(),
|
||||
@@ -89,12 +83,6 @@ public final class PbsDeclarationSemanticsValidator {
|
||||
if (topDecl instanceof PbsAst.StructDecl structDecl) {
|
||||
validateDocAttributes(structDecl.attributes(), "struct declarations", declarationDiagnostics);
|
||||
binder.registerType(structDecl.name(), structDecl.span(), "struct");
|
||||
if (interfaceModule && (structDecl.hasBody() || !structDecl.methods().isEmpty() || !structDecl.ctors().isEmpty())) {
|
||||
reportInterfaceNonDeclarativeDecl(
|
||||
structDecl.span(),
|
||||
"Interface modules must not declare executable struct bodies",
|
||||
declarationDiagnostics);
|
||||
}
|
||||
validateStructDeclaration(structDecl, binder, rules, declarationDiagnostics);
|
||||
continue;
|
||||
}
|
||||
@@ -166,12 +154,6 @@ public final class PbsDeclarationSemanticsValidator {
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.ImplementsDecl implementsDecl) {
|
||||
if (interfaceModule) {
|
||||
reportInterfaceNonDeclarativeDecl(
|
||||
implementsDecl.span(),
|
||||
"Interface modules must not declare executable 'implements' blocks",
|
||||
declarationDiagnostics);
|
||||
}
|
||||
validateImplementsDeclaration(implementsDecl, binder, rules);
|
||||
}
|
||||
}
|
||||
|
||||
+7
-3
@@ -759,9 +759,9 @@ public final class PbsEditorialSupportService {
|
||||
final Map<String, PbsEditorialCompletionCandidate> completions = new LinkedHashMap<>();
|
||||
var symbolic = symbolicStruct(receiverType);
|
||||
if (symbolic != null) {
|
||||
for (var field : symbolic.fields()) completions.put(field.name(), new PbsEditorialCompletionCandidate(
|
||||
for (var field : symbolic.fields()) if(!p.studio.compiler.pbs.PbsSdkCollections.isList(symbolic)||field.isPublic()) completions.put(field.name(), new PbsEditorialCompletionCandidate(
|
||||
field.name(), PbsEditorialSymbolKind.FIELD, field.typeRef().surface(), symbolic.name()));
|
||||
for (var method : symbolic.methods()) completions.put(method.name(), new PbsEditorialCompletionCandidate(
|
||||
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(),
|
||||
method.returnKind(), method.returnType(), method.resultErrorType()).label(), symbolic.name()));
|
||||
return List.copyOf(completions.values());
|
||||
@@ -778,6 +778,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.isSdkList(receiverType)&&!field.getValue().isPublic())continue;
|
||||
completions.put(field.getKey(), new PbsEditorialCompletionCandidate(
|
||||
field.getKey(),
|
||||
PbsEditorialSymbolKind.FIELD,
|
||||
@@ -785,6 +786,7 @@ public final class PbsEditorialSupportService {
|
||||
receiverType.name()));
|
||||
}
|
||||
for (final var method : structInfo.methods().entrySet()) {
|
||||
if(model.isSdkList(receiverType)&&java.util.Set.of("_at","_put").contains(method.getKey()))continue;
|
||||
completions.put(method.getKey(), new PbsEditorialCompletionCandidate(
|
||||
method.getKey(),
|
||||
PbsEditorialSymbolKind.METHOD,
|
||||
@@ -1435,6 +1437,7 @@ public final class PbsEditorialSupportService {
|
||||
return List.of(signatureFromFunction(name, functionDecl.parameters(), functionDecl.returnKind(), functionDecl.returnType(), functionDecl.resultErrorType()));
|
||||
}
|
||||
if (topDecl instanceof PbsAst.StructDecl structDecl) return structDecl.methods().stream()
|
||||
.filter(method -> p.studio.compiler.pbs.PbsSdkCollections.attribute(method.attributes(),"SdkPrivate")==null)
|
||||
.map(method -> signatureFromFunction(method.name(), method.parameters(), method.returnKind(), method.returnType(), method.resultErrorType())).toList();
|
||||
|
||||
if (topDecl instanceof PbsAst.ServiceDecl serviceDecl) {
|
||||
@@ -1465,8 +1468,9 @@ public final class PbsEditorialSupportService {
|
||||
if (structDecl.ctors().isEmpty()) {
|
||||
return List.of(new PbsEditorialSignature(structDecl.name(), structDecl.name() + "()", List.of(), "unit"));
|
||||
}
|
||||
var display=structDecl.applicationOrigin()==null?structDecl.name():structDecl.applicationOrigin().display();
|
||||
return structDecl.ctors().stream()
|
||||
.map(ctor -> signatureFromCtor(structDecl.name(), ctor))
|
||||
.map(ctor -> signatureFromCtor(display, ctor))
|
||||
.toList();
|
||||
}
|
||||
return List.of();
|
||||
|
||||
+23
-4
@@ -49,6 +49,9 @@ final class PbsFlowCallableResolutionAnalyzer {
|
||||
return ExprResult.type(TypeView.unit());
|
||||
}
|
||||
}
|
||||
final boolean listIndexArgument = callExpr.callee() instanceof PbsAst.MemberExpr member
|
||||
&& java.util.Set.of("insert","clearAt","removeAt","resize","reserve").contains(member.memberName())
|
||||
&& context.model().isSdkList(analyzeValueExpression(member.receiver(),context,null).type());
|
||||
final var callee = analyzeTargetExpression(callExpr.callee(), context, ExprUse.CALL_TARGET);
|
||||
|
||||
final var expectedInputs = callee.callables().size() == 1 ? callee.callables().getFirst().inputTypes() : java.util.List.<TypeView>of();
|
||||
@@ -56,7 +59,8 @@ final class PbsFlowCallableResolutionAnalyzer {
|
||||
if (callExpr.arguments().isEmpty()) {
|
||||
argumentType = TypeView.unit();
|
||||
} else if (callExpr.arguments().size() == 1) {
|
||||
argumentType = analyzeValueExpression(callExpr.arguments().getFirst(), context, expectedInputs.size() == 1 ? expectedInputs.getFirst() : null).type();
|
||||
var actual = analyzeValueExpression(callExpr.arguments().getFirst(), context, expectedInputs.size() == 1 ? expectedInputs.getFirst() : null).type();
|
||||
argumentType = listIndexArgument && actual.kind()==Kind.INT ? TypeView.longType() : actual;
|
||||
} else {
|
||||
final var fields = new ArrayList<TupleField>(callExpr.arguments().size());
|
||||
int argumentIndex = 0;
|
||||
@@ -64,7 +68,7 @@ final class PbsFlowCallableResolutionAnalyzer {
|
||||
final var expected = argumentIndex < expectedInputs.size() ? expectedInputs.get(argumentIndex) : null;
|
||||
argumentIndex++;
|
||||
final var itemType = analyzeValueExpression(argument, context, expected).type();
|
||||
fields.add(new TupleField(null, itemType));
|
||||
fields.add(new TupleField(null,listIndexArgument && argumentIndex==1 && itemType.kind()==Kind.INT ? TypeView.longType() : itemType));
|
||||
}
|
||||
argumentType = TypeView.tuple(fields);
|
||||
}
|
||||
@@ -82,6 +86,9 @@ final class PbsFlowCallableResolutionAnalyzer {
|
||||
final PbsAst.ApplyExpr applyExpr,
|
||||
final PbsFlowExpressionContext context) {
|
||||
final var callee = analyzeTargetExpression(applyExpr.callee(), context, ExprUse.APPLY_TARGET);
|
||||
boolean listIndex=applyExpr.callee() instanceof PbsAst.MemberExpr member
|
||||
&& java.util.Set.of("insert","clearAt","removeAt","resize","reserve").contains(member.memberName())
|
||||
&& context.model().isSdkList(analyzeValueExpression(member.receiver(),context,null).type());
|
||||
TypeView argument;
|
||||
if (applyExpr.argument() instanceof PbsAst.TupleExpr tuple && !tuple.items().isEmpty()
|
||||
&& tuple.items().getFirst().label() != null && callee.callables().size() == 1) {
|
||||
@@ -92,7 +99,8 @@ final class PbsFlowCallableResolutionAnalyzer {
|
||||
if (parameter == null || byName.containsKey(item.label())) {
|
||||
Diagnostics.error(context.diagnostics(), "E_SEM_NAMED_ARGUMENT", "Unknown or duplicate named argument: " + item.label(), item.span());
|
||||
}
|
||||
byName.put(item.label(), analyzeValueExpression(item.expression(), context, parameter == null ? null : parameter.type()).type());
|
||||
var actual=analyzeValueExpression(item.expression(),context,parameter==null?null:parameter.type()).type();
|
||||
byName.put(item.label(),listIndex&¶meter!=null&¶meter.order()==0&&actual.kind()==Kind.INT?TypeView.longType():actual);
|
||||
}
|
||||
var fields = new ArrayList<TupleField>();
|
||||
for (var parameter : candidate.parameters()) {
|
||||
@@ -101,7 +109,14 @@ final class PbsFlowCallableResolutionAnalyzer {
|
||||
}
|
||||
argument = TypeView.tuple(fields);
|
||||
} else {
|
||||
argument = analyzeValueExpression(applyExpr.argument(), context, callee.callables().size() == 1 && callee.callables().getFirst().inputTypes().size() == 1 ? callee.callables().getFirst().inputTypes().getFirst() : null).type();
|
||||
var inputs=callee.callables().size()==1?callee.callables().getFirst().inputTypes():java.util.List.<TypeView>of();
|
||||
var expected=inputs.size()==1?inputs.getFirst():inputs.isEmpty()?null:TypeView.tuple(inputs.stream().map(t->new TupleField(null,t)).toList());
|
||||
argument=analyzeValueExpression(applyExpr.argument(),context,expected).type();
|
||||
if(listIndex&&argument.kind()==Kind.INT)argument=TypeView.longType();
|
||||
else if(listIndex&&argument.kind()==Kind.TUPLE&&!argument.tupleFields().isEmpty()&&argument.tupleFields().getFirst().type().kind()==Kind.INT) {
|
||||
var fields=new ArrayList<>(argument.tupleFields());
|
||||
fields.set(0,new TupleField(fields.getFirst().label(),TypeView.longType()));argument=TypeView.tuple(fields);
|
||||
}
|
||||
}
|
||||
|
||||
return resolveCallableApplication(
|
||||
@@ -194,6 +209,10 @@ final class PbsFlowCallableResolutionAnalyzer {
|
||||
}
|
||||
return ExprResult.type(field.type());
|
||||
}
|
||||
if(model.isSdkList(receiver) && java.util.Set.of("_at","_put").contains(memberExpr.memberName())) {
|
||||
Diagnostics.error(diagnostics,"E_SEM_SDK_PRIVATE_MEMBER","SDK storage adapters are private",memberExpr.span());
|
||||
return ExprResult.type(TypeView.unknown());
|
||||
}
|
||||
final var methods = struct.methods().get(memberExpr.memberName());
|
||||
if (methods != null && !methods.isEmpty()) {
|
||||
if (use == ExprUse.VALUE) {
|
||||
|
||||
+4
@@ -198,6 +198,10 @@ final class PbsFlowSemanticSupport {
|
||||
|
||||
static final class Model {
|
||||
p.studio.compiler.pbs.PbsContractTypes contractTypes;
|
||||
boolean isSdkList(TypeView type) {
|
||||
return type != null && p.studio.compiler.pbs.PbsSdkCollections.isList(contractTypes.declaration(
|
||||
type.sourceType() == null ? PbsAst.TypeRef.simple(type.name(), Span.none()) : type.sourceType()));
|
||||
}
|
||||
final Map<String, List<CallableSymbol>> topLevelCallables = new HashMap<>();
|
||||
final Map<String, StructInfo> structs = new HashMap<>();
|
||||
final Map<String, ServiceInfo> services = new HashMap<>();
|
||||
|
||||
+3
@@ -53,6 +53,9 @@ final class PbsFlowStructuralExpressionAnalyzer {
|
||||
if (expression instanceof PbsAst.IndexExpr index) {
|
||||
final var receiver = analyzeValueExpression(index.receiver(), context, null).type();
|
||||
checkArrayIndex(index.index(), context);
|
||||
if (model.isSdkList(receiver)) {
|
||||
return ExprResult.type(model.structs.get(receiver.name()).methods().get("_at").getFirst().outputType());
|
||||
}
|
||||
if (receiver.kind() != Kind.ARRAY) {
|
||||
Diagnostics.error(diagnostics, "E_SEM_ARRAY_RECEIVER", "Indexing requires an array", index.receiver().span());
|
||||
return ExprResult.type(TypeView.unknown());
|
||||
|
||||
+156
@@ -0,0 +1,156 @@
|
||||
// Source algorithms own state, ranges, capacity policy and snapshot topology.
|
||||
// Only these private, origin-checked helpers bind generic storage instructions.
|
||||
[StoragePrimitive(name = "indexGuard")]
|
||||
fn _bounds(index: long, limit: long) {}
|
||||
|
||||
[StoragePrimitive(name = "checkLength")]
|
||||
fn _checkLength(length: long) {}
|
||||
|
||||
[StoragePrimitive(name = "copy")]
|
||||
fn _copy<T>(source: array<T>, sourceStart: long, target: array<T>, targetStart: long, count: long) {}
|
||||
|
||||
[StoragePrimitive(name = "publish", first = "storage", second = "length")]
|
||||
fn _publish<T>(source: array<T>, sourceStart: long, target: array<T>, targetStart: long,
|
||||
count: long, fillStart: long, fillCount: long, fill: optional T,
|
||||
owner: list<T>, storage: array<T>, length: long) {}
|
||||
|
||||
fn _grownCapacity(capacity: long, required: long) -> long {
|
||||
_checkLength(required);
|
||||
let maximum: long = 4294967295;
|
||||
let increment: long = capacity / 2 + capacity % 2;
|
||||
if increment < (1 as long) { increment = 1; }
|
||||
let candidate: long = capacity + increment;
|
||||
if candidate < required { candidate = required; }
|
||||
if candidate > maximum { candidate = maximum; }
|
||||
return candidate;
|
||||
}
|
||||
|
||||
[SdkList]
|
||||
declare struct list<T>(storage: array<T>, length: long) {
|
||||
ctor make() {
|
||||
this.storage = new array<T>(16);
|
||||
this.length = 0;
|
||||
}
|
||||
ctor make(capacity: long) {
|
||||
this.storage = new array<T>(capacity);
|
||||
this.length = 0;
|
||||
}
|
||||
fn size() -> long { return this.length; }
|
||||
fn capacity() -> long { return this.storage.length; }
|
||||
|
||||
[SdkPrivate]
|
||||
fn _at(index: long) -> optional T {
|
||||
_bounds(index, this.length);
|
||||
return this.storage[index];
|
||||
}
|
||||
[SdkPrivate]
|
||||
fn _put(index: long, value: T) {
|
||||
_bounds(index, this.length);
|
||||
this.storage[index] = value;
|
||||
}
|
||||
|
||||
fn add(value: T) { this.insert(this.length, value); }
|
||||
fn insert(index: long, value: T) {
|
||||
_bounds(index, this.length + 1);
|
||||
let required: long = this.length + 1;
|
||||
_checkLength(required);
|
||||
let target: array<T> = this.storage;
|
||||
if required > target.length {
|
||||
target = new array<T>(_grownCapacity(target.length, required));
|
||||
_copy<T>(this.storage, 0, target, 0, this.length);
|
||||
}
|
||||
_publish<T>(target, index, target, index + 1, this.length - index,
|
||||
index, 1, some(value), this, target, required);
|
||||
}
|
||||
fn clearAt(index: long) {
|
||||
_bounds(index, this.length);
|
||||
_publish<T>(this.storage, 0, this.storage, 0, 0,
|
||||
index, 1, none, this, this.storage, this.length);
|
||||
}
|
||||
fn removeAt(index: long) -> optional T {
|
||||
_bounds(index, this.length);
|
||||
let previous: optional T = this.storage[index];
|
||||
_publish<T>(this.storage, index + 1, this.storage, index, this.length - index - 1,
|
||||
this.length - 1, 1, none, this, this.storage, this.length - 1);
|
||||
return previous;
|
||||
}
|
||||
fn clear() {
|
||||
_publish<T>(this.storage, 0, this.storage, 0, 0,
|
||||
0, this.length, none, this, this.storage, 0);
|
||||
}
|
||||
fn resize(length: long) {
|
||||
_checkLength(length);
|
||||
let target: array<T> = this.storage;
|
||||
if length > target.length {
|
||||
target = new array<T>(_grownCapacity(target.length, length));
|
||||
_copy<T>(this.storage, 0, target, 0, this.length);
|
||||
}
|
||||
let start: long = this.length;
|
||||
let count: long = length - this.length;
|
||||
if length < this.length { start = length; count = this.length - length; }
|
||||
_publish<T>(target, 0, target, 0, 0, start, count, none, this, target, length);
|
||||
}
|
||||
fn reserve(capacity: long) {
|
||||
_checkLength(capacity);
|
||||
if capacity > this.storage.length {
|
||||
let target: array<T> = new array<T>(capacity);
|
||||
_copy<T>(this.storage, 0, target, 0, this.length);
|
||||
_publish<T>(target, 0, target, 0, 0, 0, 0, none, this, target, this.length);
|
||||
}
|
||||
}
|
||||
fn trim() {
|
||||
if this.storage.length != this.length {
|
||||
let target: array<T> = new array<T>(this.length);
|
||||
_copy<T>(this.storage, 0, target, 0, this.length);
|
||||
_publish<T>(target, 0, target, 0, 0, 0, 0, none, this, target, this.length);
|
||||
}
|
||||
}
|
||||
fn cursor() -> Cursor<T> {
|
||||
let head: optional _SnapshotNode<T> = none;
|
||||
let index: long = this.length;
|
||||
while index > (0 as long) {
|
||||
index = index - 1;
|
||||
if let value = this.storage[index] {
|
||||
head = some(new _SnapshotNode<T>(value, head));
|
||||
}
|
||||
}
|
||||
return new _SnapshotCursor<T>(head) as Cursor<T>;
|
||||
}
|
||||
}
|
||||
|
||||
declare contract Cursor<T> {
|
||||
fn hasNext() -> bool;
|
||||
fn next();
|
||||
fn current() -> optional T;
|
||||
}
|
||||
|
||||
// Read-only links and values; the private Cursor holds only current + suffix.
|
||||
declare struct _SnapshotNode<T>(pub value: T, pub next: optional _SnapshotNode<T>) {
|
||||
ctor make(value: T, next: optional _SnapshotNode<T>) {
|
||||
this.value = value;
|
||||
this.next = next;
|
||||
}
|
||||
}
|
||||
|
||||
declare struct _SnapshotCursor<T>(node: optional _SnapshotNode<T>) {
|
||||
ctor make(node: optional _SnapshotNode<T>) { this.node = node; }
|
||||
fn hasNext() -> bool {
|
||||
if let node = this.node { return node.next.hasSome(); }
|
||||
return false;
|
||||
}
|
||||
fn next() {
|
||||
if let node = this.node {
|
||||
if let successor = node.next { this.node = some(successor); }
|
||||
}
|
||||
}
|
||||
fn current() -> optional T {
|
||||
if let node = this.node { return some(node.value); }
|
||||
return none;
|
||||
}
|
||||
}
|
||||
|
||||
implements<T> Cursor<T> for _SnapshotCursor<T> using snapshot {
|
||||
fn hasNext() -> bool { return snapshot.hasNext(); }
|
||||
fn next() { snapshot.next(); }
|
||||
fn current() -> optional T { return snapshot.current(); }
|
||||
}
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
pub struct list<T>;
|
||||
pub contract Cursor<T>;
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
import { list, Cursor } from @sdk:collections;
|
||||
|
||||
fn collectionsExample() -> int {
|
||||
let values: list<int> = new list(0);
|
||||
values.resize(3); // Three logical holes; capacity alone creates no positions.
|
||||
values[0] = 20;
|
||||
values[2] = 22;
|
||||
let snapshot: Cursor<int> = values.cursor();
|
||||
values.clear(); // The completed snapshot keeps its captured sequence.
|
||||
|
||||
let total: int = 0;
|
||||
while true {
|
||||
if let value = snapshot.current() {
|
||||
total = total + value;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
if snapshot.hasNext() {
|
||||
snapshot.next();
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// current() still holds 22: next() cannot advance past the last node.
|
||||
return total;
|
||||
}
|
||||
+1
@@ -2,3 +2,4 @@ pub fn init() -> void;
|
||||
pub fn frame() -> void;
|
||||
pub fn contractExample() -> int;
|
||||
pub fn genericsExample() -> int;
|
||||
pub fn collectionsExample() -> int;
|
||||
|
||||
+49
-3
@@ -41,6 +41,54 @@ class PbsGateUSdkInterfaceConformanceTest {
|
||||
@TempDir
|
||||
Path tempDir;
|
||||
|
||||
@Test
|
||||
void listAndCursorUseDistributedSdkBodiesAndPrivateDefinitionScopes() throws IOException {
|
||||
var result=compileWorkspaceModule(tempDir.resolve("list-cursor"), """
|
||||
import { list, Cursor } from @sdk:collections;
|
||||
fn main() -> int {
|
||||
let capacity: int = 0;
|
||||
let values: list<int> = new list(capacity);
|
||||
values.add(20); values.insert(capacity, 22);
|
||||
let snapshot: Cursor<int> = values.cursor();
|
||||
values.clear();
|
||||
return snapshot.current() else 0;
|
||||
}
|
||||
[Frame] fn frame() -> void {let observed=main();}
|
||||
""", "pub fn main() -> int; pub fn frame() -> void;", 1, null);
|
||||
assertFalse(result.diagnostics().stream().anyMatch(d->d.getSeverity().isError()),result.diagnostics().stream().map(d->d.getCode()+":"+d.getMessage()).toList().toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
void listApplicationsAndPrivateAdaptersRejectInvalidProjectUses() throws IOException {
|
||||
var cases=java.util.Map.of(
|
||||
"optional","let values:list<optional int>=new list<optional int>();",
|
||||
"grouped","let values:list<(optional int)>=new list<(optional int)>();",
|
||||
"arity","let values:list<int,long>=new list<int,long>();",
|
||||
"context","let values=new list();",
|
||||
"invariance","let values:list<long>=new list<int>();",
|
||||
"index","let values=new list<int>();let invalid=values[1.5];",
|
||||
"storage","let values=new list<int>();let exposed=values.storage;",
|
||||
"adapter","let values=new list<int>();let exposed=values._at(0);",
|
||||
"value-promotion","let values=new list<long>();let value:int=1;values.add(value);");
|
||||
for(var entry:cases.entrySet()) {
|
||||
var source="import {list} from @sdk:collections; [Frame] fn frame() -> void {"+entry.getValue()+"}";
|
||||
var result=compileWorkspaceModule(tempDir.resolve("list-negative-"+entry.getKey()),source,"pub fn frame() -> void;",1,null);
|
||||
assertTrue(result.diagnostics().hasErrors(),entry.getKey());
|
||||
}
|
||||
var homonym=new PbsFrontendCompiler();var diagnostics=DiagnosticSink.empty();
|
||||
homonym.compileFile(new FileId(200),"""
|
||||
declare struct list<T>(value:T) {}
|
||||
fn main() {let values=new list<int>(1);let invalid=values[0];}
|
||||
""",diagnostics,SourceKind.PROJECT);
|
||||
assertTrue(diagnostics.stream().anyMatch(d->d.getCode().equals("E_SEM_ARRAY_RECEIVER")));
|
||||
var copied=DiagnosticSink.empty();
|
||||
homonym.compileFile(new FileId(201),"""
|
||||
[SdkList] declare struct list<T>(value:T) {}
|
||||
[StoragePrimitive(name="indexGuard")] fn fake(index:long,limit:long) {}
|
||||
""",copied,SourceKind.PROJECT);
|
||||
assertTrue(copied.hasErrors(),"Project attributes cannot acquire SDK bindings");
|
||||
}
|
||||
|
||||
@Test
|
||||
void removedInputObjectsExplainTheirMigration() throws IOException {
|
||||
final var result = compileWorkspaceModule(tempDir.resolve("removed-input"), """
|
||||
@@ -296,9 +344,7 @@ class PbsGateUSdkInterfaceConformanceTest {
|
||||
"fn run() -> int { return 1; }",
|
||||
negativeSemanticsDiagnostics,
|
||||
SourceKind.SDK_INTERFACE);
|
||||
final var nonDeclarative = firstDiagnostic(negativeSemanticsDiagnostics,
|
||||
d -> d.getCode().equals(PbsSemanticsErrors.E_SEM_INTERFACE_NON_DECLARATIVE_DECLARATION.name()));
|
||||
assertStableDiagnosticIdentity(nonDeclarative, PbsSemanticsErrors.E_SEM_INTERFACE_NON_DECLARATIVE_DECLARATION.name(), DiagnosticPhase.STATIC_SEMANTICS);
|
||||
assertFalse(negativeSemanticsDiagnostics.hasErrors(), "SDK modules retain ordinary executable function bodies");
|
||||
|
||||
final var negativeLinkDiagnostics = DiagnosticSink.empty();
|
||||
final var invalidBarrelAst = PbsBarrelParser.parse(
|
||||
|
||||
+22
@@ -6,6 +6,28 @@ import p.studio.compiler.source.identifiers.FileId;
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class PbsGenericStructsTest {
|
||||
@Test void recursiveOptionalBindingsAndContractViewsKeepTheirDefinitionShapes() {
|
||||
accepts("""
|
||||
declare contract Reader<T> {fn read()->optional T;}
|
||||
declare struct Node<T>(pub value:T,pub next:optional Node<T>);
|
||||
declare struct Holder<T>(node:optional Node<T>) {
|
||||
fn read()->optional T {if let node=this.node {return some(node.value);}return none;}
|
||||
fn view()->Reader<T> {return this as Reader<T>;}
|
||||
}
|
||||
implements<T> Reader<T> for Holder<T> using owner {fn read()->optional T {return owner.read();}}
|
||||
fn main()->int {
|
||||
let value=new Holder<int>(some(new Node<int>(42,none)));
|
||||
return value.view().read() else 0;
|
||||
}
|
||||
""");
|
||||
accepts("""
|
||||
declare struct Cell<T>(values:array<T>) {
|
||||
fn set(value:T) {this.values[0]=value;}
|
||||
fn get()->optional T {return this.values[0];}
|
||||
}
|
||||
fn main()->int {let cell=new Cell<int>([0]);cell.set(42);return cell.get() else 0;}
|
||||
""");
|
||||
}
|
||||
private static final String BOX = """
|
||||
declare struct Box<T>(value: T) {
|
||||
fn get() -> T { return this.value; }
|
||||
|
||||
+2
-5
@@ -109,7 +109,7 @@ class PbsInterfaceModuleSemanticsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void shouldRejectExecutableDeclarationsInInterfaceModule() {
|
||||
void shouldAllowOrdinaryExecutableSdkDeclarations() {
|
||||
final var source = """
|
||||
fn run() -> int { return 1; }
|
||||
|
||||
@@ -123,10 +123,7 @@ class PbsInterfaceModuleSemanticsTest {
|
||||
|
||||
new PbsFrontendCompiler().compileFile(new FileId(0), source, diagnostics, SourceKind.SDK_INTERFACE);
|
||||
|
||||
final var nonDeclarativeCount = diagnostics.stream()
|
||||
.filter(d -> d.getCode().equals(PbsSemanticsErrors.E_SEM_INTERFACE_NON_DECLARATIVE_DECLARATION.name()))
|
||||
.count();
|
||||
assertTrue(nonDeclarativeCount >= 2);
|
||||
assertFalse(diagnostics.hasErrors(), diagnostics.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
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 static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class PbsListCursorEditorialTest {
|
||||
@Test void concreteApiHidesStorageAndKeepsSdkDefinitionOrigins() 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 list=library.topDecls().stream().filter(d->d instanceof PbsAst.StructDecl s&&s.name().equals("list")).findFirst().orElseThrow();
|
||||
var cursor=library.topDecls().stream().filter(d->d instanceof PbsAst.ContractDecl c&&c.name().equals("Cursor")).findFirst().orElseThrow();
|
||||
var source="""
|
||||
import {list as Values,Cursor} from @sdk:collections;
|
||||
fn sample(values:Values<int>,cursor:Cursor<int>)->optional int {
|
||||
let created:Values<int>=new Values(0);
|
||||
values.add(42); cursor.hasNext(); return cursor.current();
|
||||
}
|
||||
""";
|
||||
var id=new FileId(2);var ast=PbsParser.parse(PbsLexer.lex(source,id,diagnostics),id,diagnostics);
|
||||
assertFalse(diagnostics.hasErrors());
|
||||
var supplemental=ReadOnlyList.<PbsAst.TopDecl>from(new PbsAst.TypeBindingDecl("Values",list,ast.span()),cursor);
|
||||
var service=new PbsEditorialSupportService();int member=source.indexOf("values.add")+7;
|
||||
var typeHover=service.hover(source,ast,supplemental,source.indexOf("Values<int>")).orElseThrow();
|
||||
assertFalse(typeHover.signatures().stream().anyMatch(s->s.label().startsWith("_")));
|
||||
var constructors=service.signatureHelp(source,ast,supplemental,source.indexOf("new Values(0")+11).orElseThrow().signatures();
|
||||
assertEquals(2,constructors.size());
|
||||
assertTrue(constructors.stream().allMatch(s->!s.label().contains("storage")&&!s.label().contains("$generic$")));
|
||||
var completions=service.completion(source,ast,supplemental,member);
|
||||
assertTrue(completions.stream().anyMatch(c->c.label().equals("add")&&c.detail().contains("int")));
|
||||
assertFalse(completions.stream().anyMatch(c->java.util.Set.of("storage","length","_at","_put").contains(c.label())));
|
||||
var definition=service.definition(source,ast,supplemental,member);
|
||||
assertEquals(sdkId,definition.getFirst().span().getFileId());
|
||||
int current=source.indexOf("cursor.current")+7;
|
||||
assertTrue(service.hover(source,ast,supplemental,current).orElseThrow().signatures().getFirst().label().contains("optional int"));
|
||||
var methods=service.completion(source,ast,supplemental,current);
|
||||
assertEquals(java.util.Set.of("hasNext","next","current"),methods.stream().map(c->c.label()).collect(java.util.stream.Collectors.toSet()));
|
||||
assertFalse(service.definition(source,ast,supplemental,current).isEmpty());
|
||||
var rename=service.rename(source,ast,supplemental,source.indexOf("values:Values"),"items");
|
||||
assertTrue(rename.allowed());
|
||||
assertEquals(2,rename.sites().size());
|
||||
assertTrue(service.references(source,ast,supplemental,source.indexOf("values:Values")).size()>=2);
|
||||
}
|
||||
}
|
||||
+3
-3
@@ -654,7 +654,7 @@ class PBSFrontendPhaseServiceTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void shouldSkipIrLoweringForSourcesMarkedAsSdkInterface() throws IOException {
|
||||
void shouldLowerOrdinaryExecutableSdkFunctions() throws IOException {
|
||||
final var projectRoot = tempDir.resolve("project-sdk-interface");
|
||||
final var sourceRoot = projectRoot.resolve("src");
|
||||
final var modulePath = sourceRoot.resolve("gfx");
|
||||
@@ -691,9 +691,9 @@ class PBSFrontendPhaseServiceTest {
|
||||
LogAggregator.empty(),
|
||||
BuildingIssueSink.empty());
|
||||
|
||||
assertTrue(diagnostics.stream().anyMatch(d ->
|
||||
d.getCode().equals(PbsSemanticsErrors.E_SEM_INTERFACE_NON_DECLARATIVE_DECLARATION.name())));
|
||||
assertFalse(diagnostics.hasErrors(), diagnostics.stream().map(d -> d.getMessage()).toList().toString());
|
||||
assertEquals(0, irBackend.getFunctions().size());
|
||||
assertEquals(1, irBackend.getExecutableFunctions().size());
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
Reference in New Issue
Block a user