PuqiAR
680197aafe
- 更新了 ParserTest，以改进文件路径处理和输出格式。 - 在 StmtParser 中新增了 parseConstDecl 和 parseForStmt 方法，用于处理常量声明和 for 循环。 - TypeExpr现归类为Expr。TypeExpr属于Expr，语义阶段视为Expr - 添加了新的 AST 节点：PostfixExpr、TernaryExpr、ForStmt 和 ImportStmt，用于表示新的语法结构。
550 lines
17 KiB
C++
550 lines
17 KiB
C++
/*!
|
||
@file src/Parser/ExprParser.hpp
|
||
@brief 语法分析器(Pratt + 手动递归下降) 表达式解析实现 (pratt)
|
||
@author PuqiAR (im@puqiar.top)
|
||
@date 2026-02-14
|
||
*/
|
||
|
||
#include <Parser/Parser.hpp>
|
||
|
||
namespace Fig
|
||
{
|
||
Result<Expr *, Error> Parser::parseLiteralExpr() // 当前token为literal时调用
|
||
{
|
||
StateProtector p(this, {State::ParsingLiteralExpr});
|
||
|
||
const Token &literal_token = consumeToken();
|
||
LiteralExpr *node =
|
||
arena.Allocate<LiteralExpr>(literal_token, makeSourceLocation(literal_token));
|
||
return node;
|
||
}
|
||
Result<Expr *, Error> Parser::parseIdentiExpr() // 当前token为Identifier调用
|
||
{
|
||
StateProtector p(this, {State::ParsingIdentiExpr});
|
||
|
||
const Token &identifier = consumeToken();
|
||
IdentiExpr *node = arena.Allocate<IdentiExpr>(
|
||
srcManager.GetSub(identifier.index, identifier.length), makeSourceLocation(identifier));
|
||
return node;
|
||
}
|
||
|
||
Result<Expr *, Error> Parser::parseInfixExpr(Expr *lhs) // 当前token为 op
|
||
{
|
||
StateProtector p(this, {State::ParsingInfixExpr});
|
||
|
||
const Token &op_token = consumeToken();
|
||
BinaryOperator op = TokenToBinaryOp(op_token);
|
||
BindingPower rbp = GetBinaryOpRBp(op);
|
||
|
||
const auto &rhs_result = parseExpression(rbp);
|
||
if (!rhs_result)
|
||
{
|
||
return std::unexpected(rhs_result.error());
|
||
}
|
||
Expr *rhs = *rhs_result;
|
||
|
||
InfixExpr *node = arena.Allocate<InfixExpr>(lhs, op, rhs);
|
||
return node;
|
||
}
|
||
|
||
Result<Expr *, Error> Parser::parsePrefixExpr() // 当前token为op
|
||
{
|
||
StateProtector p(this, {State::ParsingPrefixExpr});
|
||
|
||
const Token &op_token = consumeToken();
|
||
UnaryOperator op = TokenToUnaryOp(op_token);
|
||
|
||
BindingPower rbp = GetUnaryOpRBp(op);
|
||
const auto &rhs_result = parseExpression(rbp);
|
||
if (!rhs_result)
|
||
{
|
||
return std::unexpected(rhs_result.error());
|
||
}
|
||
|
||
Expr *rhs = *rhs_result;
|
||
PrefixExpr *node = arena.Allocate<PrefixExpr>(op, rhs);
|
||
return node;
|
||
}
|
||
|
||
Result<Expr *, Error>
|
||
Parser::parseIndexExpr(Expr *base) // 由 parseExpression调用, 当前token为 `[`
|
||
{
|
||
StateProtector p(this, {State::ParsingIndexExpr});
|
||
|
||
const Token &lbracket_token = consumeToken(); // consume `[`
|
||
const auto &index_result = parseExpression();
|
||
|
||
if (!index_result)
|
||
{
|
||
return std::unexpected(index_result.error());
|
||
}
|
||
|
||
if (currentToken().type != TokenType::RightBracket) // `]`
|
||
{
|
||
return std::unexpected(Error(
|
||
ErrorType::SyntaxError,
|
||
"unclosed brackets",
|
||
"insert `]`",
|
||
makeSourceLocation(lbracket_token)));
|
||
}
|
||
consumeToken(); // consume `]`
|
||
|
||
IndexExpr *indexExpr = arena.Allocate<IndexExpr>(base, *index_result);
|
||
return indexExpr;
|
||
}
|
||
|
||
Result<Expr *, Error>
|
||
Parser::parseCallExpr(Expr *callee) // 由 parseExpression调用, 当前token为 `(`
|
||
{
|
||
StateProtector p(this, {State::ParsingCallExpr});
|
||
|
||
const Token &lparen_token = consumeToken(); // consume `(`
|
||
const SourceLocation &location = makeSourceLocation(lparen_token);
|
||
|
||
FnCallArgs callArgs;
|
||
|
||
// 空参数列表
|
||
if (currentToken().type == TokenType::RightParen)
|
||
{
|
||
consumeToken(); // consume `)`
|
||
return arena.Allocate<CallExpr>(callee, callArgs, location);
|
||
}
|
||
|
||
while (true)
|
||
{
|
||
if (currentToken().type == TokenType::EndOfFile)
|
||
{
|
||
return std::unexpected(Error(
|
||
ErrorType::SyntaxError,
|
||
"fn call has unclosed parenthese",
|
||
"insert `)`",
|
||
makeSourceLocation(lparen_token)));
|
||
}
|
||
|
||
const auto &arg_result = parseExpression();
|
||
if (!arg_result)
|
||
return std::unexpected(arg_result.error());
|
||
|
||
callArgs.args.push_back(*arg_result);
|
||
|
||
if (currentToken().type == TokenType::RightParen)
|
||
{
|
||
consumeToken(); // consume `)`
|
||
break;
|
||
}
|
||
|
||
if (currentToken().type != TokenType::Comma)
|
||
{
|
||
return std::unexpected(Error(
|
||
ErrorType::SyntaxError,
|
||
"expected `,` or `)` in argument list",
|
||
"insert `,`",
|
||
makeSourceLocation(currentToken())));
|
||
}
|
||
|
||
consumeToken(); // consume `,`
|
||
}
|
||
|
||
return arena.Allocate<CallExpr>(callee, callArgs, location);
|
||
}
|
||
|
||
Result<Expr *, Error> Parser::parseNewExpr()
|
||
{
|
||
// new type{...}
|
||
StateProtector p(this, {State::ParsingNewExpr});
|
||
|
||
SourceLocation location = makeSourceLocation(consumeToken()); // consume `new`
|
||
|
||
SET_STOP_AT(TokenType::LeftBrace); // {
|
||
auto type_result = parseTypeExpr();
|
||
if (!type_result)
|
||
{
|
||
return std::unexpected(type_result.error());
|
||
}
|
||
Expr *type = *type_result;
|
||
|
||
if (!match(TokenType::LeftBrace))
|
||
{
|
||
return std::unexpected(makeUnexpectTokenError("NewExpr", "lbrace {", currentToken()));
|
||
}
|
||
|
||
const Token &lb_token = prevToken();
|
||
|
||
/*
|
||
Positional:
|
||
new Point{1, 2}
|
||
Named:
|
||
new Point{x = 1, y = 2}
|
||
Shorthand:
|
||
new Point{y, x}
|
||
*/
|
||
|
||
DynArray<NewExpr::Arg> args;
|
||
|
||
while (true)
|
||
{
|
||
if (isEOF)
|
||
{
|
||
return std::unexpected(Error(
|
||
ErrorType::SyntaxError,
|
||
"unclosed `{` in new expr",
|
||
"insert '}'",
|
||
makeSourceLocation(lb_token)
|
||
));
|
||
}
|
||
if (args.empty() && match(TokenType::RightBrace)) // 空参
|
||
{
|
||
break;
|
||
}
|
||
|
||
// named arg
|
||
if (currentToken().isIdentifier() && peekToken().type == TokenType::Colon)
|
||
{
|
||
const Token &name_token = consumeToken();
|
||
const String &name = srcManager.GetSub(name_token.index, name_token.length);
|
||
consumeToken(); // consume `:`
|
||
|
||
SET_STOP_AT(TokenType::Comma, TokenType::RightBrace); // , / }
|
||
auto result = parseExpression();
|
||
if (!result)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
args.push_back(NewExpr::Arg{
|
||
name,
|
||
*result
|
||
});
|
||
}
|
||
// shorthand
|
||
else if (currentToken().isIdentifier()
|
||
&& (peekToken().type == TokenType::Comma || peekToken().type == TokenType::RightBrace))
|
||
{
|
||
const Token &name_token = consumeToken();
|
||
const String &name = srcManager.GetSub(name_token.index, name_token.length);
|
||
|
||
|
||
|
||
IdentiExpr *ident =
|
||
arena.Allocate<IdentiExpr>(name, makeSourceLocation(name_token));
|
||
args.push_back(NewExpr::Arg{name, ident});
|
||
}
|
||
else
|
||
{
|
||
SET_STOP_AT(TokenType::Comma, TokenType::RightBrace); // , / }
|
||
auto result = parseExpression();
|
||
if (!result)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
args.push_back(NewExpr::Arg{
|
||
.value = *result
|
||
});
|
||
}
|
||
|
||
|
||
if (match(TokenType::Comma))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (match(TokenType::RightBrace))
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
NewExpr *newExpr = arena.Allocate<NewExpr>(type, args, location);
|
||
return newExpr;
|
||
}
|
||
|
||
Result<Expr *, Error> Parser::parseLambdaExpr()
|
||
{
|
||
StateProtector p(this, {State::ParsingLambdaExpr});
|
||
|
||
SourceLocation location = makeSourceLocation(consumeToken()); // consume `func`
|
||
|
||
if (currentToken().isIdentifier())
|
||
{
|
||
return std::unexpected(Error(
|
||
ErrorType::SyntaxError,
|
||
"lambda expression should not have a name",
|
||
"remove the name",
|
||
makeSourceLocation(currentToken())));
|
||
}
|
||
|
||
if (currentToken().type != TokenType::LeftParen)
|
||
{
|
||
return std::unexpected(
|
||
makeUnexpectTokenError("fn def stmt", "lparen '('", currentToken()));
|
||
}
|
||
|
||
DynArray<Param *> params;
|
||
|
||
auto paraResult = parseFnParams();
|
||
if (!paraResult)
|
||
{
|
||
return std::unexpected(paraResult.error());
|
||
}
|
||
params = *paraResult;
|
||
|
||
Expr *returnType = nullptr;
|
||
Token rightArrowToken;
|
||
if (match(TokenType::RightArrow)) // ->
|
||
{
|
||
rightArrowToken = consumeToken();
|
||
|
||
auto result = parseTypeExpr();
|
||
if (!result)
|
||
{
|
||
return std::unexpected(result.error());
|
||
}
|
||
returnType = *result;
|
||
}
|
||
|
||
if (match(TokenType::DoubleArrow)) // =>
|
||
{
|
||
if (returnType)
|
||
{
|
||
return std::unexpected(Error(
|
||
ErrorType::SyntaxError,
|
||
"use of expr body but specified return type in lambda expr",
|
||
"remove `-> ...`",
|
||
makeSourceLocation(rightArrowToken)));
|
||
}
|
||
auto result = parseExpression();
|
||
if (!result)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
Expr *expr = *result;
|
||
LambdaExpr *lambda =
|
||
arena.Allocate<LambdaExpr>(params, returnType, expr, true, location);
|
||
return lambda;
|
||
}
|
||
else if (currentToken().type == TokenType::LeftBrace)
|
||
{
|
||
auto result = parseBlockStmt();
|
||
if (!result)
|
||
{
|
||
return std::unexpected(result.error());
|
||
}
|
||
|
||
LambdaExpr *lambda =
|
||
arena.Allocate<LambdaExpr>(params, returnType, *result, false, location);
|
||
return lambda;
|
||
}
|
||
else
|
||
{
|
||
return std::unexpected(
|
||
makeUnexpectTokenError("LambdaExpr", "darrow => / lbrace {", currentToken()));
|
||
}
|
||
}
|
||
|
||
Result<Expr *, Error> Parser::parseExpression(BindingPower rbp)
|
||
{
|
||
Expr *lhs = nullptr;
|
||
Token token = currentToken();
|
||
|
||
// NUD
|
||
if (token.isIdentifier())
|
||
{
|
||
const auto &lhs_result = parseIdentiExpr();
|
||
if (!lhs_result)
|
||
{
|
||
return std::unexpected(lhs_result.error());
|
||
}
|
||
lhs = *lhs_result;
|
||
}
|
||
else if (token.isLiteral())
|
||
{
|
||
const auto &lhs_result = parseLiteralExpr();
|
||
if (!lhs_result)
|
||
{
|
||
return std::unexpected(lhs_result.error());
|
||
}
|
||
lhs = *lhs_result;
|
||
}
|
||
else if (IsTokenOp(token.type, false)) // 是否是一元前缀运算符
|
||
{
|
||
const auto &lhs_result = parsePrefixExpr();
|
||
if (!lhs_result)
|
||
{
|
||
return std::unexpected(lhs_result.error());
|
||
}
|
||
lhs = *lhs_result;
|
||
}
|
||
else if (token.type == TokenType::LeftParen)
|
||
{
|
||
const Token &lparen_token = consumeToken(); // consume `(`
|
||
const auto &expr_result = parseExpression(0);
|
||
if (!expr_result)
|
||
{
|
||
return expr_result;
|
||
}
|
||
const Token &rparen_token = consumeToken(); // consume `)`
|
||
if (rparen_token.type != TokenType::RightParen)
|
||
{
|
||
return std::unexpected(Error(
|
||
ErrorType::SyntaxError,
|
||
"unclosed parenthese",
|
||
"insert `)`",
|
||
makeSourceLocation(lparen_token)));
|
||
}
|
||
lhs = *expr_result;
|
||
}
|
||
else if (token.type == TokenType::Function)
|
||
{
|
||
auto result = parseLambdaExpr();
|
||
if (!result)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
lhs = *result;
|
||
}
|
||
else if (token.type == TokenType::New)
|
||
{
|
||
auto result = parseNewExpr();
|
||
if (!result)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
lhs = *result;
|
||
}
|
||
|
||
if (!lhs)
|
||
{
|
||
return std::unexpected(Error(
|
||
ErrorType::ExpectedExpression,
|
||
"expected expression",
|
||
"insert expressions",
|
||
makeSourceLocation(prevToken())));
|
||
}
|
||
|
||
// LED
|
||
while (true)
|
||
{
|
||
token = currentToken();
|
||
if (shouldTerminate())
|
||
{
|
||
break;
|
||
}
|
||
|
||
// is / as
|
||
if (token.type == TokenType::Is || token.type == TokenType::As)
|
||
{
|
||
BinaryOperator op = TokenToBinaryOp(token);
|
||
BindingPower lbp = GetBinaryOpLBp(op);
|
||
if (rbp >= lbp)
|
||
{
|
||
break;
|
||
}
|
||
consumeToken(); // consume `is` or `as`
|
||
auto typeRes = parseTypeExpr();
|
||
if (!typeRes)
|
||
{
|
||
return std::unexpected(typeRes.error());
|
||
}
|
||
lhs = arena.Allocate<InfixExpr>(lhs, op, *typeRes);
|
||
}
|
||
// binary
|
||
else if (IsTokenOp(token.type /* isBinary = true */))
|
||
{
|
||
BinaryOperator op = TokenToBinaryOp(token);
|
||
BindingPower lbp = GetBinaryOpLBp(op);
|
||
if (rbp >= lbp)
|
||
{
|
||
break;
|
||
}
|
||
|
||
auto result = parseInfixExpr(lhs);
|
||
if (!result)
|
||
{
|
||
return result;
|
||
}
|
||
lhs = *result;
|
||
}
|
||
// [index]
|
||
else if (token.type == TokenType::LeftBracket)
|
||
{
|
||
const auto &expr_result = parseIndexExpr(lhs);
|
||
if (!expr_result)
|
||
{
|
||
return expr_result;
|
||
}
|
||
lhs = *expr_result;
|
||
}
|
||
// call
|
||
else if (token.type == TokenType::LeftParen)
|
||
{
|
||
const auto &expr_result = parseCallExpr(lhs);
|
||
if (!expr_result)
|
||
{
|
||
return expr_result;
|
||
}
|
||
lhs = *expr_result;
|
||
}
|
||
// .member
|
||
else if (token.type == TokenType::Dot)
|
||
{
|
||
consumeToken(); // consume `.`
|
||
if (!currentToken().isIdentifier())
|
||
{
|
||
return std::unexpected(
|
||
makeUnexpectTokenError("MemberExpr", "identifier after `.`", currentToken()));
|
||
}
|
||
const Token &nameToken = consumeToken();
|
||
const String &name =
|
||
srcManager.GetSub(nameToken.index, nameToken.length);
|
||
SourceLocation loc = makeSourceLocation(nameToken);
|
||
lhs = arena.Allocate<MemberExpr>(lhs, name, loc);
|
||
}
|
||
// x++ x--
|
||
else if (token.type == TokenType::DoublePlus || token.type == TokenType::DoubleMinus)
|
||
{
|
||
UnaryOperator op = TokenToUnaryOp(consumeToken());
|
||
lhs = arena.Allocate<PostfixExpr>(op, lhs);
|
||
}
|
||
// ?:
|
||
else if (token.type == TokenType::Question)
|
||
{
|
||
// ?: 最低优先
|
||
// 赋值 rbp = 101，所以只有当 rbp < 100 时才可能进到三元
|
||
// 实际上三元是最低优先级的非赋值运算符，我们给一个很小的 lbp
|
||
constexpr BindingPower TERNARY_LBP = 150;
|
||
if (rbp >= TERNARY_LBP)
|
||
{
|
||
break;
|
||
}
|
||
consumeToken(); // consume `?`
|
||
auto thenRes = parseExpression(0); // 重置绑定力，右结合
|
||
if (!thenRes)
|
||
{
|
||
return std::unexpected(thenRes.error());
|
||
}
|
||
if (!match(TokenType::Colon))
|
||
{
|
||
return std::unexpected(
|
||
makeUnexpectTokenError("TernaryExpr", "`:` for else branch", currentToken()));
|
||
}
|
||
auto elseRes = parseExpression(TERNARY_LBP - 1); // 右结合
|
||
if (!elseRes)
|
||
{
|
||
return std::unexpected(elseRes.error());
|
||
}
|
||
lhs = arena.Allocate<TernaryExpr>(lhs, *thenRes, *elseRes, lhs->location);
|
||
}
|
||
else
|
||
{
|
||
return lhs;
|
||
}
|
||
}
|
||
return lhs;
|
||
}
|
||
|
||
}; // namespace Fig
|