mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-11-18 00:40:31 +00:00
Set up a 'Parse' namespace. (#3161)
Continuing on #3070. I moved ParseTree::Node to just Parse::Node, versus Parse::Tree::Node. Other name changes are just removing "Parse" or "Parser" prefixes. In EnumBase, I'm directly defining operator<< because the ostream.h approach just isn't working, not for either of Parse::State nor Parse::NodeKind. Errors look like: ```toolchain/parser/parser_context.cpp:449:34: error: invalid operands to binary expression ('llvm::raw_ostream' and 'const Carbon::Parse::State') output << "\t" << i << ".\t" << entry.state; ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~ ``` The expected template in `Carbon::` is not in the error list; I only see the: ``` ./common/ostream.h:112:6: note: candidate template ignored: requirement 'std::is_base_of_v<std::ostream, llvm::raw_ostream>' was not satisfied [with S = llvm::raw_ostream, T = Carbon::Parse::State] auto operator<<(S& standard_out, const T& value) -> S& { ^ ``` I'm still prodding at this, but not seeing an obvious fix. --------- Co-authored-by: Richard Smith <richard@metafoo.co.uk>
This commit is contained in:
1 parent
64687aa7d1
commit
7157445f97
75 files changed
+1181
-1277
No files matched your search
@@ -4,10 +4,9 @@
|
||||
|
||||
#include "toolchain/parser/parser_context.h"
|
||||
|
||||
namespace Carbon {
|
||||
namespace Carbon::Parse {
|
||||
|
||||
static auto DiagnoseStatementOperatorAsSubexpression(ParserContext& context)
|
||||
-> void {
|
||||
static auto DiagnoseStatementOperatorAsSubexpression(Context& context) -> void {
|
||||
CARBON_DIAGNOSTIC(StatementOperatorAsSubexpression, Error,
|
||||
"Operator `{0}` can only be used as a complete statement.",
|
||||
TokenKind);
|
||||
@@ -15,7 +14,7 @@ static auto DiagnoseStatementOperatorAsSubexpression(ParserContext& context)
|
||||
context.PositionKind());
|
||||
}
|
||||
|
||||
auto ParserHandleExpression(ParserContext& context) -> void {
|
||||
auto HandleExpression(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
// Check for a prefix operator.
|
||||
@@ -42,14 +41,14 @@ auto ParserHandleExpression(ParserContext& context) -> void {
|
||||
}
|
||||
} else {
|
||||
// Check that this operator follows the proper whitespace rules.
|
||||
context.DiagnoseOperatorFixity(ParserContext::OperatorFixity::Prefix);
|
||||
context.DiagnoseOperatorFixity(Context::OperatorFixity::Prefix);
|
||||
}
|
||||
|
||||
if (context.PositionIs(TokenKind::If)) {
|
||||
context.PushState(ParserState::IfExpressionFinish);
|
||||
context.PushState(ParserState::IfExpressionFinishCondition);
|
||||
context.PushState(State::IfExpressionFinish);
|
||||
context.PushState(State::IfExpressionFinishCondition);
|
||||
} else {
|
||||
context.PushStateForExpressionLoop(ParserState::ExpressionLoopForPrefix,
|
||||
context.PushStateForExpressionLoop(State::ExpressionLoopForPrefix,
|
||||
state.ambient_precedence,
|
||||
*operator_precedence);
|
||||
}
|
||||
@@ -57,25 +56,25 @@ auto ParserHandleExpression(ParserContext& context) -> void {
|
||||
++context.position();
|
||||
context.PushStateForExpression(*operator_precedence);
|
||||
} else {
|
||||
context.PushStateForExpressionLoop(ParserState::ExpressionLoop,
|
||||
context.PushStateForExpressionLoop(State::ExpressionLoop,
|
||||
state.ambient_precedence,
|
||||
PrecedenceGroup::ForPostfixExpression());
|
||||
context.PushState(ParserState::ExpressionInPostfix);
|
||||
context.PushState(State::ExpressionInPostfix);
|
||||
}
|
||||
}
|
||||
|
||||
auto ParserHandleExpressionInPostfix(ParserContext& context) -> void {
|
||||
auto HandleExpressionInPostfix(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
// Continue to the loop state.
|
||||
state.state = ParserState::ExpressionInPostfixLoop;
|
||||
state.state = State::ExpressionInPostfixLoop;
|
||||
|
||||
// Parses a primary expression, which is either a terminal portion of an
|
||||
// expression tree, such as an identifier or literal, or a parenthesized
|
||||
// expression.
|
||||
switch (context.PositionKind()) {
|
||||
case TokenKind::Identifier: {
|
||||
context.AddLeafNode(ParseNodeKind::NameExpression, context.Consume());
|
||||
context.AddLeafNode(NodeKind::NameExpression, context.Consume());
|
||||
context.PushState(state);
|
||||
break;
|
||||
}
|
||||
@@ -90,39 +89,38 @@ auto ParserHandleExpressionInPostfix(ParserContext& context) -> void {
|
||||
case TokenKind::FloatingPointTypeLiteral:
|
||||
case TokenKind::StringTypeLiteral:
|
||||
case TokenKind::Type: {
|
||||
context.AddLeafNode(ParseNodeKind::Literal, context.Consume());
|
||||
context.AddLeafNode(NodeKind::Literal, context.Consume());
|
||||
context.PushState(state);
|
||||
break;
|
||||
}
|
||||
case TokenKind::OpenCurlyBrace: {
|
||||
context.PushState(state);
|
||||
context.PushState(ParserState::BraceExpression);
|
||||
context.PushState(State::BraceExpression);
|
||||
break;
|
||||
}
|
||||
case TokenKind::OpenParen: {
|
||||
context.PushState(state);
|
||||
context.PushState(ParserState::ParenExpression);
|
||||
context.PushState(State::ParenExpression);
|
||||
break;
|
||||
}
|
||||
case TokenKind::OpenSquareBracket: {
|
||||
context.PushState(state);
|
||||
context.PushState(ParserState::ArrayExpression);
|
||||
context.PushState(State::ArrayExpression);
|
||||
break;
|
||||
}
|
||||
case TokenKind::SelfValueIdentifier: {
|
||||
context.AddLeafNode(ParseNodeKind::SelfValueName, context.Consume());
|
||||
context.AddLeafNode(NodeKind::SelfValueName, context.Consume());
|
||||
context.PushState(state);
|
||||
break;
|
||||
}
|
||||
case TokenKind::SelfTypeIdentifier: {
|
||||
context.AddLeafNode(ParseNodeKind::SelfTypeNameExpression,
|
||||
context.Consume());
|
||||
context.AddLeafNode(NodeKind::SelfTypeNameExpression, context.Consume());
|
||||
context.PushState(state);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
// Add a node to keep the parse tree balanced.
|
||||
context.AddLeafNode(ParseNodeKind::InvalidParse, *context.position(),
|
||||
context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
|
||||
/*has_error=*/true);
|
||||
CARBON_DIAGNOSTIC(ExpectedExpression, Error, "Expected expression.");
|
||||
context.emitter().Emit(*context.position(), ExpectedExpression);
|
||||
@@ -132,7 +130,7 @@ auto ParserHandleExpressionInPostfix(ParserContext& context) -> void {
|
||||
}
|
||||
}
|
||||
|
||||
auto ParserHandleExpressionInPostfixLoop(ParserContext& context) -> void {
|
||||
auto HandleExpressionInPostfixLoop(Context& context) -> void {
|
||||
// This is a cyclic state that repeats, so this state is typically pushed back
|
||||
// on.
|
||||
auto state = context.PopState();
|
||||
@@ -140,25 +138,25 @@ auto ParserHandleExpressionInPostfixLoop(ParserContext& context) -> void {
|
||||
switch (context.PositionKind()) {
|
||||
case TokenKind::Period: {
|
||||
context.PushState(state);
|
||||
state.state = ParserState::PeriodAsExpression;
|
||||
state.state = State::PeriodAsExpression;
|
||||
context.PushState(state);
|
||||
break;
|
||||
}
|
||||
case TokenKind::MinusGreater: {
|
||||
context.PushState(state);
|
||||
state.state = ParserState::ArrowExpression;
|
||||
state.state = State::ArrowExpression;
|
||||
context.PushState(state);
|
||||
break;
|
||||
}
|
||||
case TokenKind::OpenParen: {
|
||||
context.PushState(state);
|
||||
state.state = ParserState::CallExpression;
|
||||
state.state = State::CallExpression;
|
||||
context.PushState(state);
|
||||
break;
|
||||
}
|
||||
case TokenKind::OpenSquareBracket: {
|
||||
context.PushState(state);
|
||||
state.state = ParserState::IndexExpression;
|
||||
state.state = State::IndexExpression;
|
||||
context.PushState(state);
|
||||
break;
|
||||
}
|
||||
@@ -171,7 +169,7 @@ auto ParserHandleExpressionInPostfixLoop(ParserContext& context) -> void {
|
||||
}
|
||||
}
|
||||
|
||||
auto ParserHandleExpressionLoop(ParserContext& context) -> void {
|
||||
auto HandleExpressionLoop(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
auto operator_kind = context.PositionKind();
|
||||
@@ -217,9 +215,9 @@ auto ParserHandleExpressionLoop(ParserContext& context) -> void {
|
||||
}
|
||||
state.has_error = true;
|
||||
} else {
|
||||
context.DiagnoseOperatorFixity(
|
||||
is_binary ? ParserContext::OperatorFixity::Infix
|
||||
: ParserContext::OperatorFixity::Postfix);
|
||||
context.DiagnoseOperatorFixity(is_binary
|
||||
? Context::OperatorFixity::Infix
|
||||
: Context::OperatorFixity::Postfix);
|
||||
}
|
||||
|
||||
state.token = context.Consume();
|
||||
@@ -229,49 +227,49 @@ auto ParserHandleExpressionLoop(ParserContext& context) -> void {
|
||||
if (operator_kind == TokenKind::And || operator_kind == TokenKind::Or) {
|
||||
// For `and` and `or`, wrap the first operand in a virtual parse tree
|
||||
// node so that semantics can insert control flow here.
|
||||
context.AddNode(ParseNodeKind::ShortCircuitOperand, state.token,
|
||||
context.AddNode(NodeKind::ShortCircuitOperand, state.token,
|
||||
state.subtree_start, state.has_error);
|
||||
}
|
||||
|
||||
state.state = ParserState::ExpressionLoopForBinary;
|
||||
state.state = State::ExpressionLoopForBinary;
|
||||
context.PushState(state);
|
||||
context.PushStateForExpression(operator_precedence);
|
||||
} else {
|
||||
context.AddNode(ParseNodeKind::PostfixOperator, state.token,
|
||||
state.subtree_start, state.has_error);
|
||||
context.AddNode(NodeKind::PostfixOperator, state.token, state.subtree_start,
|
||||
state.has_error);
|
||||
state.has_error = false;
|
||||
context.PushState(state);
|
||||
}
|
||||
}
|
||||
|
||||
auto ParserHandleExpressionLoopForBinary(ParserContext& context) -> void {
|
||||
auto HandleExpressionLoopForBinary(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
context.AddNode(ParseNodeKind::InfixOperator, state.token,
|
||||
state.subtree_start, state.has_error);
|
||||
state.state = ParserState::ExpressionLoop;
|
||||
context.AddNode(NodeKind::InfixOperator, state.token, state.subtree_start,
|
||||
state.has_error);
|
||||
state.state = State::ExpressionLoop;
|
||||
state.has_error = false;
|
||||
context.PushState(state);
|
||||
}
|
||||
|
||||
auto ParserHandleExpressionLoopForPrefix(ParserContext& context) -> void {
|
||||
auto HandleExpressionLoopForPrefix(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
context.AddNode(ParseNodeKind::PrefixOperator, state.token,
|
||||
state.subtree_start, state.has_error);
|
||||
state.state = ParserState::ExpressionLoop;
|
||||
context.AddNode(NodeKind::PrefixOperator, state.token, state.subtree_start,
|
||||
state.has_error);
|
||||
state.state = State::ExpressionLoop;
|
||||
state.has_error = false;
|
||||
context.PushState(state);
|
||||
}
|
||||
|
||||
auto ParserHandleIfExpressionFinishCondition(ParserContext& context) -> void {
|
||||
auto HandleIfExpressionFinishCondition(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
context.AddNode(ParseNodeKind::IfExpressionIf, state.token,
|
||||
state.subtree_start, state.has_error);
|
||||
context.AddNode(NodeKind::IfExpressionIf, state.token, state.subtree_start,
|
||||
state.has_error);
|
||||
|
||||
if (context.PositionIs(TokenKind::Then)) {
|
||||
context.PushState(ParserState::IfExpressionFinishThen);
|
||||
context.PushState(State::IfExpressionFinishThen);
|
||||
context.ConsumeChecked(TokenKind::Then);
|
||||
context.PushStateForExpression(*PrecedenceGroup::ForLeading(TokenKind::If));
|
||||
} else {
|
||||
@@ -282,22 +280,22 @@ auto ParserHandleIfExpressionFinishCondition(ParserContext& context) -> void {
|
||||
context.emitter().Emit(*context.position(), ExpectedThenAfterIf);
|
||||
}
|
||||
// Add placeholders for `IfExpressionThen` and final `Expression`.
|
||||
context.AddLeafNode(ParseNodeKind::InvalidParse, *context.position(),
|
||||
context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
|
||||
/*has_error=*/true);
|
||||
context.AddLeafNode(ParseNodeKind::InvalidParse, *context.position(),
|
||||
context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
|
||||
/*has_error=*/true);
|
||||
context.ReturnErrorOnState();
|
||||
}
|
||||
}
|
||||
|
||||
auto ParserHandleIfExpressionFinishThen(ParserContext& context) -> void {
|
||||
auto HandleIfExpressionFinishThen(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
context.AddNode(ParseNodeKind::IfExpressionThen, state.token,
|
||||
state.subtree_start, state.has_error);
|
||||
context.AddNode(NodeKind::IfExpressionThen, state.token, state.subtree_start,
|
||||
state.has_error);
|
||||
|
||||
if (context.PositionIs(TokenKind::Else)) {
|
||||
context.PushState(ParserState::IfExpressionFinishElse);
|
||||
context.PushState(State::IfExpressionFinishElse);
|
||||
context.ConsumeChecked(TokenKind::Else);
|
||||
context.PushStateForExpression(*PrecedenceGroup::ForLeading(TokenKind::If));
|
||||
} else {
|
||||
@@ -308,13 +306,13 @@ auto ParserHandleIfExpressionFinishThen(ParserContext& context) -> void {
|
||||
context.emitter().Emit(*context.position(), ExpectedElseAfterIf);
|
||||
}
|
||||
// Add placeholder for the final `Expression`.
|
||||
context.AddLeafNode(ParseNodeKind::InvalidParse, *context.position(),
|
||||
context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
|
||||
/*has_error=*/true);
|
||||
context.ReturnErrorOnState();
|
||||
}
|
||||
}
|
||||
|
||||
auto ParserHandleIfExpressionFinishElse(ParserContext& context) -> void {
|
||||
auto HandleIfExpressionFinishElse(Context& context) -> void {
|
||||
auto else_state = context.PopState();
|
||||
|
||||
// Propagate the location of `else`.
|
||||
@@ -324,19 +322,19 @@ auto ParserHandleIfExpressionFinishElse(ParserContext& context) -> void {
|
||||
context.PushState(if_state);
|
||||
}
|
||||
|
||||
auto ParserHandleIfExpressionFinish(ParserContext& context) -> void {
|
||||
auto HandleIfExpressionFinish(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
context.AddNode(ParseNodeKind::IfExpressionElse, state.token,
|
||||
state.subtree_start, state.has_error);
|
||||
context.AddNode(NodeKind::IfExpressionElse, state.token, state.subtree_start,
|
||||
state.has_error);
|
||||
}
|
||||
|
||||
auto ParserHandleExpressionStatementFinish(ParserContext& context) -> void {
|
||||
auto HandleExpressionStatementFinish(Context& context) -> void {
|
||||
auto state = context.PopState();
|
||||
|
||||
if (auto semi = context.ConsumeIf(TokenKind::Semi)) {
|
||||
context.AddNode(ParseNodeKind::ExpressionStatement, *semi,
|
||||
state.subtree_start, state.has_error);
|
||||
context.AddNode(NodeKind::ExpressionStatement, *semi, state.subtree_start,
|
||||
state.has_error);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -347,7 +345,7 @@ auto ParserHandleExpressionStatementFinish(ParserContext& context) -> void {
|
||||
}
|
||||
|
||||
if (auto semi_token = context.SkipPastLikelyEnd(state.token)) {
|
||||
context.AddNode(ParseNodeKind::ExpressionStatement, *semi_token,
|
||||
context.AddNode(NodeKind::ExpressionStatement, *semi_token,
|
||||
state.subtree_start,
|
||||
/*has_error=*/true);
|
||||
return;
|
||||
@@ -357,4 +355,4 @@ auto ParserHandleExpressionStatementFinish(ParserContext& context) -> void {
|
||||
context.ReturnErrorOnState();
|
||||
}
|
||||
|
||||
} // namespace Carbon
|
||||
} // namespace Carbon::Parse
|
||||
Reference in new issue
Block a user