feat(pbs): implement first-class functions and explicit captures
This commit is contained in:
+1
-3
@@ -251,8 +251,6 @@ public final class PBSSemanticTokenProvider implements FrontendSemanticTokenProv
|
||||
exportedKinds.put(globalItem.name(), semanticKind);
|
||||
} else if (item instanceof PbsAst.BarrelConstItem constItem && constItem.visibility() == PbsAst.Visibility.PUB) {
|
||||
exportedKinds.put(constItem.name(), semanticKind);
|
||||
} else if (item instanceof PbsAst.BarrelCallbackItem callbackItem && callbackItem.visibility() == PbsAst.Visibility.PUB) {
|
||||
exportedKinds.put(callbackItem.name(), semanticKind);
|
||||
}
|
||||
}
|
||||
return exportedKinds;
|
||||
@@ -284,7 +282,7 @@ public final class PBSSemanticTokenProvider implements FrontendSemanticTokenProv
|
||||
case PbsAst.BarrelServiceItem ignored -> PbsSemanticKind.SERVICE;
|
||||
case PbsAst.BarrelGlobalItem ignored -> PbsSemanticKind.GLOBAL;
|
||||
case PbsAst.BarrelConstItem ignored -> PbsSemanticKind.CONST;
|
||||
case PbsAst.BarrelCallbackItem ignored -> PbsSemanticKind.CALLBACK;
|
||||
|
||||
case PbsAst.BarrelFunctionItem ignored -> null;
|
||||
};
|
||||
}
|
||||
|
||||
+1
@@ -238,6 +238,7 @@ public final class PbsReservedMetadataExtractor {
|
||||
return switch (typeRef.kind()) {
|
||||
case SIMPLE -> "simple:" + typeRef.name();
|
||||
case SELF -> "self";
|
||||
case FN -> "Fn(" + typeRef.fields().stream().map(f -> typeSurfaceKey(f.typeRef())).collect(java.util.stream.Collectors.joining(",")) + ") -> " + typeSurfaceKey(typeRef.inner());
|
||||
case ARRAY -> "array(" + typeSurfaceKey(typeRef.inner()) + ")";
|
||||
case OPTIONAL -> "optional(" + typeSurfaceKey(typeRef.inner()) + ")";
|
||||
case UNIT -> "unit";
|
||||
|
||||
+4
-2
@@ -150,7 +150,7 @@ public final class PbsStructureRanges {
|
||||
case PbsAst.HostDecl hostDecl -> visitAttributes(hostDecl.attributes(), collected);
|
||||
case PbsAst.EnumDecl enumDecl -> visitAttributes(enumDecl.attributes(), collected);
|
||||
case PbsAst.ErrorDecl errorDecl -> visitAttributes(errorDecl.attributes(), collected);
|
||||
case PbsAst.CallbackDecl callbackDecl -> visitAttributes(callbackDecl.attributes(), collected);
|
||||
|
||||
default -> {
|
||||
}
|
||||
}
|
||||
@@ -216,6 +216,8 @@ public final class PbsStructureRanges {
|
||||
private static void coverStatement(
|
||||
final PbsAst.Statement statement,
|
||||
final Collected collected) {
|
||||
if (statement != null) for (var expression : p.studio.compiler.pbs.ast.PbsLambdaTraversal.expressions(statement))
|
||||
p.studio.compiler.pbs.ast.PbsLambdaTraversal.visit(expression, lambda -> coverBlock(lambda.body(), true, collected));
|
||||
switch (statement) {
|
||||
case null -> {
|
||||
}
|
||||
@@ -239,7 +241,7 @@ public final class PbsStructureRanges {
|
||||
|| topDecl instanceof PbsAst.HostDecl
|
||||
|| topDecl instanceof PbsAst.EnumDecl
|
||||
|| topDecl instanceof PbsAst.ErrorDecl
|
||||
|| topDecl instanceof PbsAst.CallbackDecl;
|
||||
;
|
||||
}
|
||||
|
||||
private static List<SpanPair> delimiters(
|
||||
|
||||
+2
@@ -10,6 +10,8 @@ public final class PbsTypeSubstitution {
|
||||
public static PbsAst.TypeRef replaceSelf(PbsAst.TypeRef type, String owner) {
|
||||
if (type == null) return null;
|
||||
if (type.kind() == PbsAst.TypeRefKind.SELF) return PbsAst.TypeRef.simple(owner, type.span());
|
||||
if (type.kind() == PbsAst.TypeRefKind.FN) return PbsAst.TypeRef.function(ReadOnlyList.wrap(type.fields().stream().map(f ->
|
||||
new PbsAst.NamedTypeField(null, replaceSelf(f.typeRef(), owner), f.span())).toList()), replaceSelf(type.inner(), owner), type.span());
|
||||
if (type.kind() == PbsAst.TypeRefKind.NAMED_TUPLE) {
|
||||
return PbsAst.TypeRef.namedTuple(ReadOnlyList.wrap(type.fields().stream().map(field ->
|
||||
new PbsAst.NamedTypeField(field.label(), replaceSelf(field.typeRef(), owner), field.span())).toList()), type.span());
|
||||
|
||||
+20
-21
@@ -18,6 +18,7 @@ public final class PbsAst {
|
||||
|
||||
public enum TypeRefKind {
|
||||
SIMPLE,
|
||||
FN,
|
||||
SELF,
|
||||
OPTIONAL,
|
||||
ARRAY,
|
||||
@@ -119,7 +120,6 @@ public final class PbsAst {
|
||||
ServiceDecl,
|
||||
ErrorDecl,
|
||||
EnumDecl,
|
||||
CallbackDecl,
|
||||
GlobalDecl,
|
||||
ConstDecl,
|
||||
ImplementsDecl,
|
||||
@@ -198,15 +198,7 @@ public final class PbsAst {
|
||||
Span span) implements TopDecl {
|
||||
}
|
||||
|
||||
public record CallbackDecl(
|
||||
String name,
|
||||
ReadOnlyList<Parameter> parameters,
|
||||
ReturnKind returnKind,
|
||||
TypeRef returnType,
|
||||
TypeRef resultErrorType,
|
||||
ReadOnlyList<Attribute> attributes,
|
||||
Span span) implements TopDecl {
|
||||
}
|
||||
|
||||
|
||||
public record GlobalDecl(
|
||||
String name,
|
||||
@@ -255,6 +247,10 @@ public final class PbsAst {
|
||||
ReadOnlyList<NamedTypeField> fields,
|
||||
TypeRef inner,
|
||||
Span span) {
|
||||
public static TypeRef function(ReadOnlyList<NamedTypeField> inputs, TypeRef output, Span span) {
|
||||
return new TypeRef(TypeRefKind.FN, "Fn", inputs, output, span);
|
||||
}
|
||||
|
||||
public static TypeRef simple(final String name, final Span span) {
|
||||
return new TypeRef(TypeRefKind.SIMPLE, name, ReadOnlyList.empty(), null, span);
|
||||
}
|
||||
@@ -448,7 +444,7 @@ public final class PbsAst {
|
||||
GroupExpr,
|
||||
ThisExpr,
|
||||
NewExpr,
|
||||
BindExpr,
|
||||
LambdaExpr,
|
||||
SomeExpr,
|
||||
NoneExpr,
|
||||
OkExpr,
|
||||
@@ -629,12 +625,20 @@ public final class PbsAst {
|
||||
Span span) implements Expression {
|
||||
}
|
||||
|
||||
public record BindExpr(
|
||||
Expression contextExpression,
|
||||
String functionName,
|
||||
public record LambdaExpr(
|
||||
ReadOnlyList<IdentifierExpr> captures,
|
||||
ReadOnlyList<Parameter> parameters,
|
||||
TypeRef returnType,
|
||||
Block body,
|
||||
Span span) implements Expression {
|
||||
public TypeRef functionType() {
|
||||
return TypeRef.function(ReadOnlyList.wrap(parameters.stream().map(p ->
|
||||
new NamedTypeField(null, p.typeRef(), p.span())).toList()), returnType, span);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
public record SomeExpr(
|
||||
Expression value,
|
||||
Span span) implements Expression {
|
||||
@@ -688,8 +692,7 @@ public final class PbsAst {
|
||||
BarrelEnumItem,
|
||||
BarrelServiceItem,
|
||||
BarrelGlobalItem,
|
||||
BarrelConstItem,
|
||||
BarrelCallbackItem {
|
||||
BarrelConstItem {
|
||||
Span span();
|
||||
}
|
||||
|
||||
@@ -756,9 +759,5 @@ public final class PbsAst {
|
||||
Span span) implements BarrelItem {
|
||||
}
|
||||
|
||||
public record BarrelCallbackItem(
|
||||
Visibility visibility,
|
||||
String name,
|
||||
Span span) implements BarrelItem {
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
+93
@@ -0,0 +1,93 @@
|
||||
package p.studio.compiler.pbs.ast;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
/** Expression traversal shared by source scopes and structural editor projections. */
|
||||
public final class PbsLambdaTraversal {
|
||||
private PbsLambdaTraversal() {}
|
||||
|
||||
public static List<PbsAst.Expression> expressions(PbsAst.Statement statement) {
|
||||
var result = new ArrayList<PbsAst.Expression>();
|
||||
switch (statement) {
|
||||
case PbsAst.LetStatement s -> add(result, s.initializer());
|
||||
case PbsAst.AssignStatement s -> { add(result, s.target().expression()); add(result, s.value()); }
|
||||
case PbsAst.ReturnStatement s -> add(result, s.value());
|
||||
case PbsAst.ExpressionStatement s -> add(result, s.expression());
|
||||
case PbsAst.IfStatement s -> add(result, s.condition());
|
||||
case PbsAst.WhileStatement s -> add(result, s.condition());
|
||||
case PbsAst.ForStatement s -> { add(result, s.fromExpression()); add(result, s.untilExpression()); add(result, s.stepExpression()); }
|
||||
default -> { }
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
public static PbsAst.LambdaExpr enclosing(PbsAst.Statement statement, long offset) {
|
||||
for (var expression : expressions(statement)) {
|
||||
var found = enclosing(expression, offset);
|
||||
if (found != null) return found;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static PbsAst.LambdaExpr enclosing(PbsAst.Expression expression, long offset) {
|
||||
if (expression == null || !expression.span().contains(offset)) return null;
|
||||
if (expression instanceof PbsAst.LambdaExpr lambda) return lambda;
|
||||
for (var child : children(expression)) {
|
||||
var found = enclosing(child, offset);
|
||||
if (found != null) return found;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static void visit(PbsAst.Expression expression, Consumer<PbsAst.LambdaExpr> visitor) {
|
||||
if (expression == null) return;
|
||||
if (expression instanceof PbsAst.LambdaExpr lambda) { visitor.accept(lambda); return; }
|
||||
for (var child : children(expression)) visit(child, visitor);
|
||||
}
|
||||
|
||||
private static List<PbsAst.Expression> children(PbsAst.Expression expression) {
|
||||
var children = new ArrayList<PbsAst.Expression>();
|
||||
switch (expression) {
|
||||
case PbsAst.CallExpr e -> { add(children,e.callee()); children.addAll(e.arguments().asList()); }
|
||||
case PbsAst.ApplyExpr e -> { add(children,e.callee()); add(children,e.argument()); }
|
||||
case PbsAst.ArrayLiteralExpr e -> children.addAll(e.elements().asList());
|
||||
case PbsAst.TupleExpr e -> e.items().forEach(item -> add(children,item.expression()));
|
||||
case PbsAst.GroupExpr e -> add(children,e.expression());
|
||||
case PbsAst.UnaryExpr e -> add(children,e.expression());
|
||||
case PbsAst.BinaryExpr e -> { add(children,e.left()); add(children,e.right()); }
|
||||
case PbsAst.MemberExpr e -> add(children,e.receiver());
|
||||
case PbsAst.IndexExpr e -> { add(children,e.receiver()); add(children,e.index()); }
|
||||
case PbsAst.NewExpr e -> children.addAll(e.arguments().asList());
|
||||
case PbsAst.SomeExpr e -> add(children,e.value());
|
||||
case PbsAst.OkExpr e -> add(children,e.value());
|
||||
case PbsAst.AsExpr e -> add(children,e.expression());
|
||||
case PbsAst.PropagateExpr e -> add(children,e.expression());
|
||||
case PbsAst.ElseExpr e -> { add(children,e.optionalExpression()); add(children,e.fallbackExpression()); }
|
||||
case PbsAst.BlockExpr e -> addBlock(children,e.block());
|
||||
case PbsAst.IfExpr e -> { add(children,e.condition()); addBlock(children,e.thenBlock()); add(children,e.elseExpression()); }
|
||||
case PbsAst.SwitchExpr e -> { add(children,e.selector()); e.arms().forEach(a -> addBlock(children,a.block())); }
|
||||
case PbsAst.HandleExpr e -> { add(children,e.value()); e.arms().forEach(a -> addBlock(children,a.block())); }
|
||||
default -> { }
|
||||
}
|
||||
return children;
|
||||
}
|
||||
private static void addBlock(List<PbsAst.Expression> result, PbsAst.Block block) {
|
||||
if (block == null) return;
|
||||
add(result,block.tailExpression());
|
||||
for (var statement : block.statements()) {
|
||||
result.addAll(expressions(statement));
|
||||
switch (statement) {
|
||||
case PbsAst.IfStatement s -> { addBlock(result,s.thenBlock()); addBlock(result,s.elseBlock());
|
||||
if(s.elseIf()!=null) addBlock(result,new PbsAst.Block(p.studio.utilities.structures.ReadOnlyList.from(s.elseIf()),null,s.elseIf().span())); }
|
||||
case PbsAst.ForStatement s -> addBlock(result,s.body());
|
||||
case PbsAst.WhileStatement s -> addBlock(result,s.body());
|
||||
default -> { }
|
||||
}
|
||||
}
|
||||
}
|
||||
private static void add(List<PbsAst.Expression> values, PbsAst.Expression expression) {
|
||||
if (expression != null) values.add(expression);
|
||||
}
|
||||
}
|
||||
+4
-13
@@ -284,8 +284,6 @@ public final class PbsModuleVisibilityValidator {
|
||||
registerNonFunctionDeclaration(declarations, NonFunctionKind.GLOBAL, globalDecl.name(), globalDecl.span(), nameTable);
|
||||
} else if (topDecl instanceof PbsAst.ConstDecl constDecl) {
|
||||
registerNonFunctionDeclaration(declarations, NonFunctionKind.CONST, constDecl.name(), constDecl.span(), nameTable);
|
||||
} else if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
registerNonFunctionDeclaration(declarations, NonFunctionKind.CALLBACK, callbackDecl.name(), callbackDecl.span(), nameTable);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -370,9 +368,7 @@ public final class PbsModuleVisibilityValidator {
|
||||
if (item instanceof PbsAst.BarrelConstItem) {
|
||||
return NonFunctionKind.CONST;
|
||||
}
|
||||
if (item instanceof PbsAst.BarrelCallbackItem) {
|
||||
return NonFunctionKind.CALLBACK;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
@@ -401,9 +397,7 @@ public final class PbsModuleVisibilityValidator {
|
||||
if (item instanceof PbsAst.BarrelConstItem constItem) {
|
||||
return constItem.name();
|
||||
}
|
||||
if (item instanceof PbsAst.BarrelCallbackItem callbackItem) {
|
||||
return callbackItem.name();
|
||||
}
|
||||
|
||||
return "<unknown>";
|
||||
}
|
||||
|
||||
@@ -432,9 +426,7 @@ public final class PbsModuleVisibilityValidator {
|
||||
if (item instanceof PbsAst.BarrelConstItem constItem) {
|
||||
return constItem.visibility();
|
||||
}
|
||||
if (item instanceof PbsAst.BarrelCallbackItem callbackItem) {
|
||||
return callbackItem.visibility();
|
||||
}
|
||||
|
||||
return PbsAst.Visibility.MOD;
|
||||
}
|
||||
|
||||
@@ -487,8 +479,7 @@ public final class PbsModuleVisibilityValidator {
|
||||
ENUM,
|
||||
SERVICE,
|
||||
GLOBAL,
|
||||
CONST,
|
||||
CALLBACK
|
||||
CONST
|
||||
}
|
||||
|
||||
private record NonFunctionSymbolKey(
|
||||
|
||||
+1
@@ -70,6 +70,7 @@ final class PbsCallableShapeSurfaceService {
|
||||
return switch (unwrapped.kind()) {
|
||||
case SIMPLE -> "simple:" + unwrapped.name();
|
||||
case SELF -> "self";
|
||||
case FN -> "Fn(" + unwrapped.fields().stream().map(f -> typeSurfaceKey(f.typeRef())).collect(java.util.stream.Collectors.joining(",")) + ") -> " + typeSurfaceKey(unwrapped.inner());
|
||||
case ARRAY -> "array(" + typeSurfaceKey(unwrapped.inner()) + ")";
|
||||
case OPTIONAL -> "optional(" + typeSurfaceKey(unwrapped.inner()) + ")";
|
||||
case UNIT -> "unit";
|
||||
|
||||
+101
-3
@@ -49,6 +49,15 @@ final class PbsExecutableBodyLowerer {
|
||||
var separator=callableName.indexOf('.');
|
||||
if(separator>0 && metadataIndex.types().services.containsKey(callableName.substring(0,separator))) context.serviceOwner=callableName.substring(0,separator);
|
||||
context.returnType = functionDecl.returnType();
|
||||
int captureIndex = 0;
|
||||
for (var capture : metadataIndex.types().capturesByFunction.getOrDefault(functionDecl.name(), java.util.List.of())) {
|
||||
var type = capture.typeRef();
|
||||
for (var part : context.types().results(type))
|
||||
registry(GET_CAPTURE, null, captureIndex++, 0, registryWidth(part, context), capture.span(), context);
|
||||
context.localTypes.put(capture.label(), type);
|
||||
int slot = context.declareLocalSlots(capture.label(), context.types().slots(type));
|
||||
emitStoreLocalSlots(slot, context.types().slots(type), capture.span(), context);
|
||||
}
|
||||
final var terminated = lowerBlock(functionDecl.body(), context);
|
||||
finalizeFunctionInstructions(functionDecl, context, terminated);
|
||||
|
||||
@@ -313,7 +322,10 @@ final class PbsExecutableBodyLowerer {
|
||||
private boolean lowerForStatement(
|
||||
final PbsAst.ForStatement forStatement,
|
||||
final PbsExecutableLoweringContext context) {
|
||||
final var outerScope = context.snapshotScope();
|
||||
context.localSlotByNameId().remove(context.nameTable().register(forStatement.iteratorName()));
|
||||
final var iteratorSlot = context.declareLocalSlot(forStatement.iteratorName());
|
||||
context.localTypes.put(forStatement.iteratorName(), forStatement.iteratorType());
|
||||
lowerExpression(forStatement.fromExpression(), context);
|
||||
emitSetLocal(iteratorSlot, forStatement.span(), context);
|
||||
final var loopStart = context.nextLabel("for_start");
|
||||
@@ -338,6 +350,7 @@ final class PbsExecutableBodyLowerer {
|
||||
emitSetLocal(iteratorSlot, forStatement.span(), context);
|
||||
emitJump(IRBackendExecutableFunction.InstructionKind.JMP, loopStart, forStatement.span(), context);
|
||||
emitLabel(loopExit, forStatement.span(), context);
|
||||
context.restoreScope(outerScope);
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -390,6 +403,7 @@ final class PbsExecutableBodyLowerer {
|
||||
return;
|
||||
}
|
||||
switch (expression) {
|
||||
case PbsAst.LambdaExpr lambda -> lowerLambda(lambda, context);
|
||||
case PbsAst.ArrayLiteralExpr literal -> lowerArrayLiteral(literal, context);
|
||||
case PbsAst.IndexExpr index -> lowerArrayRead(index, context);
|
||||
case PbsAst.CallExpr callExpr -> lowerCallExpression(callExpr, context);
|
||||
@@ -428,7 +442,7 @@ final class PbsExecutableBodyLowerer {
|
||||
var fields = context.types().fields.get(newExpr.typeName());
|
||||
for(int i=0; i<newExpr.arguments().size(); i++) lowerExpected(newExpr.arguments().get(i), fields != null && i < fields.size() ? fields.get(i).typeRef() : null, context);
|
||||
}
|
||||
case PbsAst.BindExpr bindExpr -> lowerExpression(bindExpr.contextExpression(), context);
|
||||
|
||||
case PbsAst.SomeExpr someExpr -> {
|
||||
var optional = PbsRuntimeTypes.unwrap(context.expectedType);
|
||||
var payload = optional != null && optional.kind() == PbsAst.TypeRefKind.OPTIONAL ? optional.inner() : expressionType(someExpr.value(), context);
|
||||
@@ -463,9 +477,66 @@ final class PbsExecutableBodyLowerer {
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isDirectFunction(PbsAst.Expression callee, PbsExecutableLoweringContext c) {
|
||||
if (callee instanceof PbsAst.GroupExpr group) return isDirectFunction(group.expression(), c);
|
||||
return callee instanceof PbsAst.IdentifierExpr id && !c.localTypes.containsKey(id.name())
|
||||
&& !c.types().values.containsKey(id.name()) && c.types().functions.containsKey(id.name());
|
||||
}
|
||||
|
||||
private void makeClosure(IRRegistry.TypeRef type, p.studio.compiler.source.identifiers.CallableId target,
|
||||
int captures, Span span, PbsExecutableLoweringContext c) {
|
||||
c.instructions().add(new IRBackendExecutableFunction.Instruction(IRBackendExecutableFunction.InstructionKind.REGISTRY,
|
||||
null, "", null, null, null, "", "", captures, 1, span,
|
||||
new IRRegistryInstruction(MAKE_CLOSURE, type, null, target, 0)));
|
||||
}
|
||||
|
||||
private void lowerLambda(PbsAst.LambdaExpr lambda, PbsExecutableLoweringContext c) {
|
||||
var captures = new java.util.ArrayList<PbsAst.NamedTypeField>();
|
||||
int slots = 0;
|
||||
for (var capture : lambda.captures()) {
|
||||
var type = c.localTypes.get(capture.name());
|
||||
if (type == null) throw new IllegalStateException("Unresolved capture: " + capture.name());
|
||||
captures.add(new PbsAst.NamedTypeField(capture.name(), type, capture.span()));
|
||||
lowerExpected(capture, type, c);
|
||||
slots += c.types().slots(type);
|
||||
}
|
||||
var name = "$lambda." + lambda.span().getFileId().getId() + "." + lambda.span().getStart();
|
||||
var function = new PbsAst.FunctionDecl(name, lambda.parameters(),
|
||||
lambda.returnType().kind() == PbsAst.TypeRefKind.UNIT ? PbsAst.ReturnKind.EXPLICIT_UNIT : PbsAst.ReturnKind.PLAIN,
|
||||
lambda.returnType(), null, ReadOnlyList.empty(), PbsAst.LifecycleMarker.NONE, lambda.body(), lambda.span());
|
||||
var callable = new PbsLowerableCallable(name, function);
|
||||
var registry = c.callableRegistry();
|
||||
var id = registry.callableIdByDeclaration().get(callable);
|
||||
if (id == null) {
|
||||
id = new p.studio.compiler.source.identifiers.CallableId(registry.callableSignatureByCallableId().size());
|
||||
registry.callableIdByDeclaration().put(callable,id);
|
||||
var module = registry.callableSignatures().isEmpty() ? ModuleId.none() : registry.callableSignatures().getFirst().moduleId();
|
||||
registry.callableSignatureByCallableId().put(id, new p.studio.compiler.source.tables.CallableSignatureRef(
|
||||
module,name,lambda.parameters().size(),new PbsCallableShapeSurfaceService().callableShapeSurfaceOf(function)));
|
||||
c.types().capturesByFunction.put(name, java.util.List.copyOf(captures));
|
||||
c.types().closureBodies.add(new PbsRuntimeTypes.ClosureBody(function, java.util.List.copyOf(captures)));
|
||||
}
|
||||
makeClosure(c.types().registryType(lambda.functionType()), id, slots, lambda.span(), c);
|
||||
}
|
||||
|
||||
private void lowerCallExpression(
|
||||
final PbsAst.CallExpr callExpr,
|
||||
final PbsExecutableLoweringContext context) {
|
||||
var functionType = isDirectFunction(callExpr.callee(), context) ? null : PbsRuntimeTypes.unwrap(expressionType(callExpr.callee(), context));
|
||||
if (functionType != null && functionType.kind() == PbsAst.TypeRefKind.FN) {
|
||||
lowerExpected(callExpr.callee(), functionType, context);
|
||||
int closureSlot = save(1, callExpr.callee().span(), context);
|
||||
int argumentSlots = 0;
|
||||
for (int i = 0; i < callExpr.arguments().size(); i++) {
|
||||
var type = functionType.fields().get(i).typeRef();
|
||||
lowerExpected(callExpr.arguments().get(i), type, context);
|
||||
argumentSlots += context.types().slots(type);
|
||||
}
|
||||
emitGetLocal(closureSlot, callExpr.span(), context);
|
||||
registry(CALL_CLOSURE, context.types().registryType(functionType), 0, argumentSlots + 1,
|
||||
context.types().slots(functionType.inner()), callExpr.span(), context);
|
||||
return;
|
||||
}
|
||||
if (lowerStructuredCall(callExpr, context)) return;
|
||||
if (callExpr.callee() instanceof PbsAst.MemberExpr member) {
|
||||
var receiverType = PbsRuntimeTypes.unwrap(expressionType(member.receiver(), context));
|
||||
@@ -656,6 +727,15 @@ final class PbsExecutableBodyLowerer {
|
||||
private void lowerIdentifierExpression(
|
||||
final PbsAst.IdentifierExpr identifierExpr,
|
||||
final PbsExecutableLoweringContext context) {
|
||||
if (!context.localTypes.containsKey(identifierExpr.name()) && !context.types().values.containsKey(identifierExpr.name())) {
|
||||
var type = PbsRuntimeTypes.unwrap(expressionType(identifierExpr, context));
|
||||
if (type != null && type.kind() == PbsAst.TypeRefKind.FN) {
|
||||
var id = context.exactLocalCallable(identifierExpr.name(), type.fields().stream().map(PbsAst.NamedTypeField::typeRef).toList(), type.inner());
|
||||
if (id == null) { reportUnsupportedLowering("Unresolved function reference: " + identifierExpr.name(), identifierExpr.span(), context); return; }
|
||||
makeClosure(context.types().registryType(type), id, 0, identifierExpr.span(), context);
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (context.types().services.containsKey(identifierExpr.name())) {
|
||||
lowerServiceValue(identifierExpr.name(), identifierExpr.span(), context);
|
||||
return;
|
||||
@@ -767,7 +847,8 @@ final class PbsExecutableBodyLowerer {
|
||||
case PbsAst.PropagateExpr propagateExpr -> materializedValueSlots(propagateExpr.expression(), context);
|
||||
case PbsAst.GroupExpr groupExpr -> materializedValueSlots(groupExpr.expression(), context);
|
||||
case PbsAst.NewExpr newExpr -> expressionListValueSlots(newExpr.arguments(), context);
|
||||
case PbsAst.BindExpr bindExpr -> materializedValueSlots(bindExpr.contextExpression(), context);
|
||||
case PbsAst.LambdaExpr lambda -> 1;
|
||||
|
||||
case PbsAst.SomeExpr someExpr -> materializedValueSlots(someExpr.value(), context);
|
||||
case PbsAst.OkExpr okExpr -> materializedValueSlots(okExpr.value(), context);
|
||||
case PbsAst.TupleExpr tupleExpr -> {
|
||||
@@ -813,6 +894,8 @@ final class PbsExecutableBodyLowerer {
|
||||
private boolean producesIdentifierValue(
|
||||
final PbsAst.IdentifierExpr identifierExpr,
|
||||
final PbsExecutableLoweringContext context) {
|
||||
var valueType = PbsRuntimeTypes.unwrap(expressionType(identifierExpr, context));
|
||||
if (valueType != null && valueType.kind() == PbsAst.TypeRefKind.FN) return true;
|
||||
if (context.types().services.containsKey(identifierExpr.name())) {
|
||||
return true;
|
||||
}
|
||||
@@ -953,6 +1036,7 @@ final class PbsExecutableBodyLowerer {
|
||||
|
||||
private PbsAst.TypeRef expressionType(PbsAst.Expression e, PbsExecutableLoweringContext c) {
|
||||
if (e == null) return null;
|
||||
if (e instanceof PbsAst.LambdaExpr lambda) return lambda.functionType();
|
||||
if (e instanceof PbsAst.ArrayLiteralExpr || e instanceof PbsAst.NoneExpr) return c.expectedType;
|
||||
if (e instanceof PbsAst.TupleExpr tuple) return PbsAst.TypeRef.namedTuple(ReadOnlyList.wrap(tuple.items().stream()
|
||||
.map(item -> new PbsAst.NamedTypeField(item.label(),expressionType(item.expression(),c),item.span())).toList()),tuple.span());
|
||||
@@ -971,7 +1055,19 @@ final class PbsExecutableBodyLowerer {
|
||||
}
|
||||
if (e instanceof PbsAst.IdentifierExpr i) {
|
||||
if(c.types().services.containsKey(i.name()))return PbsRuntimeTypes.type(i.name());
|
||||
return c.localTypes.getOrDefault(i.name(), c.types().values.get(i.name()));
|
||||
var local = c.localTypes.getOrDefault(i.name(), c.types().values.get(i.name()));
|
||||
if (local != null) return local;
|
||||
var functions = c.types().functions.get(i.name());
|
||||
if (functions != null && !functions.isEmpty()) {
|
||||
var expected = PbsRuntimeTypes.unwrap(c.expectedType);
|
||||
if (expected != null && expected.kind() == PbsAst.TypeRefKind.FN) return expected;
|
||||
if (functions.size() == 1) {
|
||||
var f = functions.getFirst();
|
||||
return PbsAst.TypeRef.function(ReadOnlyList.wrap(f.parameters().stream().map(p ->
|
||||
new PbsAst.NamedTypeField(null,p.typeRef(),p.span())).toList()),f.returnType(),f.span());
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
if (e instanceof PbsAst.GroupExpr g) return expressionType(g.expression(), c);
|
||||
if (e instanceof PbsAst.AsExpr a) return PbsRuntimeTypes.type(a.contractName());
|
||||
@@ -982,6 +1078,8 @@ final class PbsExecutableBodyLowerer {
|
||||
if (e instanceof PbsAst.ApplyExpr apply) return expressionType(applyCall(apply), c);
|
||||
if (e instanceof PbsAst.NewExpr value) return value.typeName().equals("array") ? c.expectedType : PbsRuntimeTypes.type(value.typeName());
|
||||
if (e instanceof PbsAst.CallExpr call) {
|
||||
var fn = isDirectFunction(call.callee(), c) ? null : PbsRuntimeTypes.unwrap(expressionType(call.callee(),c));
|
||||
if (fn != null && fn.kind() == PbsAst.TypeRefKind.FN) return fn.inner();
|
||||
var sourceFunction = sourceFunction(call,c);
|
||||
if (sourceFunction != null) return sourceFunction.returnType();
|
||||
if (call.callee() instanceof PbsAst.MemberExpr member && member.memberName().equals("clear")) {
|
||||
|
||||
+1
-6
@@ -369,12 +369,7 @@ final class PbsExecutableCallsiteEmitter {
|
||||
identifierExpr.name(),
|
||||
nameTable.register(identifierExpr.name()));
|
||||
case PbsAst.MemberExpr memberExpr -> resolveMemberCalleeIdentity(memberExpr, nameTable);
|
||||
case PbsAst.BindExpr bindExpr ->
|
||||
new PbsCalleeIdentity(
|
||||
nameTable.register(bindExpr.functionName()),
|
||||
null,
|
||||
bindExpr.functionName(),
|
||||
nameTable.register(bindExpr.functionName()));
|
||||
|
||||
case PbsAst.GroupExpr groupExpr -> resolveCalleeIdentity(groupExpr.expression(), nameTable);
|
||||
default -> null;
|
||||
};
|
||||
|
||||
+1
@@ -25,6 +25,7 @@ final class PbsExecutableLoweringContext {
|
||||
final Map<String, p.studio.compiler.pbs.ast.PbsAst.TypeRef> localTypes = new HashMap<>();
|
||||
p.studio.compiler.pbs.ast.PbsAst.TypeRef expectedType;
|
||||
p.studio.compiler.pbs.ast.PbsAst.TypeRef returnType;
|
||||
PbsExecutableCallableRegistry callableRegistry() { return callableRegistry; }
|
||||
PbsRuntimeTypes types() { return metadataIndex.types(); }
|
||||
String serviceOwner;
|
||||
private int nextLabelId = 0;
|
||||
|
||||
+10
-1
@@ -95,13 +95,22 @@ public final class PbsExecutableLoweringService {
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < metadataIndex.types().closureBodies.size(); i++) {
|
||||
var generated = metadataIndex.types().closureBodies.get(i);
|
||||
var callable = new PbsLowerableCallable(generated.function().name(), generated.function());
|
||||
var lowered = lowerExecutableFunction(fileId, normalizedModuleId, callable, callableRegistry,
|
||||
diagnostics, nameTable, metadataIndex, intrinsicIdTable);
|
||||
if (lowered != null) executableFunctions.add(lowered);
|
||||
}
|
||||
|
||||
final var intrinsicPool = new ArrayList<IntrinsicReference>(intrinsicIdTable.size());
|
||||
for (final var intrinsicId : intrinsicIdTable.identifiers()) {
|
||||
intrinsicPool.add(intrinsicIdTable.get(intrinsicId));
|
||||
}
|
||||
return new PbsExecutableLoweringResult(
|
||||
ReadOnlyList.wrap(executableFunctions),
|
||||
callableRegistry.callableSignatures(),
|
||||
ReadOnlyList.wrap(callableRegistry.callableSignatureByCallableId().entrySet().stream()
|
||||
.sorted(java.util.Comparator.comparingInt(e -> e.getKey().getIndex())).map(java.util.Map.Entry::getValue).toList()),
|
||||
ReadOnlyList.wrap(intrinsicPool), metadataIndex.types().registry());
|
||||
}
|
||||
|
||||
|
||||
+17
-1
@@ -8,6 +8,9 @@ import java.util.*;
|
||||
|
||||
/** PBS-owned source identities and layouts; never inferred from slot widths. */
|
||||
final class PbsRuntimeTypes {
|
||||
record ClosureBody(PbsAst.FunctionDecl function, java.util.List<PbsAst.NamedTypeField> captures) {}
|
||||
final java.util.List<ClosureBody> closureBodies = new ArrayList<>();
|
||||
final Map<String, java.util.List<PbsAst.NamedTypeField>> capturesByFunction = new HashMap<>();
|
||||
final Map<String, String> builtinNames;
|
||||
final Map<String, String> aliases = new HashMap<>();
|
||||
final Map<String, ReadOnlyList<PbsAst.BuiltinFieldDecl>> fields = new HashMap<>();
|
||||
@@ -82,6 +85,7 @@ final class PbsRuntimeTypes {
|
||||
String key(PbsAst.TypeRef t) {
|
||||
t = unwrap(t);
|
||||
if (t == null) return "void";
|
||||
if (t.kind() == PbsAst.TypeRefKind.FN) return "Fn(" + t.fields().stream().map(f->key(f.typeRef())).collect(java.util.stream.Collectors.joining(",")) + ")->" + shapeKey(t.inner());
|
||||
if (t.kind() == PbsAst.TypeRefKind.ARRAY) return "array("+key(t.inner())+")";
|
||||
if (t.kind() == PbsAst.TypeRefKind.OPTIONAL) return "optional("+key(t.inner())+")";
|
||||
if (t.kind() == PbsAst.TypeRefKind.NAMED_TUPLE) return "tuple("+t.fields().stream().map(f->key(f.typeRef())).reduce((a,b)->a+","+b).orElse("")+")";
|
||||
@@ -119,6 +123,16 @@ final class PbsRuntimeTypes {
|
||||
}
|
||||
IRRegistry.TypeRef registryType(PbsAst.TypeRef type) {
|
||||
var t = unwrap(type);
|
||||
if (t.kind() == PbsAst.TypeRefKind.FN) {
|
||||
var ref = new IRRegistry.TypeRef("pbs:" + key(t));
|
||||
if (!used.containsKey(ref.declarationKey())) {
|
||||
var params = new ArrayList<IRRegistry.NamedType>();
|
||||
for (var input : t.fields()) for (var part : results(input.typeRef())) params.add(new IRRegistry.NamedType(part, null));
|
||||
var signature = new IRRegistry.Signature(ReadOnlyList.wrap(params), ReadOnlyList.wrap(results(t.inner())));
|
||||
used.put(ref.declarationKey(), new IRRegistry.TypeDeclaration(ref, null, new IRRegistry.Fn(signature)));
|
||||
}
|
||||
return ref;
|
||||
}
|
||||
if (t.kind() == PbsAst.TypeRefKind.ARRAY) return arrayStorage();
|
||||
if (t.kind() == PbsAst.TypeRefKind.OPTIONAL || t.kind() == PbsAst.TypeRefKind.NAMED_TUPLE) {
|
||||
var ref = new IRRegistry.TypeRef("pbs:value:"+key(t));
|
||||
@@ -180,7 +194,9 @@ final class PbsRuntimeTypes {
|
||||
var params=new ArrayList<IRRegistry.NamedType>();
|
||||
for(var p:f.parameters()) for(var type:results(p.typeRef())) params.add(new IRRegistry.NamedType(type,p.name()));
|
||||
var returns=f.returnKind()==PbsAst.ReturnKind.PLAIN ? results(f.returnType()) : List.<IRRegistry.TypeRef>of();
|
||||
return IRRegistry.FunctionMetadata.ordinary(new IRRegistry.Signature(ReadOnlyList.wrap(params),ReadOnlyList.wrap(returns)));
|
||||
var captures = capturesByFunction.getOrDefault(f.name(), List.of()).stream().flatMap(c -> results(c.typeRef()).stream()).toList();
|
||||
return new IRRegistry.FunctionMetadata(new IRRegistry.Signature(ReadOnlyList.wrap(params),ReadOnlyList.wrap(returns)),
|
||||
ReadOnlyList.wrap(captures), IRRegistry.Role.NONE);
|
||||
}
|
||||
IRRegistry registry() { return new IRRegistry(ReadOnlyList.wrap(new ArrayList<>(used.values())),ReadOnlyList.wrap(runtimeImplementations)); }
|
||||
Integer enumValue(String owner,String label) {
|
||||
|
||||
+2
-4
@@ -104,9 +104,7 @@ public final class PbsBarrelParser {
|
||||
if (cursor.match(PbsTokenKind.CONST)) {
|
||||
return parseSimpleItem(visibility, visibilityToken, PbsTokenKind.CONST);
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.CALLBACK)) {
|
||||
return parseSimpleItem(visibility, visibilityToken, PbsTokenKind.CALLBACK);
|
||||
}
|
||||
|
||||
|
||||
report(cursor.peek(), ParseErrors.E_PARSE_UNEXPECTED_TOKEN,
|
||||
"Expected barrel declaration kind after visibility");
|
||||
@@ -131,7 +129,7 @@ public final class PbsBarrelParser {
|
||||
case SERVICE -> new PbsAst.BarrelServiceItem(visibility, name.lexeme(), itemSpan);
|
||||
case GLOBAL -> new PbsAst.BarrelGlobalItem(visibility, name.lexeme(), itemSpan);
|
||||
case CONST -> new PbsAst.BarrelConstItem(visibility, name.lexeme(), itemSpan);
|
||||
case CALLBACK -> new PbsAst.BarrelCallbackItem(visibility, name.lexeme(), itemSpan);
|
||||
|
||||
default -> null;
|
||||
};
|
||||
}
|
||||
|
||||
+1
-23
@@ -127,10 +127,7 @@ final class PbsDeclarationParser {
|
||||
rejectUnsupportedDeclarationAttributes(pendingAttributes, "enum declarations");
|
||||
return parseEnumDeclaration(declareToken, pendingAttributes);
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.CALLBACK)) {
|
||||
rejectUnsupportedDeclarationAttributes(pendingAttributes, "callback declarations");
|
||||
return parseCallbackDeclaration(declareToken, pendingAttributes);
|
||||
}
|
||||
|
||||
if (cursor.match(PbsTokenKind.GLOBAL)) {
|
||||
rejectAttributesBeforeUnsupportedTopDecl(pendingAttributes, "global declarations");
|
||||
return parseGlobalDeclaration(declareToken);
|
||||
@@ -614,26 +611,7 @@ final class PbsDeclarationParser {
|
||||
return token;
|
||||
}
|
||||
|
||||
private PbsAst.CallbackDecl parseCallbackDeclaration(
|
||||
final PbsToken declareToken,
|
||||
final ReadOnlyList<PbsAst.Attribute> attributes) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected callback name");
|
||||
consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after callback name");
|
||||
final var parameters = typeParser.parseParametersUntilRightParen();
|
||||
final var rightParen = consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after callback parameter list");
|
||||
|
||||
final var returnSpec = typeParser.parseCallableReturnSpec(rightParen);
|
||||
|
||||
final var semicolon = consume(PbsTokenKind.SEMICOLON, "Expected ';' after callback declaration");
|
||||
return new PbsAst.CallbackDecl(
|
||||
name.lexeme(),
|
||||
ReadOnlyList.wrap(parameters),
|
||||
returnSpec.kind(),
|
||||
returnSpec.returnType(),
|
||||
returnSpec.resultErrorType(),
|
||||
attributes,
|
||||
span(declareToken.start(), semicolon.end()));
|
||||
}
|
||||
|
||||
private PbsAst.ConstDecl parseConstDeclaration(
|
||||
final PbsToken declareToken,
|
||||
|
||||
+2
@@ -18,6 +18,8 @@ final class PbsExprParserContext {
|
||||
this.blockParserDelegate = blockParserDelegate;
|
||||
}
|
||||
|
||||
PbsTypeParser typeParser() { return new PbsTypeParser(parserContext); }
|
||||
|
||||
PbsTokenCursor cursor() {
|
||||
return cursor;
|
||||
}
|
||||
|
||||
+21
-13
@@ -87,6 +87,7 @@ final class PbsExprPrimaryParser {
|
||||
}
|
||||
|
||||
PbsAst.Expression parsePrimary() {
|
||||
if (cursor.match(PbsTokenKind.FN)) return parseLambda(cursor.previous());
|
||||
if (cursor.match(PbsTokenKind.LEFT_BRACKET)) {
|
||||
final var open = cursor.previous();
|
||||
final var elements = new ArrayList<PbsAst.Expression>();
|
||||
@@ -108,9 +109,7 @@ final class PbsExprPrimaryParser {
|
||||
if (cursor.match(PbsTokenKind.NEW)) {
|
||||
return parseNewExpression(cursor.previous());
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.BIND)) {
|
||||
return parseBindExpression(cursor.previous());
|
||||
}
|
||||
|
||||
if (cursor.match(PbsTokenKind.SOME)) {
|
||||
return parseSomeExpression(cursor.previous());
|
||||
}
|
||||
@@ -252,18 +251,27 @@ final class PbsExprPrimaryParser {
|
||||
context.span(newToken.start(), close.end()));
|
||||
}
|
||||
|
||||
private PbsAst.Expression parseBindExpression(final PbsToken bindToken) {
|
||||
context.consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after 'bind'");
|
||||
final var contextExpression = expressionParserDelegate.parse();
|
||||
context.consume(PbsTokenKind.COMMA, "Expected ',' in bind(context, fn_name)");
|
||||
final var functionName = context.consume(PbsTokenKind.IDENTIFIER, "Expected function identifier in bind(context, fn_name)");
|
||||
final var close = context.consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after bind arguments");
|
||||
return new PbsAst.BindExpr(
|
||||
contextExpression,
|
||||
functionName.lexeme(),
|
||||
context.span(bindToken.start(), close.end()));
|
||||
private PbsAst.Expression parseLambda(PbsToken start) {
|
||||
context.consume(PbsTokenKind.LEFT_BRACKET, "Lambda requires explicit capture list, including []");
|
||||
var captures = new ArrayList<PbsAst.IdentifierExpr>();
|
||||
if (!cursor.check(PbsTokenKind.RIGHT_BRACKET)) do {
|
||||
var name = context.consume(PbsTokenKind.IDENTIFIER, "Expected captured binding name");
|
||||
captures.add(new PbsAst.IdentifierExpr(name.lexeme(), context.span(name.start(), name.end())));
|
||||
} while (cursor.match(PbsTokenKind.COMMA));
|
||||
context.consume(PbsTokenKind.RIGHT_BRACKET, "Expected ']' after captures");
|
||||
context.consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after captures");
|
||||
var types = context.typeParser();
|
||||
var parameters = types.parseParametersUntilRightParen();
|
||||
context.consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after lambda parameters");
|
||||
context.consume(PbsTokenKind.ARROW, "Lambda requires explicit result type");
|
||||
var result = types.parseTypeRef();
|
||||
var body = context.parseSurfaceBlock("Lambda requires a block body");
|
||||
return new PbsAst.LambdaExpr(ReadOnlyList.wrap(captures), ReadOnlyList.wrap(parameters), result, body,
|
||||
context.span(start.start(), body.span().getEnd()));
|
||||
}
|
||||
|
||||
|
||||
|
||||
private PbsAst.Expression parseSomeExpression(final PbsToken someToken) {
|
||||
context.consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after 'some'");
|
||||
final var value = expressionParserDelegate.parse();
|
||||
|
||||
+14
@@ -70,6 +70,20 @@ final class PbsTypeParser {
|
||||
}
|
||||
|
||||
private PbsAst.TypeRef parseTypeRefBody() {
|
||||
if (cursor.check(PbsTokenKind.IDENTIFIER) && cursor.peek().lexeme().equals("Fn")) {
|
||||
var start = cursor.advance();
|
||||
consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after Fn");
|
||||
var inputs = new ArrayList<PbsAst.NamedTypeField>();
|
||||
if (!cursor.check(PbsTokenKind.RIGHT_PAREN)) do {
|
||||
var type = parseTypeRef();
|
||||
inputs.add(new PbsAst.NamedTypeField(null, type, type.span()));
|
||||
} while (cursor.match(PbsTokenKind.COMMA));
|
||||
consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after Fn parameter types");
|
||||
consume(PbsTokenKind.ARROW, "Fn requires an explicit result type");
|
||||
var output = parseTypeRef();
|
||||
return PbsAst.TypeRef.function(p.studio.utilities.structures.ReadOnlyList.wrap(inputs), output,
|
||||
context.span(start.start(), output.span().getEnd()));
|
||||
}
|
||||
if (cursor.check(PbsTokenKind.IDENTIFIER) && cursor.peek().lexeme().equals("array")) {
|
||||
final var start = cursor.advance();
|
||||
int depth = 1;
|
||||
|
||||
+2
-10
@@ -70,16 +70,7 @@ final class PbsAstDocumentSymbols {
|
||||
if (topDecl instanceof PbsAst.ErrorDecl errorDecl) {
|
||||
return errorSymbol(errorDecl);
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return callableSymbol(
|
||||
callbackDecl.name(),
|
||||
PbsEditorialSymbolKind.CALLBACK,
|
||||
callbackDecl.parameters(),
|
||||
callbackDecl.returnKind(),
|
||||
callbackDecl.returnType(),
|
||||
callbackDecl.resultErrorType(),
|
||||
callbackDecl.span());
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.GlobalDecl globalDecl) {
|
||||
return namedSymbol(
|
||||
globalDecl.name(),
|
||||
@@ -306,6 +297,7 @@ final class PbsAstDocumentSymbols {
|
||||
case UNIT -> typeRef.name() == null || typeRef.name().isBlank() ? "void" : typeRef.name();
|
||||
case SELF -> "Self";
|
||||
case SIMPLE -> typeRef.name() == null ? "void" : typeRef.name();
|
||||
case FN -> "Fn(" + typeRef.fields().stream().map(f -> formatTypeRef(f.typeRef())).collect(java.util.stream.Collectors.joining(",")) + ") -> " + formatTypeRef(typeRef.inner());
|
||||
case ARRAY -> "array " + formatTypeRef(typeRef.inner());
|
||||
case OPTIONAL -> "optional " + formatTypeRef(typeRef.inner());
|
||||
case GROUP -> "(" + formatTypeRef(typeRef.inner()) + ")";
|
||||
|
||||
+1
@@ -217,6 +217,7 @@ public final class PbsBuiltinLayoutResolver {
|
||||
return switch (typeRef.kind()) {
|
||||
case SIMPLE -> typeRef.name();
|
||||
case SELF -> "Self";
|
||||
case FN -> "Fn(" + typeRef.fields().stream().map(f -> renderTypeSurface(f.typeRef())).collect(java.util.stream.Collectors.joining(",")) + ") -> " + renderTypeSurface(typeRef.inner());
|
||||
case ARRAY -> "array %s".formatted(renderTypeSurface(typeRef.inner()));
|
||||
case OPTIONAL -> "optional %s".formatted(renderTypeSurface(typeRef.inner()));
|
||||
case UNIT -> "void";
|
||||
|
||||
+1
@@ -78,6 +78,7 @@ final class PbsCallableShape {
|
||||
return switch (unwrapped.kind()) {
|
||||
case SIMPLE -> "simple:" + unwrapped.name();
|
||||
case SELF -> "self";
|
||||
case FN -> "Fn(" + unwrapped.fields().stream().map(f -> typeKey(f.typeRef())).collect(java.util.stream.Collectors.joining(",")) + ") -> " + typeKey(unwrapped.inner());
|
||||
case ARRAY -> "array(" + typeKey(unwrapped.inner()) + ")";
|
||||
case OPTIONAL -> "optional(" + typeKey(unwrapped.inner()) + ")";
|
||||
case UNIT -> "unit";
|
||||
|
||||
+1
-15
@@ -116,21 +116,7 @@ final class PbsDeclarationRuleValidator {
|
||||
}
|
||||
}
|
||||
|
||||
void validateCallbackDeclaration(final PbsAst.CallbackDecl callbackDecl) {
|
||||
validateParameters(callbackDecl.parameters(), "callback '%s'".formatted(callbackDecl.name()));
|
||||
validateReturnSurface(
|
||||
callbackDecl.returnKind(),
|
||||
callbackDecl.returnType(),
|
||||
callbackDecl.resultErrorType(),
|
||||
"callback '%s'".formatted(callbackDecl.name()),
|
||||
callbackDecl.span(),
|
||||
false);
|
||||
PbsTypeSurfaceSemanticsValidator.validateTypeSurfaceRecursive(
|
||||
callbackDecl.parameters().stream().map(PbsAst.Parameter::typeRef).toList(),
|
||||
"callback '%s'".formatted(callbackDecl.name()),
|
||||
false,
|
||||
diagnostics);
|
||||
}
|
||||
|
||||
|
||||
void validateConstDeclaration(final PbsAst.ConstDecl constDecl) {
|
||||
validateConstDeclaration(constDecl, true);
|
||||
|
||||
+1
-6
@@ -147,12 +147,7 @@ public final class PbsDeclarationSemanticsValidator {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
validateDocAttributes(callbackDecl.attributes(), "callback declarations", diagnostics);
|
||||
binder.registerType(callbackDecl.name(), callbackDecl.span(), "callback");
|
||||
rules.validateCallbackDeclaration(callbackDecl);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
if (topDecl instanceof PbsAst.GlobalDecl globalDecl) {
|
||||
binder.registerValue(globalDecl.name(), globalDecl.span(), "global");
|
||||
|
||||
+40
-32
@@ -18,9 +18,9 @@ import static p.studio.compiler.pbs.semantics.PbsFlowSemanticSupport.*;
|
||||
public final class PbsEditorialSupportService {
|
||||
private static final Set<String> BUILTIN_TYPE_NAMES = Set.of("int", "long", "float", "bool", "str", "string", "i32", "i64", "f32", "f64");
|
||||
private static final List<String> KEYWORDS = List.of(
|
||||
"fn", "declare", "let", "const", "global", "struct", "service", "host", "contract", "enum", "error", "callback",
|
||||
"fn", "declare", "let", "const", "global", "struct", "service", "host", "contract", "enum", "error", "Fn",
|
||||
"if", "else", "switch", "for", "until", "step", "while", "break", "continue", "return",
|
||||
"new", "bind", "apply", "handle", "some", "none", "ok", "err", "true", "false");
|
||||
"new", "apply", "handle", "some", "none", "ok", "err", "true", "false");
|
||||
|
||||
public List<PbsEditorialCompletionCandidate> completion(
|
||||
final String sourceText,
|
||||
@@ -456,8 +456,6 @@ public final class PbsEditorialSupportService {
|
||||
typeRefs.put(entry.getKey(), PbsAst.TypeRef.simple(enumDecl.name(), enumDecl.span()));
|
||||
} else if (entry.getValue().decl() instanceof PbsAst.ErrorDecl errorDecl) {
|
||||
typeRefs.put(entry.getKey(), PbsAst.TypeRef.simple(errorDecl.name(), errorDecl.span()));
|
||||
} else if (entry.getValue().decl() instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
typeRefs.put(entry.getKey(), PbsAst.TypeRef.simple(callbackDecl.name(), callbackDecl.span()));
|
||||
}
|
||||
}
|
||||
return Map.copyOf(typeRefs);
|
||||
@@ -492,6 +490,19 @@ public final class PbsEditorialSupportService {
|
||||
break;
|
||||
}
|
||||
if (statement.span().contains(offset)) {
|
||||
var lambda = p.studio.compiler.pbs.ast.PbsLambdaTraversal.enclosing(statement, offset);
|
||||
if (lambda != null && (lambda.body().span().contains(offset)
|
||||
|| lambda.parameters().stream().anyMatch(p -> p.span().contains(offset)))) {
|
||||
var captured = new Scope();
|
||||
for (var capture : lambda.captures()) {
|
||||
var type = scope.resolve(capture.name());
|
||||
if (type != null) captured.bind(capture.name(), type, false);
|
||||
}
|
||||
for (var parameter : lambda.parameters()) captured.bind(parameter.name(),
|
||||
typeOps.typeFromTypeRef(parameter.typeRef(), model, frame.receiverType()));
|
||||
return lambda.body().span().contains(offset)
|
||||
? populateScopeUntilOffset(lambda.body(), captured, frame, offset) : captured;
|
||||
}
|
||||
if (statement instanceof PbsAst.IfStatement ifStatement) {
|
||||
if (ifStatement.thenBlock().span().contains(offset)
|
||||
|| (ifStatement.bindingSpan() != null && ifStatement.bindingSpan().contains(offset))) {
|
||||
@@ -987,7 +998,7 @@ public final class PbsEditorialSupportService {
|
||||
}
|
||||
for (final var parameter : callableFrame.parameters()) {
|
||||
if (symbolName.equals(parameter.name())) {
|
||||
return locations(parameter.span());
|
||||
return locations(bindingSpan(callableFrame.body(), symbolName, offset, parameter.span()));
|
||||
}
|
||||
}
|
||||
return List.of();
|
||||
@@ -1000,7 +1011,9 @@ public final class PbsEditorialSupportService {
|
||||
if (callableFrame == null) {
|
||||
return List.of();
|
||||
}
|
||||
return locations(bindingSpan(callableFrame.body(), symbolName, offset, null));
|
||||
Span seed = null;
|
||||
for (var parameter : callableFrame.parameters()) if (parameter.name().equals(symbolName)) seed = parameter.span();
|
||||
return locations(bindingSpan(callableFrame.body(), symbolName, offset, seed));
|
||||
}
|
||||
|
||||
private Span bindingSpan(
|
||||
@@ -1017,6 +1030,16 @@ public final class PbsEditorialSupportService {
|
||||
found = letStatement.nameSpan() == null ? letStatement.span() : letStatement.nameSpan();
|
||||
}
|
||||
if (statement.span().contains(offset)) {
|
||||
var lambda = p.studio.compiler.pbs.ast.PbsLambdaTraversal.enclosing(statement, offset);
|
||||
if (lambda != null) {
|
||||
for (var parameter : lambda.parameters()) if (parameter.name().equals(symbolName)
|
||||
&& (parameter.span().contains(offset) || lambda.body().span().contains(offset)))
|
||||
return bindingSpan(lambda.body(), symbolName, offset, parameter.span());
|
||||
if (lambda.body().span().contains(offset)) {
|
||||
boolean captured = lambda.captures().stream().anyMatch(c -> c.name().equals(symbolName));
|
||||
return bindingSpan(lambda.body(), symbolName, offset, captured ? found : null);
|
||||
}
|
||||
}
|
||||
if (statement instanceof PbsAst.IfStatement ifStatement) {
|
||||
if (symbolName.equals(ifStatement.bindingName()) && ifStatement.bindingSpan() != null
|
||||
&& ifStatement.bindingSpan().contains(offset)) return ifStatement.bindingSpan();
|
||||
@@ -1236,9 +1259,7 @@ public final class PbsEditorialSupportService {
|
||||
if (topDecl instanceof PbsAst.ContractDecl contractDecl) {
|
||||
return contractDecl.attributes();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return callbackDecl.attributes();
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.EnumDecl enumDecl) {
|
||||
return enumDecl.attributes();
|
||||
}
|
||||
@@ -1282,9 +1303,7 @@ public final class PbsEditorialSupportService {
|
||||
if (topDecl instanceof PbsAst.FunctionDecl functionDecl) {
|
||||
return List.of(signatureFromFunction(functionDecl.name(), functionDecl.parameters(), functionDecl.returnKind(), functionDecl.returnType(), functionDecl.resultErrorType()));
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return List.of(signatureFromFunction(callbackDecl.name(), callbackDecl.parameters(), callbackDecl.returnKind(), callbackDecl.returnType(), callbackDecl.resultErrorType()));
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.ServiceDecl serviceDecl) {
|
||||
return serviceDecl.methods().stream()
|
||||
.map(method -> signatureFromFunction(method.name(), method.parameters(), method.returnKind(), method.returnType(), method.resultErrorType()))
|
||||
@@ -1392,7 +1411,8 @@ public final class PbsEditorialSupportService {
|
||||
case UNIT -> "unit";
|
||||
case SELF -> "Self";
|
||||
case SIMPLE -> typeRef.name();
|
||||
case ARRAY -> "array " + formatTypeRef(typeRef.inner());
|
||||
case FN -> "Fn(" + typeRef.fields().stream().map(f -> formatTypeRef(f.typeRef())).collect(java.util.stream.Collectors.joining(",")) + ") -> " + formatTypeRef(typeRef.inner());
|
||||
case ARRAY -> "array " + formatTypeRef(typeRef.inner());
|
||||
case OPTIONAL -> formatTypeRef(typeRef.inner()) + "?";
|
||||
case GROUP -> formatTypeRef(typeRef.inner());
|
||||
case NAMED_TUPLE -> {
|
||||
@@ -1537,9 +1557,7 @@ public final class PbsEditorialSupportService {
|
||||
if (topDecl instanceof PbsAst.ErrorDecl errorDecl) {
|
||||
return TypeView.error(errorDecl.name());
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return typeOps.typeFromTypeRef(PbsAst.TypeRef.simple(callbackDecl.name(), callbackDecl.span()), model, null);
|
||||
}
|
||||
|
||||
return TypeView.unknown();
|
||||
}
|
||||
|
||||
@@ -2021,6 +2039,9 @@ public final class PbsEditorialSupportService {
|
||||
}
|
||||
return switch (typeRef.kind()) {
|
||||
case SIMPLE -> aliasedTypeRefs.getOrDefault(typeRef.name(), typeRef);
|
||||
case FN -> PbsAst.TypeRef.function(ReadOnlyList.wrap(typeRef.fields().stream().map(f ->
|
||||
new PbsAst.NamedTypeField(null, aliasExpandedTypeRef(f.typeRef()), f.span())).toList()),
|
||||
aliasExpandedTypeRef(typeRef.inner()), typeRef.span());
|
||||
case ARRAY -> PbsAst.TypeRef.array(aliasExpandedTypeRef(typeRef.inner()), typeRef.span());
|
||||
case OPTIONAL -> PbsAst.TypeRef.optional(aliasExpandedTypeRef(typeRef.inner()), typeRef.span());
|
||||
case GROUP -> PbsAst.TypeRef.group(aliasExpandedTypeRef(typeRef.inner()), typeRef.span());
|
||||
@@ -2065,9 +2086,7 @@ public final class PbsEditorialSupportService {
|
||||
if (topDecl instanceof PbsAst.ContractDecl contractDecl) {
|
||||
return contractDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return callbackDecl.name();
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.EnumDecl enumDecl) {
|
||||
return enumDecl.name();
|
||||
}
|
||||
@@ -2135,16 +2154,7 @@ public final class PbsEditorialSupportService {
|
||||
if (topDecl instanceof PbsAst.ContractDecl contractDecl) {
|
||||
return new PbsAst.ContractDecl(newName, contractDecl.signatures(), contractDecl.attributes(), contractDecl.span());
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return new PbsAst.CallbackDecl(
|
||||
newName,
|
||||
callbackDecl.parameters(),
|
||||
callbackDecl.returnKind(),
|
||||
callbackDecl.returnType(),
|
||||
callbackDecl.resultErrorType(),
|
||||
callbackDecl.attributes(),
|
||||
callbackDecl.span());
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.EnumDecl enumDecl) {
|
||||
return new PbsAst.EnumDecl(newName, enumDecl.cases(), enumDecl.attributes(), enumDecl.span());
|
||||
}
|
||||
@@ -2191,9 +2201,7 @@ public final class PbsEditorialSupportService {
|
||||
if (topDecl instanceof PbsAst.ContractDecl) {
|
||||
return PbsEditorialSymbolKind.CONTRACT;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl) {
|
||||
return PbsEditorialSymbolKind.CALLBACK;
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.EnumDecl) {
|
||||
return PbsEditorialSymbolKind.ENUM;
|
||||
}
|
||||
|
||||
-1
@@ -266,7 +266,6 @@ final class PbsFlowAssignmentAnalyzer {
|
||||
return model.serviceSingletons.containsKey(rootName)
|
||||
|| model.constTypes.containsKey(rootName)
|
||||
|| model.topLevelCallables.containsKey(rootName)
|
||||
|| model.callbacks.containsKey(rootName)
|
||||
|| model.enums.containsKey(rootName)
|
||||
|| model.errors.containsKey(rootName)
|
||||
|| model.structs.containsKey(rootName)
|
||||
|
||||
-50
@@ -265,57 +265,7 @@ final class PbsFlowCallableResolutionAnalyzer {
|
||||
return ExprResult.type(TypeView.unknown());
|
||||
}
|
||||
|
||||
ExprResult analyzeBindExpression(
|
||||
final PbsAst.BindExpr bindExpr,
|
||||
final PbsFlowExpressionContext context) {
|
||||
final var contextType = analyzeValueExpression(bindExpr.contextExpression(), context, null).type();
|
||||
final var expectedType = context.expectedType();
|
||||
final var model = context.model();
|
||||
final var diagnostics = context.diagnostics();
|
||||
if (expectedType == null || expectedType.kind() != Kind.CALLBACK) {
|
||||
return ExprResult.type(TypeView.unknown());
|
||||
}
|
||||
|
||||
final var topLevel = model.topLevelCallables.get(bindExpr.functionName());
|
||||
if (topLevel == null || topLevel.isEmpty()) {
|
||||
return ExprResult.type(expectedType);
|
||||
}
|
||||
final var compatible = new ArrayList<CallableSymbol>();
|
||||
for (final var candidate : topLevel) {
|
||||
if (candidate.inputTypes().size() != expectedType.callbackInputs().size() + 1) {
|
||||
continue;
|
||||
}
|
||||
if (!typeOps.compatible(contextType, candidate.inputTypes().getFirst())) {
|
||||
continue;
|
||||
}
|
||||
var ok = true;
|
||||
for (int i = 0; i < expectedType.callbackInputs().size(); i++) {
|
||||
if (!typeOps.compatible(expectedType.callbackInputs().get(i), candidate.inputTypes().get(i + 1))) {
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!ok) {
|
||||
continue;
|
||||
}
|
||||
if (!typeOps.compatible(candidate.outputType(), expectedType.callbackOutput())) {
|
||||
continue;
|
||||
}
|
||||
compatible.add(candidate);
|
||||
}
|
||||
if (compatible.size() > 1) {
|
||||
Diagnostics.error(diagnostics,
|
||||
PbsSemanticsErrors.E_SEM_APPLY_AMBIGUOUS_OVERLOAD.name(),
|
||||
"Bind target resolves ambiguously for callback type",
|
||||
bindExpr.span());
|
||||
} else if (compatible.isEmpty()) {
|
||||
Diagnostics.error(diagnostics,
|
||||
PbsSemanticsErrors.E_SEM_APPLY_UNRESOLVED_OVERLOAD.name(),
|
||||
"Bind target does not resolve for callback type",
|
||||
bindExpr.span());
|
||||
}
|
||||
return ExprResult.type(expectedType);
|
||||
}
|
||||
|
||||
private ExprResult resolveCallableApplication(
|
||||
final Span wholeSpan,
|
||||
|
||||
+32
-3
@@ -73,6 +73,7 @@ final class PbsFlowExpressionAnalyzer {
|
||||
private ExprResult analyzeExpressionInternal(
|
||||
final PbsAst.Expression expression,
|
||||
final PbsFlowExpressionContext context) {
|
||||
if (expression instanceof PbsAst.LambdaExpr lambda) return analyzeLambda(lambda, context);
|
||||
final var structural = structuralExpressionAnalyzer.analyze(expression, context);
|
||||
if (structural != null) {
|
||||
return structural;
|
||||
@@ -101,13 +102,41 @@ final class PbsFlowExpressionAnalyzer {
|
||||
if (expression instanceof PbsAst.HandleExpr handleExpr) {
|
||||
return ExprResult.type(controlExpressionAnalyzer.analyzeHandleExpression(handleExpr, context));
|
||||
}
|
||||
if (expression instanceof PbsAst.BindExpr bindExpr) {
|
||||
return callableResolutionAnalyzer.analyzeBindExpression(bindExpr, context);
|
||||
}
|
||||
|
||||
|
||||
return ExprResult.type(TypeView.unknown());
|
||||
}
|
||||
|
||||
private ExprResult analyzeLambda(PbsAst.LambdaExpr lambda, PbsFlowExpressionContext context) {
|
||||
var scope = new Scope();
|
||||
scope.rejectUnknown = true;
|
||||
var names = new java.util.HashSet<String>();
|
||||
for (var capture : lambda.captures()) {
|
||||
var type = context.scope().resolve(capture.name());
|
||||
if (type == null || !names.add(capture.name())) {
|
||||
p.studio.compiler.source.diagnostics.Diagnostics.error(context.diagnostics(), "E_SEM_CAPTURE",
|
||||
"Capture must name a unique outer local binding: " + capture.name(), capture.span());
|
||||
type = TypeView.unknown();
|
||||
}
|
||||
scope.bind(capture.name(), type, false);
|
||||
}
|
||||
for (var parameter : lambda.parameters()) {
|
||||
if (!names.add(parameter.name())) p.studio.compiler.source.diagnostics.Diagnostics.error(context.diagnostics(),
|
||||
"E_SEM_LAMBDA_PARAMETER", "Duplicate parameter or capture name: " + parameter.name(), parameter.span());
|
||||
scope.bind(parameter.name(), typeOps.typeFromTypeRef(parameter.typeRef(), context.model(), context.receiverType()));
|
||||
}
|
||||
PbsTypeSurfaceSemanticsValidator.validateTypeSurfaceRecursive(java.util.List.of(lambda.functionType()),
|
||||
"lambda", context.receiverType() != null, context.diagnostics());
|
||||
var fn = typeOps.typeFromTypeRef(lambda.functionType(), context.model(), context.receiverType());
|
||||
context.blockAnalyzer().analyze(lambda.body(), scope, fn.functionOutput(), null, null,
|
||||
context.model(), context.diagnostics(), false, null);
|
||||
new PbsFlowCompletionAnalyzer().validateCallableCompletion(lambda.body(), new PbsFlowBodyContext(scope,
|
||||
fn.functionOutput(), null, null, context.model(), context.diagnostics()));
|
||||
if (lambda.body().tailExpression() != null) p.studio.compiler.source.diagnostics.Diagnostics.error(context.diagnostics(),
|
||||
"E_SEM_LAMBDA_RETURN", "Lambda bodies use explicit return statements", lambda.body().tailExpression().span());
|
||||
return ExprResult.type(fn);
|
||||
}
|
||||
|
||||
private TypeView analyzeBlock(
|
||||
final PbsAst.Block block,
|
||||
final PbsFlowExpressionContext context,
|
||||
|
||||
+12
-37
@@ -17,6 +17,8 @@ final class PbsFlowSemanticSupport {
|
||||
List<CallableSymbol> callables,
|
||||
boolean methodTarget) {
|
||||
static ExprResult type(final TypeView type) {
|
||||
if (type.kind() == Kind.FN) return new ExprResult(type,
|
||||
List.of(new CallableSymbol("Fn", List.of(), type.functionInputs(), type.functionOutput(), Span.none(), null)), false);
|
||||
return new ExprResult(type, List.of(), false);
|
||||
}
|
||||
|
||||
@@ -42,7 +44,7 @@ final class PbsFlowSemanticSupport {
|
||||
STRUCT,
|
||||
SERVICE,
|
||||
CONTRACT,
|
||||
CALLBACK,
|
||||
FN,
|
||||
ENUM,
|
||||
ERROR,
|
||||
OPTIONAL,
|
||||
@@ -65,8 +67,8 @@ final class PbsFlowSemanticSupport {
|
||||
List<TupleField> tupleFields,
|
||||
TypeView inner,
|
||||
TypeView errorType,
|
||||
List<TypeView> callbackInputs,
|
||||
TypeView callbackOutput) {
|
||||
List<TypeView> functionInputs,
|
||||
TypeView functionOutput) {
|
||||
static TypeView unknown() {
|
||||
return new TypeView(Kind.UNKNOWN, null, List.of(), null, null, List.of(), null);
|
||||
}
|
||||
@@ -107,11 +109,11 @@ final class PbsFlowSemanticSupport {
|
||||
return new TypeView(Kind.CONTRACT, name, List.of(), null, null, List.of(), null);
|
||||
}
|
||||
|
||||
static TypeView callback(
|
||||
static TypeView function(
|
||||
final String name,
|
||||
final List<TypeView> inputTypes,
|
||||
final TypeView outputType) {
|
||||
return new TypeView(Kind.CALLBACK, name, List.of(), null, null, List.copyOf(inputTypes), outputType);
|
||||
return new TypeView(Kind.FN, name, List.of(), null, null, List.copyOf(inputTypes), outputType);
|
||||
}
|
||||
|
||||
static TypeView enumType(final String name) {
|
||||
@@ -167,10 +169,6 @@ final class PbsFlowSemanticSupport {
|
||||
Span span) {
|
||||
}
|
||||
|
||||
record CallbackSignature(
|
||||
List<TypeView> inputTypes,
|
||||
TypeView outputType) {
|
||||
}
|
||||
|
||||
record StructInfo(
|
||||
Map<String, StructFieldInfo> fields,
|
||||
@@ -196,7 +194,6 @@ final class PbsFlowSemanticSupport {
|
||||
final Map<String, StructInfo> structs = new HashMap<>();
|
||||
final Map<String, ServiceInfo> services = new HashMap<>();
|
||||
final Map<String, ContractInfo> contracts = new HashMap<>();
|
||||
final Map<String, CallbackSignature> callbacks = new HashMap<>();
|
||||
final Map<String, Set<String>> enums = new HashMap<>();
|
||||
final Map<String, Set<String>> errors = new HashMap<>();
|
||||
final Map<String, TypeView> constTypes = new HashMap<>();
|
||||
@@ -208,7 +205,6 @@ final class PbsFlowSemanticSupport {
|
||||
final Set<String> knownContractNames = new HashSet<>();
|
||||
final Set<String> knownEnumNames = new HashSet<>();
|
||||
final Set<String> knownErrorNames = new HashSet<>();
|
||||
final Set<String> knownCallbackNames = new HashSet<>();
|
||||
final Map<String, Integer> assetIdByAddress = new HashMap<>();
|
||||
final Set<String> assetNamespacePrefixes = new HashSet<>();
|
||||
|
||||
@@ -268,9 +264,7 @@ final class PbsFlowSemanticSupport {
|
||||
knownErrorNames.add(errorDecl.name());
|
||||
return;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
knownCallbackNames.add(callbackDecl.name());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private void ingestTopDecl(final PbsAst.TopDecl topDecl) {
|
||||
@@ -389,22 +383,7 @@ final class PbsFlowSemanticSupport {
|
||||
documentationFromAttributes(functionDecl.attributes())));
|
||||
return;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl(
|
||||
String name, ReadOnlyList<PbsAst.Parameter> parameters, PbsAst.ReturnKind returnKind,
|
||||
PbsAst.TypeRef returnType, PbsAst.TypeRef resultErrorType,
|
||||
ReadOnlyList<PbsAst.Attribute> ignoredAttributes, Span span
|
||||
)) {
|
||||
final var symbol = callableFrom(
|
||||
name,
|
||||
parameters,
|
||||
returnKind,
|
||||
returnType,
|
||||
resultErrorType,
|
||||
span,
|
||||
"");
|
||||
callbacks.put(name, new CallbackSignature(symbol.inputTypes(), symbol.outputType()));
|
||||
return;
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.EnumDecl enumDecl) {
|
||||
final var cases = new HashSet<String>();
|
||||
for (final var enumCase : enumDecl.cases()) {
|
||||
@@ -588,15 +567,9 @@ final class PbsFlowSemanticSupport {
|
||||
if (errors.containsKey(typeRef.name()) || knownErrorNames.contains(typeRef.name())) {
|
||||
yield TypeView.error(typeRef.name());
|
||||
}
|
||||
final var callbackSignature = callbacks.get(typeRef.name());
|
||||
if (callbackSignature != null) {
|
||||
yield TypeView.callback(typeRef.name(), callbackSignature.inputTypes(), callbackSignature.outputType());
|
||||
}
|
||||
if (knownCallbackNames.contains(typeRef.name())) {
|
||||
yield TypeView.callback(typeRef.name(), List.of(), TypeView.unknown());
|
||||
}
|
||||
yield TypeView.unknown();
|
||||
}
|
||||
case FN -> TypeView.function("Fn", typeRef.fields().stream().map(f -> typeFrom(f.typeRef())).toList(), typeFrom(typeRef.inner()));
|
||||
case ARRAY -> TypeView.array(typeFrom(typeRef.inner()));
|
||||
case OPTIONAL -> TypeView.optional(typeFrom(typeRef.inner()));
|
||||
case GROUP -> typeFrom(typeRef.inner());
|
||||
@@ -613,6 +586,7 @@ final class PbsFlowSemanticSupport {
|
||||
|
||||
static final class Scope {
|
||||
private final Map<String, LocalSymbol> names = new HashMap<>();
|
||||
boolean rejectUnknown;
|
||||
|
||||
record LocalSymbol(
|
||||
TypeView type,
|
||||
@@ -622,6 +596,7 @@ final class PbsFlowSemanticSupport {
|
||||
Scope copy() {
|
||||
final var scope = new Scope();
|
||||
scope.names.putAll(names);
|
||||
scope.rejectUnknown = rejectUnknown;
|
||||
return scope;
|
||||
}
|
||||
|
||||
|
||||
+2
-1
@@ -115,7 +115,8 @@ final class PbsFlowStatementAnalyzer {
|
||||
ExprUse.VALUE,
|
||||
true,
|
||||
this::analyzeNestedBlock);
|
||||
if (expected != null && (expected.kind() == Kind.ARRAY || initializer.type().kind() == Kind.ARRAY)
|
||||
if (expected != null && (expected.kind() == Kind.ARRAY || initializer.type().kind() == Kind.ARRAY
|
||||
|| expected.kind() == Kind.FN || initializer.type().kind() == Kind.FN)
|
||||
&& !typeOps.compatible(initializer.type(),expected)) {
|
||||
Diagnostics.error(diagnostics,"E_SEM_ARRAY_TYPE_MISMATCH","Array assignment requires the exact element type",letStatement.span());
|
||||
}
|
||||
|
||||
+12
-5
@@ -124,13 +124,18 @@ final class PbsFlowStructuralExpressionAnalyzer {
|
||||
return ExprResult.type(globalType);
|
||||
}
|
||||
|
||||
final var callbackSignature = model.callbacks.get(identifierExpr.name());
|
||||
if (callbackSignature != null) {
|
||||
return ExprResult.type(TypeView.callback(identifierExpr.name(), callbackSignature.inputTypes(), callbackSignature.outputType()));
|
||||
}
|
||||
|
||||
final var callables = model.topLevelCallables.get(identifierExpr.name());
|
||||
if (callables != null && !callables.isEmpty()) {
|
||||
if (context.use() == PbsFlowSemanticSupport.ExprUse.VALUE) {
|
||||
var candidates = callables.stream().filter(f -> expectedType == null ||
|
||||
typeOps.compatible(TypeView.function("Fn", f.inputTypes(), f.outputType()), expectedType)).toList();
|
||||
if (candidates.size() == 1) {
|
||||
var f = candidates.getFirst();
|
||||
return ExprResult.type(TypeView.function("Fn", f.inputTypes(), f.outputType()));
|
||||
}
|
||||
Diagnostics.error(diagnostics, "E_SEM_FN_REFERENCE", "Function reference requires one compatible signature", identifierExpr.span());
|
||||
return ExprResult.type(TypeView.unknown());
|
||||
}
|
||||
return ExprResult.callables(callables, false);
|
||||
}
|
||||
|
||||
@@ -142,6 +147,8 @@ final class PbsFlowStructuralExpressionAnalyzer {
|
||||
return ExprResult.type(TypeView.typeRef(identifierExpr.name()));
|
||||
}
|
||||
|
||||
if (context.scope().rejectUnknown) Diagnostics.error(diagnostics, "E_SEM_CAPTURE_REQUIRED",
|
||||
"Unknown binding or missing explicit capture: " + identifierExpr.name(), identifierExpr.span());
|
||||
return ExprResult.type(TypeView.unknown());
|
||||
}
|
||||
if (expression instanceof PbsAst.GroupExpr groupExpr) {
|
||||
|
||||
+7
-5
@@ -50,7 +50,11 @@ final class PbsFlowTypeOps {
|
||||
}
|
||||
return switch (actual.kind()) {
|
||||
case UNIT, INT, LONG, FLOAT, BOOL, STR -> true;
|
||||
case STRUCT, SERVICE, CONTRACT, CALLBACK, ENUM, ERROR, TYPE_REF, ASSET_NAMESPACE -> actual.name().equals(expected.name());
|
||||
case STRUCT, SERVICE, CONTRACT, ENUM, ERROR, TYPE_REF, ASSET_NAMESPACE -> actual.name().equals(expected.name());
|
||||
case FN -> actual.functionInputs().size() == expected.functionInputs().size()
|
||||
&& java.util.stream.IntStream.range(0, actual.functionInputs().size()).allMatch(i ->
|
||||
compatible(actual.functionInputs().get(i), expected.functionInputs().get(i)))
|
||||
&& compatible(actual.functionOutput(), expected.functionOutput());
|
||||
case ADDRESSABLE -> true;
|
||||
case ARRAY -> compatible(actual.inner(), expected.inner());
|
||||
case OPTIONAL -> compatible(actual.inner(), expected.inner());
|
||||
@@ -106,6 +110,8 @@ final class PbsFlowTypeOps {
|
||||
case UNIT -> TypeView.unit();
|
||||
case SELF -> receiverType == null ? TypeView.unknown() : receiverType;
|
||||
case SIMPLE -> simpleType(typeRef.name(), model);
|
||||
case FN -> TypeView.function("Fn", typeRef.fields().stream().map(f -> typeFromTypeRef(f.typeRef(), model, receiverType)).toList(),
|
||||
collapseReturnPayload(typeFromTypeRef(typeRef.inner(), model, receiverType)));
|
||||
case ARRAY -> TypeView.array(typeFromTypeRef(typeRef.inner(), model, receiverType));
|
||||
case OPTIONAL -> TypeView.optional(typeFromTypeRef(typeRef.inner(), model, receiverType));
|
||||
case GROUP -> typeFromTypeRef(typeRef.inner(), model, receiverType);
|
||||
@@ -210,10 +216,6 @@ final class PbsFlowTypeOps {
|
||||
if (model.errors.containsKey(name)) {
|
||||
return TypeView.error(name);
|
||||
}
|
||||
final var callbackSignature = model.callbacks.get(name);
|
||||
if (callbackSignature != null) {
|
||||
return TypeView.callback(name, callbackSignature.inputTypes(), callbackSignature.outputType());
|
||||
}
|
||||
return TypeView.unknown();
|
||||
}
|
||||
}
|
||||
|
||||
+2
-1
@@ -15,11 +15,12 @@ final class PbsInlineHintSurfaceFormatter {
|
||||
case STRUCT,
|
||||
SERVICE,
|
||||
CONTRACT,
|
||||
CALLBACK,
|
||||
ENUM,
|
||||
ERROR,
|
||||
TYPE_REF,
|
||||
ADDRESSABLE -> type.name();
|
||||
case FN -> "Fn(" + type.functionInputs().stream().map(this::format)
|
||||
.collect(java.util.stream.Collectors.joining(", ")) + ") -> " + format(type.functionOutput());
|
||||
case ARRAY -> {
|
||||
final var inner = format(type.inner());
|
||||
yield inner == null ? null : "array (" + inner + ")";
|
||||
|
||||
+1
-4
@@ -232,10 +232,7 @@ public final class PbsLifecycleSemanticsValidator {
|
||||
validateExpression(propagateExpr.expression(), hostPolicy, diagnostics);
|
||||
return;
|
||||
}
|
||||
if (expression instanceof PbsAst.BindExpr bindExpr) {
|
||||
validateExpression(bindExpr.contextExpression(), hostPolicy, diagnostics);
|
||||
return;
|
||||
}
|
||||
|
||||
if (expression instanceof PbsAst.AsExpr asExpr) {
|
||||
validateExpression(asExpr.expression(), hostPolicy, diagnostics);
|
||||
return;
|
||||
|
||||
+1
-1
@@ -66,7 +66,7 @@ public final class PbsQuickFixCollector {
|
||||
}
|
||||
case PbsAst.ErrorDecl errorDecl -> duplicateDoc(errorDecl.attributes(), repairs);
|
||||
case PbsAst.EnumDecl enumDecl -> duplicateDoc(enumDecl.attributes(), repairs);
|
||||
case PbsAst.CallbackDecl callbackDecl -> duplicateDoc(callbackDecl.attributes(), repairs);
|
||||
|
||||
case PbsAst.ConstDecl constDecl -> {
|
||||
duplicateDoc(constDecl.attributes(), repairs);
|
||||
duplicateNamed(constDecl.attributes(), "BuiltinConst", repairs);
|
||||
|
||||
+9
@@ -23,6 +23,15 @@ final class PbsTypeSurfaceSemanticsValidator {
|
||||
}
|
||||
|
||||
switch (typeRef.kind()) {
|
||||
case FN -> {
|
||||
pending.add(typeRef.inner());
|
||||
for (var parameter : typeRef.fields()) {
|
||||
if (parameter.typeRef().kind() == PbsAst.TypeRefKind.UNIT)
|
||||
p.studio.compiler.source.diagnostics.Diagnostics.error(diagnostics, "E_SEM_FN_PARAMETER",
|
||||
"Fn parameter must be a value type", parameter.span());
|
||||
pending.add(parameter.typeRef());
|
||||
}
|
||||
}
|
||||
case ARRAY -> {
|
||||
var element = typeRef.inner();
|
||||
while (element != null && element.kind() == PbsAst.TypeRefKind.GROUP) element = element.inner();
|
||||
|
||||
+7
-8
@@ -259,10 +259,7 @@ final class PbsImportedSemanticContextService {
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
collectReferencedTypeNames(callbackDecl.parameters(), callbackDecl.returnType(), callbackDecl.resultErrorType(), sink);
|
||||
return;
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.FunctionDecl functionDecl) {
|
||||
collectReferencedTypeNames(functionDecl, sink);
|
||||
return;
|
||||
@@ -321,6 +318,10 @@ final class PbsImportedSemanticContextService {
|
||||
sink.addLast(simpleName);
|
||||
}
|
||||
}
|
||||
case FN -> {
|
||||
collectReferencedTypeNames(typeRef.inner(), sink);
|
||||
for (var parameter : typeRef.fields()) collectReferencedTypeNames(parameter.typeRef(), sink);
|
||||
}
|
||||
case ARRAY, OPTIONAL, GROUP -> collectReferencedTypeNames(typeRef.inner(), sink);
|
||||
case NAMED_TUPLE -> {
|
||||
for (final var field : typeRef.fields()) {
|
||||
@@ -346,7 +347,7 @@ final class PbsImportedSemanticContextService {
|
||||
|| topDecl instanceof PbsAst.ServiceDecl
|
||||
|| topDecl instanceof PbsAst.HostDecl
|
||||
|| topDecl instanceof PbsAst.ContractDecl
|
||||
|| topDecl instanceof PbsAst.CallbackDecl
|
||||
|
||||
|| topDecl instanceof PbsAst.EnumDecl
|
||||
|| topDecl instanceof PbsAst.ErrorDecl;
|
||||
}
|
||||
@@ -429,9 +430,7 @@ final class PbsImportedSemanticContextService {
|
||||
if (topDecl instanceof PbsAst.FunctionDecl functionDecl) {
|
||||
return functionDecl.name();
|
||||
}
|
||||
if (topDecl instanceof PbsAst.CallbackDecl callbackDecl) {
|
||||
return callbackDecl.name();
|
||||
}
|
||||
|
||||
if (topDecl instanceof PbsAst.EnumDecl enumDecl) {
|
||||
return enumDecl.name();
|
||||
}
|
||||
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
// A closure keeps its object alive; each invocation completes in its own frame.
|
||||
declare struct ClosureExampleCounter(pub mut value: int);
|
||||
|
||||
fn createExampleCounter(start: int) -> Fn() -> int {
|
||||
let counter = new ClosureExampleCounter(start);
|
||||
return fn [counter]() -> int {
|
||||
counter.value += 1;
|
||||
return counter.value;
|
||||
};
|
||||
}
|
||||
|
||||
fn closureExample() -> int {
|
||||
let next = createExampleCounter(40);
|
||||
let functions: array (Fn() -> int) = [next];
|
||||
if let action = functions[0] {
|
||||
let first = action();
|
||||
return action();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
+2
-2
@@ -17,7 +17,7 @@ class PbsBarrelParserTest {
|
||||
mod fn run(state: optional int) -> result<Err> (value: int, meta: float);
|
||||
pub struct Vec2;
|
||||
mod global Palette;
|
||||
pub callback Tick;
|
||||
pub fn tick(dt: int) -> void;
|
||||
""";
|
||||
|
||||
final var diagnostics = DiagnosticSink.empty();
|
||||
@@ -41,7 +41,7 @@ class PbsBarrelParserTest {
|
||||
|
||||
assertInstanceOf(PbsAst.BarrelStructItem.class, barrel.items().get(2));
|
||||
assertInstanceOf(PbsAst.BarrelGlobalItem.class, barrel.items().get(3));
|
||||
assertInstanceOf(PbsAst.BarrelCallbackItem.class, barrel.items().get(4));
|
||||
assertInstanceOf(PbsAst.BarrelFunctionItem.class, barrel.items().get(4));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
+2
-2
@@ -134,7 +134,7 @@ class PbsExprParserTest {
|
||||
err(Game.Fail);
|
||||
new Vec(v);
|
||||
new Vec.zero(v);
|
||||
bind(ctx, handler);
|
||||
fn [ctx](x: int) -> int { return ctx + x; };
|
||||
return v;
|
||||
}
|
||||
""";
|
||||
@@ -158,7 +158,7 @@ class PbsExprParserTest {
|
||||
assertInstanceOf(PbsAst.ExpressionStatement.class, body.get(4)).expression());
|
||||
assertInstanceOf(PbsAst.NewExpr.class,
|
||||
assertInstanceOf(PbsAst.ExpressionStatement.class, body.get(5)).expression());
|
||||
assertInstanceOf(PbsAst.BindExpr.class,
|
||||
assertInstanceOf(PbsAst.LambdaExpr.class,
|
||||
assertInstanceOf(PbsAst.ExpressionStatement.class, body.get(6)).expression());
|
||||
}
|
||||
|
||||
|
||||
+4
-4
@@ -51,7 +51,7 @@ class PbsParserTest {
|
||||
|
||||
fn first() -> int { return 1; }
|
||||
declare struct Point(x: int, y: int);
|
||||
declare callback Tick(dt: int) -> int;
|
||||
fn tick(dt: int) -> int { return dt; }
|
||||
""";
|
||||
final var diagnostics = DiagnosticSink.empty();
|
||||
final var fileId = new FileId(0);
|
||||
@@ -64,7 +64,7 @@ class PbsParserTest {
|
||||
assertEquals(3, ast.topDecls().size());
|
||||
assertInstanceOf(PbsAst.FunctionDecl.class, ast.topDecls().get(0));
|
||||
assertInstanceOf(PbsAst.StructDecl.class, ast.topDecls().get(1));
|
||||
assertInstanceOf(PbsAst.CallbackDecl.class, ast.topDecls().get(2));
|
||||
assertInstanceOf(PbsAst.FunctionDecl.class, ast.topDecls().get(2));
|
||||
|
||||
final var importDecl = ast.imports().getFirst();
|
||||
assertEquals("core", importDecl.moduleRef().project());
|
||||
@@ -84,7 +84,7 @@ class PbsParserTest {
|
||||
declare service Game { fn tick(x: int) -> int { return x; } }
|
||||
declare error Err { Fail; Crash; }
|
||||
declare enum Mode(Idle = 0, Run = 1);
|
||||
declare callback TickCb(x: int) -> result<Err> int;
|
||||
fn tick(x: int) -> result<Err> int { return ok(x); }
|
||||
declare global STATE: int = 10;
|
||||
declare const LIMIT: int = 10;
|
||||
implements C for S using s { fn run(x: int) -> int { return x; } }
|
||||
@@ -122,7 +122,7 @@ class PbsParserTest {
|
||||
final var enumDecl = assertInstanceOf(PbsAst.EnumDecl.class, ast.topDecls().get(7));
|
||||
assertEquals(2, enumDecl.cases().size());
|
||||
|
||||
final var callbackDecl = assertInstanceOf(PbsAst.CallbackDecl.class, ast.topDecls().get(8));
|
||||
final var callbackDecl = assertInstanceOf(PbsAst.FunctionDecl.class, ast.topDecls().get(8));
|
||||
assertEquals(PbsAst.ReturnKind.RESULT, callbackDecl.returnKind());
|
||||
assertEquals("Err", callbackDecl.resultErrorType().name());
|
||||
|
||||
|
||||
+28
-2
@@ -16,6 +16,32 @@ import static org.junit.jupiter.api.Assertions.*;
|
||||
final class PbsEditorialSupportServiceTest {
|
||||
private final PbsEditorialSupportService service = new PbsEditorialSupportService();
|
||||
|
||||
@Test
|
||||
void closuresExposeCapturedObjectsAndOwnParameters() {
|
||||
String source = """
|
||||
declare struct Counter(pub mut value: int);
|
||||
fn main() {
|
||||
let counter = new Counter(40);
|
||||
let f = fn [counter](delta: int) -> int {
|
||||
counter.value += delta;
|
||||
return counter.value;
|
||||
};
|
||||
let answer = f(2);
|
||||
}
|
||||
""";
|
||||
var ast = parseOrdinary(source);
|
||||
int use = source.indexOf("counter.value");
|
||||
assertTrue(service.hover(source,ast,ReadOnlyList.empty(),use).isPresent());
|
||||
assertTrue(service.completion(source,ast,ReadOnlyList.empty(),use+8).stream().anyMatch(c -> c.label().equals("value")));
|
||||
assertFalse(service.definition(source,ast,ReadOnlyList.empty(),source.indexOf("delta;")).isEmpty());
|
||||
var rename = service.rename(source,ast,ReadOnlyList.empty(),use,"state");
|
||||
assertTrue(rename.allowed(),rename.refusal());
|
||||
assertEquals(4,rename.sites().size(),rename.sites().toString());
|
||||
var parameter = service.rename(source,ast,ReadOnlyList.empty(),source.indexOf("delta;"),"amount");
|
||||
assertTrue(parameter.allowed(),parameter.refusal());
|
||||
assertEquals(2,parameter.sites().size(),parameter.sites().toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
void arrayAndOptionalBindingShareEditorialScope() {
|
||||
String source = """
|
||||
@@ -552,7 +578,7 @@ final class PbsEditorialSupportServiceTest {
|
||||
declare service Physics { fn tick() -> void { return; } }
|
||||
declare error Io { NotFound; Busy; }
|
||||
declare enum Mode(Idle = 0, Run = 1);
|
||||
declare callback OnClick(x: int) -> result<Io> int;
|
||||
fn OnClick(x: int) -> result<Io> int { return ok(x); }
|
||||
declare global STATE: int = 10;
|
||||
declare const LIMIT: int = 10;
|
||||
implements TickLike for Point using s { fn tick(dt: int) -> void { return; } }
|
||||
@@ -613,7 +639,7 @@ final class PbsEditorialSupportServiceTest {
|
||||
assertEquals("0", mode.children().getFirst().detail());
|
||||
|
||||
final var callback = requireNamed(symbols, "OnClick");
|
||||
assertEquals(PbsEditorialSymbolKind.CALLBACK, callback.kind());
|
||||
assertEquals(PbsEditorialSymbolKind.FUNCTION, callback.kind());
|
||||
assertEquals("(x: int) -> result<Io> int", callback.detail());
|
||||
|
||||
assertEquals(PbsEditorialSymbolKind.GLOBAL, requireNamed(symbols, "STATE").kind());
|
||||
|
||||
+2
-2
@@ -199,7 +199,7 @@ class PbsSemanticsDeclarationsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void shouldRejectInvalidCtorServiceAndCallbackShapes() {
|
||||
void shouldRejectInvalidCtorServiceAndFunctionShapes() {
|
||||
final var source = """
|
||||
declare struct S(a: int) {
|
||||
ctor make(x: int) { return; }
|
||||
@@ -211,7 +211,7 @@ class PbsSemanticsDeclarationsTest {
|
||||
fn run(b: int) -> int { return b; }
|
||||
}
|
||||
|
||||
declare callback Tick(a: int, a: int) -> int;
|
||||
fn tick(a: int, a: int) -> int { return a; }
|
||||
""";
|
||||
final var diagnostics = DiagnosticSink.empty();
|
||||
|
||||
|
||||
Reference in New Issue
Block a user