implements PR003

This commit is contained in:
2026-03-24 13:42:19 +00:00
parent 9ddfa19bf2
commit 96c5505c04
9 changed files with 531 additions and 137 deletions
@@ -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);
@@ -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) {
}
@@ -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,
}
@@ -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) {
}
}
@@ -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;
}
}