From 7157445f978a9c7a0d832df36c9153ed7139b0ab Mon Sep 17 00:00:00 2001 From: Jon Ross-Perkins Date: Mon, 28 Aug 2023 14:58:38 -0700 Subject: [PATCH] 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' 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 --- common/BUILD | 1 + common/enum_base.h | 8 + common/vlog_internal.h | 4 +- language_server/language_server.cpp | 20 +- toolchain/diagnostics/diagnostic_emitter.h | 2 +- toolchain/driver/driver.cpp | 7 +- toolchain/parser/parse_node_kind.cpp | 19 +- toolchain/parser/parse_node_kind.h | 14 +- toolchain/parser/parse_tree.cpp | 64 +++---- toolchain/parser/parse_tree.h | 78 ++++---- toolchain/parser/parse_tree_file_test.cpp | 4 +- toolchain/parser/parse_tree_fuzzer.cpp | 2 +- .../parse_tree_node_location_translator.h | 15 +- toolchain/parser/parse_tree_test.cpp | 19 +- toolchain/parser/parser_context.cpp | 101 +++++----- toolchain/parser/parser_context.h | 57 +++--- .../parser/parser_handle_array_expression.cpp | 28 +-- .../parser/parser_handle_brace_expression.cpp | 174 ++++++++--------- .../parser/parser_handle_call_expression.cpp | 28 +-- toolchain/parser/parser_handle_code_block.cpp | 24 +-- ...ser_handle_declaration_name_and_params.cpp | 74 ++++---- .../parser_handle_declaration_scope_loop.cpp | 27 ++- toolchain/parser/parser_handle_expression.cpp | 122 ++++++------ toolchain/parser/parser_handle_function.cpp | 47 +++-- .../parser/parser_handle_index_expression.cpp | 16 +- toolchain/parser/parser_handle_namespace.cpp | 20 +- toolchain/parser/parser_handle_package.cpp | 24 ++- toolchain/parser/parser_handle_parameter.cpp | 91 +++++---- .../parser/parser_handle_paren_condition.cpp | 42 ++--- .../parser/parser_handle_paren_expression.cpp | 53 +++--- toolchain/parser/parser_handle_pattern.cpp | 73 ++++---- toolchain/parser/parser_handle_period.cpp | 40 ++-- toolchain/parser/parser_handle_statement.cpp | 132 +++++++------ toolchain/parser/parser_handle_type.cpp | 87 ++++----- toolchain/parser/parser_handle_var.cpp | 37 ++-- toolchain/parser/parser_state.cpp | 8 +- toolchain/parser/parser_state.def | 176 +++++++++--------- toolchain/parser/parser_state.h | 19 +- toolchain/parser/precedence.cpp | 4 +- toolchain/parser/precedence.h | 4 +- toolchain/parser/precedence_test.cpp | 3 + toolchain/semantics/semantics_context.cpp | 53 +++--- toolchain/semantics/semantics_context.h | 64 +++---- .../semantics_declaration_name_stack.cpp | 13 +- .../semantics_declaration_name_stack.h | 12 +- .../semantics/semantics_handle_array.cpp | 11 +- .../semantics_handle_call_expression.cpp | 11 +- .../semantics/semantics_handle_class.cpp | 11 +- .../semantics/semantics_handle_codeblock.cpp | 7 +- .../semantics/semantics_handle_function.cpp | 23 +-- .../semantics_handle_if_expression.cpp | 16 +- .../semantics_handle_if_statement.cpp | 22 +-- .../semantics/semantics_handle_index.cpp | 7 +- .../semantics/semantics_handle_interface.cpp | 10 +- .../semantics/semantics_handle_literal.cpp | 2 +- .../semantics_handle_loop_statement.cpp | 27 ++- toolchain/semantics/semantics_handle_name.cpp | 26 +-- .../semantics_handle_named_constraint.cpp | 14 +- .../semantics/semantics_handle_namespace.cpp | 4 +- toolchain/semantics/semantics_handle_noop.cpp | 9 +- .../semantics/semantics_handle_operator.cpp | 10 +- .../semantics/semantics_handle_package.cpp | 13 +- .../semantics_handle_parameter_list.cpp | 16 +- .../semantics/semantics_handle_paren.cpp | 20 +- .../semantics_handle_pattern_binding.cpp | 15 +- .../semantics/semantics_handle_statement.cpp | 13 +- .../semantics/semantics_handle_struct.cpp | 40 ++-- .../semantics/semantics_handle_variable.cpp | 14 +- toolchain/semantics/semantics_ir.cpp | 10 +- toolchain/semantics/semantics_ir.h | 6 +- .../semantics/semantics_ir_formatter.cpp | 25 ++- toolchain/semantics/semantics_ir_formatter.h | 2 +- toolchain/semantics/semantics_node.h | 19 +- toolchain/semantics/semantics_node_stack.cpp | 2 +- toolchain/semantics/semantics_node_stack.h | 143 +++++++------- 75 files changed, 1181 insertions(+), 1277 deletions(-) diff --git a/common/BUILD b/common/BUILD index f39b46fadfd6..82cd4d50f715 100644 --- a/common/BUILD +++ b/common/BUILD @@ -174,6 +174,7 @@ cc_library( srcs = ["vlog_internal.h"], hdrs = ["vlog.h"], deps = [ + ":ostream", "@llvm-project//llvm:Support", ], ) diff --git a/common/enum_base.h b/common/enum_base.h index c447fbc82172..ba18b30b7308 100644 --- a/common/enum_base.h +++ b/common/enum_base.h @@ -83,6 +83,14 @@ class EnumBase { // Prints this value using its name. auto Print(llvm::raw_ostream& out) const -> void { out << name(); } + // TODO: common/ostream.h tries to provide this, but does not reliably work on + // EnumBase children. Try to find a more generic solution. + friend auto operator<<(llvm::raw_ostream& out, const DerivedT& obj) + -> llvm::raw_ostream& { + obj.Print(out); + return out; + } + protected: // The default constructor is explicitly defaulted (and constexpr) as a // protected constructor to allow derived classes to be constructed but not diff --git a/common/vlog_internal.h b/common/vlog_internal.h index 58ab072b67df..a03586b91b2b 100644 --- a/common/vlog_internal.h +++ b/common/vlog_internal.h @@ -5,9 +5,7 @@ #ifndef CARBON_COMMON_VLOG_INTERNAL_H_ #define CARBON_COMMON_VLOG_INTERNAL_H_ -#include - -#include "llvm/Support/raw_ostream.h" +#include "common/ostream.h" namespace Carbon::Internal { diff --git a/language_server/language_server.cpp b/language_server/language_server.cpp index d544a4b8ea25..eb06bdecf428 100644 --- a/language_server/language_server.cpp +++ b/language_server/language_server.cpp @@ -75,11 +75,11 @@ auto LanguageServer::onReply(llvm::json::Value /*id*/, return true; } -// Returns the text of first child of kind ParseNodeKind::Name. -static auto getName(ParseTree& p, ParseTree::Node node) +// Returns the text of first child of kind Parse::NodeKind::Name. +static auto getName(Parse::Tree& p, Parse::Node node) -> std::optional { for (auto ch : p.children(node)) { - if (p.node_kind(ch) == ParseNodeKind::Name) { + if (p.node_kind(ch) == Parse::NodeKind::Name) { return p.GetNodeText(ch); } } @@ -96,23 +96,23 @@ void LanguageServer::OnDocumentSymbol( auto buf = SourceBuffer::CreateFromFile(vfs, file); auto lexed = TokenizedBuffer::Lex(*buf, NullDiagnosticConsumer()); - auto parsed = ParseTree::Parse(lexed, NullDiagnosticConsumer(), nullptr); + auto parsed = Parse::Tree::Parse(lexed, NullDiagnosticConsumer(), nullptr); std::vector result; for (const auto& node : parsed.postorder()) { clang::clangd::SymbolKind symbol_kind; switch (parsed.node_kind(node)) { - case ParseNodeKind::FunctionDeclaration: - case ParseNodeKind::FunctionDefinitionStart: + case Parse::NodeKind::FunctionDeclaration: + case Parse::NodeKind::FunctionDefinitionStart: symbol_kind = clang::clangd::SymbolKind::Function; break; - case ParseNodeKind::Namespace: + case Parse::NodeKind::Namespace: symbol_kind = clang::clangd::SymbolKind::Namespace; break; - case ParseNodeKind::InterfaceDefinitionStart: - case ParseNodeKind::NamedConstraintDefinitionStart: + case Parse::NodeKind::InterfaceDefinitionStart: + case Parse::NodeKind::NamedConstraintDefinitionStart: symbol_kind = clang::clangd::SymbolKind::Interface; break; - case ParseNodeKind::ClassDefinitionStart: + case Parse::NodeKind::ClassDefinitionStart: symbol_kind = clang::clangd::SymbolKind::Class; break; default: diff --git a/toolchain/diagnostics/diagnostic_emitter.h b/toolchain/diagnostics/diagnostic_emitter.h index 6de75c42ac7a..a8606b19d32a 100644 --- a/toolchain/diagnostics/diagnostic_emitter.h +++ b/toolchain/diagnostics/diagnostic_emitter.h @@ -41,7 +41,7 @@ enum class DiagnosticLevel : int8_t { // See `DiagnosticEmitter::Emit` for comments about argument lifetimes. #define CARBON_DIAGNOSTIC(DiagnosticName, Level, Format, ...) \ static constexpr auto DiagnosticName = \ - Internal::DiagnosticBase<__VA_ARGS__>( \ + ::Carbon::Internal::DiagnosticBase<__VA_ARGS__>( \ ::Carbon::DiagnosticKind::DiagnosticName, \ ::Carbon::DiagnosticLevel::Level, Format) diff --git a/toolchain/driver/driver.cpp b/toolchain/driver/driver.cpp index 6409dc0413f7..0621982cd1b9 100644 --- a/toolchain/driver/driver.cpp +++ b/toolchain/driver/driver.cpp @@ -421,10 +421,11 @@ auto Driver::Compile(const CompileOptions& options) -> bool { return !has_errors; } - CARBON_VLOG() << "*** ParseTree::Parse ***\n"; - auto parse_tree = ParseTree::Parse(tokenized_source, *consumer, vlog_stream_); + CARBON_VLOG() << "*** Parse::Tree::Parse ***\n"; + auto parse_tree = + Parse::Tree::Parse(tokenized_source, *consumer, vlog_stream_); has_errors |= parse_tree.has_errors(); - CARBON_VLOG() << "*** ParseTree::Parse done ***\n"; + CARBON_VLOG() << "*** Parse::Tree::Parse done ***\n"; if (options.dump_parse_tree) { consumer->Flush(); parse_tree.Print(output_stream_, options.preorder_parse_tree); diff --git a/toolchain/parser/parse_node_kind.cpp b/toolchain/parser/parse_node_kind.cpp index a369a604bae7..4a5060d3c514 100644 --- a/toolchain/parser/parse_node_kind.cpp +++ b/toolchain/parser/parse_node_kind.cpp @@ -6,14 +6,14 @@ #include "common/check.h" -namespace Carbon { +namespace Carbon::Parse { -CARBON_DEFINE_ENUM_CLASS_NAMES(ParseNodeKind) = { +CARBON_DEFINE_ENUM_CLASS_NAMES(NodeKind) = { #define CARBON_PARSE_NODE_KIND(Name) CARBON_ENUM_CLASS_NAME_STRING(Name) #include "toolchain/parser/parse_node_kind.def" }; -auto ParseNodeKind::has_bracket() const -> bool { +auto NodeKind::has_bracket() const -> bool { static constexpr bool HasBracket[] = { #define CARBON_PARSE_NODE_KIND_BRACKET(...) true, #define CARBON_PARSE_NODE_KIND_CHILD_COUNT(...) false, @@ -22,13 +22,12 @@ auto ParseNodeKind::has_bracket() const -> bool { return HasBracket[AsInt()]; } -auto ParseNodeKind::bracket() const -> ParseNodeKind { +auto NodeKind::bracket() const -> NodeKind { // Nodes are never self-bracketed, so we use that for nodes that instead set // child_count. - static constexpr ParseNodeKind Bracket[] = { -#define CARBON_PARSE_NODE_KIND_BRACKET(Name, BracketName) \ - ParseNodeKind::BracketName, -#define CARBON_PARSE_NODE_KIND_CHILD_COUNT(Name, ...) ParseNodeKind::Name, + static constexpr NodeKind Bracket[] = { +#define CARBON_PARSE_NODE_KIND_BRACKET(Name, BracketName) NodeKind::BracketName, +#define CARBON_PARSE_NODE_KIND_CHILD_COUNT(Name, ...) NodeKind::Name, #include "toolchain/parser/parse_node_kind.def" }; auto bracket = Bracket[AsInt()]; @@ -36,7 +35,7 @@ auto ParseNodeKind::bracket() const -> ParseNodeKind { return bracket; } -auto ParseNodeKind::child_count() const -> int32_t { +auto NodeKind::child_count() const -> int32_t { static constexpr int32_t ChildCount[] = { #define CARBON_PARSE_NODE_KIND_BRACKET(...) -1, #define CARBON_PARSE_NODE_KIND_CHILD_COUNT(Name, Size) Size, @@ -47,4 +46,4 @@ auto ParseNodeKind::child_count() const -> int32_t { return child_count; } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parse_node_kind.h b/toolchain/parser/parse_node_kind.h index 8b042c168e60..0e539c67bd2b 100644 --- a/toolchain/parser/parse_node_kind.h +++ b/toolchain/parser/parse_node_kind.h @@ -9,16 +9,16 @@ #include "common/enum_base.h" -namespace Carbon { +namespace Carbon::Parse { -CARBON_DEFINE_RAW_ENUM_CLASS(ParseNodeKind, uint8_t) { +CARBON_DEFINE_RAW_ENUM_CLASS(NodeKind, uint8_t) { #define CARBON_PARSE_NODE_KIND(Name) CARBON_RAW_ENUM_ENUMERATOR(Name) #include "toolchain/parser/parse_node_kind.def" }; // A class wrapping an enumeration of the different kinds of nodes in the parse // tree. -class ParseNodeKind : public CARBON_ENUM_BASE(ParseNodeKind) { +class NodeKind : public CARBON_ENUM_BASE(NodeKind) { public: #define CARBON_PARSE_NODE_KIND(Name) CARBON_ENUM_CONSTANT_DECLARATION(Name) #include "toolchain/parser/parse_node_kind.def" @@ -28,7 +28,7 @@ class ParseNodeKind : public CARBON_ENUM_BASE(ParseNodeKind) { // Returns the bracketing node kind for the current node kind. Requires that // has_bracket is true. - auto bracket() const -> ParseNodeKind; + auto bracket() const -> NodeKind; // Returns the number of children that the node must have, often 0. Requires // that has_bracket is false. @@ -38,12 +38,12 @@ class ParseNodeKind : public CARBON_ENUM_BASE(ParseNodeKind) { }; #define CARBON_PARSE_NODE_KIND(Name) \ - CARBON_ENUM_CONSTANT_DEFINITION(ParseNodeKind, Name) + CARBON_ENUM_CONSTANT_DEFINITION(NodeKind, Name) #include "toolchain/parser/parse_node_kind.def" // We expect the parse node kind to fit compactly into 8 bits. -static_assert(sizeof(ParseNodeKind) == 1, "Kind objects include padding!"); +static_assert(sizeof(NodeKind) == 1, "Kind objects include padding!"); -} // namespace Carbon +} // namespace Carbon::Parse #endif // CARBON_TOOLCHAIN_PARSER_PARSE_NODE_KIND_H_ diff --git a/toolchain/parser/parse_tree.cpp b/toolchain/parser/parse_tree.cpp index 961201f7de2d..2ea31183e447 100644 --- a/toolchain/parser/parse_tree.cpp +++ b/toolchain/parser/parse_tree.cpp @@ -13,40 +13,40 @@ #include "toolchain/parser/parse_node_kind.h" #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParseTree::Parse(TokenizedBuffer& tokens, DiagnosticConsumer& consumer, - llvm::raw_ostream* vlog_stream) -> ParseTree { +auto Tree::Parse(TokenizedBuffer& tokens, DiagnosticConsumer& consumer, + llvm::raw_ostream* vlog_stream) -> Tree { TokenizedBuffer::TokenLocationTranslator translator(&tokens); TokenDiagnosticEmitter emitter(translator, consumer); // Delegate to the parser. - ParseTree tree(tokens); - ParserContext context(tree, tokens, emitter, vlog_stream); + Tree tree(tokens); + Context context(tree, tokens, emitter, vlog_stream); PrettyStackTraceFunction context_dumper( [&](llvm::raw_ostream& output) { context.PrintForStackDump(output); }); - context.PushState(ParserState::DeclarationScopeLoop); + context.PushState(State::DeclarationScopeLoop); // The package should always be the first token, if it's present. Any other // use is invalid. if (context.PositionIs(TokenKind::Package)) { - context.PushState(ParserState::Package); + context.PushState(State::Package); } while (!context.state_stack().empty()) { // clang warns on unhandled enum values; clang-tidy is incorrect here. // NOLINTNEXTLINE(bugprone-switch-missing-default-case) switch (context.state_stack().back().state) { -#define CARBON_PARSER_STATE(Name) \ - case ParserState::Name: \ - ParserHandle##Name(context); \ +#define CARBON_PARSE_STATE(Name) \ + case State::Name: \ + Handle##Name(context); \ break; #include "toolchain/parser/parser_state.def" } } - context.AddLeafNode(ParseNodeKind::FileEnd, *context.position()); + context.AddLeafNode(NodeKind::FileEnd, *context.position()); if (auto verify = tree.Verify(); !verify.ok()) { if (vlog_stream) { @@ -57,13 +57,12 @@ auto ParseTree::Parse(TokenizedBuffer& tokens, DiagnosticConsumer& consumer, return tree; } -auto ParseTree::postorder() const -> llvm::iterator_range { +auto Tree::postorder() const -> llvm::iterator_range { return {PostorderIterator(Node(0)), PostorderIterator(Node(node_impls_.size()))}; } -auto ParseTree::postorder(Node n) const - -> llvm::iterator_range { +auto Tree::postorder(Node n) const -> llvm::iterator_range { CARBON_CHECK(n.is_valid()); // The postorder ends after this node, the root, and begins at the start of // its subtree. @@ -73,47 +72,46 @@ auto ParseTree::postorder(Node n) const PostorderIterator(Node(end_index))}; } -auto ParseTree::children(Node n) const - -> llvm::iterator_range { +auto Tree::children(Node n) const -> llvm::iterator_range { CARBON_CHECK(n.is_valid()); int end_index = n.index - node_impls_[n.index].subtree_size; return {SiblingIterator(*this, Node(n.index - 1)), SiblingIterator(*this, Node(end_index))}; } -auto ParseTree::roots() const -> llvm::iterator_range { +auto Tree::roots() const -> llvm::iterator_range { return { SiblingIterator(*this, Node(static_cast(node_impls_.size()) - 1)), SiblingIterator(*this, Node(-1))}; } -auto ParseTree::node_has_error(Node n) const -> bool { +auto Tree::node_has_error(Node n) const -> bool { CARBON_CHECK(n.is_valid()); return node_impls_[n.index].has_error; } -auto ParseTree::node_kind(Node n) const -> ParseNodeKind { +auto Tree::node_kind(Node n) const -> NodeKind { CARBON_CHECK(n.is_valid()); return node_impls_[n.index].kind; } -auto ParseTree::node_token(Node n) const -> TokenizedBuffer::Token { +auto Tree::node_token(Node n) const -> TokenizedBuffer::Token { CARBON_CHECK(n.is_valid()); return node_impls_[n.index].token; } -auto ParseTree::node_subtree_size(Node n) const -> int32_t { +auto Tree::node_subtree_size(Node n) const -> int32_t { CARBON_CHECK(n.is_valid()); return node_impls_[n.index].subtree_size; } -auto ParseTree::GetNodeText(Node n) const -> llvm::StringRef { +auto Tree::GetNodeText(Node n) const -> llvm::StringRef { CARBON_CHECK(n.is_valid()); return tokens_->GetTokenText(node_impls_[n.index].token); } -auto ParseTree::PrintNode(llvm::raw_ostream& output, Node n, int depth, - bool preorder) const -> bool { +auto Tree::PrintNode(llvm::raw_ostream& output, Node n, int depth, + bool preorder) const -> bool { const auto& n_impl = node_impls_[n.index]; output.indent(2 * depth); output << "{"; @@ -140,7 +138,7 @@ auto ParseTree::PrintNode(llvm::raw_ostream& output, Node n, int depth, return false; } -auto ParseTree::Print(llvm::raw_ostream& output) const -> void { +auto Tree::Print(llvm::raw_ostream& output) const -> void { // Walk the tree just to calculate depths for each node. llvm::SmallVector indents; indents.append(size(), 0); @@ -168,7 +166,7 @@ auto ParseTree::Print(llvm::raw_ostream& output) const -> void { output << "]\n"; } -auto ParseTree::Print(llvm::raw_ostream& output, bool preorder) const -> void { +auto Tree::Print(llvm::raw_ostream& output, bool preorder) const -> void { if (!preorder) { Print(output); return; @@ -215,8 +213,8 @@ auto ParseTree::Print(llvm::raw_ostream& output, bool preorder) const -> void { output << "]\n"; } -auto ParseTree::Verify() const -> ErrorOr { - llvm::SmallVector nodes; +auto Tree::Verify() const -> ErrorOr { + llvm::SmallVector nodes; // Traverse the tree in postorder. for (Node n : postorder()) { const auto& n_impl = node_impls_[n.index]; @@ -282,7 +280,7 @@ auto ParseTree::Verify() const -> ErrorOr { if (!has_errors_ && static_cast(node_impls_.size()) != tokens_->expected_parse_tree_size()) { return Error( - llvm::formatv("ParseTree has {0} nodes and no errors, but " + llvm::formatv("Tree has {0} nodes and no errors, but " "TokenizedBuffer expected {1} nodes for {2} tokens.", node_impls_.size(), tokens_->expected_parse_tree_size(), tokens_->size())); @@ -290,14 +288,12 @@ auto ParseTree::Verify() const -> ErrorOr { return Success(); } -auto ParseTree::PostorderIterator::Print(llvm::raw_ostream& output) const - -> void { +auto Tree::PostorderIterator::Print(llvm::raw_ostream& output) const -> void { output << node_; } -auto ParseTree::SiblingIterator::Print(llvm::raw_ostream& output) const - -> void { +auto Tree::SiblingIterator::Print(llvm::raw_ostream& output) const -> void { output << node_; } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parse_tree.h b/toolchain/parser/parse_tree.h index bce0b9d77759..9b6c5c4feab2 100644 --- a/toolchain/parser/parse_tree.h +++ b/toolchain/parser/parse_tree.h @@ -17,7 +17,24 @@ #include "toolchain/lexer/tokenized_buffer.h" #include "toolchain/parser/parse_node_kind.h" -namespace Carbon { +namespace Carbon::Parse { + +// A lightweight handle representing a node in the tree. +// +// Objects of this type are small and cheap to copy and store. They don't +// contain any of the information about the node, and serve as a handle that +// can be used with the underlying tree to query for detailed information. +// +// That said, nodes can be compared and are part of a depth-first pre-order +// sequence across all nodes in the parse tree. +struct Node : public ComparableIndexBase { + // An explicitly invalid instance. + static const Node Invalid; + + using ComparableIndexBase::ComparableIndexBase; +}; + +constexpr Node Node::Invalid = Node(Node::InvalidIndex); // A tree of parsed tokens based on the language grammar. // @@ -40,17 +57,16 @@ namespace Carbon { // The tree is immutable once built, but is designed to support reasonably // efficient patterns that build a new tree with a specific transformation // applied. -class ParseTree { +class Tree { public: - struct Node; class PostorderIterator; class SiblingIterator; - // Parses the token buffer into a `ParseTree`. + // Parses the token buffer into a `Tree`. // // This is the factory function which is used to build parse trees. static auto Parse(TokenizedBuffer& tokens, DiagnosticConsumer& consumer, - llvm::raw_ostream* vlog_stream) -> ParseTree; + llvm::raw_ostream* vlog_stream) -> Tree; // Tests whether there are any errors in the parse tree. [[nodiscard]] auto has_errors() const -> bool { return has_errors_; } @@ -84,7 +100,7 @@ class ParseTree { [[nodiscard]] auto node_has_error(Node n) const -> bool; // Returns the kind of the given parse tree node. - [[nodiscard]] auto node_kind(Node n) const -> ParseNodeKind; + [[nodiscard]] auto node_kind(Node n) const -> NodeKind; // Returns the token the given parse tree node models. [[nodiscard]] auto node_token(Node n) const -> TokenizedBuffer::Token; @@ -149,12 +165,12 @@ class ParseTree { [[nodiscard]] auto Verify() const -> ErrorOr; private: - friend class ParserContext; + friend class Context; // The in-memory representation of data used for a particular node in the // tree. struct NodeImpl { - explicit NodeImpl(ParseNodeKind kind, bool has_error, + explicit NodeImpl(NodeKind kind, bool has_error, TokenizedBuffer::Token token, int subtree_size) : kind(kind), has_error(has_error), @@ -162,7 +178,7 @@ class ParseTree { subtree_size(subtree_size) {} // The kind of this node. Note that this is only a single byte. - ParseNodeKind kind; + NodeKind kind; // We have 3 bytes of padding here that we can pack flags or other compact // data into. @@ -207,7 +223,7 @@ class ParseTree { // Wires up the reference to the tokenized buffer. The `Parse` function should // be used to actually parse the tokens into a tree. - explicit ParseTree(TokenizedBuffer& tokens_arg) : tokens_(&tokens_arg) { + explicit Tree(TokenizedBuffer& tokens_arg) : tokens_(&tokens_arg) { // If the tree is valid, there will be one node per token, so reserve once. node_impls_.reserve(tokens_->expected_parse_tree_size()); } @@ -233,28 +249,10 @@ class ParseTree { bool has_errors_ = false; }; -// A lightweight handle representing a node in the tree. -// -// Objects of this type are small and cheap to copy and store. They don't -// contain any of the information about the node, and serve as a handle that -// can be used with the underlying tree to query for detailed information. -// -// That said, nodes can be compared and are part of a depth-first pre-order -// sequence across all nodes in the parse tree. -struct ParseTree::Node : public ComparableIndexBase { - // An explicitly invalid instance. - static const Node Invalid; - - using ComparableIndexBase::ComparableIndexBase; -}; - -constexpr ParseTree::Node ParseTree::Node::Invalid = - ParseTree::Node(ParseTree::Node::InvalidIndex); - // A random-access iterator to the depth-first postorder sequence of parse nodes -// in the parse tree. It produces `ParseTree::Node` objects which are opaque -// handles and must be used in conjunction with the `ParseTree` itself. -class ParseTree::PostorderIterator +// in the parse tree. It produces `Tree::Node` objects which are opaque +// handles and must be used in conjunction with the `Tree` itself. +class Tree::PostorderIterator : public llvm::iterator_facade_base { @@ -287,7 +285,7 @@ class ParseTree::PostorderIterator auto Print(llvm::raw_ostream& output) const -> void; private: - friend class ParseTree; + friend class Tree; explicit PostorderIterator(Node n) : node_(n) {} @@ -295,17 +293,17 @@ class ParseTree::PostorderIterator }; // A forward iterator across the siblings at a particular level in the parse -// tree. It produces `ParseTree::Node` objects which are opaque handles and must -// be used in conjunction with the `ParseTree` itself. +// tree. It produces `Tree::Node` objects which are opaque handles and must +// be used in conjunction with the `Tree` itself. // // While this is a forward iterator and may not have good locality within the -// `ParseTree` data structure, it is still constant time to increment and +// `Tree` data structure, it is still constant time to increment and // suitable for algorithms relying on that property. // // The siblings are discovered through a reverse postorder (RPO) tree traversal // (which is made constant time through cached distance information), and so the // relative order of siblings matches their RPO order. -class ParseTree::SiblingIterator +class Tree::SiblingIterator : public llvm::iterator_facade_base< SiblingIterator, std::forward_iterator_tag, Node, int, Node*, Node> { public: @@ -332,16 +330,16 @@ class ParseTree::SiblingIterator auto Print(llvm::raw_ostream& output) const -> void; private: - friend class ParseTree; + friend class Tree; - explicit SiblingIterator(const ParseTree& tree_arg, Node n) + explicit SiblingIterator(const Tree& tree_arg, Node n) : tree_(&tree_arg), node_(n) {} - const ParseTree* tree_; + const Tree* tree_; Node node_; }; -} // namespace Carbon +} // namespace Carbon::Parse #endif // CARBON_TOOLCHAIN_PARSER_PARSE_TREE_H_ diff --git a/toolchain/parser/parse_tree_file_test.cpp b/toolchain/parser/parse_tree_file_test.cpp index 82d2713f890c..56acae57eede 100644 --- a/toolchain/parser/parse_tree_file_test.cpp +++ b/toolchain/parser/parse_tree_file_test.cpp @@ -10,7 +10,7 @@ namespace Carbon::Testing { namespace { -class ParseTreeFileTest : public DriverFileTestBase { +class TreeFileTest : public DriverFileTestBase { public: using DriverFileTestBase::DriverFileTestBase; @@ -21,6 +21,6 @@ class ParseTreeFileTest : public DriverFileTestBase { } // namespace -CARBON_FILE_TEST_FACTORY(ParseTreeFileTest); +CARBON_FILE_TEST_FACTORY(TreeFileTest); } // namespace Carbon::Testing diff --git a/toolchain/parser/parse_tree_fuzzer.cpp b/toolchain/parser/parse_tree_fuzzer.cpp index 0c1bddb43f5a..957187a4bf50 100644 --- a/toolchain/parser/parse_tree_fuzzer.cpp +++ b/toolchain/parser/parse_tree_fuzzer.cpp @@ -37,7 +37,7 @@ extern "C" int LLVMFuzzerTestOneInput(const unsigned char* data, // Now parse it into a tree. Note that parsing will (when asserts are enabled) // walk the entire tree to verify it so we don't have to do that here. - ParseTree::Parse(tokens, NullDiagnosticConsumer(), /*vlog_stream=*/nullptr); + Parse::Tree::Parse(tokens, NullDiagnosticConsumer(), /*vlog_stream=*/nullptr); return 0; } diff --git a/toolchain/parser/parse_tree_node_location_translator.h b/toolchain/parser/parse_tree_node_location_translator.h index 16b9fe4d2084..91bc044bd954 100644 --- a/toolchain/parser/parse_tree_node_location_translator.h +++ b/toolchain/parser/parse_tree_node_location_translator.h @@ -7,25 +7,24 @@ #include "toolchain/parser/parse_tree.h" -namespace Carbon { +namespace Carbon::Parse { -class ParseTreeNodeLocationTranslator - : public DiagnosticLocationTranslator { +class NodeLocationTranslator : public DiagnosticLocationTranslator { public: - explicit ParseTreeNodeLocationTranslator(const TokenizedBuffer* tokens, - const ParseTree* parse_tree) + explicit NodeLocationTranslator(const TokenizedBuffer* tokens, + const Tree* parse_tree) : token_translator_(tokens), parse_tree_(parse_tree) {} // Map the given token into a diagnostic location. - auto GetLocation(ParseTree::Node node) -> DiagnosticLocation override { + auto GetLocation(Node node) -> DiagnosticLocation override { return token_translator_.GetLocation(parse_tree_->node_token(node)); } private: TokenizedBuffer::TokenLocationTranslator token_translator_; - const ParseTree* parse_tree_; + const Tree* parse_tree_; }; -} // namespace Carbon +} // namespace Carbon::Parse #endif // CARBON_TOOLCHAIN_PARSER_PARSE_TREE_NODE_LOCATION_TRANSLATOR_H_ diff --git a/toolchain/parser/parse_tree_test.cpp b/toolchain/parser/parse_tree_test.cpp index 0d1cb1a5d4c3..10aa387bc679 100644 --- a/toolchain/parser/parse_tree_test.cpp +++ b/toolchain/parser/parse_tree_test.cpp @@ -18,9 +18,10 @@ namespace Carbon::Testing { namespace { +using Parse::Tree; using ::testing::ElementsAre; -class ParseTreeTest : public ::testing::Test { +class TreeTest : public ::testing::Test { protected: auto GetSourceBuffer(llvm::StringRef t) -> SourceBuffer& { CARBON_CHECK(fs.addFile("test.carbon", /*ModificationTime=*/0, @@ -42,15 +43,15 @@ class ParseTreeTest : public ::testing::Test { DiagnosticConsumer& consumer = ConsoleDiagnosticConsumer(); }; -TEST_F(ParseTreeTest, IsValid) { +TEST_F(TreeTest, IsValid) { TokenizedBuffer tokens = GetTokenizedBuffer(""); - ParseTree tree = ParseTree::Parse(tokens, consumer, /*vlog_stream=*/nullptr); + Tree tree = Tree::Parse(tokens, consumer, /*vlog_stream=*/nullptr); EXPECT_TRUE((*tree.postorder().begin()).is_valid()); } -TEST_F(ParseTreeTest, PrintPostorderAsYAML) { +TEST_F(TreeTest, PrintPostorderAsYAML) { TokenizedBuffer tokens = GetTokenizedBuffer("fn F();"); - ParseTree tree = ParseTree::Parse(tokens, consumer, /*vlog_stream=*/nullptr); + Tree tree = Tree::Parse(tokens, consumer, /*vlog_stream=*/nullptr); EXPECT_FALSE(tree.has_errors()); TestRawOstream print_stream; tree.Print(print_stream); @@ -70,9 +71,9 @@ TEST_F(ParseTreeTest, PrintPostorderAsYAML) { EXPECT_THAT(Yaml::Value::FromText(print_stream.TakeStr()), ElementsAre(file)); } -TEST_F(ParseTreeTest, PrintPreorderAsYAML) { +TEST_F(TreeTest, PrintPreorderAsYAML) { TokenizedBuffer tokens = GetTokenizedBuffer("fn F();"); - ParseTree tree = ParseTree::Parse(tokens, consumer, /*vlog_stream=*/nullptr); + Tree tree = Tree::Parse(tokens, consumer, /*vlog_stream=*/nullptr); EXPECT_FALSE(tree.has_errors()); TestRawOstream print_stream; tree.Print(print_stream, /*preorder=*/true); @@ -106,7 +107,7 @@ TEST_F(ParseTreeTest, PrintPreorderAsYAML) { EXPECT_THAT(Yaml::Value::FromText(print_stream.TakeStr()), ElementsAre(file)); } -TEST_F(ParseTreeTest, HighRecursion) { +TEST_F(TreeTest, HighRecursion) { std::string code = "fn Foo() { return "; code.append(10000, '('); code.append(10000, ')'); @@ -114,7 +115,7 @@ TEST_F(ParseTreeTest, HighRecursion) { TokenizedBuffer tokens = GetTokenizedBuffer(code); ASSERT_FALSE(tokens.has_errors()); Testing::MockDiagnosticConsumer consumer; - ParseTree tree = ParseTree::Parse(tokens, consumer, /*vlog_stream=*/nullptr); + Tree tree = Tree::Parse(tokens, consumer, /*vlog_stream=*/nullptr); EXPECT_FALSE(tree.has_errors()); } diff --git a/toolchain/parser/parser_context.cpp b/toolchain/parser/parser_context.cpp index 899a4b22096a..15700e53dd52 100644 --- a/toolchain/parser/parser_context.cpp +++ b/toolchain/parser/parser_context.cpp @@ -7,13 +7,14 @@ #include #include "common/check.h" +#include "common/ostream.h" #include "llvm/ADT/STLExtras.h" #include "toolchain/lexer/token_kind.h" #include "toolchain/lexer/tokenized_buffer.h" #include "toolchain/parser/parse_node_kind.h" #include "toolchain/parser/parse_tree.h" -namespace Carbon { +namespace Carbon::Parse { // A relative location for characters in errors. enum class RelativeLocation : int8_t { @@ -39,9 +40,9 @@ static auto operator<<(llvm::raw_ostream& out, RelativeLocation loc) return out; } -ParserContext::ParserContext(ParseTree& tree, TokenizedBuffer& tokens, - TokenDiagnosticEmitter& emitter, - llvm::raw_ostream* vlog_stream) +Context::Context(Tree& tree, TokenizedBuffer& tokens, + TokenDiagnosticEmitter& emitter, + llvm::raw_ostream* vlog_stream) : tree_(&tree), tokens_(&tokens), emitter_(&emitter), @@ -55,28 +56,27 @@ ParserContext::ParserContext(ParseTree& tree, TokenizedBuffer& tokens, << tokens_->GetKind(*end_); } -auto ParserContext::AddLeafNode(ParseNodeKind kind, - TokenizedBuffer::Token token, bool has_error) - -> void { +auto Context::AddLeafNode(NodeKind kind, TokenizedBuffer::Token token, + bool has_error) -> void { tree_->node_impls_.push_back( - ParseTree::NodeImpl(kind, has_error, token, /*subtree_size=*/1)); + Tree::NodeImpl(kind, has_error, token, /*subtree_size=*/1)); if (has_error) { tree_->has_errors_ = true; } } -auto ParserContext::AddNode(ParseNodeKind kind, TokenizedBuffer::Token token, - int subtree_start, bool has_error) -> void { +auto Context::AddNode(NodeKind kind, TokenizedBuffer::Token token, + int subtree_start, bool has_error) -> void { int subtree_size = tree_->size() - subtree_start + 1; tree_->node_impls_.push_back( - ParseTree::NodeImpl(kind, has_error, token, subtree_size)); + Tree::NodeImpl(kind, has_error, token, subtree_size)); if (has_error) { tree_->has_errors_ = true; } } -auto ParserContext::ConsumeAndAddOpenParen(TokenizedBuffer::Token default_token, - ParseNodeKind start_kind) +auto Context::ConsumeAndAddOpenParen(TokenizedBuffer::Token default_token, + NodeKind start_kind) -> std::optional { if (auto open_paren = ConsumeIf(TokenKind::OpenParen)) { AddLeafNode(start_kind, *open_paren, /*has_error=*/false); @@ -91,9 +91,9 @@ auto ParserContext::ConsumeAndAddOpenParen(TokenizedBuffer::Token default_token, } } -auto ParserContext::ConsumeAndAddCloseSymbol( - TokenizedBuffer::Token expected_open, StateStackEntry state, - ParseNodeKind close_kind) -> void { +auto Context::ConsumeAndAddCloseSymbol(TokenizedBuffer::Token expected_open, + StateStackEntry state, + NodeKind close_kind) -> void { TokenKind open_token_kind = tokens().GetKind(expected_open); if (!open_token_kind.is_opening_symbol()) { @@ -113,8 +113,8 @@ auto ParserContext::ConsumeAndAddCloseSymbol( } } -auto ParserContext::ConsumeAndAddLeafNodeIf(TokenKind token_kind, - ParseNodeKind node_kind) -> bool { +auto Context::ConsumeAndAddLeafNodeIf(TokenKind token_kind, NodeKind node_kind) + -> bool { auto token = ConsumeIf(token_kind); if (!token) { return false; @@ -124,13 +124,13 @@ auto ParserContext::ConsumeAndAddLeafNodeIf(TokenKind token_kind, return true; } -auto ParserContext::ConsumeChecked(TokenKind kind) -> TokenizedBuffer::Token { +auto Context::ConsumeChecked(TokenKind kind) -> TokenizedBuffer::Token { CARBON_CHECK(PositionIs(kind)) << "Required " << kind << ", found " << PositionKind(); return Consume(); } -auto ParserContext::ConsumeIf(TokenKind kind) +auto Context::ConsumeIf(TokenKind kind) -> std::optional { if (!PositionIs(kind)) { return std::nullopt; @@ -138,17 +138,17 @@ auto ParserContext::ConsumeIf(TokenKind kind) return Consume(); } -auto ParserContext::ConsumeIfPatternKeyword(TokenKind keyword_token, - ParserState keyword_state, - int subtree_start) -> void { +auto Context::ConsumeIfPatternKeyword(TokenKind keyword_token, + State keyword_state, int subtree_start) + -> void { if (auto token = ConsumeIf(keyword_token)) { - PushState(ParserContext::StateStackEntry( + PushState(Context::StateStackEntry( keyword_state, PrecedenceGroup::ForTopLevelExpression(), PrecedenceGroup::ForTopLevelExpression(), *token, subtree_start)); } } -auto ParserContext::FindNextOf(std::initializer_list desired_kinds) +auto Context::FindNextOf(std::initializer_list desired_kinds) -> std::optional { auto new_position = position_; while (true) { @@ -173,7 +173,7 @@ auto ParserContext::FindNextOf(std::initializer_list desired_kinds) } } -auto ParserContext::SkipMatchingGroup() -> bool { +auto Context::SkipMatchingGroup() -> bool { if (!PositionKind().is_opening_symbol()) { return false; } @@ -183,7 +183,7 @@ auto ParserContext::SkipMatchingGroup() -> bool { return true; } -auto ParserContext::SkipPastLikelyEnd(TokenizedBuffer::Token skip_root) +auto Context::SkipPastLikelyEnd(TokenizedBuffer::Token skip_root) -> std::optional { if (position_ == end_) { return std::nullopt; @@ -230,7 +230,7 @@ auto ParserContext::SkipPastLikelyEnd(TokenizedBuffer::Token skip_root) return std::nullopt; } -auto ParserContext::SkipTo(TokenizedBuffer::Token t) -> void { +auto Context::SkipTo(TokenizedBuffer::Token t) -> void { CARBON_CHECK(t >= *position_) << "Tried to skip backwards from " << position_ << " to " << TokenizedBuffer::TokenIterator(t); position_ = TokenizedBuffer::TokenIterator(t); @@ -263,7 +263,7 @@ static auto IsPossibleStartOfOperand(TokenKind kind) -> bool { TokenKind::Semi, TokenKind::Colon}); } -auto ParserContext::IsLexicallyValidInfixOperator() -> bool { +auto Context::IsLexicallyValidInfixOperator() -> bool { CARBON_CHECK(position_ != end_) << "Expected an operator token."; bool leading_space = tokens().HasLeadingWhitespace(*position_); @@ -291,7 +291,7 @@ auto ParserContext::IsLexicallyValidInfixOperator() -> bool { return true; } -auto ParserContext::IsTrailingOperatorInfix() -> bool { +auto Context::IsTrailingOperatorInfix() -> bool { if (position_ == end_) { return false; } @@ -315,7 +315,7 @@ auto ParserContext::IsTrailingOperatorInfix() -> bool { return false; } -auto ParserContext::DiagnoseOperatorFixity(OperatorFixity fixity) -> void { +auto Context::DiagnoseOperatorFixity(OperatorFixity fixity) -> void { if (!PositionKind().is_symbol()) { // Whitespace-based fixity rules only apply to symbolic operators. return; @@ -359,9 +359,8 @@ auto ParserContext::DiagnoseOperatorFixity(OperatorFixity fixity) -> void { } } -auto ParserContext::ConsumeListToken(ParseNodeKind comma_kind, - TokenKind close_kind, - bool already_has_error) -> ListTokenKind { +auto Context::ConsumeListToken(NodeKind comma_kind, TokenKind close_kind, + bool already_has_error) -> ListTokenKind { if (!PositionIs(TokenKind::Comma) && !PositionIs(close_kind)) { // Don't error a second time on the same element. if (!already_has_error) { @@ -390,19 +389,19 @@ auto ParserContext::ConsumeListToken(ParseNodeKind comma_kind, } } -auto ParserContext::GetDeclarationContext() -> DeclarationContext { +auto Context::GetDeclarationContext() -> DeclarationContext { // i == 0 is the file-level DeclarationScopeLoop. Additionally, i == 1 can be // skipped because it will never be a DeclarationScopeLoop. for (int i = state_stack_.size() - 1; i > 1; --i) { // The declaration context is always the state _above_ a // DeclarationScopeLoop. - if (state_stack_[i].state == ParserState::DeclarationScopeLoop) { + if (state_stack_[i].state == State::DeclarationScopeLoop) { switch (state_stack_[i - 1].state) { - case ParserState::TypeDefinitionFinishAsClass: + case State::TypeDefinitionFinishAsClass: return DeclarationContext::Class; - case ParserState::TypeDefinitionFinishAsInterface: + case State::TypeDefinitionFinishAsInterface: return DeclarationContext::Interface; - case ParserState::TypeDefinitionFinishAsNamedConstraint: + case State::TypeDefinitionFinishAsNamedConstraint: return DeclarationContext::NamedConstraint; default: llvm_unreachable("Missing handling for a declaration scope"); @@ -410,14 +409,13 @@ auto ParserContext::GetDeclarationContext() -> DeclarationContext { } } CARBON_CHECK(!state_stack_.empty() && - state_stack_[0].state == ParserState::DeclarationScopeLoop); + state_stack_[0].state == State::DeclarationScopeLoop); return DeclarationContext::File; } -auto ParserContext::RecoverFromDeclarationError(StateStackEntry state, - ParseNodeKind parse_node_kind, - bool skip_past_likely_end) - -> void { +auto Context::RecoverFromDeclarationError(StateStackEntry state, + NodeKind parse_node_kind, + bool skip_past_likely_end) -> void { auto token = state.token; if (skip_past_likely_end) { if (auto semi = SkipPastLikelyEnd(token)) { @@ -428,15 +426,14 @@ auto ParserContext::RecoverFromDeclarationError(StateStackEntry state, /*has_error=*/true); } -auto ParserContext::EmitExpectedDeclarationSemi(TokenKind expected_kind) - -> void { +auto Context::EmitExpectedDeclarationSemi(TokenKind expected_kind) -> void { CARBON_DIAGNOSTIC(ExpectedDeclarationSemi, Error, "`{0}` declarations must end with a `;`.", TokenKind); emitter().Emit(*position(), ExpectedDeclarationSemi, expected_kind); } -auto ParserContext::EmitExpectedDeclarationSemiOrDefinition( - TokenKind expected_kind) -> void { +auto Context::EmitExpectedDeclarationSemiOrDefinition(TokenKind expected_kind) + -> void { CARBON_DIAGNOSTIC(ExpectedDeclarationSemiOrDefinition, Error, "`{0}` declarations must either end with a `;` or " "have a `{{ ... }` block for a definition.", @@ -445,7 +442,7 @@ auto ParserContext::EmitExpectedDeclarationSemiOrDefinition( expected_kind); } -auto ParserContext::PrintForStackDump(llvm::raw_ostream& output) const -> void { +auto Context::PrintForStackDump(llvm::raw_ostream& output) const -> void { output << "Parser stack:\n"; for (auto [i, entry] : llvm::enumerate(state_stack_)) { output << "\t" << i << ".\t" << entry.state; @@ -455,12 +452,12 @@ auto ParserContext::PrintForStackDump(llvm::raw_ostream& output) const -> void { PrintTokenForStackDump(output, *position_); } -auto ParserContext::PrintTokenForStackDump(llvm::raw_ostream& output, - TokenizedBuffer::Token token) const +auto Context::PrintTokenForStackDump(llvm::raw_ostream& output, + TokenizedBuffer::Token token) const -> void { output << " @ " << tokens_->GetLineNumber(tokens_->GetLine(token)) << ":" << tokens_->GetColumnNumber(token) << ": token " << token << " : " << tokens_->GetKind(token) << "\n"; } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_context.h b/toolchain/parser/parser_context.h index bdf52f10a225..4ae6f502594f 100644 --- a/toolchain/parser/parser_context.h +++ b/toolchain/parser/parser_context.h @@ -16,11 +16,11 @@ #include "toolchain/parser/parser_state.h" #include "toolchain/parser/precedence.h" -namespace Carbon { +namespace Carbon::Parse { // Context and shared functionality for parser handlers. See parser_state.def // for state documentation. -class ParserContext { +class Context { public: // Possible operator fixities for errors. enum class OperatorFixity : int8_t { Prefix, Infix, Postfix }; @@ -41,8 +41,7 @@ class ParserContext { // Used to track state on state_stack_. struct StateStackEntry { - explicit StateStackEntry(ParserState state, - PrecedenceGroup ambient_precedence, + explicit StateStackEntry(State state, PrecedenceGroup ambient_precedence, PrecedenceGroup lhs_precedence, TokenizedBuffer::Token token, int32_t subtree_start) @@ -59,7 +58,7 @@ class ParserContext { }; // The state. - ParserState state; + State state; // Set to true to indicate that an error was found, and that contextual // error recovery may be needed. bool has_error = false; @@ -75,7 +74,7 @@ class ParserContext { // the first token in the subtree, but may sometimes be a token within. It // will typically be used for the subtree's root node. TokenizedBuffer::Token token; - // The offset within the ParseTree of the subtree start. + // The offset within the Tree of the subtree start. int32_t subtree_start; }; @@ -91,17 +90,17 @@ class ParserContext { static_assert(sizeof(StateStackEntry) == 12, "StateStackEntry has unexpected size!"); - explicit ParserContext(ParseTree& tree, TokenizedBuffer& tokens, - TokenDiagnosticEmitter& emitter, - llvm::raw_ostream* vlog_stream); + explicit Context(Tree& tree, TokenizedBuffer& tokens, + TokenDiagnosticEmitter& emitter, + llvm::raw_ostream* vlog_stream); // Adds a node to the parse tree that has no children (a leaf). - auto AddLeafNode(ParseNodeKind kind, TokenizedBuffer::Token token, + auto AddLeafNode(NodeKind kind, TokenizedBuffer::Token token, bool has_error = false) -> void; // Adds a node to the parse tree that has children. - auto AddNode(ParseNodeKind kind, TokenizedBuffer::Token token, - int subtree_start, bool has_error) -> void; + auto AddNode(NodeKind kind, TokenizedBuffer::Token token, int subtree_start, + bool has_error) -> void; // Returns the current position and moves past it. auto Consume() -> TokenizedBuffer::Token { return *(position_++); } @@ -110,7 +109,7 @@ class ParserContext { // leaf parse node of the specified start kind. The default_token is used when // there's no open paren. Returns the open paren token if it was found. auto ConsumeAndAddOpenParen(TokenizedBuffer::Token default_token, - ParseNodeKind start_kind) + NodeKind start_kind) -> std::optional; // Parses a closing symbol corresponding to the opening symbol @@ -119,12 +118,12 @@ class ParserContext { // an opening symbol, the parse node will be associated with `state.token`, // no input will be consumed, and no diagnostic will be emitted. auto ConsumeAndAddCloseSymbol(TokenizedBuffer::Token expected_open, - StateStackEntry state, ParseNodeKind close_kind) + StateStackEntry state, NodeKind close_kind) -> void; // Composes `ConsumeIf` and `AddLeafNode`, returning false when ConsumeIf // fails. - auto ConsumeAndAddLeafNodeIf(TokenKind token_kind, ParseNodeKind node_kind) + auto ConsumeAndAddLeafNodeIf(TokenKind token_kind, NodeKind node_kind) -> bool; // Returns the current position and moves past it. Requires the token is the @@ -185,7 +184,7 @@ class ParserContext { // `,)`). Handles cases where invalid tokens are present by advancing the // position, and may emit errors. Pass already_has_error in order to suppress // duplicate errors. - auto ConsumeListToken(ParseNodeKind comma_kind, TokenKind close_kind, + auto ConsumeListToken(NodeKind comma_kind, TokenKind close_kind, bool already_has_error) -> ListTokenKind; // Gets the kind of the next token to be consumed. @@ -213,7 +212,7 @@ class ParserContext { } // Pushes a new state with the current position for context. - auto PushState(ParserState state) -> void { + auto PushState(State state) -> void { PushState(StateStackEntry(state, PrecedenceGroup::ForTopLevelExpression(), PrecedenceGroup::ForTopLevelExpression(), *position_, tree_->size())); @@ -221,7 +220,7 @@ class ParserContext { // Pushes a new state with a specific token for context. Used when forming a // new subtree with a token that isn't the start of the subtree. - auto PushState(ParserState state, TokenizedBuffer::Token token) -> void { + auto PushState(State state, TokenizedBuffer::Token token) -> void { PushState(StateStackEntry(state, PrecedenceGroup::ForTopLevelExpression(), PrecedenceGroup::ForTopLevelExpression(), token, tree_->size())); @@ -229,13 +228,13 @@ class ParserContext { // Pushes a new expression state with specific precedence. auto PushStateForExpression(PrecedenceGroup ambient_precedence) -> void { - PushState(StateStackEntry(ParserState::Expression, ambient_precedence, + PushState(StateStackEntry(State::Expression, ambient_precedence, PrecedenceGroup::ForTopLevelExpression(), *position_, tree_->size())); } // Pushes a new state with detailed precedence for expression resume states. - auto PushStateForExpressionLoop(ParserState state, + auto PushStateForExpressionLoop(State state, PrecedenceGroup ambient_precedence, PrecedenceGroup lhs_precedence) -> void { PushState(StateStackEntry(state, ambient_precedence, lhs_precedence, @@ -262,10 +261,9 @@ class ParserContext { // Propagates an error up the state stack, to the parent state. auto ReturnErrorOnState() -> void { state_stack_.back().has_error = true; } - // For ParserHandlePattern, tries to consume a wrapping keyword. - auto ConsumeIfPatternKeyword(TokenKind keyword_token, - ParserState keyword_state, int subtree_start) - -> void; + // For HandlePattern, tries to consume a wrapping keyword. + auto ConsumeIfPatternKeyword(TokenKind keyword_token, State keyword_state, + int subtree_start) -> void; // Emits a diagnostic for a declaration missing a semi. auto EmitExpectedDeclarationSemi(TokenKind expected_kind) -> void; @@ -278,13 +276,13 @@ class ParserContext { // semicolon when it makes sense as a possible end, otherwise use the // introducer token for the error. auto RecoverFromDeclarationError(StateStackEntry state, - ParseNodeKind parse_node_kind, + NodeKind parse_node_kind, bool skip_past_likely_end) -> void; // Prints information for a stack dump. auto PrintForStackDump(llvm::raw_ostream& output) const -> void; - auto tree() const -> const ParseTree& { return *tree_; } + auto tree() const -> const Tree& { return *tree_; } auto tokens() const -> const TokenizedBuffer& { return *tokens_; } @@ -306,7 +304,7 @@ class ParserContext { auto PrintTokenForStackDump(llvm::raw_ostream& output, TokenizedBuffer::Token token) const -> void; - ParseTree* tree_; + Tree* tree_; TokenizedBuffer* tokens_; TokenDiagnosticEmitter* emitter_; @@ -323,10 +321,9 @@ class ParserContext { // `clang-format` has a bug with spacing around `->` returns in macros. See // https://bugs.llvm.org/show_bug.cgi?id=48320 for details. -#define CARBON_PARSER_STATE(Name) \ - auto ParserHandle##Name(ParserContext& context)->void; +#define CARBON_PARSE_STATE(Name) auto Handle##Name(Context& context)->void; #include "toolchain/parser/parser_state.def" -} // namespace Carbon +} // namespace Carbon::Parse #endif // CARBON_TOOLCHAIN_PARSER_PARSER_CONTEXT_H_ diff --git a/toolchain/parser/parser_handle_array_expression.cpp b/toolchain/parser/parser_handle_array_expression.cpp index 9081836e9e38..02c261adba5e 100644 --- a/toolchain/parser/parser_handle_array_expression.cpp +++ b/toolchain/parser/parser_handle_array_expression.cpp @@ -8,43 +8,43 @@ #include "toolchain/parser/parser_context.h" #include "toolchain/parser/parser_state.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleArrayExpression(ParserContext& context) -> void { +auto HandleArrayExpression(Context& context) -> void { auto state = context.PopState(); - state.state = ParserState::ArrayExpressionSemi; - context.AddLeafNode(ParseNodeKind::ArrayExpressionStart, + state.state = State::ArrayExpressionSemi; + context.AddLeafNode(NodeKind::ArrayExpressionStart, context.ConsumeChecked(TokenKind::OpenSquareBracket), state.has_error); context.PushState(state); - context.PushState(ParserState::Expression); + context.PushState(State::Expression); } -auto ParserHandleArrayExpressionSemi(ParserContext& context) -> void { +auto HandleArrayExpressionSemi(Context& context) -> void { auto state = context.PopState(); auto semi = context.ConsumeIf(TokenKind::Semi); if (!semi) { - context.AddNode(ParseNodeKind::ArrayExpressionSemi, *context.position(), + context.AddNode(NodeKind::ArrayExpressionSemi, *context.position(), state.subtree_start, true); CARBON_DIAGNOSTIC(ExpectedArraySemi, Error, "Expected `;` in array type."); context.emitter().Emit(*context.position(), ExpectedArraySemi); state.has_error = true; } else { - context.AddNode(ParseNodeKind::ArrayExpressionSemi, *semi, - state.subtree_start, state.has_error); + context.AddNode(NodeKind::ArrayExpressionSemi, *semi, state.subtree_start, + state.has_error); } - state.state = ParserState::ArrayExpressionFinish; + state.state = State::ArrayExpressionFinish; context.PushState(state); if (!context.PositionIs(TokenKind::CloseSquareBracket)) { - context.PushState(ParserState::Expression); + context.PushState(State::Expression); } } -auto ParserHandleArrayExpressionFinish(ParserContext& context) -> void { +auto HandleArrayExpressionFinish(Context& context) -> void { auto state = context.PopState(); context.ConsumeAndAddCloseSymbol( *(TokenizedBuffer::TokenIterator(state.token)), state, - ParseNodeKind::ArrayExpression); + NodeKind::ArrayExpression); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_brace_expression.cpp b/toolchain/parser/parser_handle_brace_expression.cpp index 7a3ec17da7f8..699c00aa554a 100644 --- a/toolchain/parser/parser_handle_brace_expression.cpp +++ b/toolchain/parser/parser_handle_brace_expression.cpp @@ -4,32 +4,33 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleBraceExpression(ParserContext& context) -> void { +auto HandleBraceExpression(Context& context) -> void { auto state = context.PopState(); - state.state = ParserState::BraceExpressionFinishAsUnknown; + state.state = State::BraceExpressionFinishAsUnknown; context.PushState(state); CARBON_CHECK(context.ConsumeAndAddLeafNodeIf( TokenKind::OpenCurlyBrace, - ParseNodeKind::StructLiteralOrStructTypeLiteralStart)); + NodeKind::StructLiteralOrStructTypeLiteralStart)); if (!context.PositionIs(TokenKind::CloseCurlyBrace)) { - context.PushState(ParserState::BraceExpressionParameterAsUnknown); + context.PushState(State::BraceExpressionParameterAsUnknown); } } // Prints a diagnostic for brace expression syntax errors. -static auto ParserHandleBraceExpressionParameterError( - ParserContext& context, ParserContext::StateStackEntry state, - ParserState param_finish_state) -> void { +static auto HandleBraceExpressionParameterError(Context& context, + Context::StateStackEntry state, + State param_finish_state) + -> void { bool is_type = - param_finish_state == ParserState::BraceExpressionParameterFinishAsType; + param_finish_state == State::BraceExpressionParameterFinishAsType; bool is_value = - param_finish_state == ParserState::BraceExpressionParameterFinishAsValue; - bool is_unknown = param_finish_state == - ParserState::BraceExpressionParameterFinishAsUnknown; + param_finish_state == State::BraceExpressionParameterFinishAsValue; + bool is_unknown = + param_finish_state == State::BraceExpressionParameterFinishAsUnknown; CARBON_CHECK(is_type || is_value || is_unknown); CARBON_DIAGNOSTIC(ExpectedStructLiteralField, Error, "Expected {0}{1}{2}.", llvm::StringRef, llvm::StringRef, llvm::StringRef); @@ -44,46 +45,42 @@ static auto ParserHandleBraceExpressionParameterError( } // Handles BraceExpressionParameterAs(Type|Value|Unknown). -static auto ParserHandleBraceExpressionParameter( - ParserContext& context, ParserState after_designator_state, - ParserState param_finish_state) -> void { +static auto HandleBraceExpressionParameter(Context& context, + State after_designator_state, + State param_finish_state) -> void { auto state = context.PopState(); if (!context.PositionIs(TokenKind::Period)) { - ParserHandleBraceExpressionParameterError(context, state, - param_finish_state); + HandleBraceExpressionParameterError(context, state, param_finish_state); return; } state.state = after_designator_state; context.PushState(state); - context.PushState(ParserState::PeriodAsStruct); + context.PushState(State::PeriodAsStruct); } -auto ParserHandleBraceExpressionParameterAsType(ParserContext& context) - -> void { - ParserHandleBraceExpressionParameter( - context, ParserState::BraceExpressionParameterAfterDesignatorAsType, - ParserState::BraceExpressionParameterFinishAsType); +auto HandleBraceExpressionParameterAsType(Context& context) -> void { + HandleBraceExpressionParameter( + context, State::BraceExpressionParameterAfterDesignatorAsType, + State::BraceExpressionParameterFinishAsType); } -auto ParserHandleBraceExpressionParameterAsValue(ParserContext& context) - -> void { - ParserHandleBraceExpressionParameter( - context, ParserState::BraceExpressionParameterAfterDesignatorAsValue, - ParserState::BraceExpressionParameterFinishAsValue); +auto HandleBraceExpressionParameterAsValue(Context& context) -> void { + HandleBraceExpressionParameter( + context, State::BraceExpressionParameterAfterDesignatorAsValue, + State::BraceExpressionParameterFinishAsValue); } -auto ParserHandleBraceExpressionParameterAsUnknown(ParserContext& context) - -> void { - ParserHandleBraceExpressionParameter( - context, ParserState::BraceExpressionParameterAfterDesignatorAsUnknown, - ParserState::BraceExpressionParameterFinishAsUnknown); +auto HandleBraceExpressionParameterAsUnknown(Context& context) -> void { + HandleBraceExpressionParameter( + context, State::BraceExpressionParameterAfterDesignatorAsUnknown, + State::BraceExpressionParameterFinishAsUnknown); } // Handles BraceExpressionParameterAfterDesignatorAs(Type|Value|Unknown). -static auto ParserHandleBraceExpressionParameterAfterDesignator( - ParserContext& context, ParserState param_finish_state) -> void { +static auto HandleBraceExpressionParameterAfterDesignator( + Context& context, State param_finish_state) -> void { auto state = context.PopState(); if (state.has_error) { @@ -105,33 +102,29 @@ static auto ParserHandleBraceExpressionParameterAfterDesignator( } else if (context.PositionIs(TokenKind::Equal)) { is_type = false; } else { - ParserHandleBraceExpressionParameterError(context, state, - param_finish_state); + HandleBraceExpressionParameterError(context, state, param_finish_state); return; } // If we're changing from unknown, update the related finish states. - if (param_finish_state == - ParserState::BraceExpressionParameterFinishAsUnknown) { + if (param_finish_state == State::BraceExpressionParameterFinishAsUnknown) { auto finish_state = context.PopState(); - CARBON_CHECK(finish_state.state == - ParserState::BraceExpressionFinishAsUnknown); + CARBON_CHECK(finish_state.state == State::BraceExpressionFinishAsUnknown); if (is_type) { - finish_state.state = ParserState::BraceExpressionFinishAsType; - param_finish_state = ParserState::BraceExpressionParameterFinishAsType; + finish_state.state = State::BraceExpressionFinishAsType; + param_finish_state = State::BraceExpressionParameterFinishAsType; } else { - finish_state.state = ParserState::BraceExpressionFinishAsValue; - param_finish_state = ParserState::BraceExpressionParameterFinishAsValue; + finish_state.state = State::BraceExpressionFinishAsValue; + param_finish_state = State::BraceExpressionParameterFinishAsValue; } context.PushState(finish_state); } auto want_param_finish_state = - is_type ? ParserState::BraceExpressionParameterFinishAsType - : ParserState::BraceExpressionParameterFinishAsValue; + is_type ? State::BraceExpressionParameterFinishAsType + : State::BraceExpressionParameterFinishAsValue; if (param_finish_state != want_param_finish_state) { - ParserHandleBraceExpressionParameterError(context, state, - param_finish_state); + HandleBraceExpressionParameterError(context, state, param_finish_state); return; } @@ -140,90 +133,83 @@ static auto ParserHandleBraceExpressionParameterAfterDesignator( state.state = param_finish_state; state.token = context.Consume(); context.PushState(state); - context.PushState(ParserState::Expression); + context.PushState(State::Expression); } -auto ParserHandleBraceExpressionParameterAfterDesignatorAsType( - ParserContext& context) -> void { - ParserHandleBraceExpressionParameterAfterDesignator( - context, ParserState::BraceExpressionParameterFinishAsType); +auto HandleBraceExpressionParameterAfterDesignatorAsType(Context& context) + -> void { + HandleBraceExpressionParameterAfterDesignator( + context, State::BraceExpressionParameterFinishAsType); } -auto ParserHandleBraceExpressionParameterAfterDesignatorAsValue( - ParserContext& context) -> void { - ParserHandleBraceExpressionParameterAfterDesignator( - context, ParserState::BraceExpressionParameterFinishAsValue); +auto HandleBraceExpressionParameterAfterDesignatorAsValue(Context& context) + -> void { + HandleBraceExpressionParameterAfterDesignator( + context, State::BraceExpressionParameterFinishAsValue); } -auto ParserHandleBraceExpressionParameterAfterDesignatorAsUnknown( - ParserContext& context) -> void { - ParserHandleBraceExpressionParameterAfterDesignator( - context, ParserState::BraceExpressionParameterFinishAsUnknown); +auto HandleBraceExpressionParameterAfterDesignatorAsUnknown(Context& context) + -> void { + HandleBraceExpressionParameterAfterDesignator( + context, State::BraceExpressionParameterFinishAsUnknown); } // Handles BraceExpressionParameterFinishAs(Type|Value|Unknown). -static auto ParserHandleBraceExpressionParameterFinish(ParserContext& context, - ParseNodeKind node_kind, - ParserState param_state) - -> void { +static auto HandleBraceExpressionParameterFinish(Context& context, + NodeKind node_kind, + State param_state) -> void { auto state = context.PopState(); if (state.has_error) { - context.AddLeafNode(ParseNodeKind::StructFieldUnknown, state.token, + context.AddLeafNode(NodeKind::StructFieldUnknown, state.token, /*has_error=*/true); } else { context.AddNode(node_kind, state.token, state.subtree_start, /*has_error=*/false); } - if (context.ConsumeListToken(ParseNodeKind::StructComma, + if (context.ConsumeListToken(NodeKind::StructComma, TokenKind::CloseCurlyBrace, state.has_error) == - ParserContext::ListTokenKind::Comma) { + Context::ListTokenKind::Comma) { context.PushState(param_state); } } -auto ParserHandleBraceExpressionParameterFinishAsType(ParserContext& context) - -> void { - ParserHandleBraceExpressionParameterFinish( - context, ParseNodeKind::StructFieldType, - ParserState::BraceExpressionParameterAsType); +auto HandleBraceExpressionParameterFinishAsType(Context& context) -> void { + HandleBraceExpressionParameterFinish(context, NodeKind::StructFieldType, + State::BraceExpressionParameterAsType); } -auto ParserHandleBraceExpressionParameterFinishAsValue(ParserContext& context) - -> void { - ParserHandleBraceExpressionParameterFinish( - context, ParseNodeKind::StructFieldValue, - ParserState::BraceExpressionParameterAsValue); +auto HandleBraceExpressionParameterFinishAsValue(Context& context) -> void { + HandleBraceExpressionParameterFinish(context, NodeKind::StructFieldValue, + State::BraceExpressionParameterAsValue); } -auto ParserHandleBraceExpressionParameterFinishAsUnknown(ParserContext& context) - -> void { - ParserHandleBraceExpressionParameterFinish( - context, ParseNodeKind::StructFieldUnknown, - ParserState::BraceExpressionParameterAsUnknown); +auto HandleBraceExpressionParameterFinishAsUnknown(Context& context) -> void { + HandleBraceExpressionParameterFinish( + context, NodeKind::StructFieldUnknown, + State::BraceExpressionParameterAsUnknown); } // Handles BraceExpressionFinishAs(Type|Value|Unknown). -static auto ParserHandleBraceExpressionFinish(ParserContext& context, - ParseNodeKind node_kind) -> void { +static auto HandleBraceExpressionFinish(Context& context, NodeKind node_kind) + -> void { auto state = context.PopState(); context.AddNode(node_kind, context.Consume(), state.subtree_start, state.has_error); } -auto ParserHandleBraceExpressionFinishAsType(ParserContext& context) -> void { - ParserHandleBraceExpressionFinish(context, ParseNodeKind::StructTypeLiteral); +auto HandleBraceExpressionFinishAsType(Context& context) -> void { + HandleBraceExpressionFinish(context, NodeKind::StructTypeLiteral); } -auto ParserHandleBraceExpressionFinishAsValue(ParserContext& context) -> void { - ParserHandleBraceExpressionFinish(context, ParseNodeKind::StructLiteral); +auto HandleBraceExpressionFinishAsValue(Context& context) -> void { + HandleBraceExpressionFinish(context, NodeKind::StructLiteral); } -auto ParserHandleBraceExpressionFinishAsUnknown(ParserContext& context) - -> void { - ParserHandleBraceExpressionFinish(context, ParseNodeKind::StructLiteral); +auto HandleBraceExpressionFinishAsUnknown(Context& context) -> void { + HandleBraceExpressionFinish(context, NodeKind::StructLiteral); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_call_expression.cpp b/toolchain/parser/parser_handle_call_expression.cpp index 976c85c31c6e..fa317e8ac806 100644 --- a/toolchain/parser/parser_handle_call_expression.cpp +++ b/toolchain/parser/parser_handle_call_expression.cpp @@ -4,42 +4,42 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleCallExpression(ParserContext& context) -> void { +auto HandleCallExpression(Context& context) -> void { auto state = context.PopState(); - state.state = ParserState::CallExpressionFinish; + state.state = State::CallExpressionFinish; context.PushState(state); - context.AddNode(ParseNodeKind::CallExpressionStart, context.Consume(), + context.AddNode(NodeKind::CallExpressionStart, context.Consume(), state.subtree_start, state.has_error); if (!context.PositionIs(TokenKind::CloseParen)) { - context.PushState(ParserState::CallExpressionParameterFinish); - context.PushState(ParserState::Expression); + context.PushState(State::CallExpressionParameterFinish); + context.PushState(State::Expression); } } -auto ParserHandleCallExpressionParameterFinish(ParserContext& context) -> void { +auto HandleCallExpressionParameterFinish(Context& context) -> void { auto state = context.PopState(); if (state.has_error) { context.ReturnErrorOnState(); } - if (context.ConsumeListToken(ParseNodeKind::CallExpressionComma, + if (context.ConsumeListToken(NodeKind::CallExpressionComma, TokenKind::CloseParen, state.has_error) == - ParserContext::ListTokenKind::Comma) { - context.PushState(ParserState::CallExpressionParameterFinish); - context.PushState(ParserState::Expression); + Context::ListTokenKind::Comma) { + context.PushState(State::CallExpressionParameterFinish); + context.PushState(State::Expression); } } -auto ParserHandleCallExpressionFinish(ParserContext& context) -> void { +auto HandleCallExpressionFinish(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::CallExpression, context.Consume(), + context.AddNode(NodeKind::CallExpression, context.Consume(), state.subtree_start, state.has_error); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_code_block.cpp b/toolchain/parser/parser_handle_code_block.cpp index df48807d00c1..6b31c2d44e13 100644 --- a/toolchain/parser/parser_handle_code_block.cpp +++ b/toolchain/parser/parser_handle_code_block.cpp @@ -4,38 +4,38 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleCodeBlock(ParserContext& context) -> void { +auto HandleCodeBlock(Context& context) -> void { context.PopAndDiscardState(); - context.PushState(ParserState::CodeBlockFinish); + context.PushState(State::CodeBlockFinish); if (context.ConsumeAndAddLeafNodeIf(TokenKind::OpenCurlyBrace, - ParseNodeKind::CodeBlockStart)) { - context.PushState(ParserState::StatementScopeLoop); + NodeKind::CodeBlockStart)) { + context.PushState(State::StatementScopeLoop); } else { - context.AddLeafNode(ParseNodeKind::CodeBlockStart, *context.position(), + context.AddLeafNode(NodeKind::CodeBlockStart, *context.position(), /*has_error=*/true); // Recover by parsing a single statement. CARBON_DIAGNOSTIC(ExpectedCodeBlock, Error, "Expected braced code block."); context.emitter().Emit(*context.position(), ExpectedCodeBlock); - context.PushState(ParserState::Statement); + context.PushState(State::Statement); } } -auto ParserHandleCodeBlockFinish(ParserContext& context) -> void { +auto HandleCodeBlockFinish(Context& context) -> void { auto state = context.PopState(); // If the block started with an open curly, this is a close curly. if (context.tokens().GetKind(state.token) == TokenKind::OpenCurlyBrace) { - context.AddNode(ParseNodeKind::CodeBlock, context.Consume(), - state.subtree_start, state.has_error); + context.AddNode(NodeKind::CodeBlock, context.Consume(), state.subtree_start, + state.has_error); } else { - context.AddNode(ParseNodeKind::CodeBlock, state.token, state.subtree_start, + context.AddNode(NodeKind::CodeBlock, state.token, state.subtree_start, /*has_error=*/true); } } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_declaration_name_and_params.cpp b/toolchain/parser/parser_handle_declaration_name_and_params.cpp index e98cd31b8afb..cbd352523800 100644 --- a/toolchain/parser/parser_handle_declaration_name_and_params.cpp +++ b/toolchain/parser/parser_handle_declaration_name_and_params.cpp @@ -4,11 +4,10 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { // Handles DeclarationNameAndParamsAs(Optional|Required). -static auto ParserHandleDeclarationNameAndParams(ParserContext& context, - ParserState after_name) +static auto HandleDeclarationNameAndParams(Context& context, State after_name) -> void { auto state = context.PopState(); @@ -21,11 +20,11 @@ static auto ParserHandleDeclarationNameAndParams(ParserContext& context, // Because there's a qualifier, we process the first segment as an // expression for simplicity. This just means semantics has one less thing // to handle here. - context.AddLeafNode(ParseNodeKind::NameExpression, *identifier); - state.state = ParserState::PeriodAsDeclaration; + context.AddLeafNode(NodeKind::NameExpression, *identifier); + state.state = State::PeriodAsDeclaration; context.PushState(state); } else { - context.AddLeafNode(ParseNodeKind::Name, *identifier); + context.AddLeafNode(NodeKind::Name, *identifier); } } else { CARBON_DIAGNOSTIC(ExpectedDeclarationName, Error, @@ -34,26 +33,23 @@ static auto ParserHandleDeclarationNameAndParams(ParserContext& context, context.emitter().Emit(*context.position(), ExpectedDeclarationName, context.tokens().GetKind(state.token)); context.ReturnErrorOnState(); - context.AddLeafNode(ParseNodeKind::InvalidParse, *context.position()); + context.AddLeafNode(NodeKind::InvalidParse, *context.position()); } } -auto ParserHandleDeclarationNameAndParamsAsNone(ParserContext& context) - -> void { - ParserHandleDeclarationNameAndParams( - context, ParserState::DeclarationNameAndParamsAfterNameAsNone); +auto HandleDeclarationNameAndParamsAsNone(Context& context) -> void { + HandleDeclarationNameAndParams( + context, State::DeclarationNameAndParamsAfterNameAsNone); } -auto ParserHandleDeclarationNameAndParamsAsOptional(ParserContext& context) - -> void { - ParserHandleDeclarationNameAndParams( - context, ParserState::DeclarationNameAndParamsAfterNameAsOptional); +auto HandleDeclarationNameAndParamsAsOptional(Context& context) -> void { + HandleDeclarationNameAndParams( + context, State::DeclarationNameAndParamsAfterNameAsOptional); } -auto ParserHandleDeclarationNameAndParamsAsRequired(ParserContext& context) - -> void { - ParserHandleDeclarationNameAndParams( - context, ParserState::DeclarationNameAndParamsAfterNameAsRequired); +auto HandleDeclarationNameAndParamsAsRequired(Context& context) -> void { + HandleDeclarationNameAndParams( + context, State::DeclarationNameAndParamsAfterNameAsRequired); } enum class Params : int8_t { @@ -62,14 +58,14 @@ enum class Params : int8_t { Required, }; -static auto ParserHandleDeclarationNameAndParamsAfterName( - ParserContext& context, Params params) -> void { +static auto HandleDeclarationNameAndParamsAfterName(Context& context, + Params params) -> void { auto state = context.PopState(); if (context.PositionIs(TokenKind::Period)) { // Continue designator processing. context.PushState(state); - state.state = ParserState::PeriodAsDeclaration; + state.state = State::PeriodAsDeclaration; context.PushState(state); return; } @@ -79,10 +75,10 @@ static auto ParserHandleDeclarationNameAndParamsAfterName( } if (context.PositionIs(TokenKind::OpenSquareBracket)) { - context.PushState(ParserState::DeclarationNameAndParamsAfterDeduced); - context.PushState(ParserState::ParameterListAsDeduced); + context.PushState(State::DeclarationNameAndParamsAfterDeduced); + context.PushState(State::ParameterListAsDeduced); } else if (context.PositionIs(TokenKind::OpenParen)) { - context.PushState(ParserState::ParameterListAsRegular); + context.PushState(State::ParameterListAsRegular); } else if (params == Params::Required) { CARBON_DIAGNOSTIC(ParametersRequiredByIntroducer, Error, "`{0}` requires a `(` for parameters.", TokenKind); @@ -92,27 +88,25 @@ static auto ParserHandleDeclarationNameAndParamsAfterName( } } -auto ParserHandleDeclarationNameAndParamsAfterNameAsNone(ParserContext& context) +auto HandleDeclarationNameAndParamsAfterNameAsNone(Context& context) -> void { + HandleDeclarationNameAndParamsAfterName(context, Params::None); +} + +auto HandleDeclarationNameAndParamsAfterNameAsOptional(Context& context) -> void { - ParserHandleDeclarationNameAndParamsAfterName(context, Params::None); + HandleDeclarationNameAndParamsAfterName(context, Params::Optional); } -auto ParserHandleDeclarationNameAndParamsAfterNameAsOptional( - ParserContext& context) -> void { - ParserHandleDeclarationNameAndParamsAfterName(context, Params::Optional); -} - -auto ParserHandleDeclarationNameAndParamsAfterNameAsRequired( - ParserContext& context) -> void { - ParserHandleDeclarationNameAndParamsAfterName(context, Params::Required); -} - -auto ParserHandleDeclarationNameAndParamsAfterDeduced(ParserContext& context) +auto HandleDeclarationNameAndParamsAfterNameAsRequired(Context& context) -> void { + HandleDeclarationNameAndParamsAfterName(context, Params::Required); +} + +auto HandleDeclarationNameAndParamsAfterDeduced(Context& context) -> void { context.PopAndDiscardState(); if (context.PositionIs(TokenKind::OpenParen)) { - context.PushState(ParserState::ParameterListAsRegular); + context.PushState(State::ParameterListAsRegular); } else { CARBON_DIAGNOSTIC( ParametersRequiredByDeduced, Error, @@ -122,4 +116,4 @@ auto ParserHandleDeclarationNameAndParamsAfterDeduced(ParserContext& context) } } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_declaration_scope_loop.cpp b/toolchain/parser/parser_handle_declaration_scope_loop.cpp index 122c3549fe2f..3488674b55d6 100644 --- a/toolchain/parser/parser_handle_declaration_scope_loop.cpp +++ b/toolchain/parser/parser_handle_declaration_scope_loop.cpp @@ -4,11 +4,10 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { // Handles an unrecognized declaration, adding an error node. -static auto ParserHandleUnrecognizedDeclaration(ParserContext& context) - -> void { +static auto HandleUnrecognizedDeclaration(Context& context) -> void { CARBON_DIAGNOSTIC(UnrecognizedDeclaration, Error, "Unrecognized declaration introducer."); context.emitter().Emit(*context.position(), UnrecognizedDeclaration); @@ -16,11 +15,11 @@ static auto ParserHandleUnrecognizedDeclaration(ParserContext& context) auto semi = context.SkipPastLikelyEnd(cursor); // Locate the EmptyDeclaration at the semi when found, but use the // original cursor location for an error when not. - context.AddLeafNode(ParseNodeKind::EmptyDeclaration, semi ? *semi : cursor, + context.AddLeafNode(NodeKind::EmptyDeclaration, semi ? *semi : cursor, /*has_error=*/true); } -auto ParserHandleDeclarationScopeLoop(ParserContext& context) -> void { +auto HandleDeclarationScopeLoop(Context& context) -> void { // This maintains the current state unless we're at the end of the scope. switch (context.PositionKind()) { @@ -31,38 +30,38 @@ auto ParserHandleDeclarationScopeLoop(ParserContext& context) -> void { break; } case TokenKind::Class: { - context.PushState(ParserState::TypeIntroducerAsClass); + context.PushState(State::TypeIntroducerAsClass); break; } case TokenKind::Constraint: { - context.PushState(ParserState::TypeIntroducerAsNamedConstraint); + context.PushState(State::TypeIntroducerAsNamedConstraint); break; } case TokenKind::Fn: { - context.PushState(ParserState::FunctionIntroducer); + context.PushState(State::FunctionIntroducer); break; } case TokenKind::Interface: { - context.PushState(ParserState::TypeIntroducerAsInterface); + context.PushState(State::TypeIntroducerAsInterface); break; } case TokenKind::Namespace: { - context.PushState(ParserState::Namespace); + context.PushState(State::Namespace); break; } case TokenKind::Semi: { - context.AddLeafNode(ParseNodeKind::EmptyDeclaration, context.Consume()); + context.AddLeafNode(NodeKind::EmptyDeclaration, context.Consume()); break; } case TokenKind::Var: { - context.PushState(ParserState::VarAsSemicolon); + context.PushState(State::VarAsSemicolon); break; } default: { - ParserHandleUnrecognizedDeclaration(context); + HandleUnrecognizedDeclaration(context); break; } } } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_expression.cpp b/toolchain/parser/parser_handle_expression.cpp index ce52f6d1c010..f65f3f82732b 100644 --- a/toolchain/parser/parser_handle_expression.cpp +++ b/toolchain/parser/parser_handle_expression.cpp @@ -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 diff --git a/toolchain/parser/parser_handle_function.cpp b/toolchain/parser/parser_handle_function.cpp index 0f7dc1b8efe6..189efb634bd0 100644 --- a/toolchain/parser/parser_handle_function.cpp +++ b/toolchain/parser/parser_handle_function.cpp @@ -4,72 +4,71 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleFunctionIntroducer(ParserContext& context) -> void { +auto HandleFunctionIntroducer(Context& context) -> void { auto state = context.PopState(); - context.AddLeafNode(ParseNodeKind::FunctionIntroducer, context.Consume()); + context.AddLeafNode(NodeKind::FunctionIntroducer, context.Consume()); - state.state = ParserState::FunctionAfterParameters; + state.state = State::FunctionAfterParameters; context.PushState(state); - context.PushState(ParserState::DeclarationNameAndParamsAsRequired, - state.token); + context.PushState(State::DeclarationNameAndParamsAsRequired, state.token); } -auto ParserHandleFunctionAfterParameters(ParserContext& context) -> void { +auto HandleFunctionAfterParameters(Context& context) -> void { auto state = context.PopState(); // Regardless of whether there's a return type, we'll finish the signature. - state.state = ParserState::FunctionSignatureFinish; + state.state = State::FunctionSignatureFinish; context.PushState(state); // If there is a return type, parse the expression before adding the return // type nod.e if (context.PositionIs(TokenKind::MinusGreater)) { - context.PushState(ParserState::FunctionReturnTypeFinish); + context.PushState(State::FunctionReturnTypeFinish); ++context.position(); context.PushStateForExpression(PrecedenceGroup::ForType()); } } -auto ParserHandleFunctionReturnTypeFinish(ParserContext& context) -> void { +auto HandleFunctionReturnTypeFinish(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::ReturnType, state.token, state.subtree_start, + context.AddNode(NodeKind::ReturnType, state.token, state.subtree_start, state.has_error); } -auto ParserHandleFunctionSignatureFinish(ParserContext& context) -> void { +auto HandleFunctionSignatureFinish(Context& context) -> void { auto state = context.PopState(); switch (context.PositionKind()) { case TokenKind::Semi: { - context.AddNode(ParseNodeKind::FunctionDeclaration, context.Consume(), + context.AddNode(NodeKind::FunctionDeclaration, context.Consume(), state.subtree_start, state.has_error); break; } case TokenKind::OpenCurlyBrace: { if (auto decl_context = context.GetDeclarationContext(); - decl_context == ParserContext::DeclarationContext::Interface || - decl_context == ParserContext::DeclarationContext::NamedConstraint) { + decl_context == Context::DeclarationContext::Interface || + decl_context == Context::DeclarationContext::NamedConstraint) { CARBON_DIAGNOSTIC( MethodImplNotAllowed, Error, "Method implementations are not allowed in interfaces."); context.emitter().Emit(*context.position(), MethodImplNotAllowed); context.RecoverFromDeclarationError(state, - ParseNodeKind::FunctionDeclaration, + NodeKind::FunctionDeclaration, /*skip_past_likely_end=*/true); break; } - context.AddNode(ParseNodeKind::FunctionDefinitionStart, context.Consume(), + context.AddNode(NodeKind::FunctionDefinitionStart, context.Consume(), state.subtree_start, state.has_error); // Any error is recorded on the FunctionDefinitionStart. state.has_error = false; - state.state = ParserState::FunctionDefinitionFinish; + state.state = State::FunctionDefinitionFinish; context.PushState(state); - context.PushState(ParserState::StatementScopeLoop); + context.PushState(State::StatementScopeLoop); break; } default: { @@ -80,17 +79,17 @@ auto ParserHandleFunctionSignatureFinish(ParserContext& context) -> void { bool skip_past_likely_end = context.tokens().GetLine(*context.position()) == context.tokens().GetLine(state.token); - context.RecoverFromDeclarationError( - state, ParseNodeKind::FunctionDeclaration, skip_past_likely_end); + context.RecoverFromDeclarationError(state, NodeKind::FunctionDeclaration, + skip_past_likely_end); break; } } } -auto ParserHandleFunctionDefinitionFinish(ParserContext& context) -> void { +auto HandleFunctionDefinitionFinish(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::FunctionDefinition, context.Consume(), + context.AddNode(NodeKind::FunctionDefinition, context.Consume(), state.subtree_start, state.has_error); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_index_expression.cpp b/toolchain/parser/parser_handle_index_expression.cpp index 114663863553..eddf70ed15c5 100644 --- a/toolchain/parser/parser_handle_index_expression.cpp +++ b/toolchain/parser/parser_handle_index_expression.cpp @@ -5,23 +5,23 @@ #include "toolchain/lexer/token_kind.h" #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleIndexExpression(ParserContext& context) -> void { +auto HandleIndexExpression(Context& context) -> void { auto state = context.PopState(); - state.state = ParserState::IndexExpressionFinish; + state.state = State::IndexExpressionFinish; context.PushState(state); - context.AddNode(ParseNodeKind::IndexExpressionStart, + context.AddNode(NodeKind::IndexExpressionStart, context.ConsumeChecked(TokenKind::OpenSquareBracket), state.subtree_start, state.has_error); - context.PushState(ParserState::Expression); + context.PushState(State::Expression); } -auto ParserHandleIndexExpressionFinish(ParserContext& context) -> void { +auto HandleIndexExpressionFinish(Context& context) -> void { auto state = context.PopState(); context.ConsumeAndAddCloseSymbol(state.token, state, - ParseNodeKind::IndexExpression); + NodeKind::IndexExpression); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_namespace.cpp b/toolchain/parser/parser_handle_namespace.cpp index c4ade164e978..e9108ceb951b 100644 --- a/toolchain/parser/parser_handle_namespace.cpp +++ b/toolchain/parser/parser_handle_namespace.cpp @@ -4,36 +4,36 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleNamespace(ParserContext& context) -> void { +auto HandleNamespace(Context& context) -> void { auto state = context.PopState(); - context.AddLeafNode(ParseNodeKind::NamespaceStart, context.Consume()); + context.AddLeafNode(NodeKind::NamespaceStart, context.Consume()); - state.state = ParserState::NamespaceFinish; + state.state = State::NamespaceFinish; context.PushState(state); - context.PushState(ParserState::DeclarationNameAndParamsAsNone, state.token); + context.PushState(State::DeclarationNameAndParamsAsNone, state.token); } -auto ParserHandleNamespaceFinish(ParserContext& context) -> void { +auto HandleNamespaceFinish(Context& context) -> void { auto state = context.PopState(); if (state.has_error) { - context.RecoverFromDeclarationError(state, ParseNodeKind::Namespace, + context.RecoverFromDeclarationError(state, NodeKind::Namespace, /*skip_past_likely_end=*/true); return; } if (auto semi = context.ConsumeIf(TokenKind::Semi)) { - context.AddNode(ParseNodeKind::Namespace, *semi, state.subtree_start, + context.AddNode(NodeKind::Namespace, *semi, state.subtree_start, state.has_error); } else { context.EmitExpectedDeclarationSemi(TokenKind::Namespace); - context.RecoverFromDeclarationError(state, ParseNodeKind::Namespace, + context.RecoverFromDeclarationError(state, NodeKind::Namespace, /*skip_past_likely_end=*/true); } } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_package.cpp b/toolchain/parser/parser_handle_package.cpp index 700239ff4080..2c337f268799 100644 --- a/toolchain/parser/parser_handle_package.cpp +++ b/toolchain/parser/parser_handle_package.cpp @@ -4,23 +4,22 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandlePackage(ParserContext& context) -> void { +auto HandlePackage(Context& context) -> void { auto state = context.PopState(); - context.AddLeafNode(ParseNodeKind::PackageIntroducer, context.Consume()); + context.AddLeafNode(NodeKind::PackageIntroducer, context.Consume()); auto exit_on_parse_error = [&]() { auto semi_token = context.SkipPastLikelyEnd(state.token); - return context.AddNode(ParseNodeKind::PackageDirective, + return context.AddNode(NodeKind::PackageDirective, semi_token ? *semi_token : state.token, state.subtree_start, /*has_error=*/true); }; - if (!context.ConsumeAndAddLeafNodeIf(TokenKind::Identifier, - ParseNodeKind::Name)) { + if (!context.ConsumeAndAddLeafNodeIf(TokenKind::Identifier, NodeKind::Name)) { CARBON_DIAGNOSTIC(ExpectedIdentifierAfterPackage, Error, "Expected identifier after `package`."); context.emitter().Emit(*context.position(), ExpectedIdentifierAfterPackage); @@ -33,7 +32,7 @@ auto ParserHandlePackage(ParserContext& context) -> void { auto library_start = context.tree().size(); if (!context.ConsumeAndAddLeafNodeIf(TokenKind::StringLiteral, - ParseNodeKind::Literal)) { + NodeKind::Literal)) { CARBON_DIAGNOSTIC( ExpectedLibraryName, Error, "Expected a string literal to specify the library name."); @@ -42,8 +41,7 @@ auto ParserHandlePackage(ParserContext& context) -> void { return; } - context.AddNode(ParseNodeKind::PackageLibrary, *library_token, - library_start, + context.AddNode(NodeKind::PackageLibrary, *library_token, library_start, /*has_error=*/false); library_parsed = true; } @@ -51,11 +49,11 @@ auto ParserHandlePackage(ParserContext& context) -> void { switch (auto api_or_impl_token = context.tokens().GetKind(*(context.position()))) { case TokenKind::Api: { - context.AddLeafNode(ParseNodeKind::PackageApi, context.Consume()); + context.AddLeafNode(NodeKind::PackageApi, context.Consume()); break; } case TokenKind::Impl: { - context.AddLeafNode(ParseNodeKind::PackageImpl, context.Consume()); + context.AddLeafNode(NodeKind::PackageImpl, context.Consume()); break; } default: { @@ -82,9 +80,9 @@ auto ParserHandlePackage(ParserContext& context) -> void { return; } - context.AddNode(ParseNodeKind::PackageDirective, context.Consume(), + context.AddNode(NodeKind::PackageDirective, context.Consume(), state.subtree_start, /*has_error=*/false); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_parameter.cpp b/toolchain/parser/parser_handle_parameter.cpp index 3eb1e6c7190e..e6eece27a530 100644 --- a/toolchain/parser/parser_handle_parameter.cpp +++ b/toolchain/parser/parser_handle_parameter.cpp @@ -4,62 +4,58 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { // Handles ParameterAs(Deduced|Regular). -static auto ParserHandleParameter(ParserContext& context, - ParserState pattern_state, - ParserState finish_state) -> void { +static auto HandleParameter(Context& context, State pattern_state, + State finish_state) -> void { context.PopAndDiscardState(); context.PushState(finish_state); context.PushState(pattern_state); } -auto ParserHandleParameterAsDeduced(ParserContext& context) -> void { - ParserHandleParameter(context, ParserState::PatternAsDeducedParameter, - ParserState::ParameterFinishAsDeduced); +auto HandleParameterAsDeduced(Context& context) -> void { + HandleParameter(context, State::PatternAsDeducedParameter, + State::ParameterFinishAsDeduced); } -auto ParserHandleParameterAsRegular(ParserContext& context) -> void { - ParserHandleParameter(context, ParserState::PatternAsParameter, - ParserState::ParameterFinishAsRegular); +auto HandleParameterAsRegular(Context& context) -> void { + HandleParameter(context, State::PatternAsParameter, + State::ParameterFinishAsRegular); } // Handles ParameterFinishAs(Deduced|Regular). -static auto ParserHandleParameterFinish(ParserContext& context, - TokenKind close_token, - ParserState param_state) -> void { +static auto HandleParameterFinish(Context& context, TokenKind close_token, + State param_state) -> void { auto state = context.PopState(); if (state.has_error) { context.ReturnErrorOnState(); } - if (context.ConsumeListToken(ParseNodeKind::ParameterListComma, close_token, + if (context.ConsumeListToken(NodeKind::ParameterListComma, close_token, state.has_error) == - ParserContext::ListTokenKind::Comma) { + Context::ListTokenKind::Comma) { context.PushState(param_state); } } -auto ParserHandleParameterFinishAsDeduced(ParserContext& context) -> void { - ParserHandleParameterFinish(context, TokenKind::CloseSquareBracket, - ParserState::ParameterAsDeduced); +auto HandleParameterFinishAsDeduced(Context& context) -> void { + HandleParameterFinish(context, TokenKind::CloseSquareBracket, + State::ParameterAsDeduced); } -auto ParserHandleParameterFinishAsRegular(ParserContext& context) -> void { - ParserHandleParameterFinish(context, TokenKind::CloseParen, - ParserState::ParameterAsRegular); +auto HandleParameterFinishAsRegular(Context& context) -> void { + HandleParameterFinish(context, TokenKind::CloseParen, + State::ParameterAsRegular); } // Handles ParameterListAs(Deduced|Regular). -static auto ParserHandleParameterList(ParserContext& context, - ParseNodeKind parse_node_kind, - TokenKind open_token_kind, - TokenKind close_token_kind, - ParserState param_state, - ParserState finish_state) -> void { +static auto HandleParameterList(Context& context, NodeKind parse_node_kind, + TokenKind open_token_kind, + TokenKind close_token_kind, State param_state, + State finish_state) -> void { context.PopAndDiscardState(); context.PushState(finish_state); @@ -70,39 +66,38 @@ static auto ParserHandleParameterList(ParserContext& context, } } -auto ParserHandleParameterListAsDeduced(ParserContext& context) -> void { - ParserHandleParameterList(context, ParseNodeKind::DeducedParameterListStart, - TokenKind::OpenSquareBracket, - TokenKind::CloseSquareBracket, - ParserState::ParameterAsDeduced, - ParserState::ParameterListFinishAsDeduced); +auto HandleParameterListAsDeduced(Context& context) -> void { + HandleParameterList(context, NodeKind::DeducedParameterListStart, + TokenKind::OpenSquareBracket, + TokenKind::CloseSquareBracket, State::ParameterAsDeduced, + State::ParameterListFinishAsDeduced); } -auto ParserHandleParameterListAsRegular(ParserContext& context) -> void { - ParserHandleParameterList(context, ParseNodeKind::ParameterListStart, - TokenKind::OpenParen, TokenKind::CloseParen, - ParserState::ParameterAsRegular, - ParserState::ParameterListFinishAsRegular); +auto HandleParameterListAsRegular(Context& context) -> void { + HandleParameterList(context, NodeKind::ParameterListStart, + TokenKind::OpenParen, TokenKind::CloseParen, + State::ParameterAsRegular, + State::ParameterListFinishAsRegular); } // Handles ParameterListFinishAs(Deduced|Regular). -static auto ParserHandleParameterListFinish(ParserContext& context, - ParseNodeKind parse_node_kind, - TokenKind token_kind) -> void { +static auto HandleParameterListFinish(Context& context, + NodeKind parse_node_kind, + TokenKind token_kind) -> void { auto state = context.PopState(); context.AddNode(parse_node_kind, context.ConsumeChecked(token_kind), state.subtree_start, state.has_error); } -auto ParserHandleParameterListFinishAsDeduced(ParserContext& context) -> void { - ParserHandleParameterListFinish(context, ParseNodeKind::DeducedParameterList, - TokenKind::CloseSquareBracket); +auto HandleParameterListFinishAsDeduced(Context& context) -> void { + HandleParameterListFinish(context, NodeKind::DeducedParameterList, + TokenKind::CloseSquareBracket); } -auto ParserHandleParameterListFinishAsRegular(ParserContext& context) -> void { - ParserHandleParameterListFinish(context, ParseNodeKind::ParameterList, - TokenKind::CloseParen); +auto HandleParameterListFinishAsRegular(Context& context) -> void { + HandleParameterListFinish(context, NodeKind::ParameterList, + TokenKind::CloseParen); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_paren_condition.cpp b/toolchain/parser/parser_handle_paren_condition.cpp index c12d0ec96482..ece601ddb314 100644 --- a/toolchain/parser/parser_handle_paren_condition.cpp +++ b/toolchain/parser/parser_handle_paren_condition.cpp @@ -4,12 +4,11 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { // Handles ParenConditionAs(If|While). -static auto ParserHandleParenCondition(ParserContext& context, - ParseNodeKind start_kind, - ParserState finish_state) -> void { +static auto HandleParenCondition(Context& context, NodeKind start_kind, + State finish_state) -> void { auto state = context.PopState(); std::optional open_paren = @@ -24,35 +23,34 @@ static auto ParserHandleParenCondition(ParserContext& context, // For an open curly, assume the condition was completely omitted. // Expression parsing would treat the { as a struct, but instead assume it's // a code block and just emit an invalid parse. - context.AddLeafNode(ParseNodeKind::InvalidParse, *context.position(), + context.AddLeafNode(NodeKind::InvalidParse, *context.position(), /*has_error=*/true); } else { - context.PushState(ParserState::Expression); + context.PushState(State::Expression); } } -auto ParserHandleParenConditionAsIf(ParserContext& context) -> void { - ParserHandleParenCondition(context, ParseNodeKind::IfConditionStart, - ParserState::ParenConditionFinishAsIf); +auto HandleParenConditionAsIf(Context& context) -> void { + HandleParenCondition(context, NodeKind::IfConditionStart, + State::ParenConditionFinishAsIf); } -auto ParserHandleParenConditionAsWhile(ParserContext& context) -> void { - ParserHandleParenCondition(context, ParseNodeKind::WhileConditionStart, - ParserState::ParenConditionFinishAsWhile); +auto HandleParenConditionAsWhile(Context& context) -> void { + HandleParenCondition(context, NodeKind::WhileConditionStart, + State::ParenConditionFinishAsWhile); } -auto ParserHandleParenConditionFinishAsIf(ParserContext& context) -> void { +auto HandleParenConditionFinishAsIf(Context& context) -> void { + auto state = context.PopState(); + + context.ConsumeAndAddCloseSymbol(state.token, state, NodeKind::IfCondition); +} + +auto HandleParenConditionFinishAsWhile(Context& context) -> void { auto state = context.PopState(); context.ConsumeAndAddCloseSymbol(state.token, state, - ParseNodeKind::IfCondition); + NodeKind::WhileCondition); } -auto ParserHandleParenConditionFinishAsWhile(ParserContext& context) -> void { - auto state = context.PopState(); - - context.ConsumeAndAddCloseSymbol(state.token, state, - ParseNodeKind::WhileCondition); -} - -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_paren_expression.cpp b/toolchain/parser/parser_handle_paren_expression.cpp index d6b21732c888..5190a07ed60f 100644 --- a/toolchain/parser/parser_handle_paren_expression.cpp +++ b/toolchain/parser/parser_handle_paren_expression.cpp @@ -4,34 +4,34 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleParenExpression(ParserContext& context) -> void { +auto HandleParenExpression(Context& context) -> void { auto state = context.PopState(); // Advance past the open paren. - context.AddLeafNode(ParseNodeKind::ParenExpressionOrTupleLiteralStart, + context.AddLeafNode(NodeKind::ParenExpressionOrTupleLiteralStart, context.ConsumeChecked(TokenKind::OpenParen)); if (context.PositionIs(TokenKind::CloseParen)) { - state.state = ParserState::ParenExpressionFinishAsTuple; + state.state = State::ParenExpressionFinishAsTuple; context.PushState(state); } else { - state.state = ParserState::ParenExpressionFinishAsNormal; + state.state = State::ParenExpressionFinishAsNormal; context.PushState(state); - context.PushState(ParserState::ParenExpressionParameterFinishAsUnknown); - context.PushState(ParserState::Expression); + context.PushState(State::ParenExpressionParameterFinishAsUnknown); + context.PushState(State::Expression); } } // Handles ParenExpressionParameterFinishAs(Unknown|Tuple). -static auto ParserHandleParenExpressionParameterFinish(ParserContext& context, - bool as_tuple) -> void { +static auto HandleParenExpressionParameterFinish(Context& context, + bool as_tuple) -> void { auto state = context.PopState(); auto list_token_kind = context.ConsumeListToken( - ParseNodeKind::TupleLiteralComma, TokenKind::CloseParen, state.has_error); - if (list_token_kind == ParserContext::ListTokenKind::Close) { + NodeKind::TupleLiteralComma, TokenKind::CloseParen, state.has_error); + if (list_token_kind == Context::ListTokenKind::Close) { return; } @@ -39,45 +39,42 @@ static auto ParserHandleParenExpressionParameterFinish(ParserContext& context, // Note this could be `(expr,)` so we may not reuse the current state, but // it's still necessary to switch the parent. if (!as_tuple) { - state.state = ParserState::ParenExpressionParameterFinishAsTuple; + state.state = State::ParenExpressionParameterFinishAsTuple; auto finish_state = context.PopState(); - CARBON_CHECK(finish_state.state == - ParserState::ParenExpressionFinishAsNormal) + CARBON_CHECK(finish_state.state == State::ParenExpressionFinishAsNormal) << "Unexpected parent state, found: " << finish_state.state; - finish_state.state = ParserState::ParenExpressionFinishAsTuple; + finish_state.state = State::ParenExpressionFinishAsTuple; context.PushState(finish_state); } // On a comma, push another expression handler. - if (list_token_kind == ParserContext::ListTokenKind::Comma) { + if (list_token_kind == Context::ListTokenKind::Comma) { context.PushState(state); - context.PushState(ParserState::Expression); + context.PushState(State::Expression); } } -auto ParserHandleParenExpressionParameterFinishAsUnknown(ParserContext& context) - -> void { - ParserHandleParenExpressionParameterFinish(context, /*as_tuple=*/false); +auto HandleParenExpressionParameterFinishAsUnknown(Context& context) -> void { + HandleParenExpressionParameterFinish(context, /*as_tuple=*/false); } -auto ParserHandleParenExpressionParameterFinishAsTuple(ParserContext& context) - -> void { - ParserHandleParenExpressionParameterFinish(context, /*as_tuple=*/true); +auto HandleParenExpressionParameterFinishAsTuple(Context& context) -> void { + HandleParenExpressionParameterFinish(context, /*as_tuple=*/true); } -auto ParserHandleParenExpressionFinishAsNormal(ParserContext& context) -> void { +auto HandleParenExpressionFinishAsNormal(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::ParenExpression, context.Consume(), + context.AddNode(NodeKind::ParenExpression, context.Consume(), state.subtree_start, state.has_error); } -auto ParserHandleParenExpressionFinishAsTuple(ParserContext& context) -> void { +auto HandleParenExpressionFinishAsTuple(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::TupleLiteral, context.Consume(), + context.AddNode(NodeKind::TupleLiteral, context.Consume(), state.subtree_start, state.has_error); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_pattern.cpp b/toolchain/parser/parser_handle_pattern.cpp index e15886194c20..05bfca33aaa8 100644 --- a/toolchain/parser/parser_handle_pattern.cpp +++ b/toolchain/parser/parser_handle_pattern.cpp @@ -4,34 +4,33 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { // Handles PatternAs(DeducedParameter|FunctionParameter|Variable). -static auto ParserHandlePattern(ParserContext& context, - ParserContext::PatternKind pattern_kind) +static auto HandlePattern(Context& context, Context::PatternKind pattern_kind) -> void { auto state = context.PopState(); // Parameters may have keywords prefixing the pattern. They become the parent // for the full PatternBinding. - if (pattern_kind != ParserContext::PatternKind::Variable) { - context.ConsumeIfPatternKeyword( - TokenKind::Template, ParserState::PatternTemplate, state.subtree_start); - context.ConsumeIfPatternKeyword( - TokenKind::Addr, ParserState::PatternAddress, state.subtree_start); + if (pattern_kind != Context::PatternKind::Variable) { + context.ConsumeIfPatternKeyword(TokenKind::Template, State::PatternTemplate, + state.subtree_start); + context.ConsumeIfPatternKeyword(TokenKind::Addr, State::PatternAddress, + state.subtree_start); } - // ParserHandle an invalid pattern introducer for parameters and variables. + // Handle an invalid pattern introducer for parameters and variables. auto on_error = [&]() { switch (pattern_kind) { - case ParserContext::PatternKind::DeducedParameter: - case ParserContext::PatternKind::Parameter: { + case Context::PatternKind::DeducedParameter: + case Context::PatternKind::Parameter: { CARBON_DIAGNOSTIC(ExpectedParameterName, Error, "Expected parameter declaration."); context.emitter().Emit(*context.position(), ExpectedParameterName); break; } - case ParserContext::PatternKind::Variable: { + case Context::PatternKind::Variable: { CARBON_DIAGNOSTIC(ExpectedVariableName, Error, "Expected pattern in `var` declaration."); context.emitter().Emit(*context.position(), ExpectedVariableName); @@ -39,9 +38,9 @@ static auto ParserHandlePattern(ParserContext& context, } } // Add a placeholder for the type. - context.AddLeafNode(ParseNodeKind::InvalidParse, *context.position(), + context.AddLeafNode(NodeKind::InvalidParse, *context.position(), /*has_error=*/true); - state.state = ParserState::PatternFinishAsRegular; + state.state = State::PatternFinishAsRegular; state.has_error = true; context.PushState(state); }; @@ -49,17 +48,17 @@ static auto ParserHandlePattern(ParserContext& context, // The first item should be an identifier or, for deduced parameters, `self`. bool has_name = false; if (auto identifier = context.ConsumeIf(TokenKind::Identifier)) { - context.AddLeafNode(ParseNodeKind::Name, *identifier); + context.AddLeafNode(NodeKind::Name, *identifier); has_name = true; - } else if (pattern_kind == ParserContext::PatternKind::DeducedParameter) { + } else if (pattern_kind == Context::PatternKind::DeducedParameter) { if (auto self = context.ConsumeIf(TokenKind::SelfValueIdentifier)) { - context.AddLeafNode(ParseNodeKind::SelfValueName, *self); + context.AddLeafNode(NodeKind::SelfValueName, *self); has_name = true; } } if (!has_name) { // Add a placeholder for the name. - context.AddLeafNode(ParseNodeKind::Name, *context.position(), + context.AddLeafNode(NodeKind::Name, *context.position(), /*has_error=*/true); on_error(); return; @@ -67,9 +66,8 @@ static auto ParserHandlePattern(ParserContext& context, if (auto kind = context.PositionKind(); kind == TokenKind::Colon || kind == TokenKind::ColonExclaim) { - state.state = kind == TokenKind::Colon - ? ParserState::PatternFinishAsRegular - : ParserState::PatternFinishAsGeneric; + state.state = kind == TokenKind::Colon ? State::PatternFinishAsRegular + : State::PatternFinishAsGeneric; // Use the `:` or `:!` for the root node. state.token = context.Consume(); context.PushState(state); @@ -80,21 +78,20 @@ static auto ParserHandlePattern(ParserContext& context, } } -auto ParserHandlePatternAsDeducedParameter(ParserContext& context) -> void { - ParserHandlePattern(context, ParserContext::PatternKind::DeducedParameter); +auto HandlePatternAsDeducedParameter(Context& context) -> void { + HandlePattern(context, Context::PatternKind::DeducedParameter); } -auto ParserHandlePatternAsParameter(ParserContext& context) -> void { - ParserHandlePattern(context, ParserContext::PatternKind::Parameter); +auto HandlePatternAsParameter(Context& context) -> void { + HandlePattern(context, Context::PatternKind::Parameter); } -auto ParserHandlePatternAsVariable(ParserContext& context) -> void { - ParserHandlePattern(context, ParserContext::PatternKind::Variable); +auto HandlePatternAsVariable(Context& context) -> void { + HandlePattern(context, Context::PatternKind::Variable); } // Handles PatternFinishAs(Generic|Regular). -static auto ParserHandlePatternFinish(ParserContext& context, - ParseNodeKind node_kind) -> void { +static auto HandlePatternFinish(Context& context, NodeKind node_kind) -> void { auto state = context.PopState(); context.AddNode(node_kind, state.token, state.subtree_start, state.has_error); @@ -106,18 +103,18 @@ static auto ParserHandlePatternFinish(ParserContext& context, } } -auto ParserHandlePatternFinishAsGeneric(ParserContext& context) -> void { - ParserHandlePatternFinish(context, ParseNodeKind::GenericPatternBinding); +auto HandlePatternFinishAsGeneric(Context& context) -> void { + HandlePatternFinish(context, NodeKind::GenericPatternBinding); } -auto ParserHandlePatternFinishAsRegular(ParserContext& context) -> void { - ParserHandlePatternFinish(context, ParseNodeKind::PatternBinding); +auto HandlePatternFinishAsRegular(Context& context) -> void { + HandlePatternFinish(context, NodeKind::PatternBinding); } -auto ParserHandlePatternAddress(ParserContext& context) -> void { +auto HandlePatternAddress(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::Address, state.token, state.subtree_start, + context.AddNode(NodeKind::Address, state.token, state.subtree_start, state.has_error); // If an error was encountered, propagate it while adding a node. @@ -126,10 +123,10 @@ auto ParserHandlePatternAddress(ParserContext& context) -> void { } } -auto ParserHandlePatternTemplate(ParserContext& context) -> void { +auto HandlePatternTemplate(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::Template, state.token, state.subtree_start, + context.AddNode(NodeKind::Template, state.token, state.subtree_start, state.has_error); // If an error was encountered, propagate it while adding a node. @@ -138,4 +135,4 @@ auto ParserHandlePatternTemplate(ParserContext& context) -> void { } } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_period.cpp b/toolchain/parser/parser_handle_period.cpp index ee18f974361a..4188a3aa399a 100644 --- a/toolchain/parser/parser_handle_period.cpp +++ b/toolchain/parser/parser_handle_period.cpp @@ -4,22 +4,20 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { // Handles PeriodAs variants and ArrowExpression. // TODO: This currently only supports identifiers on the rhs, but will in the // future need to handle things like `object.(Interface.member)` for qualifiers. -static auto ParserHandlePeriodOrArrow(ParserContext& context, - ParseNodeKind node_kind, bool is_arrow) - -> void { +static auto HandlePeriodOrArrow(Context& context, NodeKind node_kind, + bool is_arrow) -> void { auto state = context.PopState(); // `.` identifier auto dot = context.ConsumeChecked(is_arrow ? TokenKind::MinusGreater : TokenKind::Period); - if (!context.ConsumeAndAddLeafNodeIf(TokenKind::Identifier, - ParseNodeKind::Name)) { + if (!context.ConsumeAndAddLeafNodeIf(TokenKind::Identifier, NodeKind::Name)) { CARBON_DIAGNOSTIC(ExpectedIdentifierAfterDotOrArrow, Error, "Expected identifier after `{0}`.", llvm::StringRef); context.emitter().Emit(*context.position(), @@ -28,10 +26,10 @@ static auto ParserHandlePeriodOrArrow(ParserContext& context, // If we see a keyword, assume it was intended to be a name. // TODO: Should keywords be valid here? if (context.PositionKind().is_keyword()) { - context.AddLeafNode(ParseNodeKind::Name, context.Consume(), + context.AddLeafNode(NodeKind::Name, context.Consume(), /*has_error=*/true); } else { - context.AddLeafNode(ParseNodeKind::Name, *context.position(), + context.AddLeafNode(NodeKind::Name, *context.position(), /*has_error=*/true); // Indicate the error to the parent state so that it can avoid producing // more errors. @@ -42,24 +40,24 @@ static auto ParserHandlePeriodOrArrow(ParserContext& context, context.AddNode(node_kind, dot, state.subtree_start, state.has_error); } -auto ParserHandlePeriodAsDeclaration(ParserContext& context) -> void { - ParserHandlePeriodOrArrow(context, ParseNodeKind::QualifiedDeclaration, - /*is_arrow=*/false); +auto HandlePeriodAsDeclaration(Context& context) -> void { + HandlePeriodOrArrow(context, NodeKind::QualifiedDeclaration, + /*is_arrow=*/false); } -auto ParserHandlePeriodAsExpression(ParserContext& context) -> void { - ParserHandlePeriodOrArrow(context, ParseNodeKind::MemberAccessExpression, - /*is_arrow=*/false); +auto HandlePeriodAsExpression(Context& context) -> void { + HandlePeriodOrArrow(context, NodeKind::MemberAccessExpression, + /*is_arrow=*/false); } -auto ParserHandlePeriodAsStruct(ParserContext& context) -> void { - ParserHandlePeriodOrArrow(context, ParseNodeKind::StructFieldDesignator, - /*is_arrow=*/false); +auto HandlePeriodAsStruct(Context& context) -> void { + HandlePeriodOrArrow(context, NodeKind::StructFieldDesignator, + /*is_arrow=*/false); } -auto ParserHandleArrowExpression(ParserContext& context) -> void { - ParserHandlePeriodOrArrow( - context, ParseNodeKind::PointerMemberAccessExpression, /*is_arrow=*/true); +auto HandleArrowExpression(Context& context) -> void { + HandlePeriodOrArrow(context, NodeKind::PointerMemberAccessExpression, + /*is_arrow=*/true); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_statement.cpp b/toolchain/parser/parser_handle_statement.cpp index 6fe7249958ae..91fe7cd5312b 100644 --- a/toolchain/parser/parser_handle_statement.cpp +++ b/toolchain/parser/parser_handle_statement.cpp @@ -4,48 +4,46 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { -auto ParserHandleStatement(ParserContext& context) -> void { +auto HandleStatement(Context& context) -> void { context.PopAndDiscardState(); switch (context.PositionKind()) { case TokenKind::Break: { - context.PushState(ParserState::StatementBreakFinish); - context.AddLeafNode(ParseNodeKind::BreakStatementStart, - context.Consume()); + context.PushState(State::StatementBreakFinish); + context.AddLeafNode(NodeKind::BreakStatementStart, context.Consume()); break; } case TokenKind::Continue: { - context.PushState(ParserState::StatementContinueFinish); - context.AddLeafNode(ParseNodeKind::ContinueStatementStart, - context.Consume()); + context.PushState(State::StatementContinueFinish); + context.AddLeafNode(NodeKind::ContinueStatementStart, context.Consume()); break; } case TokenKind::For: { - context.PushState(ParserState::StatementForFinish); - context.PushState(ParserState::StatementForHeader); + context.PushState(State::StatementForFinish); + context.PushState(State::StatementForHeader); ++context.position(); break; } case TokenKind::If: { - context.PushState(ParserState::StatementIf); + context.PushState(State::StatementIf); break; } case TokenKind::Return: { - context.PushState(ParserState::StatementReturn); + context.PushState(State::StatementReturn); break; } case TokenKind::Var: { - context.PushState(ParserState::VarAsSemicolon); + context.PushState(State::VarAsSemicolon); break; } case TokenKind::While: { - context.PushState(ParserState::StatementWhile); + context.PushState(State::StatementWhile); break; } default: { - context.PushState(ParserState::ExpressionStatementFinish); + context.PushState(State::ExpressionStatementFinish); context.PushStateForExpression(PrecedenceGroup::ForExpressionStatement()); break; } @@ -53,8 +51,7 @@ auto ParserHandleStatement(ParserContext& context) -> void { } // Handles the `;` after a keyword statement. -static auto ParserHandleStatementKeywordFinish(ParserContext& context, - ParseNodeKind node_kind) +static auto HandleStatementKeywordFinish(Context& context, NodeKind node_kind) -> void { auto state = context.PopState(); @@ -75,28 +72,27 @@ static auto ParserHandleStatementKeywordFinish(ParserContext& context, context.AddNode(node_kind, *semi, state.subtree_start, state.has_error); } -auto ParserHandleStatementBreakFinish(ParserContext& context) -> void { - ParserHandleStatementKeywordFinish(context, ParseNodeKind::BreakStatement); +auto HandleStatementBreakFinish(Context& context) -> void { + HandleStatementKeywordFinish(context, NodeKind::BreakStatement); } -auto ParserHandleStatementContinueFinish(ParserContext& context) -> void { - ParserHandleStatementKeywordFinish(context, ParseNodeKind::ContinueStatement); +auto HandleStatementContinueFinish(Context& context) -> void { + HandleStatementKeywordFinish(context, NodeKind::ContinueStatement); } -auto ParserHandleStatementForHeader(ParserContext& context) -> void { +auto HandleStatementForHeader(Context& context) -> void { auto state = context.PopState(); std::optional open_paren = - context.ConsumeAndAddOpenParen(state.token, - ParseNodeKind::ForHeaderStart); + context.ConsumeAndAddOpenParen(state.token, NodeKind::ForHeaderStart); if (open_paren) { state.token = *open_paren; } - state.state = ParserState::StatementForHeaderIn; + state.state = State::StatementForHeaderIn; if (context.PositionIs(TokenKind::Var)) { context.PushState(state); - context.PushState(ParserState::VarAsFor); + context.PushState(State::VarAsFor); } else { CARBON_DIAGNOSTIC(ExpectedVariableDeclaration, Error, "Expected `var` declaration."); @@ -111,85 +107,83 @@ auto ParserHandleStatementForHeader(ParserContext& context) -> void { } } -auto ParserHandleStatementForHeaderIn(ParserContext& context) -> void { +auto HandleStatementForHeaderIn(Context& context) -> void { auto state = context.PopState(); - state.state = ParserState::StatementForHeaderFinish; + state.state = State::StatementForHeaderFinish; context.PushState(state); - context.PushState(ParserState::Expression); + context.PushState(State::Expression); } -auto ParserHandleStatementForHeaderFinish(ParserContext& context) -> void { +auto HandleStatementForHeaderFinish(Context& context) -> void { auto state = context.PopState(); - context.ConsumeAndAddCloseSymbol(state.token, state, - ParseNodeKind::ForHeader); + context.ConsumeAndAddCloseSymbol(state.token, state, NodeKind::ForHeader); - context.PushState(ParserState::CodeBlock); + context.PushState(State::CodeBlock); } -auto ParserHandleStatementForFinish(ParserContext& context) -> void { +auto HandleStatementForFinish(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::ForStatement, state.token, state.subtree_start, + context.AddNode(NodeKind::ForStatement, state.token, state.subtree_start, state.has_error); } -auto ParserHandleStatementIf(ParserContext& context) -> void { +auto HandleStatementIf(Context& context) -> void { context.PopAndDiscardState(); - context.PushState(ParserState::StatementIfConditionFinish); - context.PushState(ParserState::ParenConditionAsIf); + context.PushState(State::StatementIfConditionFinish); + context.PushState(State::ParenConditionAsIf); ++context.position(); } -auto ParserHandleStatementIfConditionFinish(ParserContext& context) -> void { +auto HandleStatementIfConditionFinish(Context& context) -> void { auto state = context.PopState(); - state.state = ParserState::StatementIfThenBlockFinish; + state.state = State::StatementIfThenBlockFinish; context.PushState(state); - context.PushState(ParserState::CodeBlock); + context.PushState(State::CodeBlock); } -auto ParserHandleStatementIfThenBlockFinish(ParserContext& context) -> void { +auto HandleStatementIfThenBlockFinish(Context& context) -> void { auto state = context.PopState(); if (context.ConsumeAndAddLeafNodeIf(TokenKind::Else, - ParseNodeKind::IfStatementElse)) { - state.state = ParserState::StatementIfElseBlockFinish; + NodeKind::IfStatementElse)) { + state.state = State::StatementIfElseBlockFinish; context.PushState(state); // `else if` is permitted as a special case. - context.PushState(context.PositionIs(TokenKind::If) - ? ParserState::StatementIf - : ParserState::CodeBlock); + context.PushState(context.PositionIs(TokenKind::If) ? State::StatementIf + : State::CodeBlock); } else { - context.AddNode(ParseNodeKind::IfStatement, state.token, - state.subtree_start, state.has_error); + context.AddNode(NodeKind::IfStatement, state.token, state.subtree_start, + state.has_error); } } -auto ParserHandleStatementIfElseBlockFinish(ParserContext& context) -> void { +auto HandleStatementIfElseBlockFinish(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::IfStatement, state.token, state.subtree_start, + context.AddNode(NodeKind::IfStatement, state.token, state.subtree_start, state.has_error); } -auto ParserHandleStatementReturn(ParserContext& context) -> void { +auto HandleStatementReturn(Context& context) -> void { auto state = context.PopState(); - state.state = ParserState::StatementReturnFinish; + state.state = State::StatementReturnFinish; context.PushState(state); - context.AddLeafNode(ParseNodeKind::ReturnStatementStart, context.Consume()); + context.AddLeafNode(NodeKind::ReturnStatementStart, context.Consume()); if (!context.PositionIs(TokenKind::Semi)) { - context.PushState(ParserState::Expression); + context.PushState(State::Expression); } } -auto ParserHandleStatementReturnFinish(ParserContext& context) -> void { - ParserHandleStatementKeywordFinish(context, ParseNodeKind::ReturnStatement); +auto HandleStatementReturnFinish(Context& context) -> void { + HandleStatementKeywordFinish(context, NodeKind::ReturnStatement); } -auto ParserHandleStatementScopeLoop(ParserContext& context) -> void { +auto HandleStatementScopeLoop(Context& context) -> void { // This maintains the current state until we're at the end of the scope. auto token_kind = context.PositionKind(); @@ -199,31 +193,31 @@ auto ParserHandleStatementScopeLoop(ParserContext& context) -> void { context.ReturnErrorOnState(); } } else { - context.PushState(ParserState::Statement); + context.PushState(State::Statement); } } -auto ParserHandleStatementWhile(ParserContext& context) -> void { +auto HandleStatementWhile(Context& context) -> void { context.PopAndDiscardState(); - context.PushState(ParserState::StatementWhileConditionFinish); - context.PushState(ParserState::ParenConditionAsWhile); + context.PushState(State::StatementWhileConditionFinish); + context.PushState(State::ParenConditionAsWhile); ++context.position(); } -auto ParserHandleStatementWhileConditionFinish(ParserContext& context) -> void { +auto HandleStatementWhileConditionFinish(Context& context) -> void { auto state = context.PopState(); - state.state = ParserState::StatementWhileBlockFinish; + state.state = State::StatementWhileBlockFinish; context.PushState(state); - context.PushState(ParserState::CodeBlock); + context.PushState(State::CodeBlock); } -auto ParserHandleStatementWhileBlockFinish(ParserContext& context) -> void { +auto HandleStatementWhileBlockFinish(Context& context) -> void { auto state = context.PopState(); - context.AddNode(ParseNodeKind::WhileStatement, state.token, - state.subtree_start, state.has_error); + context.AddNode(NodeKind::WhileStatement, state.token, state.subtree_start, + state.has_error); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_type.cpp b/toolchain/parser/parser_handle_type.cpp index 3c6d4bdf3b23..d688cbbe231e 100644 --- a/toolchain/parser/parser_handle_type.cpp +++ b/toolchain/parser/parser_handle_type.cpp @@ -4,45 +4,40 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { // Handles processing of a type's introducer. -static auto ParserHandleTypeIntroducer(ParserContext& context, - ParseNodeKind introducer_kind, - ParserState after_params_state) -> void { +static auto HandleTypeIntroducer(Context& context, NodeKind introducer_kind, + State after_params_state) -> void { auto state = context.PopState(); context.AddLeafNode(introducer_kind, context.Consume()); state.state = after_params_state; context.PushState(state); - context.PushState(ParserState::DeclarationNameAndParamsAsOptional, - state.token); + context.PushState(State::DeclarationNameAndParamsAsOptional, state.token); } -auto ParserHandleTypeIntroducerAsClass(ParserContext& context) -> void { - ParserHandleTypeIntroducer(context, ParseNodeKind::ClassIntroducer, - ParserState::TypeAfterParamsAsClass); +auto HandleTypeIntroducerAsClass(Context& context) -> void { + HandleTypeIntroducer(context, NodeKind::ClassIntroducer, + State::TypeAfterParamsAsClass); } -auto ParserHandleTypeIntroducerAsInterface(ParserContext& context) -> void { - ParserHandleTypeIntroducer(context, ParseNodeKind::InterfaceIntroducer, - ParserState::TypeAfterParamsAsInterface); +auto HandleTypeIntroducerAsInterface(Context& context) -> void { + HandleTypeIntroducer(context, NodeKind::InterfaceIntroducer, + State::TypeAfterParamsAsInterface); } -auto ParserHandleTypeIntroducerAsNamedConstraint(ParserContext& context) - -> void { - ParserHandleTypeIntroducer(context, ParseNodeKind::NamedConstraintIntroducer, - ParserState::TypeAfterParamsAsNamedConstraint); +auto HandleTypeIntroducerAsNamedConstraint(Context& context) -> void { + HandleTypeIntroducer(context, NodeKind::NamedConstraintIntroducer, + State::TypeAfterParamsAsNamedConstraint); } // Handles processing after params, deciding whether it's a declaration or // definition. -static auto ParserHandleTypeAfterParams(ParserContext& context, - ParseNodeKind declaration_kind, - ParseNodeKind definition_start_kind, - ParserState definition_finish_state) - -> void { +static auto HandleTypeAfterParams(Context& context, NodeKind declaration_kind, + NodeKind definition_start_kind, + State definition_finish_state) -> void { auto state = context.PopState(); if (state.has_error) { @@ -67,54 +62,48 @@ static auto ParserHandleTypeAfterParams(ParserContext& context, state.state = definition_finish_state; context.PushState(state); - context.PushState(ParserState::DeclarationScopeLoop); + context.PushState(State::DeclarationScopeLoop); context.AddNode(definition_start_kind, context.Consume(), state.subtree_start, state.has_error); } -auto ParserHandleTypeAfterParamsAsClass(ParserContext& context) -> void { - ParserHandleTypeAfterParams(context, ParseNodeKind::ClassDeclaration, - ParseNodeKind::ClassDefinitionStart, - ParserState::TypeDefinitionFinishAsClass); +auto HandleTypeAfterParamsAsClass(Context& context) -> void { + HandleTypeAfterParams(context, NodeKind::ClassDeclaration, + NodeKind::ClassDefinitionStart, + State::TypeDefinitionFinishAsClass); } -auto ParserHandleTypeAfterParamsAsInterface(ParserContext& context) -> void { - ParserHandleTypeAfterParams(context, ParseNodeKind::InterfaceDeclaration, - ParseNodeKind::InterfaceDefinitionStart, - ParserState::TypeDefinitionFinishAsInterface); +auto HandleTypeAfterParamsAsInterface(Context& context) -> void { + HandleTypeAfterParams(context, NodeKind::InterfaceDeclaration, + NodeKind::InterfaceDefinitionStart, + State::TypeDefinitionFinishAsInterface); } -auto ParserHandleTypeAfterParamsAsNamedConstraint(ParserContext& context) - -> void { - ParserHandleTypeAfterParams( - context, ParseNodeKind::NamedConstraintDeclaration, - ParseNodeKind::NamedConstraintDefinitionStart, - ParserState::TypeDefinitionFinishAsNamedConstraint); +auto HandleTypeAfterParamsAsNamedConstraint(Context& context) -> void { + HandleTypeAfterParams(context, NodeKind::NamedConstraintDeclaration, + NodeKind::NamedConstraintDefinitionStart, + State::TypeDefinitionFinishAsNamedConstraint); } // Handles parsing after the declaration scope of a type. -static auto ParserHandleTypeDefinitionFinish(ParserContext& context, - ParseNodeKind definition_kind) - -> void { +static auto HandleTypeDefinitionFinish(Context& context, + NodeKind definition_kind) -> void { auto state = context.PopState(); context.AddNode(definition_kind, context.Consume(), state.subtree_start, state.has_error); } -auto ParserHandleTypeDefinitionFinishAsClass(ParserContext& context) -> void { - ParserHandleTypeDefinitionFinish(context, ParseNodeKind::ClassDefinition); +auto HandleTypeDefinitionFinishAsClass(Context& context) -> void { + HandleTypeDefinitionFinish(context, NodeKind::ClassDefinition); } -auto ParserHandleTypeDefinitionFinishAsInterface(ParserContext& context) - -> void { - ParserHandleTypeDefinitionFinish(context, ParseNodeKind::InterfaceDefinition); +auto HandleTypeDefinitionFinishAsInterface(Context& context) -> void { + HandleTypeDefinitionFinish(context, NodeKind::InterfaceDefinition); } -auto ParserHandleTypeDefinitionFinishAsNamedConstraint(ParserContext& context) - -> void { - ParserHandleTypeDefinitionFinish(context, - ParseNodeKind::NamedConstraintDefinition); +auto HandleTypeDefinitionFinishAsNamedConstraint(Context& context) -> void { + HandleTypeDefinitionFinish(context, NodeKind::NamedConstraintDefinition); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_handle_var.cpp b/toolchain/parser/parser_handle_var.cpp index db8128424803..67005855ddf0 100644 --- a/toolchain/parser/parser_handle_var.cpp +++ b/toolchain/parser/parser_handle_var.cpp @@ -4,32 +4,31 @@ #include "toolchain/parser/parser_context.h" -namespace Carbon { +namespace Carbon::Parse { // Handles VarAs(Semicolon|For). -static auto ParserHandleVar(ParserContext& context, ParserState finish_state) - -> void { +static auto HandleVar(Context& context, State finish_state) -> void { context.PopAndDiscardState(); // These will start at the `var`. context.PushState(finish_state); - context.PushState(ParserState::VarAfterPattern); + context.PushState(State::VarAfterPattern); - context.AddLeafNode(ParseNodeKind::VariableIntroducer, context.Consume()); + context.AddLeafNode(NodeKind::VariableIntroducer, context.Consume()); // This will start at the pattern. - context.PushState(ParserState::PatternAsVariable); + context.PushState(State::PatternAsVariable); } -auto ParserHandleVarAsSemicolon(ParserContext& context) -> void { - ParserHandleVar(context, ParserState::VarFinishAsSemicolon); +auto HandleVarAsSemicolon(Context& context) -> void { + HandleVar(context, State::VarFinishAsSemicolon); } -auto ParserHandleVarAsFor(ParserContext& context) -> void { - ParserHandleVar(context, ParserState::VarFinishAsFor); +auto HandleVarAsFor(Context& context) -> void { + HandleVar(context, State::VarFinishAsFor); } -auto ParserHandleVarAfterPattern(ParserContext& context) -> void { +auto HandleVarAfterPattern(Context& context) -> void { auto state = context.PopState(); if (state.has_error) { @@ -40,12 +39,12 @@ auto ParserHandleVarAfterPattern(ParserContext& context) -> void { } if (auto equals = context.ConsumeIf(TokenKind::Equal)) { - context.AddLeafNode(ParseNodeKind::VariableInitializer, *equals); - context.PushState(ParserState::Expression); + context.AddLeafNode(NodeKind::VariableInitializer, *equals); + context.PushState(State::Expression); } } -auto ParserHandleVarFinishAsSemicolon(ParserContext& context) -> void { +auto HandleVarFinishAsSemicolon(Context& context) -> void { auto state = context.PopState(); auto end_token = state.token; @@ -59,11 +58,11 @@ auto ParserHandleVarFinishAsSemicolon(ParserContext& context) -> void { end_token = *semi_token; } } - context.AddNode(ParseNodeKind::VariableDeclaration, end_token, - state.subtree_start, state.has_error); + context.AddNode(NodeKind::VariableDeclaration, end_token, state.subtree_start, + state.has_error); } -auto ParserHandleVarFinishAsFor(ParserContext& context) -> void { +auto HandleVarFinishAsFor(Context& context) -> void { auto state = context.PopState(); auto end_token = state.token; @@ -82,8 +81,8 @@ auto ParserHandleVarFinishAsFor(ParserContext& context) -> void { state.has_error = true; } - context.AddNode(ParseNodeKind::ForIn, end_token, state.subtree_start, + context.AddNode(NodeKind::ForIn, end_token, state.subtree_start, state.has_error); } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_state.cpp b/toolchain/parser/parser_state.cpp index 8193217489d4..e2640b14c057 100644 --- a/toolchain/parser/parser_state.cpp +++ b/toolchain/parser/parser_state.cpp @@ -4,11 +4,11 @@ #include "toolchain/parser/parser_state.h" -namespace Carbon { +namespace Carbon::Parse { -CARBON_DEFINE_ENUM_CLASS_NAMES(ParserState) = { -#define CARBON_PARSER_STATE(Name) CARBON_ENUM_CLASS_NAME_STRING(Name) +CARBON_DEFINE_ENUM_CLASS_NAMES(State) = { +#define CARBON_PARSE_STATE(Name) CARBON_ENUM_CLASS_NAME_STRING(Name) #include "toolchain/parser/parser_state.def" }; -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/parser_state.def b/toolchain/parser/parser_state.def index fe937e31b5d5..6016a5f6ea6b 100644 --- a/toolchain/parser/parser_state.def +++ b/toolchain/parser/parser_state.def @@ -8,7 +8,7 @@ // at the end of this file. // // Supported x-macros are: -// - CARBON_PARSER_STATE(Name) +// - CARBON_PARSE_STATE(Name) // Defines a parser state. // // Parser states may be clustered when there are multiple related variants, @@ -24,40 +24,40 @@ // the TokenKind should be used rather than the string name in order to make it // easier to compare with code. -#ifndef CARBON_PARSER_STATE +#ifndef CARBON_PARSE_STATE #error "Must define the x-macro to use this file." #endif -// Use CARBON_PARSER_STATE_VARIANTSN(State, Variant1, Variant2, ...) to generate +// Use CARBON_PARSE_STATE_VARIANTSN(State, Variant1, Variant2, ...) to generate // StateAsVariant1, StateAsVariant2, ... states. -#define CARBON_PARSER_STATE_VARIANT(State, Variant) \ - CARBON_PARSER_STATE(State##As##Variant) -#define CARBON_PARSER_STATE_VARIANTS2(State, Variant1, Variant2) \ - CARBON_PARSER_STATE_VARIANT(State, Variant1) \ - CARBON_PARSER_STATE_VARIANT(State, Variant2) -#define CARBON_PARSER_STATE_VARIANTS3(State, Variant1, Variant2, Variant3) \ - CARBON_PARSER_STATE_VARIANT(State, Variant1) \ - CARBON_PARSER_STATE_VARIANTS2(State, Variant2, Variant3) +#define CARBON_PARSE_STATE_VARIANT(State, Variant) \ + CARBON_PARSE_STATE(State##As##Variant) +#define CARBON_PARSE_STATE_VARIANTS2(State, Variant1, Variant2) \ + CARBON_PARSE_STATE_VARIANT(State, Variant1) \ + CARBON_PARSE_STATE_VARIANT(State, Variant2) +#define CARBON_PARSE_STATE_VARIANTS3(State, Variant1, Variant2, Variant3) \ + CARBON_PARSE_STATE_VARIANT(State, Variant1) \ + CARBON_PARSE_STATE_VARIANTS2(State, Variant2, Variant3) // Handles an index expression `a[0]`. // // Always: // 1. Expression // 2. IndexExpressionFinish -CARBON_PARSER_STATE(IndexExpression) +CARBON_PARSE_STATE(IndexExpression) // Handles finishing the index expression. // // Always: // (state done) -CARBON_PARSER_STATE(IndexExpressionFinish) +CARBON_PARSE_STATE(IndexExpressionFinish) // Handles an array expression `[T; N]`. // // Always: // 1. Expression // 2. ArrayExpressionSemi -CARBON_PARSER_STATE(ArrayExpression) +CARBON_PARSE_STATE(ArrayExpression) // Handles ';' in an array expression `[T; N]`. // @@ -66,13 +66,13 @@ CARBON_PARSER_STATE(ArrayExpression) // Else: // 1. Expression // 2. ArrayExpressionFinish -CARBON_PARSER_STATE(ArrayExpressionSemi) +CARBON_PARSE_STATE(ArrayExpressionSemi) // Handles finishing the array expression. // // Always: // (state done) -CARBON_PARSER_STATE(ArrayExpressionFinish) +CARBON_PARSE_STATE(ArrayExpressionFinish) // Handles the `{` of a brace expression. // @@ -81,7 +81,7 @@ CARBON_PARSER_STATE(ArrayExpressionFinish) // Else: // 1. BraceExpressionParameterAsUnknown // 2. BraceExpressionFinishAsUnknown -CARBON_PARSER_STATE(BraceExpression) +CARBON_PARSE_STATE(BraceExpression) // Handles a brace expression parameter. Note this will always start as unknown, // but should be known after the first valid parameter. All later inconsistent @@ -92,7 +92,7 @@ CARBON_PARSER_STATE(BraceExpression) // 2. BraceExpressionParameterAfterDesignatorAs(Type|Value|Unknown) // Else: // 1. BraceExpressionParameterFinishAs(Type|Value|Unknown) -CARBON_PARSER_STATE_VARIANTS3(BraceExpressionParameter, Type, Value, Unknown) +CARBON_PARSE_STATE_VARIANTS3(BraceExpressionParameter, Type, Value, Unknown) // Handles a brace expression parameter after the initial designator. This // should be at a `:` or `=`, depending on whether it's a type or value literal. @@ -102,7 +102,7 @@ CARBON_PARSER_STATE_VARIANTS3(BraceExpressionParameter, Type, Value, Unknown) // 2. BraceExpressionParameterFinishAs(Type|Value|Unknown) // Else: // 1. BraceExpressionParameterFinishAs(Type|Value|Unknown) -CARBON_PARSER_STATE_VARIANTS3(BraceExpressionParameterAfterDesignator, Type, +CARBON_PARSE_STATE_VARIANTS3(BraceExpressionParameterAfterDesignator, Type, Value, Unknown) // Handles the end of a brace expression parameter. @@ -111,14 +111,14 @@ CARBON_PARSER_STATE_VARIANTS3(BraceExpressionParameterAfterDesignator, Type, // 1. BraceExpressionParameterAsUnknown // Else: // (state done) -CARBON_PARSER_STATE_VARIANTS3(BraceExpressionParameterFinish, Type, Value, +CARBON_PARSE_STATE_VARIANTS3(BraceExpressionParameterFinish, Type, Value, Unknown) // Handles the `}` of a brace expression. // // Always: // (state done) -CARBON_PARSER_STATE_VARIANTS3(BraceExpressionFinish, Type, Value, Unknown) +CARBON_PARSE_STATE_VARIANTS3(BraceExpressionFinish, Type, Value, Unknown) // Handles a call expression `(...)`. // @@ -128,7 +128,7 @@ CARBON_PARSER_STATE_VARIANTS3(BraceExpressionFinish, Type, Value, Unknown) // 1. Expression // 2. CallExpressionParameterFinish // 3. CallExpressionFinish -CARBON_PARSER_STATE(CallExpression) +CARBON_PARSE_STATE(CallExpression) // Handles the `,` or `)` after a call parameter. // @@ -137,13 +137,13 @@ CARBON_PARSER_STATE(CallExpression) // 2. CallExpressionParameterFinish // Else: // (state done) -CARBON_PARSER_STATE(CallExpressionParameterFinish) +CARBON_PARSE_STATE(CallExpressionParameterFinish) // Handles finishing the call expression. // // Always: // (state done) -CARBON_PARSER_STATE(CallExpressionFinish) +CARBON_PARSE_STATE(CallExpressionFinish) // Handles processing at the `{` on a typical code block. // @@ -153,14 +153,14 @@ CARBON_PARSER_STATE(CallExpressionFinish) // Else: // 1. Statement // 2. CodeBlockFinish -CARBON_PARSER_STATE(CodeBlock) +CARBON_PARSE_STATE(CodeBlock) // Handles processing at the `}` on a typical code block, after a statement // scope is done. // // Always: // (state done) -CARBON_PARSER_STATE(CodeBlockFinish) +CARBON_PARSE_STATE(CodeBlockFinish) // Handles a declaration name and parameters, such as `Foo[...](...)`. // @@ -176,7 +176,7 @@ CARBON_PARSER_STATE(CodeBlockFinish) // 2. PeriodAsDeclaration // Else: // (state done) -CARBON_PARSER_STATE_VARIANTS3(DeclarationNameAndParams, None, Optional, +CARBON_PARSE_STATE_VARIANTS3(DeclarationNameAndParams, None, Optional, Required) // Handles a declaration name between the main name and deduced parameters. @@ -194,7 +194,7 @@ CARBON_PARSER_STATE_VARIANTS3(DeclarationNameAndParams, None, Optional, // 1. ParameterListAsRegular // Else: // (state done) -CARBON_PARSER_STATE_VARIANTS3(DeclarationNameAndParamsAfterName, None, Optional, +CARBON_PARSE_STATE_VARIANTS3(DeclarationNameAndParamsAfterName, None, Optional, Required) // Handles regular parameters such as `(...)` for the general declaration case. @@ -204,7 +204,7 @@ CARBON_PARSER_STATE_VARIANTS3(DeclarationNameAndParamsAfterName, None, Optional, // 1. ParameterListAsRegular // Else: // (state done) -CARBON_PARSER_STATE(DeclarationNameAndParamsAfterDeduced) +CARBON_PARSE_STATE(DeclarationNameAndParamsAfterDeduced) // Handles processing of a declaration scope. Things like fn, class, interface, // and so on. @@ -233,7 +233,7 @@ CARBON_PARSER_STATE(DeclarationNameAndParamsAfterDeduced) // 2. DeclarationScopeLoop // Else: // 1. DeclarationScopeLoop -CARBON_PARSER_STATE(DeclarationScopeLoop) +CARBON_PARSE_STATE(DeclarationScopeLoop) // Handles periods. Only does one `.` segment; the source is // responsible for handling chaining. @@ -248,14 +248,14 @@ CARBON_PARSER_STATE(DeclarationScopeLoop) // // Always: // (state done) -CARBON_PARSER_STATE_VARIANTS3(Period, Declaration, Expression, Struct) +CARBON_PARSE_STATE_VARIANTS3(Period, Declaration, Expression, Struct) // Handles `->name` expressions. Identical to PeriodAsExpression except for the // leading token. // // Always: // (state done) -CARBON_PARSER_STATE(ArrowExpression) +CARBON_PARSE_STATE(ArrowExpression) // Handles processing of an expression. // @@ -269,7 +269,7 @@ CARBON_PARSER_STATE(ArrowExpression) // Else: // 1. ExpressionInPostfix // 2. ExpressionLoop -CARBON_PARSER_STATE(Expression) +CARBON_PARSE_STATE(Expression) // Handles the initial part of postfix expressions, such as an identifier or // literal value, then proceeds to the loop. @@ -287,7 +287,7 @@ CARBON_PARSER_STATE(Expression) // 2. ExpressionInPostfixLoop // Else: // (state done) -CARBON_PARSER_STATE(ExpressionInPostfix) +CARBON_PARSE_STATE(ExpressionInPostfix) // Handles looping through elements following the initial postfix expression, // such as designators or parenthesized parameters. @@ -306,7 +306,7 @@ CARBON_PARSER_STATE(ExpressionInPostfix) // 2. ExpressionInPostfixLoop // Else: // (state done) -CARBON_PARSER_STATE(ExpressionInPostfixLoop) +CARBON_PARSE_STATE(ExpressionInPostfixLoop) // Handles processing of an expression. // @@ -317,21 +317,21 @@ CARBON_PARSER_STATE(ExpressionInPostfixLoop) // 1. ExpressionLoop // Else: // (state done) -CARBON_PARSER_STATE(ExpressionLoop) +CARBON_PARSE_STATE(ExpressionLoop) // Completes an ExpressionLoop pass by adding an infix operator, then goes back // to ExpressionLoop. // // Always: // 1. ExpressionLoop -CARBON_PARSER_STATE(ExpressionLoopForBinary) +CARBON_PARSE_STATE(ExpressionLoopForBinary) // Completes an ExpressionLoop pass by adding a prefix operator, then goes back // to ExpressionLoop. // // Always: // 1. ExpressionLoop -CARBON_PARSER_STATE(ExpressionLoopForPrefix) +CARBON_PARSE_STATE(ExpressionLoopForPrefix) // Completes the condition of an `if` expression and handles the `then` token. // @@ -340,7 +340,7 @@ CARBON_PARSER_STATE(ExpressionLoopForPrefix) // 2. IfExpressionFinishThen // Else: // (state done) -CARBON_PARSER_STATE(IfExpressionFinishCondition) +CARBON_PARSE_STATE(IfExpressionFinishCondition) // Completes the first alternative in an `if` expression and handles the `else` // token. @@ -350,26 +350,26 @@ CARBON_PARSER_STATE(IfExpressionFinishCondition) // 2. IfExpressionFinishElse // Else: // (state done) -CARBON_PARSER_STATE(IfExpressionFinishThen) +CARBON_PARSE_STATE(IfExpressionFinishThen) // Completes the second alternative in an `if` expression. // // Always: // (state done) -CARBON_PARSER_STATE(IfExpressionFinishElse) +CARBON_PARSE_STATE(IfExpressionFinishElse) // Completes an IfExpression. // // Always: // (state done) -CARBON_PARSER_STATE(IfExpressionFinish) +CARBON_PARSE_STATE(IfExpressionFinish) // Handles the `;` for an expression statement, which is different from most // keyword statements. // // Always: // (state done) -CARBON_PARSER_STATE(ExpressionStatementFinish) +CARBON_PARSE_STATE(ExpressionStatementFinish) // Handles a function's introducer. // @@ -378,7 +378,7 @@ CARBON_PARSER_STATE(ExpressionStatementFinish) // Else: // 1. DeclarationNameAndParamsAsRequired // 2. FunctionAfterParameters -CARBON_PARSER_STATE(FunctionIntroducer) +CARBON_PARSE_STATE(FunctionIntroducer) // Handles processing of a function's syntax after `)`, primarily the // possibility a `->` return type is there. Always enqueues signature finish @@ -390,13 +390,13 @@ CARBON_PARSER_STATE(FunctionIntroducer) // 3. FunctionSignatureFinish // Else: // 1. FunctionSignatureFinish -CARBON_PARSER_STATE(FunctionAfterParameters) +CARBON_PARSE_STATE(FunctionAfterParameters) // Finishes a function return type. // // Always: // (state done) -CARBON_PARSER_STATE(FunctionReturnTypeFinish) +CARBON_PARSE_STATE(FunctionReturnTypeFinish) // Finishes a function signature. If it's a declaration, the function is done; // otherwise, this also starts definition processing. @@ -408,39 +408,39 @@ CARBON_PARSER_STATE(FunctionReturnTypeFinish) // 2. FunctionDefinitionFinish // Else: // (state done) -CARBON_PARSER_STATE(FunctionSignatureFinish) +CARBON_PARSE_STATE(FunctionSignatureFinish) // Finishes a function definition. // // Always: // (state done) -CARBON_PARSER_STATE(FunctionDefinitionFinish) +CARBON_PARSE_STATE(FunctionDefinitionFinish) // Handles `namespace`. // // Always: // 1. DeclarationNameAndParamsAsNone // 2. NamespaceFinish -CARBON_PARSER_STATE(Namespace) +CARBON_PARSE_STATE(Namespace) // Handles `namespace` after the name. // // Always: // (state done) -CARBON_PARSER_STATE(NamespaceFinish) +CARBON_PARSE_STATE(NamespaceFinish) // Handles `package`. // // Always: // (state done) -CARBON_PARSER_STATE(Package) +CARBON_PARSE_STATE(Package) // Starts deduced parameter processing. // // Always: // 1. PatternAs(DeducedParameter|Parameter) // 2. ParameterFinishAs(Deduced|Regular) -CARBON_PARSER_STATE_VARIANTS2(Parameter, Deduced, Regular) +CARBON_PARSE_STATE_VARIANTS2(Parameter, Deduced, Regular) // Finishes deduced parameter processing, including `,`. If there are more // parameters, enqueues another parameter processing state. @@ -449,7 +449,7 @@ CARBON_PARSER_STATE_VARIANTS2(Parameter, Deduced, Regular) // 1. ParameterAs(Deduced|Regular) // Else: // (state done) -CARBON_PARSER_STATE_VARIANTS2(ParameterFinish, Deduced, Regular) +CARBON_PARSE_STATE_VARIANTS2(ParameterFinish, Deduced, Regular) // Handles processing of a parameter list `[` or `(`. // @@ -458,13 +458,13 @@ CARBON_PARSER_STATE_VARIANTS2(ParameterFinish, Deduced, Regular) // Else: // 1. ParameterAs(Deduced|Regular) // 2. ParameterListFinishAs(Deduced|Regular) -CARBON_PARSER_STATE_VARIANTS2(ParameterList, Deduced, Regular) +CARBON_PARSE_STATE_VARIANTS2(ParameterList, Deduced, Regular) // Handles processing of a parameter list `]` or `)`. // // Always: // (state done) -CARBON_PARSER_STATE_VARIANTS2(ParameterListFinish, Deduced, Regular) +CARBON_PARSE_STATE_VARIANTS2(ParameterListFinish, Deduced, Regular) // Handles the processing of a `(condition)` up through the expression. // @@ -473,13 +473,13 @@ CARBON_PARSER_STATE_VARIANTS2(ParameterListFinish, Deduced, Regular) // Else: // 1. Expression // 2. ParenConditionAs(If|While)Finish -CARBON_PARSER_STATE_VARIANTS2(ParenCondition, If, While) +CARBON_PARSE_STATE_VARIANTS2(ParenCondition, If, While) // Finishes the processing of a `(condition)` after the expression. // // Always: // (state done) -CARBON_PARSER_STATE_VARIANTS2(ParenConditionFinish, If, While) +CARBON_PARSE_STATE_VARIANTS2(ParenConditionFinish, If, While) // Handles the `(` of a parenthesized expression. // @@ -489,7 +489,7 @@ CARBON_PARSER_STATE_VARIANTS2(ParenConditionFinish, If, While) // 1. Expression // 2. ParenExpressionParameterFinishAsUnknown // 3. ParenExpressionFinish -CARBON_PARSER_STATE(ParenExpression) +CARBON_PARSE_STATE(ParenExpression) // Handles the end of a parenthesized expression's parameter. This will start as // AsUnknown on the first parameter; if there are more, it switches to AsTuple @@ -504,13 +504,13 @@ CARBON_PARSER_STATE(ParenExpression) // SPECIAL: Parent becomes ParenExpressionFinishAsTuple // Else `CloseParen`: // (state done) -CARBON_PARSER_STATE_VARIANTS2(ParenExpressionParameterFinish, Unknown, Tuple) +CARBON_PARSE_STATE_VARIANTS2(ParenExpressionParameterFinish, Unknown, Tuple) // Handles the `)` of a parenthesized expression. // // Always: // (state done) -CARBON_PARSER_STATE_VARIANTS2(ParenExpressionFinish, Normal, Tuple) +CARBON_PARSE_STATE_VARIANTS2(ParenExpressionFinish, Normal, Tuple) // Handles pattern parsing for a pattern, enqueuing type expression processing. // This covers parameter and `var` support. @@ -520,25 +520,25 @@ CARBON_PARSER_STATE_VARIANTS2(ParenExpressionFinish, Normal, Tuple) // 2. PatternFinishAs(Generic|Regular) // Else: // 1. PatternFinish -CARBON_PARSER_STATE_VARIANTS3(Pattern, DeducedParameter, Parameter, Variable) +CARBON_PARSE_STATE_VARIANTS3(Pattern, DeducedParameter, Parameter, Variable) // Handles `addr` in a pattern. // // Always: // (state done) -CARBON_PARSER_STATE(PatternAddress) +CARBON_PARSE_STATE(PatternAddress) // Handles `template` in a pattern. // // Always: // (state done) -CARBON_PARSER_STATE(PatternTemplate) +CARBON_PARSE_STATE(PatternTemplate) // Finishes pattern processing. // // Always: // (state done) -CARBON_PARSER_STATE_VARIANTS2(PatternFinish, Generic, Regular) +CARBON_PARSE_STATE_VARIANTS2(PatternFinish, Generic, Regular) // Handles a single statement. While typically within a statement block, this // can also be used for error recovery where we expect a statement block and @@ -564,19 +564,19 @@ CARBON_PARSER_STATE_VARIANTS2(PatternFinish, Generic, Regular) // Else: // 1. Expression // 2. ExpressionStatementFinish -CARBON_PARSER_STATE(Statement) +CARBON_PARSE_STATE(Statement) // Handles `break` processing at the `;`. // // Always: // (state done) -CARBON_PARSER_STATE(StatementBreakFinish) +CARBON_PARSE_STATE(StatementBreakFinish) // Handles `continue` processing at the `;`. // // Always: // (state done) -CARBON_PARSER_STATE(StatementContinueFinish) +CARBON_PARSE_STATE(StatementContinueFinish) // Handles `for` processing of `(var`, proceeding to a pattern before // continuing. @@ -588,7 +588,7 @@ CARBON_PARSER_STATE(StatementContinueFinish) // 2. StatementForHeaderIn // Else: // 1. StatementForHeaderIn -CARBON_PARSER_STATE(StatementForHeader) +CARBON_PARSE_STATE(StatementForHeader) // Handles `for` procesisng of `in`, proceeding to an expression before // continuing. @@ -598,26 +598,26 @@ CARBON_PARSER_STATE(StatementForHeader) // 2. StatementForHeaderFinish // Else: // 1. StatementForHeaderFinish -CARBON_PARSER_STATE(StatementForHeaderIn) +CARBON_PARSE_STATE(StatementForHeaderIn) // Handles `for` processing of `)`, proceeding to the statement block. // // Always: // 1. CodeBlock -CARBON_PARSER_STATE(StatementForHeaderFinish) +CARBON_PARSE_STATE(StatementForHeaderFinish) // Handles `for` processing at the final `}`. // // Always: // (state done) -CARBON_PARSER_STATE(StatementForFinish) +CARBON_PARSE_STATE(StatementForFinish) // Handles `if` processing at the start. // // Always: // 1. ParenConditionAsIf // 2. StatementIfConditionFinish -CARBON_PARSER_STATE(StatementIf) +CARBON_PARSE_STATE(StatementIf) // Handles `if` processing between the condition and start of the first code // block. @@ -625,7 +625,7 @@ CARBON_PARSER_STATE(StatementIf) // Always: // 1. CodeBlock // 2. StatementIfThenBlockFinish -CARBON_PARSER_STATE(StatementIfConditionFinish) +CARBON_PARSE_STATE(StatementIfConditionFinish) // Handles `if` processing after the end of the first code block, with the // optional `else`. @@ -638,13 +638,13 @@ CARBON_PARSER_STATE(StatementIfConditionFinish) // 2. StatementIfElseBlockFinish // Else: // (state done) -CARBON_PARSER_STATE(StatementIfThenBlockFinish) +CARBON_PARSE_STATE(StatementIfThenBlockFinish) // Handles `if` processing after a provided `else` code block. // // Always: // (state done) -CARBON_PARSER_STATE(StatementIfElseBlockFinish) +CARBON_PARSE_STATE(StatementIfElseBlockFinish) // Handles `return` processing. // @@ -653,13 +653,13 @@ CARBON_PARSER_STATE(StatementIfElseBlockFinish) // Else: // 1. Expression // 2. StatementReturnFinish -CARBON_PARSER_STATE(StatementReturn) +CARBON_PARSE_STATE(StatementReturn) // Handles `return` processing at the `;` when there's an expression. // // Always: // (state done) -CARBON_PARSER_STATE(StatementReturnFinish) +CARBON_PARSE_STATE(StatementReturnFinish) // Handles processing of statements within a scope. // @@ -668,33 +668,33 @@ CARBON_PARSER_STATE(StatementReturnFinish) // Else: // 1. Statement // 2. StatementScopeLoop -CARBON_PARSER_STATE(StatementScopeLoop) +CARBON_PARSE_STATE(StatementScopeLoop) // Handles `while` processing. // // Always: // 1. ParenConditionAsWhile // 2. StatementWhileConditionFinish -CARBON_PARSER_STATE(StatementWhile) +CARBON_PARSE_STATE(StatementWhile) // Handles `while` processing between the condition and start of the code block. // // Always: // 1. CodeBlock // 2. StatementWhileBlockFinish -CARBON_PARSER_STATE(StatementWhileConditionFinish) +CARBON_PARSE_STATE(StatementWhileConditionFinish) // Handles `while` processing after the end of the code block. // // Always: // (state done) -CARBON_PARSER_STATE(StatementWhileBlockFinish) +CARBON_PARSE_STATE(StatementWhileBlockFinish) // Handles parsing after the declaration scope of a type. // // Always: // (state done) -CARBON_PARSER_STATE_VARIANTS3(TypeDefinitionFinish, Class, Interface, +CARBON_PARSE_STATE_VARIANTS3(TypeDefinitionFinish, Class, Interface, NamedConstraint) // Handles processing of a type's introducer. @@ -702,7 +702,7 @@ CARBON_PARSER_STATE_VARIANTS3(TypeDefinitionFinish, Class, Interface, // Always: // 1. DeclarationNameAndParamsAsOptional // 2. TypeAfterParamsAs(Class|Interface|NamedConstraint) -CARBON_PARSER_STATE_VARIANTS3(TypeIntroducer, Class, Interface, NamedConstraint) +CARBON_PARSE_STATE_VARIANTS3(TypeIntroducer, Class, Interface, NamedConstraint) // Handles processing of a type after its optional parameters. // @@ -713,7 +713,7 @@ CARBON_PARSER_STATE_VARIANTS3(TypeIntroducer, Class, Interface, NamedConstraint) // 2. TypeDefinitionFinishAs(Class|Interface|NamedConstraint) // Else: // (state done) -CARBON_PARSER_STATE_VARIANTS3(TypeAfterParams, Class, Interface, +CARBON_PARSE_STATE_VARIANTS3(TypeAfterParams, Class, Interface, NamedConstraint) // Handles the start of a `var`. @@ -722,7 +722,7 @@ CARBON_PARSER_STATE_VARIANTS3(TypeAfterParams, Class, Interface, // 1. PatternAsVariable // 2. VarAfterPattern // 3. VarFinishAs(Semicolon|For) -CARBON_PARSER_STATE_VARIANTS2(Var, Semicolon, For) +CARBON_PARSE_STATE_VARIANTS2(Var, Semicolon, For) // Handles `var` after the pattern, either followed by an initializer or the // semicolon. @@ -731,12 +731,12 @@ CARBON_PARSER_STATE_VARIANTS2(Var, Semicolon, For) // 1. Expression // Else: // (state done) -CARBON_PARSER_STATE(VarAfterPattern) +CARBON_PARSE_STATE(VarAfterPattern) // Handles `var` parsing at the end. // // Always: // (state done) -CARBON_PARSER_STATE_VARIANTS2(VarFinish, Semicolon, For) +CARBON_PARSE_STATE_VARIANTS2(VarFinish, Semicolon, For) -#undef CARBON_PARSER_STATE +#undef CARBON_PARSE_STATE diff --git a/toolchain/parser/parser_state.h b/toolchain/parser/parser_state.h index 5c9729d70162..b26ac04a0c8b 100644 --- a/toolchain/parser/parser_state.h +++ b/toolchain/parser/parser_state.h @@ -9,26 +9,25 @@ #include "common/enum_base.h" -namespace Carbon { +namespace Carbon::Parse { -CARBON_DEFINE_RAW_ENUM_CLASS(ParserState, uint8_t) { -#define CARBON_PARSER_STATE(Name) CARBON_RAW_ENUM_ENUMERATOR(Name) +CARBON_DEFINE_RAW_ENUM_CLASS(State, uint8_t) { +#define CARBON_PARSE_STATE(Name) CARBON_RAW_ENUM_ENUMERATOR(Name) #include "toolchain/parser/parser_state.def" }; -class ParserState : public CARBON_ENUM_BASE(ParserState) { +class State : public CARBON_ENUM_BASE(State) { public: -#define CARBON_PARSER_STATE(Name) CARBON_ENUM_CONSTANT_DECLARATION(Name) +#define CARBON_PARSE_STATE(Name) CARBON_ENUM_CONSTANT_DECLARATION(Name) #include "toolchain/parser/parser_state.def" }; -#define CARBON_PARSER_STATE(Name) \ - CARBON_ENUM_CONSTANT_DEFINITION(ParserState, Name) +#define CARBON_PARSE_STATE(Name) CARBON_ENUM_CONSTANT_DEFINITION(State, Name) #include "toolchain/parser/parser_state.def" -// We expect ParserState to fit compactly into 8 bits. -static_assert(sizeof(ParserState) == 1, "ParserState includes padding!"); +// We expect State to fit compactly into 8 bits. +static_assert(sizeof(State) == 1, "State includes padding!"); -} // namespace Carbon +} // namespace Carbon::Parse #endif // CARBON_TOOLCHAIN_PARSER_PARSER_STATE_H_ diff --git a/toolchain/parser/precedence.cpp b/toolchain/parser/precedence.cpp index 636847be9cff..57cda50d5edb 100644 --- a/toolchain/parser/precedence.cpp +++ b/toolchain/parser/precedence.cpp @@ -6,7 +6,7 @@ #include "common/check.h" -namespace Carbon { +namespace Carbon::Parse { namespace { enum PrecedenceLevel : int8_t { @@ -329,4 +329,4 @@ auto PrecedenceGroup::GetPriority(PrecedenceGroup left, PrecedenceGroup right) return Lookup.table[left.level_][right.level_]; } -} // namespace Carbon +} // namespace Carbon::Parse diff --git a/toolchain/parser/precedence.h b/toolchain/parser/precedence.h index 138c309f470f..e72f7d807577 100644 --- a/toolchain/parser/precedence.h +++ b/toolchain/parser/precedence.h @@ -9,7 +9,7 @@ #include "toolchain/lexer/token_kind.h" -namespace Carbon { +namespace Carbon::Parse { // Given two operators `$` and `@`, and an expression `a $ b @ c`, how should // the expression be parsed? @@ -101,6 +101,6 @@ struct PrecedenceGroup::Trailing { bool is_binary; }; -} // namespace Carbon +} // namespace Carbon::Parse #endif // CARBON_TOOLCHAIN_PARSER_PRECEDENCE_H_ diff --git a/toolchain/parser/precedence_test.cpp b/toolchain/parser/precedence_test.cpp index 5fb035f6ce03..7997281d99bc 100644 --- a/toolchain/parser/precedence_test.cpp +++ b/toolchain/parser/precedence_test.cpp @@ -12,6 +12,9 @@ namespace Carbon::Testing { namespace { +using Parse::Associativity; +using Parse::OperatorPriority; +using Parse::PrecedenceGroup; using ::testing::Eq; TEST(PrecedenceTest, OperatorsAreRecognized) { diff --git a/toolchain/semantics/semantics_context.cpp b/toolchain/semantics/semantics_context.cpp index bfe071797c52..0c08f93078a8 100644 --- a/toolchain/semantics/semantics_context.cpp +++ b/toolchain/semantics/semantics_context.cpp @@ -21,8 +21,8 @@ namespace Carbon::Check { Context::Context(const TokenizedBuffer& tokens, - DiagnosticEmitter& emitter, - const ParseTree& parse_tree, SemIR::File& semantics_ir, + DiagnosticEmitter& emitter, + const Parse::Tree& parse_tree, SemIR::File& semantics_ir, llvm::raw_ostream* vlog_stream) : tokens_(&tokens), emitter_(&emitter), @@ -41,7 +41,7 @@ Context::Context(const TokenizedBuffer& tokens, {SemIR::NodeId::BuiltinTypeType, SemIR::TypeId::TypeType}); } -auto Context::TODO(ParseTree::Node parse_node, std::string label) -> bool { +auto Context::TODO(Parse::Node parse_node, std::string label) -> bool { CARBON_DIAGNOSTIC(SemanticsTodo, Error, "Semantics TODO: `{0}`.", std::string); emitter_->Emit(parse_node, SemanticsTodo, std::move(label)); @@ -69,13 +69,12 @@ auto Context::AddNodeToBlock(SemIR::NodeBlockId block, SemIR::Node node) return semantics_ir_->AddNode(block, node); } -auto Context::AddNodeAndPush(ParseTree::Node parse_node, SemIR::Node node) - -> void { +auto Context::AddNodeAndPush(Parse::Node parse_node, SemIR::Node node) -> void { auto node_id = AddNode(node); node_stack_.Push(parse_node, node_id); } -auto Context::DiagnoseDuplicateName(ParseTree::Node parse_node, +auto Context::DiagnoseDuplicateName(Parse::Node parse_node, SemIR::NodeId prev_def_id) -> void { CARBON_DIAGNOSTIC(NameDeclarationDuplicate, Error, "Duplicate name being declared in the same scope."); @@ -87,16 +86,15 @@ auto Context::DiagnoseDuplicateName(ParseTree::Node parse_node, .Emit(); } -auto Context::DiagnoseNameNotFound(ParseTree::Node parse_node, +auto Context::DiagnoseNameNotFound(Parse::Node parse_node, SemIR::StringId name_id) -> void { CARBON_DIAGNOSTIC(NameNotFound, Error, "Name `{0}` not found.", llvm::StringRef); emitter_->Emit(parse_node, NameNotFound, semantics_ir_->GetString(name_id)); } -auto Context::AddNameToLookup(ParseTree::Node name_node, - SemIR::StringId name_id, SemIR::NodeId target_id) - -> void { +auto Context::AddNameToLookup(Parse::Node name_node, SemIR::StringId name_id, + SemIR::NodeId target_id) -> void { if (current_scope().names.insert(name_id).second) { name_lookup_[name_id].push_back(target_id); } else { @@ -104,7 +102,7 @@ auto Context::AddNameToLookup(ParseTree::Node name_node, } } -auto Context::LookupName(ParseTree::Node parse_node, SemIR::StringId name_id, +auto Context::LookupName(Parse::Node parse_node, SemIR::StringId name_id, SemIR::NameScopeId scope_id, bool print_diagnostics) -> SemIR::NodeId { if (scope_id == SemIR::NameScopeId::Invalid) { @@ -151,8 +149,8 @@ auto Context::PopScope() -> void { template static auto AddDominatedBlockAndBranchImpl(Context& context, - ParseTree::Node parse_node, - Args... args) -> SemIR::NodeBlockId { + Parse::Node parse_node, Args... args) + -> SemIR::NodeBlockId { if (!context.node_block_stack().is_current_block_reachable()) { return SemIR::NodeBlockId::Unreachable; } @@ -161,19 +159,19 @@ static auto AddDominatedBlockAndBranchImpl(Context& context, return block_id; } -auto Context::AddDominatedBlockAndBranch(ParseTree::Node parse_node) +auto Context::AddDominatedBlockAndBranch(Parse::Node parse_node) -> SemIR::NodeBlockId { return AddDominatedBlockAndBranchImpl(*this, parse_node); } -auto Context::AddDominatedBlockAndBranchWithArg(ParseTree::Node parse_node, +auto Context::AddDominatedBlockAndBranchWithArg(Parse::Node parse_node, SemIR::NodeId arg_id) -> SemIR::NodeBlockId { return AddDominatedBlockAndBranchImpl( *this, parse_node, arg_id); } -auto Context::AddDominatedBlockAndBranchIf(ParseTree::Node parse_node, +auto Context::AddDominatedBlockAndBranchIf(Parse::Node parse_node, SemIR::NodeId cond_id) -> SemIR::NodeBlockId { return AddDominatedBlockAndBranchImpl( @@ -181,8 +179,8 @@ auto Context::AddDominatedBlockAndBranchIf(ParseTree::Node parse_node, } auto Context::AddConvergenceBlockAndPush( - ParseTree::Node parse_node, - std::initializer_list blocks) -> void { + Parse::Node parse_node, std::initializer_list blocks) + -> void { CARBON_CHECK(blocks.size() >= 2) << "no convergence"; SemIR::NodeBlockId new_block_id = SemIR::NodeBlockId::Unreachable; @@ -199,7 +197,7 @@ auto Context::AddConvergenceBlockAndPush( } auto Context::AddConvergenceBlockWithArgAndPush( - ParseTree::Node parse_node, + Parse::Node parse_node, std::initializer_list> blocks_and_args) -> SemIR::NodeId { CARBON_CHECK(blocks_and_args.size() >= 2) << "no convergence"; @@ -263,7 +261,7 @@ auto Context::is_current_position_reachable() -> bool { } } -auto Context::Initialize(ParseTree::Node parse_node, SemIR::NodeId target_id, +auto Context::Initialize(Parse::Node parse_node, SemIR::NodeId target_id, SemIR::NodeId value_id) -> void { // Implicitly convert the value to the type of the target. auto type_id = semantics_ir().GetNode(target_id).type_id(); @@ -442,9 +440,9 @@ auto Context::HandleDiscardedExpression(SemIR::NodeId expr_id) -> void { } auto Context::ImplicitAsForArgs( - SemIR::NodeBlockId arg_refs_id, ParseTree::Node param_parse_node, + SemIR::NodeBlockId arg_refs_id, Parse::Node param_parse_node, SemIR::NodeBlockId param_refs_id, - DiagnosticEmitter::DiagnosticBuilder* diagnostic) -> bool { + DiagnosticEmitter::DiagnosticBuilder* diagnostic) -> bool { // If both arguments and parameters are empty, return quickly. Otherwise, // we'll fetch both so that errors are consistent. if (arg_refs_id == SemIR::NodeBlockId::Empty && @@ -498,8 +496,7 @@ auto Context::ImplicitAsForArgs( return true; } -auto Context::ImplicitAsRequired(ParseTree::Node parse_node, - SemIR::NodeId value_id, +auto Context::ImplicitAsRequired(Parse::Node parse_node, SemIR::NodeId value_id, SemIR::TypeId as_type_id) -> SemIR::NodeId { SemIR::NodeId output_value_id = value_id; if (ImplicitAsImpl(value_id, as_type_id, &output_value_id) == @@ -623,7 +620,7 @@ auto Context::ParamOrArgComma(bool for_args) -> void { ParamOrArgSave(for_args); } -auto Context::ParamOrArgEnd(bool for_args, ParseNodeKind start_kind) +auto Context::ParamOrArgEnd(bool for_args, Parse::NodeKind start_kind) -> SemIR::NodeBlockId { if (parse_tree_->node_kind(node_stack_.PeekParseNode()) != start_kind) { ParamOrArgSave(for_args); @@ -773,14 +770,14 @@ auto Context::CanonicalizeType(SemIR::NodeId node_id) -> SemIR::TypeId { return CanonicalizeTypeImpl(node.kind(), profile_node, make_node); } -auto Context::CanonicalizeStructType(ParseTree::Node parse_node, +auto Context::CanonicalizeStructType(Parse::Node parse_node, SemIR::NodeBlockId refs_id) -> SemIR::TypeId { return CanonicalizeTypeAndAddNodeIfNew(SemIR::Node::StructType::Make( parse_node, SemIR::TypeId::TypeType, refs_id)); } -auto Context::CanonicalizeTupleType(ParseTree::Node parse_node, +auto Context::CanonicalizeTupleType(Parse::Node parse_node, llvm::SmallVector&& type_ids) -> SemIR::TypeId { // Defer allocating a SemIR::TypeBlockId until we know this is a new type. @@ -798,7 +795,7 @@ auto Context::CanonicalizeTupleType(ParseTree::Node parse_node, make_tuple_node); } -auto Context::GetPointerType(ParseTree::Node parse_node, +auto Context::GetPointerType(Parse::Node parse_node, SemIR::TypeId pointee_type_id) -> SemIR::TypeId { return CanonicalizeTypeAndAddNodeIfNew(SemIR::Node::PointerType::Make( parse_node, SemIR::TypeId::TypeType, pointee_type_id)); diff --git a/toolchain/semantics/semantics_context.h b/toolchain/semantics/semantics_context.h index e420ac81967c..e98457597051 100644 --- a/toolchain/semantics/semantics_context.h +++ b/toolchain/semantics/semantics_context.h @@ -23,12 +23,12 @@ class Context { public: // Stores references for work. explicit Context(const TokenizedBuffer& tokens, - DiagnosticEmitter& emitter, - const ParseTree& parse_tree, SemIR::File& semantics, + DiagnosticEmitter& emitter, + const Parse::Tree& parse_tree, SemIR::File& semantics, llvm::raw_ostream* vlog_stream); // Marks an implementation TODO. Always returns false. - auto TODO(ParseTree::Node parse_node, std::string label) -> bool; + auto TODO(Parse::Node parse_node, std::string label) -> bool; // Runs verification that the processing cleanly finished. auto VerifyOnFinish() -> void; @@ -42,24 +42,24 @@ class Context { // Pushes a parse tree node onto the stack, storing the SemIR::Node as the // result. - auto AddNodeAndPush(ParseTree::Node parse_node, SemIR::Node node) -> void; + auto AddNodeAndPush(Parse::Node parse_node, SemIR::Node node) -> void; // Adds a name to name lookup. Prints a diagnostic for name conflicts. - auto AddNameToLookup(ParseTree::Node name_node, SemIR::StringId name_id, + auto AddNameToLookup(Parse::Node name_node, SemIR::StringId name_id, SemIR::NodeId target_id) -> void; // Performs name lookup in a specified scope, returning the referenced node. // If scope_id is invalid, uses the current contextual scope. - auto LookupName(ParseTree::Node parse_node, SemIR::StringId name_id, + auto LookupName(Parse::Node parse_node, SemIR::StringId name_id, SemIR::NameScopeId scope_id, bool print_diagnostics) -> SemIR::NodeId; // Prints a diagnostic for a duplicate name. - auto DiagnoseDuplicateName(ParseTree::Node parse_node, - SemIR::NodeId prev_def_id) -> void; + auto DiagnoseDuplicateName(Parse::Node parse_node, SemIR::NodeId prev_def_id) + -> void; // Prints a diagnostic for a missing name. - auto DiagnoseNameNotFound(ParseTree::Node parse_node, SemIR::StringId name_id) + auto DiagnoseNameNotFound(Parse::Node parse_node, SemIR::StringId name_id) -> void; // Pushes a new scope onto scope_stack_. @@ -71,20 +71,19 @@ class Context { // Adds a `Branch` node branching to a new node block, and returns the ID of // the new block. All paths to the branch target must go through the current // block, though not necessarily through this branch. - auto AddDominatedBlockAndBranch(ParseTree::Node parse_node) - -> SemIR::NodeBlockId; + auto AddDominatedBlockAndBranch(Parse::Node parse_node) -> SemIR::NodeBlockId; // Adds a `Branch` node branching to a new node block with a value, and // returns the ID of the new block. All paths to the branch target must go // through the current block. - auto AddDominatedBlockAndBranchWithArg(ParseTree::Node parse_node, + auto AddDominatedBlockAndBranchWithArg(Parse::Node parse_node, SemIR::NodeId arg_id) -> SemIR::NodeBlockId; // Adds a `BranchIf` node branching to a new node block, and returns the ID // of the new block. All paths to the branch target must go through the // current block. - auto AddDominatedBlockAndBranchIf(ParseTree::Node parse_node, + auto AddDominatedBlockAndBranchIf(Parse::Node parse_node, SemIR::NodeId cond_id) -> SemIR::NodeBlockId; @@ -92,15 +91,15 @@ class Context { // reconvergence of control flow, and pushes the new block onto the node // block stack. auto AddConvergenceBlockAndPush( - ParseTree::Node parse_node, - std::initializer_list blocks) -> void; + Parse::Node parse_node, std::initializer_list blocks) + -> void; // Adds branches from the given list of blocks and values to a new block, for // reconvergence of control flow with a result value, and pushes the new // block onto the node block stack. Returns a node referring to the result // value. auto AddConvergenceBlockWithArgAndPush( - ParseTree::Node parse_node, + Parse::Node parse_node, std::initializer_list> blocks_and_args) -> SemIR::NodeId; @@ -124,18 +123,18 @@ class Context { auto ConvertToValueExpression(SemIR::NodeId expr_id) -> SemIR::NodeId; // Performs initialization of `target_id` from `value_id`. - auto Initialize(ParseTree::Node parse_node, SemIR::NodeId target_id, + auto Initialize(Parse::Node parse_node, SemIR::NodeId target_id, SemIR::NodeId value_id) -> void; // Converts `value_id` to a value expression of type `type_id`. - auto ConvertToValueOfType(ParseTree::Node parse_node, SemIR::NodeId value_id, + auto ConvertToValueOfType(Parse::Node parse_node, SemIR::NodeId value_id, SemIR::TypeId type_id) -> SemIR::NodeId { return ConvertToValueExpression( ImplicitAsRequired(parse_node, value_id, type_id)); } // Converts `value_id` to a value expression of type `bool`. - auto ConvertToBoolValue(ParseTree::Node parse_node, SemIR::NodeId value_id) + auto ConvertToBoolValue(Parse::Node parse_node, SemIR::NodeId value_id) -> SemIR::NodeId { return ConvertToValueOfType( parse_node, value_id, CanonicalizeType(SemIR::NodeId::BuiltinBoolType)); @@ -152,15 +151,14 @@ class Context { // future we may want to remember the right implicit conversions to do for // valid cases in order to efficiently handle generics. auto ImplicitAsForArgs( - SemIR::NodeBlockId arg_refs_id, ParseTree::Node param_parse_node, + SemIR::NodeBlockId arg_refs_id, Parse::Node param_parse_node, SemIR::NodeBlockId param_refs_id, - DiagnosticEmitter::DiagnosticBuilder* diagnostic) - -> bool; + DiagnosticEmitter::DiagnosticBuilder* diagnostic) -> bool; // Runs ImplicitAsImpl for a situation where a cast is required, returning the // updated `value_id`. Prints a diagnostic and returns an Error if // unsupported. - auto ImplicitAsRequired(ParseTree::Node parse_node, SemIR::NodeId value_id, + auto ImplicitAsRequired(Parse::Node parse_node, SemIR::NodeId value_id, SemIR::TypeId as_type_id) -> SemIR::NodeId; // Canonicalizes a type which is tracked as a single node. @@ -174,22 +172,22 @@ class Context { // Individual struct type fields aren't canonicalized because they may have // name conflicts or other diagnostics during creation, which can use the // parse node. - auto CanonicalizeStructType(ParseTree::Node parse_node, + auto CanonicalizeStructType(Parse::Node parse_node, SemIR::NodeBlockId refs_id) -> SemIR::TypeId; // Handles canonicalization of tuple types. This may create a new tuple type // if the `type_ids` doesn't match an existing tuple type. - auto CanonicalizeTupleType(ParseTree::Node parse_node, + auto CanonicalizeTupleType(Parse::Node parse_node, llvm::SmallVector&& type_ids) -> SemIR::TypeId; // Returns a pointer type whose pointee type is `pointee_type_id`. - auto GetPointerType(ParseTree::Node parse_node, SemIR::TypeId pointee_type_id) + auto GetPointerType(Parse::Node parse_node, SemIR::TypeId pointee_type_id) -> SemIR::TypeId; // Converts an expression for use as a type. // TODO: This should eventually return a type ID. - auto ExpressionAsType(ParseTree::Node parse_node, SemIR::NodeId value_id) + auto ExpressionAsType(Parse::Node parse_node, SemIR::NodeId value_id) -> SemIR::TypeId { auto node = semantics_ir_->GetNode(value_id); if (node.kind() == SemIR::NodeKind::StubReference) { @@ -216,7 +214,7 @@ class Context { // Detects whether there's an entry to push. On return, the top of // node_stack_ will be start_kind, and the caller should do type-specific // processing. Returns refs_id. - auto ParamOrArgEnd(bool for_args, ParseNodeKind start_kind) + auto ParamOrArgEnd(bool for_args, Parse::NodeKind start_kind) -> SemIR::NodeBlockId; // Saves a parameter from the top block in node_stack_ to the top block in @@ -231,9 +229,9 @@ class Context { auto tokens() -> const TokenizedBuffer& { return *tokens_; } - auto emitter() -> DiagnosticEmitter& { return *emitter_; } + auto emitter() -> DiagnosticEmitter& { return *emitter_; } - auto parse_tree() -> const ParseTree& { return *parse_tree_; } + auto parse_tree() -> const Parse::Tree& { return *parse_tree_; } auto semantics_ir() -> SemIR::File& { return *semantics_ir_; } @@ -336,10 +334,10 @@ class Context { const TokenizedBuffer* tokens_; // Handles diagnostics. - DiagnosticEmitter* emitter_; + DiagnosticEmitter* emitter_; // The file's parse tree. - const ParseTree* parse_tree_; + const Parse::Tree* parse_tree_; // The SemIR::File being added to. SemIR::File* semantics_ir_; @@ -398,7 +396,7 @@ class Context { // Parse node handlers. Returns false for unrecoverable errors. #define CARBON_PARSE_NODE_KIND(Name) \ - auto Handle##Name(Context& context, ParseTree::Node parse_node)->bool; + auto Handle##Name(Context& context, Parse::Node parse_node)->bool; #include "toolchain/parser/parse_node_kind.def" } // namespace Carbon::Check diff --git a/toolchain/semantics/semantics_declaration_name_stack.cpp b/toolchain/semantics/semantics_declaration_name_stack.cpp index a1e7ec7602ad..1e044f014eed 100644 --- a/toolchain/semantics/semantics_declaration_name_stack.cpp +++ b/toolchain/semantics/semantics_declaration_name_stack.cpp @@ -18,15 +18,15 @@ auto DeclarationNameStack::Push() -> void { auto DeclarationNameStack::Pop() -> NameContext { if (context_->parse_tree().node_kind( context_->node_stack().PeekParseNode()) == - ParseNodeKind::QualifiedDeclaration) { + Parse::NodeKind::QualifiedDeclaration) { // Any parts from a QualifiedDeclaration will already have been processed // into the name. context_->node_stack() - .PopAndDiscardSoloParseNode(); + .PopAndDiscardSoloParseNode(); } else { // The name had no qualifiers, so we need to process the node now. auto [parse_node, name_id] = - context_->node_stack().PopWithParseNode(); + context_->node_stack().PopWithParseNode(); ApplyNameQualifier(parse_node, name_id); } @@ -68,7 +68,7 @@ auto DeclarationNameStack::AddNameToLookup(NameContext name_context, } } -auto DeclarationNameStack::ApplyExpressionQualifier(ParseTree::Node parse_node, +auto DeclarationNameStack::ApplyExpressionQualifier(Parse::Node parse_node, SemIR::NodeId node_id) -> void { auto& name_context = declaration_name_stack_.back(); @@ -88,7 +88,7 @@ auto DeclarationNameStack::ApplyExpressionQualifier(ParseTree::Node parse_node, } } -auto DeclarationNameStack::ApplyNameQualifier(ParseTree::Node parse_node, +auto DeclarationNameStack::ApplyNameQualifier(Parse::Node parse_node, SemIR::StringId name_id) -> void { auto& name_context = declaration_name_stack_.back(); if (CanResolveQualifier(name_context, parse_node)) { @@ -129,8 +129,7 @@ auto DeclarationNameStack::UpdateScopeIfNeeded(NameContext& name_context) } auto DeclarationNameStack::CanResolveQualifier(NameContext& name_context, - ParseTree::Node parse_node) - -> bool { + Parse::Node parse_node) -> bool { switch (name_context.state) { case NameContext::State::Error: // Already in an error state, so return without examining. diff --git a/toolchain/semantics/semantics_declaration_name_stack.h b/toolchain/semantics/semantics_declaration_name_stack.h index 3e7bfdada84c..de90b9bd5385 100644 --- a/toolchain/semantics/semantics_declaration_name_stack.h +++ b/toolchain/semantics/semantics_declaration_name_stack.h @@ -80,7 +80,7 @@ class DeclarationNameStack { SemIR::NameScopeId target_scope_id = SemIR::NameScopeId::Invalid; // The last parse node used. - ParseTree::Node parse_node = ParseTree::Node::Invalid; + Parse::Node parse_node = Parse::Node::Invalid; union { // The ID of a resolved qualifier, including both identifiers and @@ -105,12 +105,12 @@ class DeclarationNameStack { // Applies an expression from the node stack to the top of the declaration // name stack. - auto ApplyExpressionQualifier(ParseTree::Node parse_node, - SemIR::NodeId node_id) -> void; + auto ApplyExpressionQualifier(Parse::Node parse_node, SemIR::NodeId node_id) + -> void; // Applies a Name from the node stack to the top of the declaration name // stack. - auto ApplyNameQualifier(ParseTree::Node parse_node, SemIR::StringId name_id) + auto ApplyNameQualifier(Parse::Node parse_node, SemIR::StringId name_id) -> void; // Adds a name to name lookup. Prints a diagnostic for name conflicts. @@ -120,8 +120,8 @@ class DeclarationNameStack { private: // Returns true if the context is in a state where it can resolve qualifiers. // Updates name_context as needed. - auto CanResolveQualifier(NameContext& name_context, - ParseTree::Node parse_node) -> bool; + auto CanResolveQualifier(NameContext& name_context, Parse::Node parse_node) + -> bool; // Updates the scope on name_context as needed. This is called after // resolution is complete, whether for Name or expression. diff --git a/toolchain/semantics/semantics_handle_array.cpp b/toolchain/semantics/semantics_handle_array.cpp index 6b08f1cd5153..685fc67408e3 100644 --- a/toolchain/semantics/semantics_handle_array.cpp +++ b/toolchain/semantics/semantics_handle_array.cpp @@ -10,21 +10,20 @@ namespace Carbon::Check { auto HandleArrayExpressionStart(Context& /*context*/, - ParseTree::Node /*parse_node*/) -> bool { + Parse::Node /*parse_node*/) -> bool { return true; } -auto HandleArrayExpressionSemi(Context& context, ParseTree::Node parse_node) +auto HandleArrayExpressionSemi(Context& context, Parse::Node parse_node) -> bool { context.node_stack().Push(parse_node); return true; } -auto HandleArrayExpression(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleArrayExpression(Context& context, Parse::Node parse_node) -> bool { // TODO: Handle array type with undefined bound. if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) == - ParseNodeKind::ArrayExpressionSemi) { + Parse::NodeKind::ArrayExpressionSemi) { context.node_stack().PopAndIgnore(); context.node_stack().PopAndIgnore(); return context.TODO(parse_node, "HandleArrayExpressionWithoutBounds"); @@ -32,7 +31,7 @@ auto HandleArrayExpression(Context& context, ParseTree::Node parse_node) auto bound_node_id = context.node_stack().PopExpression(); context.node_stack() - .PopAndDiscardSoloParseNode(); + .PopAndDiscardSoloParseNode(); auto element_type_node_id = context.node_stack().PopExpression(); auto bound_node = context.semantics_ir().GetNode(bound_node_id); if (bound_node.kind() == SemIR::NodeKind::IntegerLiteral) { diff --git a/toolchain/semantics/semantics_handle_call_expression.cpp b/toolchain/semantics/semantics_handle_call_expression.cpp index 620cc15eff6d..3d8bd387c8e8 100644 --- a/toolchain/semantics/semantics_handle_call_expression.cpp +++ b/toolchain/semantics/semantics_handle_call_expression.cpp @@ -7,15 +7,14 @@ namespace Carbon::Check { -auto HandleCallExpression(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleCallExpression(Context& context, Parse::Node parse_node) -> bool { auto refs_id = context.ParamOrArgEnd( - /*for_args=*/true, ParseNodeKind::CallExpressionStart); + /*for_args=*/true, Parse::NodeKind::CallExpressionStart); // TODO: Convert to call expression. auto [call_expr_parse_node, name_id] = context.node_stack() - .PopWithParseNode(); + .PopWithParseNode(); auto name_node = context.semantics_ir().GetNode(name_id); if (name_node.kind() != SemIR::NodeKind::FunctionDeclaration) { // TODO: Work on error. @@ -67,13 +66,13 @@ auto HandleCallExpression(Context& context, ParseTree::Node parse_node) return true; } -auto HandleCallExpressionComma(Context& context, ParseTree::Node /*parse_node*/) +auto HandleCallExpressionComma(Context& context, Parse::Node /*parse_node*/) -> bool { context.ParamOrArgComma(/*for_args=*/true); return true; } -auto HandleCallExpressionStart(Context& context, ParseTree::Node parse_node) +auto HandleCallExpressionStart(Context& context, Parse::Node parse_node) -> bool { auto name_id = context.node_stack().PopExpression(); context.node_stack().Push(parse_node, name_id); diff --git a/toolchain/semantics/semantics_handle_class.cpp b/toolchain/semantics/semantics_handle_class.cpp index 7339e8a2e51d..127ee3d093d3 100644 --- a/toolchain/semantics/semantics_handle_class.cpp +++ b/toolchain/semantics/semantics_handle_class.cpp @@ -6,23 +6,20 @@ namespace Carbon::Check { -auto HandleClassDeclaration(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleClassDeclaration(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleClassDeclaration"); } -auto HandleClassDefinition(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleClassDefinition(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleClassDefinition"); } -auto HandleClassDefinitionStart(Context& context, ParseTree::Node parse_node) +auto HandleClassDefinitionStart(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleClassDefinitionStart"); } -auto HandleClassIntroducer(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleClassIntroducer(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleClassIntroducer"); } diff --git a/toolchain/semantics/semantics_handle_codeblock.cpp b/toolchain/semantics/semantics_handle_codeblock.cpp index b693ff603dbb..eea5dbe70506 100644 --- a/toolchain/semantics/semantics_handle_codeblock.cpp +++ b/toolchain/semantics/semantics_handle_codeblock.cpp @@ -6,16 +6,15 @@ namespace Carbon::Check { -auto HandleCodeBlockStart(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleCodeBlockStart(Context& context, Parse::Node parse_node) -> bool { context.node_stack().Push(parse_node); context.PushScope(); return true; } -auto HandleCodeBlock(Context& context, ParseTree::Node /*parse_node*/) -> bool { +auto HandleCodeBlock(Context& context, Parse::Node /*parse_node*/) -> bool { context.PopScope(); - context.node_stack().PopForSoloParseNode(); + context.node_stack().PopForSoloParseNode(); return true; } diff --git a/toolchain/semantics/semantics_handle_function.cpp b/toolchain/semantics/semantics_handle_function.cpp index a20337b17d03..3c29fc22fd6c 100644 --- a/toolchain/semantics/semantics_handle_function.cpp +++ b/toolchain/semantics/semantics_handle_function.cpp @@ -23,8 +23,8 @@ static auto BuildFunctionDeclaration(Context& context) auto return_type_id = SemIR::TypeId::Invalid; auto return_slot_id = SemIR::NodeId::Invalid; if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) == - ParseNodeKind::ReturnType) { - return_slot_id = context.node_stack().Pop(); + Parse::NodeKind::ReturnType) { + return_slot_id = context.node_stack().Pop(); return_type_id = context.semantics_ir().GetNode(return_slot_id).type_id(); // The function only has a return slot if it uses in-place initialization. @@ -36,10 +36,11 @@ static auto BuildFunctionDeclaration(Context& context) } SemIR::NodeBlockId param_refs_id = - context.node_stack().Pop(); + context.node_stack().Pop(); auto name_context = context.declaration_name_stack().Pop(); - auto fn_node = context.node_stack() - .PopForSoloParseNode(); + auto fn_node = + context.node_stack() + .PopForSoloParseNode(); // TODO: Support out-of-line definitions, which will have a resolved // name_context. Right now, those become errors in AddNameToLookup. @@ -60,16 +61,16 @@ static auto BuildFunctionDeclaration(Context& context) return {function_id, decl_id}; } -auto HandleFunctionDeclaration(Context& context, ParseTree::Node /*parse_node*/) +auto HandleFunctionDeclaration(Context& context, Parse::Node /*parse_node*/) -> bool { BuildFunctionDeclaration(context); return true; } -auto HandleFunctionDefinition(Context& context, ParseTree::Node parse_node) +auto HandleFunctionDefinition(Context& context, Parse::Node parse_node) -> bool { SemIR::FunctionId function_id = - context.node_stack().Pop(); + context.node_stack().Pop(); // If the `}` of the function is reachable, reject if we need a return value // and otherwise add an implicit `return;`. @@ -92,7 +93,7 @@ auto HandleFunctionDefinition(Context& context, ParseTree::Node parse_node) return true; } -auto HandleFunctionDefinitionStart(Context& context, ParseTree::Node parse_node) +auto HandleFunctionDefinitionStart(Context& context, Parse::Node parse_node) -> bool { // Process the declaration portion of the function. auto [function_id, decl_id] = BuildFunctionDeclaration(context); @@ -116,7 +117,7 @@ auto HandleFunctionDefinitionStart(Context& context, ParseTree::Node parse_node) return true; } -auto HandleFunctionIntroducer(Context& context, ParseTree::Node parse_node) +auto HandleFunctionIntroducer(Context& context, Parse::Node parse_node) -> bool { // Create a node block to hold the nodes created as part of the function // signature, such as parameter and return types. @@ -128,7 +129,7 @@ auto HandleFunctionIntroducer(Context& context, ParseTree::Node parse_node) return true; } -auto HandleReturnType(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleReturnType(Context& context, Parse::Node parse_node) -> bool { // Propagate the type expression. auto [type_parse_node, type_node_id] = context.node_stack().PopExpressionWithParseNode(); diff --git a/toolchain/semantics/semantics_handle_if_expression.cpp b/toolchain/semantics/semantics_handle_if_expression.cpp index 24c073999819..ea9de7fa6817 100644 --- a/toolchain/semantics/semantics_handle_if_expression.cpp +++ b/toolchain/semantics/semantics_handle_if_expression.cpp @@ -6,8 +6,7 @@ namespace Carbon::Check { -auto HandleIfExpressionIf(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleIfExpressionIf(Context& context, Parse::Node parse_node) -> bool { // Alias parse_node for if/then/else consistency. auto& if_node = parse_node; @@ -29,8 +28,7 @@ auto HandleIfExpressionIf(Context& context, ParseTree::Node parse_node) return true; } -auto HandleIfExpressionThen(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleIfExpressionThen(Context& context, Parse::Node parse_node) -> bool { // Alias parse_node for if/then/else consistency. auto& then_node = parse_node; @@ -45,17 +43,17 @@ auto HandleIfExpressionThen(Context& context, ParseTree::Node parse_node) return true; } -auto HandleIfExpressionElse(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleIfExpressionElse(Context& context, Parse::Node parse_node) -> bool { // Alias parse_node for if/then/else consistency. auto& else_node = parse_node; auto else_value_id = context.node_stack().PopExpression(); auto [then_node, then_end_block_id] = - context.node_stack().PopWithParseNode(); + context.node_stack() + .PopWithParseNode(); auto then_value_id = context.node_stack().PopExpression(); - auto if_node = - context.node_stack().PopForSoloParseNode(); + auto if_node = context.node_stack() + .PopForSoloParseNode(); // Convert the `else` value to the `then` value's type, and finish the `else` // block. diff --git a/toolchain/semantics/semantics_handle_if_statement.cpp b/toolchain/semantics/semantics_handle_if_statement.cpp index 22400befec3e..095d69a22b8e 100644 --- a/toolchain/semantics/semantics_handle_if_statement.cpp +++ b/toolchain/semantics/semantics_handle_if_statement.cpp @@ -7,12 +7,12 @@ namespace Carbon::Check { -auto HandleIfConditionStart(Context& /*context*/, - ParseTree::Node /*parse_node*/) -> bool { +auto HandleIfConditionStart(Context& /*context*/, Parse::Node /*parse_node*/) + -> bool { return true; } -auto HandleIfCondition(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleIfCondition(Context& context, Parse::Node parse_node) -> bool { // Convert the condition to `bool`. auto cond_value_id = context.node_stack().PopExpression(); cond_value_id = context.ConvertToBoolValue(parse_node, cond_value_id); @@ -34,9 +34,9 @@ auto HandleIfCondition(Context& context, ParseTree::Node parse_node) -> bool { return true; } -auto HandleIfStatementElse(Context& context, ParseTree::Node parse_node) - -> bool { - context.node_stack().PopAndDiscardSoloParseNode(); +auto HandleIfStatementElse(Context& context, Parse::Node parse_node) -> bool { + context.node_stack() + .PopAndDiscardSoloParseNode(); // Switch to emitting the else block. auto then_block_id = context.node_block_stack().PopForAdd(); @@ -45,17 +45,17 @@ auto HandleIfStatementElse(Context& context, ParseTree::Node parse_node) return true; } -auto HandleIfStatement(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleIfStatement(Context& context, Parse::Node parse_node) -> bool { // Either the then or else block, depending on whether there's an `else` node // on the top of the node stack. auto sub_block_id = context.node_block_stack().PopForAdd(); switch (auto kind = context.parse_tree().node_kind( context.node_stack().PeekParseNode())) { - case ParseNodeKind::IfCondition: { + case Parse::NodeKind::IfCondition: { // Branch from then block to else block. context.node_stack() - .PopAndDiscardSoloParseNode(); + .PopAndDiscardSoloParseNode(); context.AddNodeToBlock( sub_block_id, SemIR::Node::Branch::Make(parse_node, @@ -63,10 +63,10 @@ auto HandleIfStatement(Context& context, ParseTree::Node parse_node) -> bool { break; } - case ParseNodeKind::IfStatementElse: { + case Parse::NodeKind::IfStatementElse: { // Branch from the then and else blocks to a new resumption block. SemIR::NodeBlockId then_block_id = - context.node_stack().Pop(); + context.node_stack().Pop(); context.AddConvergenceBlockAndPush(parse_node, {then_block_id, sub_block_id}); break; diff --git a/toolchain/semantics/semantics_handle_index.cpp b/toolchain/semantics/semantics_handle_index.cpp index 5d9531c481ee..3895631b2aa8 100644 --- a/toolchain/semantics/semantics_handle_index.cpp +++ b/toolchain/semantics/semantics_handle_index.cpp @@ -10,7 +10,7 @@ namespace Carbon::Check { auto HandleIndexExpressionStart(Context& /*context*/, - ParseTree::Node /*parse_node*/) -> bool { + Parse::Node /*parse_node*/) -> bool { // Leave the expression on the stack for IndexExpression. return true; } @@ -18,7 +18,7 @@ auto HandleIndexExpressionStart(Context& /*context*/, // Validates that the index (required to be an IntegerLiteral) is valid within // the array or tuple size. Returns the index on success, or nullptr on failure. static auto ValidateIntegerLiteralBound(Context& context, - ParseTree::Node parse_node, + Parse::Node parse_node, SemIR::Node operand_node, SemIR::Node index_node, int size) -> const llvm::APInt* { @@ -37,8 +37,7 @@ static auto ValidateIntegerLiteralBound(Context& context, return &index_val; } -auto HandleIndexExpression(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleIndexExpression(Context& context, Parse::Node parse_node) -> bool { auto index_node_id = context.node_stack().PopExpression(); auto index_node = context.semantics_ir().GetNode(index_node_id); auto operand_node_id = context.node_stack().PopExpression(); diff --git a/toolchain/semantics/semantics_handle_interface.cpp b/toolchain/semantics/semantics_handle_interface.cpp index 20022740a514..5177b2725d4f 100644 --- a/toolchain/semantics/semantics_handle_interface.cpp +++ b/toolchain/semantics/semantics_handle_interface.cpp @@ -6,22 +6,22 @@ namespace Carbon::Check { -auto HandleInterfaceDeclaration(Context& context, ParseTree::Node parse_node) +auto HandleInterfaceDeclaration(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleInterfaceDeclaration"); } -auto HandleInterfaceDefinition(Context& context, ParseTree::Node parse_node) +auto HandleInterfaceDefinition(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleInterfaceDefinition"); } -auto HandleInterfaceDefinitionStart(Context& context, - ParseTree::Node parse_node) -> bool { +auto HandleInterfaceDefinitionStart(Context& context, Parse::Node parse_node) + -> bool { return context.TODO(parse_node, "HandleInterfaceDefinitionStart"); } -auto HandleInterfaceIntroducer(Context& context, ParseTree::Node parse_node) +auto HandleInterfaceIntroducer(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleInterfaceIntroducer"); } diff --git a/toolchain/semantics/semantics_handle_literal.cpp b/toolchain/semantics/semantics_handle_literal.cpp index e764fb7fcad0..d4c9f445e727 100644 --- a/toolchain/semantics/semantics_handle_literal.cpp +++ b/toolchain/semantics/semantics_handle_literal.cpp @@ -6,7 +6,7 @@ namespace Carbon::Check { -auto HandleLiteral(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleLiteral(Context& context, Parse::Node parse_node) -> bool { auto token = context.parse_tree().node_token(parse_node); switch (auto token_kind = context.tokens().GetKind(token)) { case TokenKind::False: diff --git a/toolchain/semantics/semantics_handle_loop_statement.cpp b/toolchain/semantics/semantics_handle_loop_statement.cpp index b82425cf4b9c..0b87a8aa6641 100644 --- a/toolchain/semantics/semantics_handle_loop_statement.cpp +++ b/toolchain/semantics/semantics_handle_loop_statement.cpp @@ -6,55 +6,50 @@ namespace Carbon::Check { -auto HandleBreakStatement(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleBreakStatement(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleBreakStatement"); } -auto HandleBreakStatementStart(Context& context, ParseTree::Node parse_node) +auto HandleBreakStatementStart(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleBreakStatementStart"); } -auto HandleContinueStatement(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleContinueStatement(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleContinueStatement"); } -auto HandleContinueStatementStart(Context& context, ParseTree::Node parse_node) +auto HandleContinueStatementStart(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleContinueStatementStart"); } -auto HandleForHeader(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleForHeader(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleForHeader"); } -auto HandleForHeaderStart(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleForHeaderStart(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleForHeaderStart"); } -auto HandleForIn(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleForIn(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleForIn"); } -auto HandleForStatement(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleForStatement(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleForStatement"); } -auto HandleWhileCondition(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleWhileCondition(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleWhileCondition"); } -auto HandleWhileConditionStart(Context& context, ParseTree::Node parse_node) +auto HandleWhileConditionStart(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleWhileConditionStart"); } -auto HandleWhileStatement(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleWhileStatement(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleWhileStatement"); } diff --git a/toolchain/semantics/semantics_handle_name.cpp b/toolchain/semantics/semantics_handle_name.cpp index 21d0aebcda6d..acd8bf098d43 100644 --- a/toolchain/semantics/semantics_handle_name.cpp +++ b/toolchain/semantics/semantics_handle_name.cpp @@ -8,9 +8,9 @@ namespace Carbon::Check { -auto HandleMemberAccessExpression(Context& context, ParseTree::Node parse_node) +auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node) -> bool { - SemIR::StringId name_id = context.node_stack().Pop(); + SemIR::StringId name_id = context.node_stack().Pop(); auto base_id = context.node_stack().PopExpression(); @@ -74,11 +74,11 @@ auto HandleMemberAccessExpression(Context& context, ParseTree::Node parse_node) } auto HandlePointerMemberAccessExpression(Context& context, - ParseTree::Node parse_node) -> bool { + Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandlePointerMemberAccessExpression"); } -auto HandleName(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleName(Context& context, Parse::Node parse_node) -> bool { auto name_str = context.parse_tree().GetNodeText(parse_node); auto name_id = context.semantics_ir().AddString(name_str); // The parent is responsible for binding the name. @@ -86,8 +86,7 @@ auto HandleName(Context& context, ParseTree::Node parse_node) -> bool { return true; } -auto HandleNameExpression(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleNameExpression(Context& context, Parse::Node parse_node) -> bool { auto name_str = context.parse_tree().GetNodeText(parse_node); auto name_id = context.semantics_ir().AddString(name_str); context.node_stack().Push( @@ -97,11 +96,11 @@ auto HandleNameExpression(Context& context, ParseTree::Node parse_node) return true; } -auto HandleQualifiedDeclaration(Context& context, ParseTree::Node parse_node) +auto HandleQualifiedDeclaration(Context& context, Parse::Node parse_node) -> bool { auto pop_and_apply_first_child = [&]() { if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) != - ParseNodeKind::QualifiedDeclaration) { + Parse::NodeKind::QualifiedDeclaration) { // First QualifiedDeclaration in a chain. auto [parse_node1, node_id1] = context.node_stack().PopExpressionWithParseNode(); @@ -115,9 +114,10 @@ auto HandleQualifiedDeclaration(Context& context, ParseTree::Node parse_node) } }; - ParseTree::Node parse_node2 = context.node_stack().PeekParseNode(); - if (context.parse_tree().node_kind(parse_node2) == ParseNodeKind::Name) { - SemIR::StringId name_id2 = context.node_stack().Pop(); + Parse::Node parse_node2 = context.node_stack().PeekParseNode(); + if (context.parse_tree().node_kind(parse_node2) == Parse::NodeKind::Name) { + SemIR::StringId name_id2 = + context.node_stack().Pop(); pop_and_apply_first_child(); context.declaration_name_stack().ApplyNameQualifier(parse_node2, name_id2); } else { @@ -130,12 +130,12 @@ auto HandleQualifiedDeclaration(Context& context, ParseTree::Node parse_node) return true; } -auto HandleSelfTypeNameExpression(Context& context, ParseTree::Node parse_node) +auto HandleSelfTypeNameExpression(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleSelfTypeNameExpression"); } -auto HandleSelfValueName(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleSelfValueName(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleSelfValueName"); } diff --git a/toolchain/semantics/semantics_handle_named_constraint.cpp b/toolchain/semantics/semantics_handle_named_constraint.cpp index 1527a7b288f1..688cf682cbf3 100644 --- a/toolchain/semantics/semantics_handle_named_constraint.cpp +++ b/toolchain/semantics/semantics_handle_named_constraint.cpp @@ -6,23 +6,23 @@ namespace Carbon::Check { -auto HandleNamedConstraintDeclaration(Context& context, - ParseTree::Node parse_node) -> bool { +auto HandleNamedConstraintDeclaration(Context& context, Parse::Node parse_node) + -> bool { return context.TODO(parse_node, "HandleNamedConstraintDeclaration"); } -auto HandleNamedConstraintDefinition(Context& context, - ParseTree::Node parse_node) -> bool { +auto HandleNamedConstraintDefinition(Context& context, Parse::Node parse_node) + -> bool { return context.TODO(parse_node, "HandleNamedConstraintDefinition"); } auto HandleNamedConstraintDefinitionStart(Context& context, - ParseTree::Node parse_node) -> bool { + Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleNamedConstraintDefinitionStart"); } -auto HandleNamedConstraintIntroducer(Context& context, - ParseTree::Node parse_node) -> bool { +auto HandleNamedConstraintIntroducer(Context& context, Parse::Node parse_node) + -> bool { return context.TODO(parse_node, "HandleNamedConstraintIntroducer"); } diff --git a/toolchain/semantics/semantics_handle_namespace.cpp b/toolchain/semantics/semantics_handle_namespace.cpp index c9e8b65410d5..4574babccaf7 100644 --- a/toolchain/semantics/semantics_handle_namespace.cpp +++ b/toolchain/semantics/semantics_handle_namespace.cpp @@ -7,13 +7,13 @@ namespace Carbon::Check { -auto HandleNamespaceStart(Context& context, ParseTree::Node /*parse_node*/) +auto HandleNamespaceStart(Context& context, Parse::Node /*parse_node*/) -> bool { context.declaration_name_stack().Push(); return true; } -auto HandleNamespace(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleNamespace(Context& context, Parse::Node parse_node) -> bool { auto name_context = context.declaration_name_stack().Pop(); auto namespace_id = context.AddNode(SemIR::Node::Namespace::Make( parse_node, context.semantics_ir().AddNameScope())); diff --git a/toolchain/semantics/semantics_handle_noop.cpp b/toolchain/semantics/semantics_handle_noop.cpp index 03794f40fce4..3eacef6190e3 100644 --- a/toolchain/semantics/semantics_handle_noop.cpp +++ b/toolchain/semantics/semantics_handle_noop.cpp @@ -6,19 +6,18 @@ namespace Carbon::Check { -auto HandleEmptyDeclaration(Context& /*context*/, - ParseTree::Node /*parse_node*/) -> bool { +auto HandleEmptyDeclaration(Context& /*context*/, Parse::Node /*parse_node*/) + -> bool { // Empty declarations have no actions associated. return true; } -auto HandleFileEnd(Context& /*context*/, ParseTree::Node /*parse_node*/) - -> bool { +auto HandleFileEnd(Context& /*context*/, Parse::Node /*parse_node*/) -> bool { // Do nothing, no need to balance this node. return true; } -auto HandleInvalidParse(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleInvalidParse(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleInvalidParse"); } diff --git a/toolchain/semantics/semantics_handle_operator.cpp b/toolchain/semantics/semantics_handle_operator.cpp index 4575106ad7d0..674822c6aee9 100644 --- a/toolchain/semantics/semantics_handle_operator.cpp +++ b/toolchain/semantics/semantics_handle_operator.cpp @@ -6,7 +6,7 @@ namespace Carbon::Check { -auto HandleInfixOperator(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleInfixOperator(Context& context, Parse::Node parse_node) -> bool { auto rhs_id = context.node_stack().PopExpression(); auto [lhs_node, lhs_id] = context.node_stack().PopExpressionWithParseNode(); @@ -72,8 +72,7 @@ auto HandleInfixOperator(Context& context, ParseTree::Node parse_node) -> bool { } } -auto HandlePostfixOperator(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandlePostfixOperator(Context& context, Parse::Node parse_node) -> bool { auto value_id = context.node_stack().PopExpression(); // Figure out the operator for the token. @@ -92,8 +91,7 @@ auto HandlePostfixOperator(Context& context, ParseTree::Node parse_node) } } -auto HandlePrefixOperator(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandlePrefixOperator(Context& context, Parse::Node parse_node) -> bool { auto value_id = context.node_stack().PopExpression(); // Figure out the operator for the token. @@ -191,7 +189,7 @@ auto HandlePrefixOperator(Context& context, ParseTree::Node parse_node) } } -auto HandleShortCircuitOperand(Context& context, ParseTree::Node parse_node) +auto HandleShortCircuitOperand(Context& context, Parse::Node parse_node) -> bool { // Convert the condition to `bool`. auto cond_value_id = context.node_stack().PopExpression(); diff --git a/toolchain/semantics/semantics_handle_package.cpp b/toolchain/semantics/semantics_handle_package.cpp index 7b678a9c33ca..ecbc01f6e6c0 100644 --- a/toolchain/semantics/semantics_handle_package.cpp +++ b/toolchain/semantics/semantics_handle_package.cpp @@ -6,26 +6,23 @@ namespace Carbon::Check { -auto HandlePackageApi(Context& context, ParseTree::Node parse_node) -> bool { +auto HandlePackageApi(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandlePackageApi"); } -auto HandlePackageDirective(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandlePackageDirective(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandlePackageDirective"); } -auto HandlePackageImpl(Context& context, ParseTree::Node parse_node) -> bool { +auto HandlePackageImpl(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandlePackageImpl"); } -auto HandlePackageIntroducer(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandlePackageIntroducer(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandlePackageIntroducer"); } -auto HandlePackageLibrary(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandlePackageLibrary(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandlePackageLibrary"); } diff --git a/toolchain/semantics/semantics_handle_parameter_list.cpp b/toolchain/semantics/semantics_handle_parameter_list.cpp index 345669435761..dd92eae06b00 100644 --- a/toolchain/semantics/semantics_handle_parameter_list.cpp +++ b/toolchain/semantics/semantics_handle_parameter_list.cpp @@ -6,33 +6,33 @@ namespace Carbon::Check { -auto HandleDeducedParameterList(Context& context, ParseTree::Node parse_node) +auto HandleDeducedParameterList(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleDeducedParameterList"); } -auto HandleDeducedParameterListStart(Context& context, - ParseTree::Node parse_node) -> bool { +auto HandleDeducedParameterListStart(Context& context, Parse::Node parse_node) + -> bool { return context.TODO(parse_node, "HandleDeducedParameterListStart"); } -auto HandleParameterList(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleParameterList(Context& context, Parse::Node parse_node) -> bool { auto refs_id = context.ParamOrArgEnd( - /*for_args=*/false, ParseNodeKind::ParameterListStart); + /*for_args=*/false, Parse::NodeKind::ParameterListStart); context.PopScope(); context.node_stack() - .PopAndDiscardSoloParseNode(); + .PopAndDiscardSoloParseNode(); context.node_stack().Push(parse_node, refs_id); return true; } -auto HandleParameterListComma(Context& context, ParseTree::Node /*parse_node*/) +auto HandleParameterListComma(Context& context, Parse::Node /*parse_node*/) -> bool { context.ParamOrArgComma(/*for_args=*/false); return true; } -auto HandleParameterListStart(Context& context, ParseTree::Node parse_node) +auto HandleParameterListStart(Context& context, Parse::Node parse_node) -> bool { context.PushScope(); context.node_stack().Push(parse_node); diff --git a/toolchain/semantics/semantics_handle_paren.cpp b/toolchain/semantics/semantics_handle_paren.cpp index a9421f69bd15..c15999b91fc1 100644 --- a/toolchain/semantics/semantics_handle_paren.cpp +++ b/toolchain/semantics/semantics_handle_paren.cpp @@ -8,23 +8,21 @@ namespace Carbon::Check { -auto HandleParenExpression(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleParenExpression(Context& context, Parse::Node parse_node) -> bool { auto value_id = context.node_stack().PopExpression(); // ParamOrArgStart was called for tuple handling; clean up the ParamOrArg // support for non-tuple cases. context.ParamOrArgEnd( - /*for_args=*/true, ParseNodeKind::ParenExpressionOrTupleLiteralStart); + /*for_args=*/true, Parse::NodeKind::ParenExpressionOrTupleLiteralStart); context.node_stack() .PopAndDiscardSoloParseNode< - ParseNodeKind::ParenExpressionOrTupleLiteralStart>(); + Parse::NodeKind::ParenExpressionOrTupleLiteralStart>(); context.node_stack().Push(parse_node, value_id); return true; } auto HandleParenExpressionOrTupleLiteralStart(Context& context, - ParseTree::Node parse_node) - -> bool { + Parse::Node parse_node) -> bool { context.node_stack().Push(parse_node); context.ParamOrArgStart(); return true; @@ -40,25 +38,25 @@ static auto HandleTupleLiteralElement(Context& context) -> void { context.node_stack().Push(value_node, value_id); } -auto HandleTupleLiteralComma(Context& context, ParseTree::Node /*parse_node*/) +auto HandleTupleLiteralComma(Context& context, Parse::Node /*parse_node*/) -> bool { HandleTupleLiteralElement(context); context.ParamOrArgComma(/*for_args=*/true); return true; } -auto HandleTupleLiteral(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleTupleLiteral(Context& context, Parse::Node parse_node) -> bool { if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) != - ParseNodeKind::ParenExpressionOrTupleLiteralStart) { + Parse::NodeKind::ParenExpressionOrTupleLiteralStart) { HandleTupleLiteralElement(context); } auto refs_id = context.ParamOrArgEnd( - /*for_args=*/true, ParseNodeKind::ParenExpressionOrTupleLiteralStart); + /*for_args=*/true, Parse::NodeKind::ParenExpressionOrTupleLiteralStart); context.node_stack() .PopAndDiscardSoloParseNode< - ParseNodeKind::ParenExpressionOrTupleLiteralStart>(); + Parse::NodeKind::ParenExpressionOrTupleLiteralStart>(); const auto& node_block = context.semantics_ir().GetNodeBlock(refs_id); llvm::SmallVector type_ids; type_ids.reserve(node_block.size()); diff --git a/toolchain/semantics/semantics_handle_pattern_binding.cpp b/toolchain/semantics/semantics_handle_pattern_binding.cpp index 8b693b9c8d3e..80ac646ed14a 100644 --- a/toolchain/semantics/semantics_handle_pattern_binding.cpp +++ b/toolchain/semantics/semantics_handle_pattern_binding.cpp @@ -7,34 +7,33 @@ namespace Carbon::Check { -auto HandleAddress(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleAddress(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleAddress"); } -auto HandleGenericPatternBinding(Context& context, ParseTree::Node parse_node) +auto HandleGenericPatternBinding(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "GenericPatternBinding"); } -auto HandlePatternBinding(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandlePatternBinding(Context& context, Parse::Node parse_node) -> bool { auto [type_node, parsed_type_id] = context.node_stack().PopExpressionWithParseNode(); auto cast_type_id = context.ExpressionAsType(type_node, parsed_type_id); // Get the name. auto [name_node, name_id] = - context.node_stack().PopWithParseNode(); + context.node_stack().PopWithParseNode(); // Allocate a node of the appropriate kind, linked to the name for error // locations. switch (auto context_parse_node_kind = context.parse_tree().node_kind( context.node_stack().PeekParseNode())) { - case ParseNodeKind::VariableIntroducer: + case Parse::NodeKind::VariableIntroducer: context.AddNodeAndPush(parse_node, SemIR::Node::VarStorage::Make( name_node, cast_type_id, name_id)); break; - case ParseNodeKind::ParameterListStart: + case Parse::NodeKind::ParameterListStart: context.AddNodeAndPush(parse_node, SemIR::Node::Parameter::Make( name_node, cast_type_id, name_id)); break; @@ -45,7 +44,7 @@ auto HandlePatternBinding(Context& context, ParseTree::Node parse_node) return true; } -auto HandleTemplate(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleTemplate(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleTemplate"); } diff --git a/toolchain/semantics/semantics_handle_statement.cpp b/toolchain/semantics/semantics_handle_statement.cpp index 428843480269..33c12a44b5dc 100644 --- a/toolchain/semantics/semantics_handle_statement.cpp +++ b/toolchain/semantics/semantics_handle_statement.cpp @@ -7,14 +7,13 @@ namespace Carbon::Check { -auto HandleExpressionStatement(Context& context, ParseTree::Node /*parse_node*/) +auto HandleExpressionStatement(Context& context, Parse::Node /*parse_node*/) -> bool { context.HandleDiscardedExpression(context.node_stack().PopExpression()); return true; } -auto HandleReturnStatement(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleReturnStatement(Context& context, Parse::Node parse_node) -> bool { CARBON_CHECK(!context.return_scope_stack().empty()); const auto& fn_node = context.semantics_ir().GetNode(context.return_scope_stack().back()); @@ -22,9 +21,9 @@ auto HandleReturnStatement(Context& context, ParseTree::Node parse_node) context.semantics_ir().GetFunction(fn_node.GetAsFunctionDeclaration()); if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) == - ParseNodeKind::ReturnStatementStart) { + Parse::NodeKind::ReturnStatementStart) { context.node_stack() - .PopAndDiscardSoloParseNode(); + .PopAndDiscardSoloParseNode(); if (callable.return_type_id.is_valid()) { // TODO: Add a note pointing at the return type's parse node. @@ -40,7 +39,7 @@ auto HandleReturnStatement(Context& context, ParseTree::Node parse_node) } else { auto arg = context.node_stack().PopExpression(); context.node_stack() - .PopAndDiscardSoloParseNode(); + .PopAndDiscardSoloParseNode(); if (!callable.return_type_id.is_valid()) { CARBON_DIAGNOSTIC( @@ -80,7 +79,7 @@ auto HandleReturnStatement(Context& context, ParseTree::Node parse_node) return true; } -auto HandleReturnStatementStart(Context& context, ParseTree::Node parse_node) +auto HandleReturnStatementStart(Context& context, Parse::Node parse_node) -> bool { // No action, just a bracketing node. context.node_stack().Push(parse_node); diff --git a/toolchain/semantics/semantics_handle_struct.cpp b/toolchain/semantics/semantics_handle_struct.cpp index 6660fbf9c0ef..5d55f21a4114 100644 --- a/toolchain/semantics/semantics_handle_struct.cpp +++ b/toolchain/semantics/semantics_handle_struct.cpp @@ -6,47 +6,44 @@ namespace Carbon::Check { -auto HandleStructComma(Context& context, ParseTree::Node /*parse_node*/) - -> bool { +auto HandleStructComma(Context& context, Parse::Node /*parse_node*/) -> bool { context.ParamOrArgComma( /*for_args=*/context.parse_tree().node_kind( context.node_stack().PeekParseNode()) != - ParseNodeKind::StructFieldType); + Parse::NodeKind::StructFieldType); return true; } -auto HandleStructFieldDesignator(Context& context, - ParseTree::Node /*parse_node*/) -> bool { +auto HandleStructFieldDesignator(Context& context, Parse::Node /*parse_node*/) + -> bool { // This leaves the designated name on top because the `.` isn't interesting. CARBON_CHECK( context.parse_tree().node_kind(context.node_stack().PeekParseNode()) == - ParseNodeKind::Name); + Parse::NodeKind::Name); return true; } -auto HandleStructFieldType(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleStructFieldType(Context& context, Parse::Node parse_node) -> bool { auto [type_node, type_id] = context.node_stack().PopExpressionWithParseNode(); SemIR::TypeId cast_type_id = context.ExpressionAsType(type_node, type_id); auto [name_node, name_id] = - context.node_stack().PopWithParseNode(); + context.node_stack().PopWithParseNode(); context.AddNodeAndPush(parse_node, SemIR::Node::StructTypeField::Make( name_node, name_id, cast_type_id)); return true; } -auto HandleStructFieldUnknown(Context& context, ParseTree::Node parse_node) +auto HandleStructFieldUnknown(Context& context, Parse::Node parse_node) -> bool { return context.TODO(parse_node, "HandleStructFieldUnknown"); } -auto HandleStructFieldValue(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleStructFieldValue(Context& context, Parse::Node parse_node) -> bool { auto [value_parse_node, value_node_id] = context.node_stack().PopExpressionWithParseNode(); - SemIR::StringId name_id = context.node_stack().Pop(); + SemIR::StringId name_id = context.node_stack().Pop(); // Convert the operand to a value. // TODO: We need to decide how struct literals interact with expression @@ -66,14 +63,15 @@ auto HandleStructFieldValue(Context& context, ParseTree::Node parse_node) return true; } -auto HandleStructLiteral(Context& context, ParseTree::Node parse_node) -> bool { +auto HandleStructLiteral(Context& context, Parse::Node parse_node) -> bool { auto refs_id = context.ParamOrArgEnd( - /*for_args=*/true, ParseNodeKind::StructLiteralOrStructTypeLiteralStart); + /*for_args=*/true, + Parse::NodeKind::StructLiteralOrStructTypeLiteralStart); context.PopScope(); context.node_stack() .PopAndDiscardSoloParseNode< - ParseNodeKind::StructLiteralOrStructTypeLiteralStart>(); + Parse::NodeKind::StructLiteralOrStructTypeLiteralStart>(); auto type_block_id = context.args_type_info_stack().Pop(); auto type_id = context.CanonicalizeStructType(parse_node, type_block_id); @@ -85,7 +83,7 @@ auto HandleStructLiteral(Context& context, ParseTree::Node parse_node) -> bool { } auto HandleStructLiteralOrStructTypeLiteralStart(Context& context, - ParseTree::Node parse_node) + Parse::Node parse_node) -> bool { context.PushScope(); context.node_stack().Push(parse_node); @@ -97,15 +95,15 @@ auto HandleStructLiteralOrStructTypeLiteralStart(Context& context, return true; } -auto HandleStructTypeLiteral(Context& context, ParseTree::Node parse_node) - -> bool { +auto HandleStructTypeLiteral(Context& context, Parse::Node parse_node) -> bool { auto refs_id = context.ParamOrArgEnd( - /*for_args=*/false, ParseNodeKind::StructLiteralOrStructTypeLiteralStart); + /*for_args=*/false, + Parse::NodeKind::StructLiteralOrStructTypeLiteralStart); context.PopScope(); context.node_stack() .PopAndDiscardSoloParseNode< - ParseNodeKind::StructLiteralOrStructTypeLiteralStart>(); + Parse::NodeKind::StructLiteralOrStructTypeLiteralStart>(); // This is only used for value literals. context.args_type_info_stack().Pop(); diff --git a/toolchain/semantics/semantics_handle_variable.cpp b/toolchain/semantics/semantics_handle_variable.cpp index fb6009ee6f52..e32770dff8c5 100644 --- a/toolchain/semantics/semantics_handle_variable.cpp +++ b/toolchain/semantics/semantics_handle_variable.cpp @@ -7,22 +7,22 @@ namespace Carbon::Check { -auto HandleVariableDeclaration(Context& context, ParseTree::Node parse_node) +auto HandleVariableDeclaration(Context& context, Parse::Node parse_node) -> bool { // Handle the optional initializer. auto expr_node_id = SemIR::NodeId::Invalid; bool has_init = context.parse_tree().node_kind(context.node_stack().PeekParseNode()) != - ParseNodeKind::PatternBinding; + Parse::NodeKind::PatternBinding; if (has_init) { expr_node_id = context.node_stack().PopExpression(); context.node_stack() - .PopAndDiscardSoloParseNode(); + .PopAndDiscardSoloParseNode(); } // Get the storage and add it to name lookup. SemIR::NodeId var_id = - context.node_stack().Pop(); + context.node_stack().Pop(); auto var = context.semantics_ir().GetNode(var_id); auto name_id = var.GetAsVarStorage(); context.AddNameToLookup(var.parse_node(), name_id, var_id); @@ -32,19 +32,19 @@ auto HandleVariableDeclaration(Context& context, ParseTree::Node parse_node) } context.node_stack() - .PopAndDiscardSoloParseNode(); + .PopAndDiscardSoloParseNode(); return true; } -auto HandleVariableIntroducer(Context& context, ParseTree::Node parse_node) +auto HandleVariableIntroducer(Context& context, Parse::Node parse_node) -> bool { // No action, just a bracketing node. context.node_stack().Push(parse_node); return true; } -auto HandleVariableInitializer(Context& context, ParseTree::Node parse_node) +auto HandleVariableInitializer(Context& context, Parse::Node parse_node) -> bool { // No action, just a bracketing node. context.node_stack().Push(parse_node); diff --git a/toolchain/semantics/semantics_ir.cpp b/toolchain/semantics/semantics_ir.cpp index c69d6ea91c68..50af883fa236 100644 --- a/toolchain/semantics/semantics_ir.cpp +++ b/toolchain/semantics/semantics_ir.cpp @@ -41,7 +41,7 @@ auto File::MakeBuiltinIR() -> File { auto File::MakeFromParseTree(const File& builtin_ir, const TokenizedBuffer& tokens, - const ParseTree& parse_tree, + const Parse::Tree& parse_tree, DiagnosticConsumer& consumer, llvm::raw_ostream* vlog_stream) -> File { File semantics_ir(&builtin_ir); @@ -57,16 +57,16 @@ auto File::MakeFromParseTree(const File& builtin_ir, Node::CrossReference::Make(type, BuiltinIR, NodeId(i)); } - ParseTreeNodeLocationTranslator translator(&tokens, &parse_tree); + Parse::NodeLocationTranslator translator(&tokens, &parse_tree); ErrorTrackingDiagnosticConsumer err_tracker(consumer); - DiagnosticEmitter emitter(translator, err_tracker); + DiagnosticEmitter emitter(translator, err_tracker); Check::Context context(tokens, emitter, parse_tree, semantics_ir, vlog_stream); PrettyStackTraceFunction context_dumper( [&](llvm::raw_ostream& output) { context.PrintForStackDump(output); }); - // Add a block for the ParseTree. + // Add a block for the Parse::Tree. context.node_block_stack().Push(); context.PushScope(); @@ -77,7 +77,7 @@ auto File::MakeFromParseTree(const File& builtin_ir, // NOLINTNEXTLINE(bugprone-switch-missing-default-case) switch (auto parse_kind = parse_tree.node_kind(parse_node)) { #define CARBON_PARSE_NODE_KIND(Name) \ - case ParseNodeKind::Name: { \ + case Parse::NodeKind::Name: { \ if (!Check::Handle##Name(context, parse_node)) { \ semantics_ir.has_errors_ = true; \ return semantics_ir; \ diff --git a/toolchain/semantics/semantics_ir.h b/toolchain/semantics/semantics_ir.h index f517e2eb897e..4c63e706e468 100644 --- a/toolchain/semantics/semantics_ir.h +++ b/toolchain/semantics/semantics_ir.h @@ -67,16 +67,16 @@ struct RealLiteral { bool is_decimal; }; -// Provides semantic analysis on a ParseTree. +// Provides semantic analysis on a Parse::Tree. class File { public: // Produces the builtins. static auto MakeBuiltinIR() -> File; - // Adds the IR for the provided ParseTree. + // Adds the IR for the provided Parse::Tree. static auto MakeFromParseTree(const File& builtin_ir, const TokenizedBuffer& tokens, - const ParseTree& parse_tree, + const Parse::Tree& parse_tree, DiagnosticConsumer& consumer, llvm::raw_ostream* vlog_stream) -> File; diff --git a/toolchain/semantics/semantics_ir_formatter.cpp b/toolchain/semantics/semantics_ir_formatter.cpp index dd37d99a8043..f94271a6d2f9 100644 --- a/toolchain/semantics/semantics_ir_formatter.cpp +++ b/toolchain/semantics/semantics_ir_formatter.cpp @@ -31,7 +31,7 @@ class NodeNamer { static_assert(sizeof(ScopeIndex) == sizeof(FunctionId)); NodeNamer(const TokenizedBuffer& tokenized_buffer, - const ParseTree& parse_tree, const File& semantics_ir) + const Parse::Tree& parse_tree, const File& semantics_ir) : tokenized_buffer_(tokenized_buffer), parse_tree_(parse_tree), semantics_ir_(semantics_ir) { @@ -51,7 +51,7 @@ class NodeNamer { const auto& fn = semantics_ir.GetFunction(fn_id); // TODO: Provide a location for the function for use as a // disambiguator. - auto fn_loc = ParseTree::Node::Invalid; + auto fn_loc = Parse::Node::Invalid; GetScopeInfo(fn_scope).name = globals.AllocateName( *this, fn_loc, fn.name_id.is_valid() ? semantics_ir.GetString(fn.name_id).str() @@ -174,7 +174,7 @@ class NodeNamer { return Name(allocated.insert({name, NameResult()}).first); } - auto AllocateName(const NodeNamer& namer, ParseTree::Node node, + auto AllocateName(const NodeNamer& namer, Parse::Node node, std::string name = "") -> Name { // The best (shortest) name for this node so far, and the current name // for it. @@ -250,13 +250,12 @@ class NodeNamer { auto AddBlockLabel(ScopeIndex scope_idx, NodeBlockId block_id, std::string name = "", - ParseTree::Node parse_node = ParseTree::Node::Invalid) - -> void { + Parse::Node parse_node = Parse::Node::Invalid) -> void { if (!block_id.is_valid() || labels[block_id.index].second) { return; } - if (parse_node == ParseTree::Node::Invalid) { + if (parse_node == Parse::Node::Invalid) { if (const auto& block = semantics_ir_.GetNodeBlock(block_id); !block.empty()) { parse_node = semantics_ir_.GetNode(block.front()).parse_node(); @@ -274,7 +273,7 @@ class NodeNamer { -> void { llvm::StringRef name; switch (parse_tree_.node_kind(node.parse_node())) { - case ParseNodeKind::IfExpressionIf: + case Parse::NodeKind::IfExpressionIf: switch (node.kind()) { case NodeKind::BranchIf: name = "if.expr.then"; @@ -290,7 +289,7 @@ class NodeNamer { } break; - case ParseNodeKind::IfCondition: + case Parse::NodeKind::IfCondition: switch (node.kind()) { case NodeKind::BranchIf: name = "if.then"; @@ -303,11 +302,11 @@ class NodeNamer { } break; - case ParseNodeKind::IfStatement: + case Parse::NodeKind::IfStatement: name = "if.done"; break; - case ParseNodeKind::ShortCircuitOperand: { + case Parse::NodeKind::ShortCircuitOperand: { bool is_rhs = node.kind() == NodeKind::BranchIf; bool is_and = tokenized_buffer_.GetKind(parse_tree_.node_token( node.parse_node())) == TokenKind::And; @@ -384,7 +383,7 @@ class NodeNamer { } const TokenizedBuffer& tokenized_buffer_; - const ParseTree& parse_tree_; + const Parse::Tree& parse_tree_; const File& semantics_ir_; Namespace globals = {.prefix = "@"}; @@ -398,7 +397,7 @@ class NodeNamer { class Formatter { public: explicit Formatter(const TokenizedBuffer& tokenized_buffer, - const ParseTree& parse_tree, const File& semantics_ir, + const Parse::Tree& parse_tree, const File& semantics_ir, llvm::raw_ostream& out) : semantics_ir_(semantics_ir), out_(out), @@ -760,7 +759,7 @@ class Formatter { }; auto FormatFile(const TokenizedBuffer& tokenized_buffer, - const ParseTree& parse_tree, const File& semantics_ir, + const Parse::Tree& parse_tree, const File& semantics_ir, llvm::raw_ostream& out) -> void { Formatter(tokenized_buffer, parse_tree, semantics_ir, out).Format(); } diff --git a/toolchain/semantics/semantics_ir_formatter.h b/toolchain/semantics/semantics_ir_formatter.h index c075daf05167..3562af1d099c 100644 --- a/toolchain/semantics/semantics_ir_formatter.h +++ b/toolchain/semantics/semantics_ir_formatter.h @@ -11,7 +11,7 @@ namespace Carbon::SemIR { auto FormatFile(const TokenizedBuffer& tokenized_buffer, - const ParseTree& parse_tree, const File& semantics_ir, + const Parse::Tree& parse_tree, const File& semantics_ir, llvm::raw_ostream& out) -> void; } // namespace Carbon::SemIR diff --git a/toolchain/semantics/semantics_node.h b/toolchain/semantics/semantics_node.h index d232e2877b2a..c6ec4e5cbe18 100644 --- a/toolchain/semantics/semantics_node.h +++ b/toolchain/semantics/semantics_node.h @@ -239,7 +239,7 @@ class Node { template class FactoryBase { protected: - static auto Make(ParseTree::Node parse_node, TypeId type_id, + static auto Make(Parse::Node parse_node, TypeId type_id, ArgTypes... arg_ids) -> Node { return Node(parse_node, NodeKind::Create(Kind), type_id, arg_ids.index...); @@ -282,7 +282,7 @@ class Node { template class FactoryNoType : public FactoryBase { public: - static auto Make(ParseTree::Node parse_node, ArgTypes... args) { + static auto Make(Parse::Node parse_node, ArgTypes... args) { return FactoryBase::Make(parse_node, TypeId::Invalid, args...); } @@ -332,11 +332,11 @@ class Node { class Builtin { public: static auto Make(BuiltinKind builtin_kind, TypeId type_id) -> Node { - // Builtins won't have a ParseTree node associated, so we provide the + // Builtins won't have a Parse::Tree node associated, so we provide the // default invalid one. // This can't use the standard Make function because of the `AsInt()` cast // instead of `.index`. - return Node(ParseTree::Node::Invalid, NodeKind::Builtin, type_id, + return Node(Parse::Node::Invalid, NodeKind::Builtin, type_id, builtin_kind.AsInt()); } static auto Get(Node node) -> BuiltinKind { @@ -358,8 +358,7 @@ class Node { // A node's parse tree node must refer to a node in the current parse // tree. This cannot use the cross-referenced node's parse tree node // because it will be in a different parse tree. - return FactoryBase::Make(ParseTree::Node::Invalid, type_id, ir_id, - node_id); + return FactoryBase::Make(Parse::Node::Invalid, type_id, ir_id, node_id); } using FactoryBase::Get; }; @@ -419,7 +418,7 @@ class Node { using VarStorage = Factory; explicit Node() - : Node(ParseTree::Node::Invalid, NodeKind::Invalid, TypeId::Invalid) {} + : Node(Parse::Node::Invalid, NodeKind::Invalid, TypeId::Invalid) {} // Provide `node.GetAsKind()` as an instance method for all kinds, essentially // an alias for`Node::Kind::Get(node)`. @@ -427,7 +426,7 @@ class Node { auto GetAs##Name() const { return Name::Get(*this); } #include "toolchain/semantics/semantics_node_kind.def" - auto parse_node() const -> ParseTree::Node { return parse_node_; } + auto parse_node() const -> Parse::Node { return parse_node_; } auto kind() const -> NodeKind { return kind_; } // Gets the type of the value produced by evaluating this node. @@ -440,7 +439,7 @@ class Node { // a factory base class. friend struct NodeForBuiltin; - explicit Node(ParseTree::Node parse_node, NodeKind kind, TypeId type_id, + explicit Node(Parse::Node parse_node, NodeKind kind, TypeId type_id, int32_t arg0 = NodeId::InvalidIndex, int32_t arg1 = NodeId::InvalidIndex) : parse_node_(parse_node), @@ -449,7 +448,7 @@ class Node { arg0_(arg0), arg1_(arg1) {} - ParseTree::Node parse_node_; + Parse::Node parse_node_; NodeKind kind_; TypeId type_id_; diff --git a/toolchain/semantics/semantics_node_stack.cpp b/toolchain/semantics/semantics_node_stack.cpp index ac13fc1b62e7..51a38ef19a83 100644 --- a/toolchain/semantics/semantics_node_stack.cpp +++ b/toolchain/semantics/semantics_node_stack.cpp @@ -14,7 +14,7 @@ auto NodeStack::PrintForStackDump(llvm::raw_ostream& output) const -> void { for (auto [i, entry] : llvm::enumerate(stack_)) { auto parse_node_kind = parse_tree_->node_kind(entry.parse_node); output << "\t" << i << ".\t" << parse_node_kind; - if (parse_node_kind == ParseNodeKind::PatternBinding) { + if (parse_node_kind == Parse::NodeKind::PatternBinding) { output << " -> " << entry.name_id; } else { if (entry.node_id.is_valid()) { diff --git a/toolchain/semantics/semantics_node_stack.h b/toolchain/semantics/semantics_node_stack.h index b817e214485f..5fdb4841b191 100644 --- a/toolchain/semantics/semantics_node_stack.h +++ b/toolchain/semantics/semantics_node_stack.h @@ -30,13 +30,13 @@ namespace Carbon::Check { // method. The main exception is PopAndIgnore, which doesn't do verification. class NodeStack { public: - explicit NodeStack(const ParseTree& parse_tree, + explicit NodeStack(const Parse::Tree& parse_tree, llvm::raw_ostream* vlog_stream) : parse_tree_(&parse_tree), vlog_stream_(vlog_stream) {} // Pushes a solo parse tree node onto the stack. Used when there is no // IR generated by the node. - auto Push(ParseTree::Node parse_node) -> void { + auto Push(Parse::Node parse_node) -> void { CARBON_CHECK(ParseNodeKindToIdKind(parse_tree_->node_kind(parse_node)) == IdKind::SoloParseNode) << "Parse kind expects an Id: " << parse_tree_->node_kind(parse_node); @@ -49,7 +49,7 @@ class NodeStack { // Pushes a parse tree node onto the stack with an ID. template - auto Push(ParseTree::Node parse_node, IdT id) -> void { + auto Push(Parse::Node parse_node, IdT id) -> void { CARBON_CHECK(ParseNodeKindToIdKind(parse_tree_->node_kind(parse_node)) == IdTypeToIdKind()) << "Parse kind expected a different IdT: " @@ -67,33 +67,32 @@ class NodeStack { auto PopAndIgnore() -> void { PopEntry(); } // Pops the top of the stack and returns the parse_node. - template - auto PopForSoloParseNode() -> ParseTree::Node { + template + auto PopForSoloParseNode() -> Parse::Node { Entry back = PopEntry(); - RequireIdKind(ParseNodeKind::Create(RequiredParseKind), + RequireIdKind(Parse::NodeKind::Create(RequiredParseKind), IdKind::SoloParseNode); RequireParseKind(back.parse_node); return back.parse_node; } // Pops the top of the stack. - template + template auto PopAndDiscardSoloParseNode() -> void { PopForSoloParseNode(); } // Pops an expression from the top of the stack and returns the parse_node and // the ID. - auto PopExpressionWithParseNode() - -> std::pair { + auto PopExpressionWithParseNode() -> std::pair { return PopWithParseNode(); } // Pops the top of the stack and returns the parse_node and the ID. - template + template auto PopWithParseNode() -> auto { constexpr IdKind RequiredIdKind = - ParseNodeKindToIdKind(ParseNodeKind::Create(RequiredParseKind)); + ParseNodeKindToIdKind(Parse::NodeKind::Create(RequiredParseKind)); if constexpr (RequiredIdKind == IdKind::NodeId) { auto back = PopWithParseNode(); RequireParseKind(back.first); @@ -120,32 +119,32 @@ class NodeStack { return back; } CARBON_FATAL() << "Unpoppable IdKind for parse kind: " - << ParseNodeKind::Create(RequiredParseKind) + << Parse::NodeKind::Create(RequiredParseKind) << "; see value in ParseNodeKindToIdKind"; } // Pops an expression from the top of the stack and returns the ID. - // Expressions map multiple ParseNodeKinds to SemIR::NodeId always. + // Expressions map multiple Parse::NodeKinds to SemIR::NodeId always. auto PopExpression() -> SemIR::NodeId { return PopExpressionWithParseNode().second; } // Pops the top of the stack and returns the ID. - template + template auto Pop() -> auto { return PopWithParseNode().second; } // Peeks at the parse_node of the top of the stack. - auto PeekParseNode() -> ParseTree::Node { return stack_.back().parse_node; } + auto PeekParseNode() -> Parse::Node { return stack_.back().parse_node; } // Peeks at the ID of the top of the stack. - template + template auto Peek() -> auto { Entry back = stack_.back(); RequireParseKind(back.parse_node); constexpr IdKind RequiredIdKind = - ParseNodeKindToIdKind(ParseNodeKind::Create(RequiredParseKind)); + ParseNodeKindToIdKind(Parse::NodeKind::Create(RequiredParseKind)); if constexpr (RequiredIdKind == IdKind::NodeId) { return back.id(); } @@ -162,7 +161,7 @@ class NodeStack { return back.id(); } CARBON_FATAL() << "Unpeekable IdKind for parse kind: " - << ParseNodeKind::Create(RequiredParseKind) + << Parse::NodeKind::Create(RequiredParseKind) << "; see value in ParseNodeKindToIdKind"; } @@ -188,15 +187,15 @@ class NodeStack { // An entry in stack_. struct Entry { - explicit Entry(ParseTree::Node parse_node, SemIR::NodeId node_id) + explicit Entry(Parse::Node parse_node, SemIR::NodeId node_id) : parse_node(parse_node), node_id(node_id) {} - explicit Entry(ParseTree::Node parse_node, SemIR::NodeBlockId node_block_id) + explicit Entry(Parse::Node parse_node, SemIR::NodeBlockId node_block_id) : parse_node(parse_node), node_block_id(node_block_id) {} - explicit Entry(ParseTree::Node parse_node, SemIR::FunctionId function_id) + explicit Entry(Parse::Node parse_node, SemIR::FunctionId function_id) : parse_node(parse_node), function_id(function_id) {} - explicit Entry(ParseTree::Node parse_node, SemIR::StringId name_id) + explicit Entry(Parse::Node parse_node, SemIR::StringId name_id) : parse_node(parse_node), name_id(name_id) {} - explicit Entry(ParseTree::Node parse_node, SemIR::TypeId type_id) + explicit Entry(Parse::Node parse_node, SemIR::TypeId type_id) : parse_node(parse_node), type_id(type_id) {} // Returns the appropriate ID basaed on type. @@ -220,13 +219,13 @@ class NodeStack { } // The node associated with the stack entry. - ParseTree::Node parse_node; + Parse::Node parse_node; // The entries will evaluate as invalid if and only if they're a solo // parse_node. Invalid is used instead of optional to save space. // // A discriminator isn't needed because the caller can determine which field - // is used based on the ParseNodeKind. + // is used based on the Parse::NodeKind. union { SemIR::NodeId node_id; SemIR::NodeBlockId node_block_id; @@ -238,49 +237,49 @@ class NodeStack { static_assert(sizeof(Entry) == 8, "Unexpected Entry size"); // Translate a parse node kind to the enum ID kind it should always provide. - static constexpr auto ParseNodeKindToIdKind(ParseNodeKind kind) -> IdKind { + static constexpr auto ParseNodeKindToIdKind(Parse::NodeKind kind) -> IdKind { switch (kind) { - case ParseNodeKind::ArrayExpression: - case ParseNodeKind::CallExpression: - case ParseNodeKind::CallExpressionStart: - case ParseNodeKind::IfExpressionElse: - case ParseNodeKind::IndexExpression: - case ParseNodeKind::InfixOperator: - case ParseNodeKind::Literal: - case ParseNodeKind::MemberAccessExpression: - case ParseNodeKind::NameExpression: - case ParseNodeKind::ParenExpression: - case ParseNodeKind::PatternBinding: - case ParseNodeKind::PostfixOperator: - case ParseNodeKind::PrefixOperator: - case ParseNodeKind::ReturnType: - case ParseNodeKind::ShortCircuitOperand: - case ParseNodeKind::StructFieldValue: - case ParseNodeKind::StructLiteral: - case ParseNodeKind::StructFieldType: - case ParseNodeKind::StructTypeLiteral: - case ParseNodeKind::TupleLiteral: + case Parse::NodeKind::ArrayExpression: + case Parse::NodeKind::CallExpression: + case Parse::NodeKind::CallExpressionStart: + case Parse::NodeKind::IfExpressionElse: + case Parse::NodeKind::IndexExpression: + case Parse::NodeKind::InfixOperator: + case Parse::NodeKind::Literal: + case Parse::NodeKind::MemberAccessExpression: + case Parse::NodeKind::NameExpression: + case Parse::NodeKind::ParenExpression: + case Parse::NodeKind::PatternBinding: + case Parse::NodeKind::PostfixOperator: + case Parse::NodeKind::PrefixOperator: + case Parse::NodeKind::ReturnType: + case Parse::NodeKind::ShortCircuitOperand: + case Parse::NodeKind::StructFieldValue: + case Parse::NodeKind::StructLiteral: + case Parse::NodeKind::StructFieldType: + case Parse::NodeKind::StructTypeLiteral: + case Parse::NodeKind::TupleLiteral: return IdKind::NodeId; - case ParseNodeKind::IfExpressionThen: - case ParseNodeKind::IfStatementElse: - case ParseNodeKind::ParameterList: + case Parse::NodeKind::IfExpressionThen: + case Parse::NodeKind::IfStatementElse: + case Parse::NodeKind::ParameterList: return IdKind::NodeBlockId; - case ParseNodeKind::FunctionDefinitionStart: + case Parse::NodeKind::FunctionDefinitionStart: return IdKind::FunctionId; - case ParseNodeKind::Name: + case Parse::NodeKind::Name: return IdKind::StringId; - case ParseNodeKind::ArrayExpressionSemi: - case ParseNodeKind::CodeBlockStart: - case ParseNodeKind::FunctionIntroducer: - case ParseNodeKind::IfCondition: - case ParseNodeKind::IfExpressionIf: - case ParseNodeKind::ParameterListStart: - case ParseNodeKind::ParenExpressionOrTupleLiteralStart: - case ParseNodeKind::QualifiedDeclaration: - case ParseNodeKind::ReturnStatementStart: - case ParseNodeKind::StructLiteralOrStructTypeLiteralStart: - case ParseNodeKind::VariableInitializer: - case ParseNodeKind::VariableIntroducer: + case Parse::NodeKind::ArrayExpressionSemi: + case Parse::NodeKind::CodeBlockStart: + case Parse::NodeKind::FunctionIntroducer: + case Parse::NodeKind::IfCondition: + case Parse::NodeKind::IfExpressionIf: + case Parse::NodeKind::ParameterListStart: + case Parse::NodeKind::ParenExpressionOrTupleLiteralStart: + case Parse::NodeKind::QualifiedDeclaration: + case Parse::NodeKind::ReturnStatementStart: + case Parse::NodeKind::StructLiteralOrStructTypeLiteralStart: + case Parse::NodeKind::VariableInitializer: + case Parse::NodeKind::VariableIntroducer: return IdKind::SoloParseNode; default: return IdKind::Unused; @@ -320,30 +319,30 @@ class NodeStack { // Pops the top of the stack and returns the parse_node and the ID. template - auto PopWithParseNode() -> std::pair { + auto PopWithParseNode() -> std::pair { Entry back = PopEntry(); RequireIdKind(parse_tree_->node_kind(back.parse_node), IdTypeToIdKind()); return {back.parse_node, back.id()}; } - // Require a ParseNodeKind be mapped to a particular IdKind. - auto RequireIdKind(ParseNodeKind parse_kind, IdKind id_kind) -> void { + // Require a Parse::NodeKind be mapped to a particular IdKind. + auto RequireIdKind(Parse::NodeKind parse_kind, IdKind id_kind) -> void { CARBON_CHECK(ParseNodeKindToIdKind(parse_kind) == id_kind) << "Unexpected IdKind mapping for " << parse_kind; } - // Require an entry to have the given ParseNodeKind. - template - auto RequireParseKind(ParseTree::Node parse_node) -> void { + // Require an entry to have the given Parse::NodeKind. + template + auto RequireParseKind(Parse::Node parse_node) -> void { auto actual_kind = parse_tree_->node_kind(parse_node); CARBON_CHECK(RequiredParseKind == actual_kind) - << "Expected " << ParseNodeKind::Create(RequiredParseKind) << ", found " - << actual_kind; + << "Expected " << Parse::NodeKind::Create(RequiredParseKind) + << ", found " << actual_kind; } // The file's parse tree. - const ParseTree* parse_tree_; + const Parse::Tree* parse_tree_; // Whether to print verbose output. llvm::raw_ostream* vlog_stream_;