PuqiAR/Fig
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 添加函数定义和类型表达式支持，重构解析器以处理新语法(函数定义)

Browse Source
This commit is contained in:
PuqiAR
2026-02-26 14:41:41 +08:00
parent 12dc31a6c0
commit bb23ddf9fa
9 changed files with 376 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/Parser/Parser.hpp
View File

@@ -165,6 +165,9 @@ namespace Fig
ParsingVarDecl,
ParsingIf,
ParsingWhile,
ParsingFnDefStmt,
ParsingNamedTypeExpr,
} type = StateType::Standby;
std::unordered_set<TokenType> stopAt = {};
@@ -273,6 +276,12 @@ namespace Fig
magic_enum::enum_name(currentState().type).data());
}
/* TypeExpressions */
Result<NamedTypeExpr *, Error> parseNamedTypeExpr(); // 当前token为identifier
Result<TypeExpr *, Error> parseTypeExpr();
/* Expressions */
Result<LiteralExpr *, Error> parseLiteralExpr(); // 当前token为literal时调用
Result<IdentiExpr *, Error> parseIdentiExpr(); // 当前token为Identifier调用
@@ -292,6 +301,10 @@ namespace Fig
Result<VarDecl *, Error> parseVarDecl(bool); // 由 parseStatement调用, 当前token为 var
Result<IfStmt *, Error> parseIfStmt(); // 由 parseStatement调用, 当前token为 if
Result<WhileStmt *, Error> parseWhileStmt(); // 由 parseStatement调用, 当前token为 while
Result<DynArray<Param *>, Error> parseFnParams(); // 由 parseFnDefStmt或lambda调用
Result<FnDefStmt *, Error> parseFnDefStmt(bool); // 由 parseStatement调用, 当前token为 func
Result<Stmt *, Error> parseStatement();
public:

152
src/Parser/StmtParser.cpp
View File

@@ -49,11 +49,11 @@ namespace Fig
const String &name = srcManager.GetSub(currentToken().index, currentToken().length);
consumeToken(); // consume name
Expr *typeSpeicifer = nullptr;
TypeExpr *typeSpeicifer = nullptr;
if (match(TokenType::Colon)) // `:`
{
SET_STOP_AT(TokenType::Walrus, TokenType::Assign);
auto result = parseExpression(0);
// SET_STOP_AT(TokenType::Walrus, TokenType::Assign);
auto result = parseTypeExpr();
if (!result)
{
return std::unexpected(result.error());
@@ -295,6 +295,136 @@ namespace Fig
return whileStmt;
}
Result<DynArray<Param *>, Error> Parser::parseFnParams() // 由 parseFnDefStmt或lambda调用
{
StateProtector p(this, {State::ParsingFnDefStmt});
const Token &lpToken = consumeToken(); // consume `(`
DynArray<Param *> params;
while (true)
{
if (isEOF)
{
return std::unexpected(Error(ErrorType::SyntaxError,
"unclosed parenthese in function parameters",
"insert ')'",
makeSourceLocation(lpToken)));
}
if (match(TokenType::RightParen))
{
break;
}
const Token &nToken = consumeToken();
SourceLocation location = makeSourceLocation(nToken);
const String &name = srcManager.GetSub(nToken.index, nToken.length);
// TODO: 支持剩余参数解析...
TypeExpr *type = nullptr;
if (match(TokenType::Colon)) // :
{
auto result = parseTypeExpr();
if (!result)
{
return std::unexpected(result.error());
}
type = *result;
}
Expr *defaultValue = nullptr;
if (match(TokenType::Assign)) // =
{
SET_STOP_AT(TokenType::Comma, TokenType::RightParen, TokenType::LeftBrace); // , ) {
auto result = parseExpression();
if (!result)
{
if (type)
{
delete type;
}
return std::unexpected(result.error());
}
defaultValue = *result;
}
PosParam *posParam = new PosParam(name, type, defaultValue, location);
params.push_back(posParam);
if (match(TokenType::Comma))
{
if (!currentToken().isIdentifier())
{
return std::unexpected(makeUnexpectTokenError("fn params", "param name", currentToken()));
}
}
}
return params;
}
Result<FnDefStmt *, Error> Parser::parseFnDefStmt(
bool isPublic) // 由 parseStatement调用, 当前token为 func
{
SourceLocation location = makeSourceLocation(
consumeToken()); // 无论是否加了public, location都设置为 func token (我懒 :D)
if (!currentToken().isIdentifier())
{
return std::unexpected(
makeUnexpectTokenError("fn def stmt", "function name", currentToken()));
}
const Token &nameToken = consumeToken(); // consume name
const String &name = srcManager.GetSub(nameToken.index, nameToken.length);
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;
TypeExpr *returnType = nullptr;
if (match(TokenType::RightArrow)) // ->
{
auto result = parseTypeExpr();
if (!result)
{
return std::unexpected(result.error());
}
returnType = *result;
}
if (currentToken().type != TokenType::LeftBrace)
{
return std::unexpected(
makeUnexpectTokenError("fn def stmt", "function body '{'", currentToken()));
}
BlockStmt *body = nullptr;
auto bodyResult = parseBlockStmt();
if (!bodyResult)
{
if (returnType)
{
delete returnType;
}
body = *bodyResult;
}
FnDefStmt *fnDef = new FnDefStmt(isPublic, name, params, returnType, body, location);
return fnDef;
}
Result<Stmt *, Error> Parser::parseStatement()
{
StateProtector p(this, {State::Standby});
@@ -306,11 +436,14 @@ namespace Fig
{
return parseVarDecl(true);
}
else
if (currentToken().type == TokenType::Function)
{
return std::unexpected(
makeUnexpectTokenError("public", "var/const/func/struct", currentToken()));
return parseFnDefStmt(true);
}
return std::unexpected(
makeUnexpectTokenError("public", "var/const/func/struct", currentToken()));
}
if (currentToken().type == TokenType::LeftBrace)
@@ -333,11 +466,16 @@ namespace Fig
return parseWhileStmt();
}
if (currentToken().type == TokenType::Function)
{
return parseFnDefStmt(false);
}
if (isEOF)
{
return nullptr;
}
const auto &expr_result = parseExpression();
if (!expr_result)
{

56
src/Parser/TypeExprParser.cpp Normal file
View File

@@ -0,0 +1,56 @@
/*!
@file src/Parser/TypeExprParser.cpp
@brief 类型表达式解析器实现
@author PuqiAR (im@puqiar.top)
@date 2026-02-25
*/
#pragma once
#include <Parser/Parser.hpp>
namespace Fig
{
Result<NamedTypeExpr *, Error> Parser::parseNamedTypeExpr() // 当前token为identifier
{
StateProtector p(this, {State::ParsingNamedTypeExpr});
SourceLocation location = makeSourceLocation(currentToken());
DynArray<String> path;
while (true)
{
const Token &subPathTok = consumeToken();
const String &subPath = srcManager.GetSub(subPathTok.index, subPathTok.length);
path.push_back(subPath);
if (match(TokenType::Dot))
{
if (!currentToken().isIdentifier())
{
return std::unexpected(
makeUnexpectTokenError("named type expr", "identifier", currentToken()));
}
}
else
{
break;
}
}
NamedTypeExpr *namedTypeExpr = new NamedTypeExpr(path, location);
return namedTypeExpr;
}
Result<TypeExpr *, Error> Parser::parseTypeExpr()
{
// TODO: 泛型表达式解析
if (currentToken().isIdentifier())
{
return parseNamedTypeExpr();
}
else
{
return std::unexpected(makeUnexpectTokenError("type expr", "name/...", currentToken()));
}
}
}; // namespace Fig