implements PR004

This commit is contained in:
2026-03-24 13:42:19 +00:00
parent 96c5505c04
commit 41f90930e5
5 changed files with 385 additions and 37 deletions
@@ -213,7 +213,24 @@ public final class PbsAst {
Span span) {
}
public sealed interface Statement permits LetStatement, ReturnStatement, ExpressionStatement {
public enum AssignOperator {
ASSIGN,
ADD_ASSIGN,
SUB_ASSIGN,
MUL_ASSIGN,
DIV_ASSIGN,
MOD_ASSIGN
}
public sealed interface Statement permits LetStatement,
AssignStatement,
ReturnStatement,
IfStatement,
ForStatement,
WhileStatement,
BreakStatement,
ContinueStatement,
ExpressionStatement {
Span span();
}
@@ -222,18 +239,64 @@ public final class PbsAst {
Span span) {
}
public record LValue(
String rootName,
ReadOnlyList<String> pathSegments,
Span span) {
}
public record LetStatement(
boolean isConst,
String name,
TypeRef explicitType,
Expression initializer,
Span span) implements Statement {
}
public record AssignStatement(
LValue target,
AssignOperator operator,
Expression value,
Span span) implements Statement {
}
public record ReturnStatement(
Expression value,
Span span) implements Statement {
}
public record IfStatement(
Expression condition,
Block thenBlock,
IfStatement elseIf,
Block elseBlock,
Span span) implements Statement {
}
public record ForStatement(
String iteratorName,
TypeRef iteratorType,
Expression fromExpression,
Expression untilExpression,
Expression stepExpression,
Block body,
Span span) implements Statement {
}
public record WhileStatement(
Expression condition,
Block body,
Span span) implements Statement {
}
public record BreakStatement(
Span span) implements Statement {
}
public record ContinueStatement(
Span span) implements Statement {
}
public record ExpressionStatement(
Expression expression,
Span span) implements Statement {
@@ -9,4 +9,7 @@ public enum ParseErrors {
E_PARSE_INVALID_RETURN_ANNOTATION,
E_PARSE_INVALID_TYPE_SURFACE,
E_PARSE_RESERVED_DECLARATION,
E_PARSE_INVALID_ASSIGN_TARGET,
E_PARSE_INVALID_FOR_FORM,
E_PARSE_LOOP_CONTROL_OUTSIDE_LOOP,
}
@@ -22,6 +22,7 @@ public final class PbsParser {
private final PbsExprParser exprParser;
private final FileId fileId;
private final DiagnosticSink diagnostics;
private int loopDepth;
private PbsParser(
final ReadOnlyList<PbsToken> tokens,
@@ -639,9 +640,27 @@ public final class PbsParser {
if (cursor.match(PbsTokenKind.LET)) {
return parseLetStatement(cursor.previous());
}
if (cursor.match(PbsTokenKind.IF)) {
return parseIfStatement(cursor.previous());
}
if (cursor.match(PbsTokenKind.FOR)) {
return parseForStatement(cursor.previous());
}
if (cursor.match(PbsTokenKind.WHILE)) {
return parseWhileStatement(cursor.previous());
}
if (cursor.match(PbsTokenKind.BREAK)) {
return parseBreakStatement(cursor.previous());
}
if (cursor.match(PbsTokenKind.CONTINUE)) {
return parseContinueStatement(cursor.previous());
}
if (cursor.match(PbsTokenKind.RETURN)) {
return parseReturnStatement(cursor.previous());
}
if (isAssignmentStatementStart()) {
return parseAssignStatement();
}
return parseExpressionStatement();
}
@@ -649,7 +668,7 @@ public final class PbsParser {
* Parses a local binding statement.
*/
private PbsAst.Statement parseLetStatement(final PbsToken letToken) {
cursor.match(PbsTokenKind.CONST);
final boolean isConst = cursor.match(PbsTokenKind.CONST);
final var name = consume(PbsTokenKind.IDENTIFIER, "Expected variable name");
PbsAst.TypeRef explicitType = null;
@@ -662,12 +681,160 @@ public final class PbsParser {
final var semicolon = consume(PbsTokenKind.SEMICOLON, "Expected ';' after let statement");
return new PbsAst.LetStatement(
isConst,
name.lexeme(),
explicitType,
initializer,
span(letToken.start(), semicolon.end()));
}
private PbsAst.Statement parseAssignStatement() {
final var lValue = parseLValue();
final var operatorToken = cursor.peek();
final var operator = parseAssignOperator(consumeAssignOperator());
final var value = exprParser.parseExpression();
final var semicolon = consume(PbsTokenKind.SEMICOLON, "Expected ';' after assignment");
return new PbsAst.AssignStatement(
lValue,
operator,
value,
span(lValue.span().getStart(), semicolon.end()));
}
private PbsAst.LValue parseLValue() {
final var root = consume(PbsTokenKind.IDENTIFIER, "Expected assignment target identifier");
final var segments = new ArrayList<String>();
var end = root.end();
while (cursor.match(PbsTokenKind.DOT)) {
final var segment = consume(PbsTokenKind.IDENTIFIER, "Expected member name after '.' in assignment target");
segments.add(segment.lexeme());
end = segment.end();
}
return new PbsAst.LValue(root.lexeme(), ReadOnlyList.wrap(segments), span(root.start(), end));
}
private PbsToken consumeAssignOperator() {
if (cursor.match(PbsTokenKind.EQUAL,
PbsTokenKind.PLUS_EQUAL,
PbsTokenKind.MINUS_EQUAL,
PbsTokenKind.STAR_EQUAL,
PbsTokenKind.SLASH_EQUAL,
PbsTokenKind.PERCENT_EQUAL)) {
return cursor.previous();
}
final var token = cursor.peek();
report(token, ParseErrors.E_PARSE_INVALID_ASSIGN_TARGET,
"Expected assignment operator after assignment target");
if (!cursor.isAtEnd()) {
return cursor.advance();
}
return token;
}
private PbsAst.AssignOperator parseAssignOperator(final PbsToken token) {
return switch (token.kind()) {
case EQUAL -> PbsAst.AssignOperator.ASSIGN;
case PLUS_EQUAL -> PbsAst.AssignOperator.ADD_ASSIGN;
case MINUS_EQUAL -> PbsAst.AssignOperator.SUB_ASSIGN;
case STAR_EQUAL -> PbsAst.AssignOperator.MUL_ASSIGN;
case SLASH_EQUAL -> PbsAst.AssignOperator.DIV_ASSIGN;
case PERCENT_EQUAL -> PbsAst.AssignOperator.MOD_ASSIGN;
default -> PbsAst.AssignOperator.ASSIGN;
};
}
private PbsAst.IfStatement parseIfStatement(final PbsToken ifToken) {
final var condition = exprParser.parseExpression();
final var thenBlock = parseBlock();
PbsAst.IfStatement elseIf = null;
PbsAst.Block elseBlock = null;
if (cursor.match(PbsTokenKind.ELSE)) {
if (cursor.match(PbsTokenKind.IF)) {
elseIf = parseIfStatement(cursor.previous());
} else {
elseBlock = parseBlock();
}
}
final var end = elseIf != null
? elseIf.span().getEnd()
: (elseBlock != null ? elseBlock.span().getEnd() : thenBlock.span().getEnd());
return new PbsAst.IfStatement(
condition,
thenBlock,
elseIf,
elseBlock,
span(ifToken.start(), end));
}
private PbsAst.Statement parseForStatement(final PbsToken forToken) {
final var iterator = consume(PbsTokenKind.IDENTIFIER, "Expected loop iterator name in 'for'");
consumeForToken(PbsTokenKind.COLON, "Expected ':' after iterator name in 'for'");
final var iteratorType = parseTypeRef();
consumeForToken(PbsTokenKind.FROM, "Expected 'from' in 'for' statement");
final var fromExpression = exprParser.parseExpression();
consumeForToken(PbsTokenKind.UNTIL, "Expected 'until' in 'for' statement");
final var untilExpression = exprParser.parseExpression();
PbsAst.Expression stepExpression = null;
if (cursor.match(PbsTokenKind.STEP)) {
stepExpression = exprParser.parseExpression();
}
loopDepth++;
final var body = parseBlock();
loopDepth--;
return new PbsAst.ForStatement(
iterator.lexeme(),
iteratorType,
fromExpression,
untilExpression,
stepExpression,
body,
span(forToken.start(), body.span().getEnd()));
}
private PbsToken consumeForToken(final PbsTokenKind kind, final String message) {
if (cursor.check(kind)) {
return cursor.advance();
}
final var token = cursor.peek();
report(token, ParseErrors.E_PARSE_INVALID_FOR_FORM, message + ", found " + token.kind());
if (!cursor.isAtEnd()) {
return cursor.advance();
}
return token;
}
private PbsAst.Statement parseWhileStatement(final PbsToken whileToken) {
final var condition = exprParser.parseExpression();
loopDepth++;
final var body = parseBlock();
loopDepth--;
return new PbsAst.WhileStatement(condition, body, span(whileToken.start(), body.span().getEnd()));
}
private PbsAst.Statement parseBreakStatement(final PbsToken breakToken) {
final var semicolon = consume(PbsTokenKind.SEMICOLON, "Expected ';' after 'break'");
if (loopDepth <= 0) {
report(breakToken, ParseErrors.E_PARSE_LOOP_CONTROL_OUTSIDE_LOOP,
"'break' is only valid inside loop contexts");
}
return new PbsAst.BreakStatement(span(breakToken.start(), semicolon.end()));
}
private PbsAst.Statement parseContinueStatement(final PbsToken continueToken) {
final var semicolon = consume(PbsTokenKind.SEMICOLON, "Expected ';' after 'continue'");
if (loopDepth <= 0) {
report(continueToken, ParseErrors.E_PARSE_LOOP_CONTROL_OUTSIDE_LOOP,
"'continue' is only valid inside loop contexts");
}
return new PbsAst.ContinueStatement(span(continueToken.start(), semicolon.end()));
}
/**
* Parses a return statement with an optional returned value.
*/
@@ -689,6 +856,28 @@ public final class PbsParser {
return new PbsAst.ExpressionStatement(expression, span(expression.span().getStart(), semicolon.end()));
}
private boolean isAssignmentStatementStart() {
if (!cursor.check(PbsTokenKind.IDENTIFIER)) {
return false;
}
int offset = 1;
while (cursor.peek(offset).kind() == PbsTokenKind.DOT) {
if (cursor.peek(offset + 1).kind() != PbsTokenKind.IDENTIFIER) {
return false;
}
if (cursor.peek(offset + 2).kind() == PbsTokenKind.LEFT_PAREN) {
return false;
}
offset += 2;
}
return switch (cursor.peek(offset).kind()) {
case EQUAL, PLUS_EQUAL, MINUS_EQUAL, STAR_EQUAL, SLASH_EQUAL, PERCENT_EQUAL -> true;
default -> false;
};
}
private void consumeBlockForMember(final String memberKind) {
if (!cursor.match(PbsTokenKind.LEFT_BRACE)) {
report(cursor.peek(), ParseErrors.E_PARSE_INVALID_DECL_SHAPE,