implements PR003
This commit is contained in:
+1
-1
@@ -49,7 +49,7 @@ public final class PbsFrontendCompiler {
|
||||
fileId,
|
||||
fn.name(),
|
||||
fn.parameters().size(),
|
||||
fn.returnType() != null,
|
||||
fn.returnKind() != PbsAst.ReturnKind.INFERRED_UNIT,
|
||||
fn.span()));
|
||||
}
|
||||
return ReadOnlyList.wrap(functions);
|
||||
|
||||
+86
@@ -9,6 +9,23 @@ public final class PbsAst {
|
||||
private PbsAst() {
|
||||
}
|
||||
|
||||
public enum ReturnKind {
|
||||
INFERRED_UNIT,
|
||||
EXPLICIT_UNIT,
|
||||
PLAIN,
|
||||
RESULT
|
||||
}
|
||||
|
||||
public enum TypeRefKind {
|
||||
SIMPLE,
|
||||
SELF,
|
||||
OPTIONAL,
|
||||
UNIT,
|
||||
GROUP,
|
||||
NAMED_TUPLE,
|
||||
ERROR
|
||||
}
|
||||
|
||||
public record File(
|
||||
ReadOnlyList<ImportDecl> imports,
|
||||
ReadOnlyList<TopDecl> topDecls,
|
||||
@@ -59,7 +76,9 @@ public final class PbsAst {
|
||||
public record FunctionDecl(
|
||||
String name,
|
||||
ReadOnlyList<Parameter> parameters,
|
||||
ReturnKind returnKind,
|
||||
TypeRef returnType,
|
||||
TypeRef resultErrorType,
|
||||
Expression elseFallback,
|
||||
Block body,
|
||||
Span span) implements TopDecl {
|
||||
@@ -67,33 +86,41 @@ public final class PbsAst {
|
||||
|
||||
public record StructDecl(
|
||||
String name,
|
||||
ReadOnlyList<StructField> fields,
|
||||
boolean hasBody,
|
||||
Span span) implements TopDecl {
|
||||
}
|
||||
|
||||
public record ContractDecl(
|
||||
String name,
|
||||
ReadOnlyList<FunctionSignature> signatures,
|
||||
Span span) implements TopDecl {
|
||||
}
|
||||
|
||||
public record ServiceDecl(
|
||||
String name,
|
||||
ReadOnlyList<FunctionDecl> methods,
|
||||
Span span) implements TopDecl {
|
||||
}
|
||||
|
||||
public record ErrorDecl(
|
||||
String name,
|
||||
ReadOnlyList<String> cases,
|
||||
Span span) implements TopDecl {
|
||||
}
|
||||
|
||||
public record EnumDecl(
|
||||
String name,
|
||||
ReadOnlyList<EnumCase> cases,
|
||||
Span span) implements TopDecl {
|
||||
}
|
||||
|
||||
public record CallbackDecl(
|
||||
String name,
|
||||
ReadOnlyList<Parameter> parameters,
|
||||
ReturnKind returnKind,
|
||||
TypeRef returnType,
|
||||
TypeRef resultErrorType,
|
||||
Span span) implements TopDecl {
|
||||
}
|
||||
|
||||
@@ -123,7 +150,66 @@ public final class PbsAst {
|
||||
}
|
||||
|
||||
public record TypeRef(
|
||||
TypeRefKind kind,
|
||||
String name,
|
||||
ReadOnlyList<NamedTypeField> fields,
|
||||
TypeRef inner,
|
||||
Span span) {
|
||||
public static TypeRef simple(final String name, final Span span) {
|
||||
return new TypeRef(TypeRefKind.SIMPLE, name, ReadOnlyList.empty(), null, span);
|
||||
}
|
||||
|
||||
public static TypeRef self(final Span span) {
|
||||
return new TypeRef(TypeRefKind.SELF, "Self", ReadOnlyList.empty(), null, span);
|
||||
}
|
||||
|
||||
public static TypeRef optional(final TypeRef inner, final Span span) {
|
||||
return new TypeRef(TypeRefKind.OPTIONAL, "optional", ReadOnlyList.empty(), inner, span);
|
||||
}
|
||||
|
||||
public static TypeRef unit(final Span span) {
|
||||
return new TypeRef(TypeRefKind.UNIT, "void", ReadOnlyList.empty(), null, span);
|
||||
}
|
||||
|
||||
public static TypeRef group(final TypeRef inner, final Span span) {
|
||||
return new TypeRef(TypeRefKind.GROUP, "group", ReadOnlyList.empty(), inner, span);
|
||||
}
|
||||
|
||||
public static TypeRef namedTuple(final ReadOnlyList<NamedTypeField> fields, final Span span) {
|
||||
return new TypeRef(TypeRefKind.NAMED_TUPLE, "tuple", fields, null, span);
|
||||
}
|
||||
|
||||
public static TypeRef error(final Span span) {
|
||||
return new TypeRef(TypeRefKind.ERROR, "<error>", ReadOnlyList.empty(), null, span);
|
||||
}
|
||||
}
|
||||
|
||||
public record NamedTypeField(
|
||||
String label,
|
||||
TypeRef typeRef,
|
||||
Span span) {
|
||||
}
|
||||
|
||||
public record StructField(
|
||||
String name,
|
||||
TypeRef typeRef,
|
||||
boolean isPublic,
|
||||
boolean isMutable,
|
||||
Span span) {
|
||||
}
|
||||
|
||||
public record FunctionSignature(
|
||||
String name,
|
||||
ReadOnlyList<Parameter> parameters,
|
||||
ReturnKind returnKind,
|
||||
TypeRef returnType,
|
||||
TypeRef resultErrorType,
|
||||
Span span) {
|
||||
}
|
||||
|
||||
public record EnumCase(
|
||||
String name,
|
||||
Long explicitValue,
|
||||
Span span) {
|
||||
}
|
||||
|
||||
|
||||
+4
@@ -5,4 +5,8 @@ public enum ParseErrors {
|
||||
E_PARSE_UNEXPECTED_TOKEN,
|
||||
E_PARSE_VISIBILITY_IN_SOURCE,
|
||||
E_PARSE_NON_ASSOC,
|
||||
E_PARSE_INVALID_DECL_SHAPE,
|
||||
E_PARSE_INVALID_RETURN_ANNOTATION,
|
||||
E_PARSE_INVALID_TYPE_SURFACE,
|
||||
E_PARSE_RESERVED_DECLARATION,
|
||||
}
|
||||
|
||||
+335
-39
@@ -157,19 +157,19 @@ public final class PbsParser {
|
||||
*/
|
||||
private PbsAst.TopDecl parseDeclareTopDecl(final PbsToken declareToken) {
|
||||
if (cursor.match(PbsTokenKind.STRUCT)) {
|
||||
return parseSimpleNamedDecl(declareToken, "struct", PbsAst.StructDecl::new);
|
||||
return parseStructDeclaration(declareToken);
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.CONTRACT)) {
|
||||
return parseSimpleNamedDecl(declareToken, "contract", PbsAst.ContractDecl::new);
|
||||
return parseContractDeclaration(declareToken);
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.SERVICE)) {
|
||||
return parseSimpleNamedDecl(declareToken, "service", PbsAst.ServiceDecl::new);
|
||||
return parseServiceDeclaration(declareToken);
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.ERROR)) {
|
||||
return parseSimpleNamedDecl(declareToken, "error", PbsAst.ErrorDecl::new);
|
||||
return parseErrorDeclaration(declareToken);
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.ENUM)) {
|
||||
return parseSimpleNamedDecl(declareToken, "enum", PbsAst.EnumDecl::new);
|
||||
return parseEnumDeclaration(declareToken);
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.CALLBACK)) {
|
||||
return parseCallbackDeclaration(declareToken);
|
||||
@@ -179,14 +179,14 @@ public final class PbsParser {
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.HOST)) {
|
||||
final var end = consumeDeclarationTerminator();
|
||||
report(cursor.previous(), ParseErrors.E_PARSE_UNEXPECTED_TOKEN,
|
||||
report(cursor.previous(), ParseErrors.E_PARSE_RESERVED_DECLARATION,
|
||||
"'declare host' is reserved and not supported in ordinary source modules");
|
||||
return new PbsAst.InvalidDecl("reserved declare host", span(declareToken.start(), end));
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.BUILTIN)) {
|
||||
cursor.match(PbsTokenKind.TYPE);
|
||||
consume(PbsTokenKind.TYPE, "Expected 'type' in 'declare builtin type' declaration");
|
||||
final var end = consumeDeclarationTerminator();
|
||||
report(cursor.previous(), ParseErrors.E_PARSE_UNEXPECTED_TOKEN,
|
||||
report(cursor.previous(), ParseErrors.E_PARSE_RESERVED_DECLARATION,
|
||||
"'declare builtin type' is reserved and not supported in ordinary source modules");
|
||||
return new PbsAst.InvalidDecl("reserved declare builtin type", span(declareToken.start(), end));
|
||||
}
|
||||
@@ -198,22 +198,177 @@ public final class PbsParser {
|
||||
return new PbsAst.InvalidDecl("invalid declare form", span(declareToken.start(), token.end()));
|
||||
}
|
||||
|
||||
private PbsAst.StructDecl parseStructDeclaration(final PbsToken declareToken) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected struct name");
|
||||
consume(PbsTokenKind.LEFT_PAREN, "Expected '(' in struct declaration");
|
||||
final var fields = parseStructFields();
|
||||
consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after struct fields");
|
||||
|
||||
final boolean hasBody;
|
||||
long end;
|
||||
if (cursor.match(PbsTokenKind.SEMICOLON)) {
|
||||
hasBody = false;
|
||||
end = cursor.previous().end();
|
||||
} else if (cursor.match(PbsTokenKind.LEFT_BRACE)) {
|
||||
hasBody = true;
|
||||
end = parseStructBodyAndConsumeRightBrace(cursor.previous());
|
||||
} else {
|
||||
report(cursor.peek(), ParseErrors.E_PARSE_INVALID_DECL_SHAPE,
|
||||
"Struct declaration must end with ';' or contain a '{...}' body");
|
||||
hasBody = false;
|
||||
end = consumeDeclarationTerminator();
|
||||
}
|
||||
|
||||
return new PbsAst.StructDecl(name.lexeme(), ReadOnlyList.wrap(fields), hasBody, span(declareToken.start(), end));
|
||||
}
|
||||
|
||||
private ArrayList<PbsAst.StructField> parseStructFields() {
|
||||
final var fields = new ArrayList<PbsAst.StructField>();
|
||||
if (cursor.check(PbsTokenKind.RIGHT_PAREN)) {
|
||||
return fields;
|
||||
}
|
||||
|
||||
do {
|
||||
final var start = cursor.peek();
|
||||
var isPublic = false;
|
||||
var isMutable = false;
|
||||
if (cursor.match(PbsTokenKind.PUB)) {
|
||||
isPublic = true;
|
||||
if (cursor.match(PbsTokenKind.MUT)) {
|
||||
isMutable = true;
|
||||
}
|
||||
} else if (cursor.match(PbsTokenKind.MUT)) {
|
||||
final var mutToken = cursor.previous();
|
||||
report(mutToken, ParseErrors.E_PARSE_INVALID_DECL_SHAPE,
|
||||
"'mut' is only valid immediately after 'pub' in struct fields");
|
||||
}
|
||||
|
||||
final var fieldName = consume(PbsTokenKind.IDENTIFIER, "Expected struct field name");
|
||||
consume(PbsTokenKind.COLON, "Expected ':' after struct field name");
|
||||
final var typeRef = parseTypeRef();
|
||||
fields.add(new PbsAst.StructField(
|
||||
fieldName.lexeme(),
|
||||
typeRef,
|
||||
isPublic,
|
||||
isMutable,
|
||||
span(start.start(), typeRef.span().getEnd())));
|
||||
} while (cursor.match(PbsTokenKind.COMMA));
|
||||
|
||||
return fields;
|
||||
}
|
||||
|
||||
private long parseStructBodyAndConsumeRightBrace(final PbsToken leftBrace) {
|
||||
while (!cursor.check(PbsTokenKind.RIGHT_BRACE) && !cursor.isAtEnd()) {
|
||||
if (cursor.match(PbsTokenKind.FN)) {
|
||||
parseMethodDeclarationInBody(cursor.previous());
|
||||
continue;
|
||||
}
|
||||
if (cursor.match(PbsTokenKind.CTOR)) {
|
||||
parseCtorDeclarationInBody(cursor.previous());
|
||||
continue;
|
||||
}
|
||||
report(cursor.peek(), ParseErrors.E_PARSE_INVALID_DECL_SHAPE,
|
||||
"Struct body accepts only 'fn' methods and 'ctor' declarations");
|
||||
cursor.advance();
|
||||
}
|
||||
final var rightBrace = consume(PbsTokenKind.RIGHT_BRACE, "Expected '}' to end struct body");
|
||||
return rightBrace.end();
|
||||
}
|
||||
|
||||
private void parseCtorDeclarationInBody(final PbsToken ctorToken) {
|
||||
consume(PbsTokenKind.IDENTIFIER, "Expected constructor name");
|
||||
consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after constructor name");
|
||||
parseParametersUntilRightParen();
|
||||
consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after constructor parameters");
|
||||
consumeBlockForMember("constructor");
|
||||
}
|
||||
|
||||
private PbsAst.ContractDecl parseContractDeclaration(final PbsToken declareToken) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected contract name");
|
||||
consume(PbsTokenKind.LEFT_BRACE, "Expected '{' to start contract body");
|
||||
final var signatures = new ArrayList<PbsAst.FunctionSignature>();
|
||||
while (!cursor.check(PbsTokenKind.RIGHT_BRACE) && !cursor.isAtEnd()) {
|
||||
if (!cursor.match(PbsTokenKind.FN)) {
|
||||
report(cursor.peek(), ParseErrors.E_PARSE_INVALID_DECL_SHAPE,
|
||||
"Contract body accepts only function signatures");
|
||||
cursor.advance();
|
||||
continue;
|
||||
}
|
||||
signatures.add(parseFunctionSignature(cursor.previous(), true));
|
||||
}
|
||||
final var rightBrace = consume(PbsTokenKind.RIGHT_BRACE, "Expected '}' to end contract body");
|
||||
return new PbsAst.ContractDecl(name.lexeme(), ReadOnlyList.wrap(signatures), span(declareToken.start(), rightBrace.end()));
|
||||
}
|
||||
|
||||
private PbsAst.ServiceDecl parseServiceDeclaration(final PbsToken declareToken) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected service name");
|
||||
consume(PbsTokenKind.LEFT_BRACE, "Expected '{' to start service body");
|
||||
final var methods = new ArrayList<PbsAst.FunctionDecl>();
|
||||
while (!cursor.check(PbsTokenKind.RIGHT_BRACE) && !cursor.isAtEnd()) {
|
||||
if (!cursor.match(PbsTokenKind.FN)) {
|
||||
report(cursor.peek(), ParseErrors.E_PARSE_INVALID_DECL_SHAPE,
|
||||
"Service body accepts only method declarations");
|
||||
cursor.advance();
|
||||
continue;
|
||||
}
|
||||
methods.add(parseFunctionLike(cursor.previous(), false));
|
||||
}
|
||||
final var rightBrace = consume(PbsTokenKind.RIGHT_BRACE, "Expected '}' to end service body");
|
||||
return new PbsAst.ServiceDecl(name.lexeme(), ReadOnlyList.wrap(methods), span(declareToken.start(), rightBrace.end()));
|
||||
}
|
||||
|
||||
private PbsAst.ErrorDecl parseErrorDeclaration(final PbsToken declareToken) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected error name");
|
||||
consume(PbsTokenKind.LEFT_BRACE, "Expected '{' to start error body");
|
||||
final var cases = new ArrayList<String>();
|
||||
while (!cursor.check(PbsTokenKind.RIGHT_BRACE) && !cursor.isAtEnd()) {
|
||||
final var caseToken = consume(PbsTokenKind.IDENTIFIER, "Expected error case label");
|
||||
cases.add(caseToken.lexeme());
|
||||
consume(PbsTokenKind.SEMICOLON, "Expected ';' after error case label");
|
||||
}
|
||||
final var rightBrace = consume(PbsTokenKind.RIGHT_BRACE, "Expected '}' to end error body");
|
||||
return new PbsAst.ErrorDecl(name.lexeme(), ReadOnlyList.wrap(cases), span(declareToken.start(), rightBrace.end()));
|
||||
}
|
||||
|
||||
private PbsAst.EnumDecl parseEnumDeclaration(final PbsToken declareToken) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected enum name");
|
||||
consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after enum name");
|
||||
|
||||
final var cases = new ArrayList<PbsAst.EnumCase>();
|
||||
if (!cursor.check(PbsTokenKind.RIGHT_PAREN)) {
|
||||
do {
|
||||
final var caseName = consume(PbsTokenKind.IDENTIFIER, "Expected enum case label");
|
||||
Long explicitValue = null;
|
||||
if (cursor.match(PbsTokenKind.EQUAL)) {
|
||||
final var intToken = consume(PbsTokenKind.INT_LITERAL, "Expected integer literal after '=' in enum case");
|
||||
explicitValue = parseLongOrNull(intToken.lexeme());
|
||||
}
|
||||
cases.add(new PbsAst.EnumCase(caseName.lexeme(), explicitValue, span(caseName.start(), cursor.previous().end())));
|
||||
} while (cursor.match(PbsTokenKind.COMMA) && !cursor.check(PbsTokenKind.RIGHT_PAREN));
|
||||
}
|
||||
|
||||
final var rightParen = consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after enum cases");
|
||||
final var semicolon = consume(PbsTokenKind.SEMICOLON, "Expected ';' after enum declaration");
|
||||
return new PbsAst.EnumDecl(name.lexeme(), ReadOnlyList.wrap(cases), span(declareToken.start(), Math.max(rightParen.end(), semicolon.end())));
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a top-level function declaration.
|
||||
*/
|
||||
private PbsAst.FunctionDecl parseFunction(final PbsToken fnToken) {
|
||||
return parseFunctionLike(fnToken, true);
|
||||
}
|
||||
|
||||
private PbsAst.FunctionDecl parseFunctionLike(final PbsToken fnToken, final boolean allowElseFallback) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected function name");
|
||||
consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after function name");
|
||||
final var parameters = parseParametersUntilRightParen();
|
||||
consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after parameter list");
|
||||
final var rightParen = consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after parameter list");
|
||||
|
||||
PbsAst.TypeRef returnType = null;
|
||||
if (cursor.match(PbsTokenKind.COLON, PbsTokenKind.ARROW)) {
|
||||
returnType = parseTypeRef();
|
||||
}
|
||||
final var returnSpec = parseCallableReturnSpec(rightParen);
|
||||
|
||||
PbsAst.Expression elseFallback = null;
|
||||
if (cursor.match(PbsTokenKind.ELSE)) {
|
||||
if (allowElseFallback && cursor.match(PbsTokenKind.ELSE)) {
|
||||
elseFallback = exprParser.parseExpression();
|
||||
}
|
||||
|
||||
@@ -221,12 +376,40 @@ public final class PbsParser {
|
||||
return new PbsAst.FunctionDecl(
|
||||
name.lexeme(),
|
||||
ReadOnlyList.wrap(parameters),
|
||||
returnType,
|
||||
returnSpec.kind,
|
||||
returnSpec.returnType,
|
||||
returnSpec.resultErrorType,
|
||||
elseFallback,
|
||||
body,
|
||||
span(fnToken.start(), body.span().getEnd()));
|
||||
}
|
||||
|
||||
private PbsAst.FunctionSignature parseFunctionSignature(final PbsToken fnToken, final boolean requireSemicolon) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected function name");
|
||||
consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after function name");
|
||||
final var parameters = parseParametersUntilRightParen();
|
||||
final var rightParen = consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after parameter list");
|
||||
|
||||
final var returnSpec = parseCallableReturnSpec(rightParen);
|
||||
|
||||
long end = returnSpec.returnType.span().getEnd();
|
||||
if (requireSemicolon) {
|
||||
end = consume(PbsTokenKind.SEMICOLON, "Expected ';' after function signature").end();
|
||||
}
|
||||
|
||||
return new PbsAst.FunctionSignature(
|
||||
name.lexeme(),
|
||||
ReadOnlyList.wrap(parameters),
|
||||
returnSpec.kind,
|
||||
returnSpec.returnType,
|
||||
returnSpec.resultErrorType,
|
||||
span(fnToken.start(), end));
|
||||
}
|
||||
|
||||
private void parseMethodDeclarationInBody(final PbsToken fnToken) {
|
||||
parseFunctionLike(fnToken, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses `declare callback` declaration.
|
||||
*/
|
||||
@@ -234,18 +417,17 @@ public final class PbsParser {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected callback name");
|
||||
consume(PbsTokenKind.LEFT_PAREN, "Expected '(' after callback name");
|
||||
final var parameters = parseParametersUntilRightParen();
|
||||
consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after callback parameter list");
|
||||
final var rightParen = consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after callback parameter list");
|
||||
|
||||
PbsAst.TypeRef returnType = null;
|
||||
if (cursor.match(PbsTokenKind.COLON, PbsTokenKind.ARROW)) {
|
||||
returnType = parseTypeRef();
|
||||
}
|
||||
final var returnSpec = parseCallableReturnSpec(rightParen);
|
||||
|
||||
final var semicolon = consume(PbsTokenKind.SEMICOLON, "Expected ';' after callback declaration");
|
||||
return new PbsAst.CallbackDecl(
|
||||
name.lexeme(),
|
||||
ReadOnlyList.wrap(parameters),
|
||||
returnType,
|
||||
returnSpec.kind,
|
||||
returnSpec.returnType,
|
||||
returnSpec.resultErrorType,
|
||||
span(declareToken.start(), semicolon.end()));
|
||||
}
|
||||
|
||||
@@ -296,15 +478,6 @@ public final class PbsParser {
|
||||
span(implementsToken.start(), end));
|
||||
}
|
||||
|
||||
private PbsAst.TopDecl parseSimpleNamedDecl(
|
||||
final PbsToken declareToken,
|
||||
final String kind,
|
||||
final NamedDeclFactory factory) {
|
||||
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected " + kind + " name");
|
||||
final var end = consumeDeclarationTerminator();
|
||||
return factory.build(name.lexeme(), span(declareToken.start(), end));
|
||||
}
|
||||
|
||||
private ArrayList<PbsAst.Parameter> parseParametersUntilRightParen() {
|
||||
final var parameters = new ArrayList<PbsAst.Parameter>();
|
||||
if (cursor.check(PbsTokenKind.RIGHT_PAREN)) {
|
||||
@@ -325,21 +498,125 @@ public final class PbsParser {
|
||||
return parameters;
|
||||
}
|
||||
|
||||
private ParsedReturnSpec parseCallableReturnSpec(final PbsToken anchorToken) {
|
||||
if (cursor.match(PbsTokenKind.ARROW)) {
|
||||
return parseReturnSpecFromMarker(cursor.previous());
|
||||
}
|
||||
|
||||
if (cursor.match(PbsTokenKind.COLON)) {
|
||||
report(cursor.previous(), ParseErrors.E_PARSE_INVALID_RETURN_ANNOTATION,
|
||||
"Return annotations must use '->' syntax");
|
||||
return parseReturnSpecFromMarker(cursor.previous());
|
||||
}
|
||||
|
||||
final var inferredSpan = span(anchorToken.end(), anchorToken.end());
|
||||
return new ParsedReturnSpec(
|
||||
PbsAst.ReturnKind.INFERRED_UNIT,
|
||||
PbsAst.TypeRef.unit(inferredSpan),
|
||||
null);
|
||||
}
|
||||
|
||||
private ParsedReturnSpec parseReturnSpecFromMarker(final PbsToken markerToken) {
|
||||
if (cursor.match(PbsTokenKind.RESULT)) {
|
||||
final var resultToken = cursor.previous();
|
||||
consume(PbsTokenKind.LESS, "Expected '<' after 'result'");
|
||||
final var errorType = parseTypeRef();
|
||||
consume(PbsTokenKind.GREATER, "Expected '>' after result error type");
|
||||
|
||||
final PbsAst.TypeRef payloadType;
|
||||
if (isTypeStart(cursor.peek().kind())) {
|
||||
payloadType = parseTypeRef();
|
||||
} else {
|
||||
payloadType = PbsAst.TypeRef.unit(span(resultToken.end(), resultToken.end()));
|
||||
}
|
||||
|
||||
return new ParsedReturnSpec(
|
||||
PbsAst.ReturnKind.RESULT,
|
||||
payloadType,
|
||||
errorType);
|
||||
}
|
||||
|
||||
final var typeRef = parseTypeRef();
|
||||
if (typeRef.kind() == PbsAst.TypeRefKind.UNIT) {
|
||||
return new ParsedReturnSpec(PbsAst.ReturnKind.EXPLICIT_UNIT, typeRef, null);
|
||||
}
|
||||
return new ParsedReturnSpec(PbsAst.ReturnKind.PLAIN, typeRef, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a simple identifier-based type reference such as {@code int} or {@code Vector}.
|
||||
* Parses type references including optional, unit, grouped, and named-tuple forms.
|
||||
*/
|
||||
private PbsAst.TypeRef parseTypeRef() {
|
||||
if (cursor.match(PbsTokenKind.IDENTIFIER, PbsTokenKind.SELF)) {
|
||||
final var identifier = cursor.previous();
|
||||
return new PbsAst.TypeRef(identifier.lexeme(), span(identifier.start(), identifier.end()));
|
||||
if (cursor.match(PbsTokenKind.OPTIONAL)) {
|
||||
final var optionalToken = cursor.previous();
|
||||
final var inner = parseTypeRef();
|
||||
if (inner.kind() == PbsAst.TypeRefKind.UNIT) {
|
||||
report(optionalToken, ParseErrors.E_PARSE_INVALID_TYPE_SURFACE,
|
||||
"'optional void' is not a valid type surface");
|
||||
}
|
||||
return PbsAst.TypeRef.optional(inner, span(optionalToken.start(), inner.span().getEnd()));
|
||||
}
|
||||
|
||||
if (cursor.match(PbsTokenKind.VOID)) {
|
||||
final var token = cursor.previous();
|
||||
return PbsAst.TypeRef.unit(span(token.start(), token.end()));
|
||||
}
|
||||
|
||||
if (cursor.match(PbsTokenKind.SELF)) {
|
||||
final var token = cursor.previous();
|
||||
return PbsAst.TypeRef.self(span(token.start(), token.end()));
|
||||
}
|
||||
|
||||
if (cursor.match(PbsTokenKind.IDENTIFIER)) {
|
||||
final var token = cursor.previous();
|
||||
return PbsAst.TypeRef.simple(token.lexeme(), span(token.start(), token.end()));
|
||||
}
|
||||
|
||||
if (cursor.match(PbsTokenKind.LEFT_PAREN)) {
|
||||
final var open = cursor.previous();
|
||||
if (cursor.match(PbsTokenKind.RIGHT_PAREN)) {
|
||||
return PbsAst.TypeRef.unit(span(open.start(), cursor.previous().end()));
|
||||
}
|
||||
|
||||
if (cursor.check(PbsTokenKind.IDENTIFIER) && cursor.checkNext(PbsTokenKind.COLON)) {
|
||||
final var fields = parseNamedTupleTypeFields();
|
||||
final var close = consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after named tuple type");
|
||||
return PbsAst.TypeRef.namedTuple(ReadOnlyList.wrap(fields), span(open.start(), close.end()));
|
||||
}
|
||||
|
||||
final var inner = parseTypeRef();
|
||||
final var close = consume(PbsTokenKind.RIGHT_PAREN, "Expected ')' after grouped type");
|
||||
return PbsAst.TypeRef.group(inner, span(open.start(), close.end()));
|
||||
}
|
||||
|
||||
final var token = cursor.peek();
|
||||
report(token, ParseErrors.E_PARSE_EXPECTED_TOKEN, "Expected type name");
|
||||
report(token, ParseErrors.E_PARSE_EXPECTED_TOKEN, "Expected type surface");
|
||||
if (!cursor.isAtEnd()) {
|
||||
cursor.advance();
|
||||
}
|
||||
return new PbsAst.TypeRef("<error>", span(token.start(), token.end()));
|
||||
return PbsAst.TypeRef.error(span(token.start(), token.end()));
|
||||
}
|
||||
|
||||
private ArrayList<PbsAst.NamedTypeField> parseNamedTupleTypeFields() {
|
||||
final var fields = new ArrayList<PbsAst.NamedTypeField>();
|
||||
do {
|
||||
final var label = consume(PbsTokenKind.IDENTIFIER, "Expected tuple field label");
|
||||
consume(PbsTokenKind.COLON, "Expected ':' after tuple field label");
|
||||
final var typeRef = parseTypeRef();
|
||||
fields.add(new PbsAst.NamedTypeField(
|
||||
label.lexeme(),
|
||||
typeRef,
|
||||
span(label.start(), typeRef.span().getEnd())));
|
||||
} while (cursor.match(PbsTokenKind.COMMA) && !cursor.check(PbsTokenKind.RIGHT_PAREN));
|
||||
return fields;
|
||||
}
|
||||
|
||||
private boolean isTypeStart(final PbsTokenKind kind) {
|
||||
return kind == PbsTokenKind.IDENTIFIER
|
||||
|| kind == PbsTokenKind.SELF
|
||||
|| kind == PbsTokenKind.OPTIONAL
|
||||
|| kind == PbsTokenKind.VOID
|
||||
|| kind == PbsTokenKind.LEFT_PAREN;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -412,6 +689,16 @@ public final class PbsParser {
|
||||
return new PbsAst.ExpressionStatement(expression, span(expression.span().getStart(), semicolon.end()));
|
||||
}
|
||||
|
||||
private void consumeBlockForMember(final String memberKind) {
|
||||
if (!cursor.match(PbsTokenKind.LEFT_BRACE)) {
|
||||
report(cursor.peek(), ParseErrors.E_PARSE_INVALID_DECL_SHAPE,
|
||||
"Expected '{' to start " + memberKind + " body");
|
||||
consumeDeclarationTerminator();
|
||||
return;
|
||||
}
|
||||
consumeBalancedBraces(cursor.previous());
|
||||
}
|
||||
|
||||
private long consumeDeclarationTerminator() {
|
||||
var end = cursor.previous().end();
|
||||
var parenDepth = 0;
|
||||
@@ -486,6 +773,14 @@ public final class PbsParser {
|
||||
return token;
|
||||
}
|
||||
|
||||
private Long parseLongOrNull(final String text) {
|
||||
try {
|
||||
return Long.parseLong(text);
|
||||
} catch (NumberFormatException ignored) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds a source span for the current file.
|
||||
*/
|
||||
@@ -500,8 +795,9 @@ public final class PbsParser {
|
||||
diagnostics.error(parseErrors.name(), message, new Span(fileId, token.start(), token.end()));
|
||||
}
|
||||
|
||||
@FunctionalInterface
|
||||
private interface NamedDeclFactory {
|
||||
PbsAst.TopDecl build(String name, Span declarationSpan);
|
||||
private record ParsedReturnSpec(
|
||||
PbsAst.ReturnKind kind,
|
||||
PbsAst.TypeRef returnType,
|
||||
PbsAst.TypeRef resultErrorType) {
|
||||
}
|
||||
}
|
||||
|
||||
+15
@@ -74,4 +74,19 @@ final class PbsTokenCursor {
|
||||
PbsToken previous() {
|
||||
return tokens.get(Math.max(current - 1, 0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the token at a positive lookahead offset from current token.
|
||||
*/
|
||||
PbsToken peek(final int offset) {
|
||||
final var index = Math.min(current + Math.max(offset, 0), tokens.size() - 1);
|
||||
return tokens.get(index);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether the token at lookahead offset 1 matches the expected kind.
|
||||
*/
|
||||
boolean checkNext(final PbsTokenKind kind) {
|
||||
return peek(1).kind() == kind;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user