Set up a 'Parse' namespace. (#3161)

Continuing on #3070.

I moved ParseTree::Node to just Parse::Node, versus Parse::Tree::Node.
Other name changes are just removing "Parse" or "Parser" prefixes.

In EnumBase, I'm directly defining operator<< because the ostream.h
approach just isn't working, not for either of Parse::State nor
Parse::NodeKind. Errors look like:

```toolchain/parser/parser_context.cpp:449:34: error: invalid operands to binary expression ('llvm::raw_ostream' and 'const Carbon::Parse::State')
    output << "\t" << i << ".\t" << entry.state;
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^  ~~~~~~~~~~~
```

The expected template in `Carbon::` is not in the error list; I only see
the:

```
./common/ostream.h:112:6: note: candidate template ignored: requirement 'std::is_base_of_v<std::ostream, llvm::raw_ostream>' was not satisfied [with S = llvm::raw_ostream, T = Carbon::Parse::State]
auto operator<<(S& standard_out, const T& value) -> S& {
     ^
```

I'm still prodding at this, but not seeing an obvious fix.

---------

Co-authored-by: Richard Smith <richard@metafoo.co.uk>

common/BUILD

@@ -174,6 +174,7 @@ cc_library(
     srcs = ["vlog_internal.h"],
     hdrs = ["vlog.h"],
     deps = [
+        ":ostream",
         "@llvm-project//llvm:Support",
     ],
 )

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

common/vlog_internal.h

@@ -5,9 +5,7 @@
 #ifndef CARBON_COMMON_VLOG_INTERNAL_H_
 #define CARBON_COMMON_VLOG_INTERNAL_H_
 
-#include <cstdlib>
-
-#include "llvm/Support/raw_ostream.h"
+#include "common/ostream.h"
 
 namespace Carbon::Internal {
 

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<llvm::StringRef> {
   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<clang::clangd::DocumentSymbol> 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:

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)
 

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);

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

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_

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<PostorderIterator> {
+auto Tree::postorder() const -> llvm::iterator_range<PostorderIterator> {
   return {PostorderIterator(Node(0)),
           PostorderIterator(Node(node_impls_.size()))};
 }
 
-auto ParseTree::postorder(Node n) const
-    -> llvm::iterator_range<PostorderIterator> {
+auto Tree::postorder(Node n) const -> llvm::iterator_range<PostorderIterator> {
   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<SiblingIterator> {
+auto Tree::children(Node n) const -> llvm::iterator_range<SiblingIterator> {
   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<SiblingIterator> {
+auto Tree::roots() const -> llvm::iterator_range<SiblingIterator> {
   return {
       SiblingIterator(*this, Node(static_cast<int>(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<int> 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<Success> {
-  llvm::SmallVector<ParseTree::Node> nodes;
+auto Tree::Verify() const -> ErrorOr<Success> {
+  llvm::SmallVector<Node> 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<Success> {
   if (!has_errors_ && static_cast<int32_t>(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<Success> {
   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

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<Success>;
 
  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<PostorderIterator,
                                         std::random_access_iterator_tag, Node,
                                         int, Node*, Node> {
@@ -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_

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

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;
 }
 

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<ParseTree::Node> {
+class NodeLocationTranslator : public DiagnosticLocationTranslator<Node> {
  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_

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());
 }
 

toolchain/parser/parser_context.cpp

@@ -7,13 +7,14 @@
 #include <optional>
 
 #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<TokenizedBuffer::Token> {
   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<TokenizedBuffer::Token> {
   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<TokenKind> desired_kinds)
+auto Context::FindNextOf(std::initializer_list<TokenKind> desired_kinds)
     -> std::optional<TokenizedBuffer::Token> {
   auto new_position = position_;
   while (true) {
@@ -173,7 +173,7 @@ auto ParserContext::FindNextOf(std::initializer_list<TokenKind> 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<TokenizedBuffer::Token> {
   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

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<TokenizedBuffer::Token>;
 
   // 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_

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

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

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

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

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)
-    -> void {
-  ParserHandleDeclarationNameAndParamsAfterName(context, Params::None);
+auto HandleDeclarationNameAndParamsAfterNameAsNone(Context& context) -> void {
+  HandleDeclarationNameAndParamsAfterName(context, Params::None);
 }
 
-auto ParserHandleDeclarationNameAndParamsAfterNameAsOptional(
-    ParserContext& context) -> void {
-  ParserHandleDeclarationNameAndParamsAfterName(context, Params::Optional);
+auto HandleDeclarationNameAndParamsAfterNameAsOptional(Context& context)
+    -> void {
+  HandleDeclarationNameAndParamsAfterName(context, Params::Optional);
 }
 
-auto ParserHandleDeclarationNameAndParamsAfterNameAsRequired(
-    ParserContext& context) -> void {
-  ParserHandleDeclarationNameAndParamsAfterName(context, Params::Required);
+auto HandleDeclarationNameAndParamsAfterNameAsRequired(Context& context)
+    -> void {
+  HandleDeclarationNameAndParamsAfterName(context, Params::Required);
 }
 
-auto ParserHandleDeclarationNameAndParamsAfterDeduced(ParserContext& context)
-    -> void {
+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

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

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

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

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

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

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

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

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<TokenizedBuffer::Token> 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,
-                                   ParseNodeKind::IfCondition);
+  context.ConsumeAndAddCloseSymbol(state.token, state, NodeKind::IfCondition);
 }
 
-auto ParserHandleParenConditionFinishAsWhile(ParserContext& context) -> void {
+auto HandleParenConditionFinishAsWhile(Context& context) -> void {
   auto state = context.PopState();
 
   context.ConsumeAndAddCloseSymbol(state.token, state,
-                                   ParseNodeKind::WhileCondition);
+                                   NodeKind::WhileCondition);
 }
 
-}  // namespace Carbon
+}  // namespace Carbon::Parse

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

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

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

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<TokenizedBuffer::Token> 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

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

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

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

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 `.<expression>` 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

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_

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

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_

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) {

toolchain/semantics/semantics_context.cpp

@@ -21,8 +21,8 @@
 namespace Carbon::Check {
 
 Context::Context(const TokenizedBuffer& tokens,
-                 DiagnosticEmitter<ParseTree::Node>& emitter,
-                 const ParseTree& parse_tree, SemIR::File& semantics_ir,
+                 DiagnosticEmitter<Parse::Node>& 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 <typename BranchNode, typename... Args>
 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<SemIR::Node::Branch>(*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<SemIR::Node::BranchWithArg>(
       *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<SemIR::Node::BranchIf>(
@@ -181,8 +179,8 @@ auto Context::AddDominatedBlockAndBranchIf(ParseTree::Node parse_node,
 }
 
 auto Context::AddConvergenceBlockAndPush(
-    ParseTree::Node parse_node,
-    std::initializer_list<SemIR::NodeBlockId> blocks) -> void {
+    Parse::Node parse_node, std::initializer_list<SemIR::NodeBlockId> 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<std::pair<SemIR::NodeBlockId, SemIR::NodeId>>
         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<ParseTree::Node>::DiagnosticBuilder* diagnostic) -> bool {
+    DiagnosticEmitter<Parse::Node>::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<SemIR::TypeId>&& 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));

toolchain/semantics/semantics_context.h

@@ -23,12 +23,12 @@ class Context {
  public:
   // Stores references for work.
   explicit Context(const TokenizedBuffer& tokens,
-                   DiagnosticEmitter<ParseTree::Node>& emitter,
-                   const ParseTree& parse_tree, SemIR::File& semantics,
+                   DiagnosticEmitter<Parse::Node>& 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<SemIR::NodeBlockId> blocks) -> void;
+      Parse::Node parse_node, std::initializer_list<SemIR::NodeBlockId> 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<std::pair<SemIR::NodeBlockId, SemIR::NodeId>>
           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<ParseTree::Node>::DiagnosticBuilder* diagnostic)
-      -> bool;
+      DiagnosticEmitter<Parse::Node>::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<SemIR::TypeId>&& 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<ParseTree::Node>& { return *emitter_; }
+  auto emitter() -> DiagnosticEmitter<Parse::Node>& { 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<ParseTree::Node>* emitter_;
+  DiagnosticEmitter<Parse::Node>* 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

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<ParseNodeKind::QualifiedDeclaration>();
+        .PopAndDiscardSoloParseNode<Parse::NodeKind::QualifiedDeclaration>();
   } else {
     // The name had no qualifiers, so we need to process the node now.
     auto [parse_node, name_id] =
-        context_->node_stack().PopWithParseNode<ParseNodeKind::Name>();
+        context_->node_stack().PopWithParseNode<Parse::NodeKind::Name>();
     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.

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.

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<ParseNodeKind::ArrayExpressionSemi>();
+      .PopAndDiscardSoloParseNode<Parse::NodeKind::ArrayExpressionSemi>();
   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) {

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<ParseNodeKind::CallExpressionStart>();
+          .PopWithParseNode<Parse::NodeKind::CallExpressionStart>();
   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);

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");
 }
 

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<ParseNodeKind::CodeBlockStart>();
+  context.node_stack().PopForSoloParseNode<Parse::NodeKind::CodeBlockStart>();
   return true;
 }
 

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<ParseNodeKind::ReturnType>();
+      Parse::NodeKind::ReturnType) {
+    return_slot_id = context.node_stack().Pop<Parse::NodeKind::ReturnType>();
     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<ParseNodeKind::ParameterList>();
+      context.node_stack().Pop<Parse::NodeKind::ParameterList>();
   auto name_context = context.declaration_name_stack().Pop();
-  auto fn_node = context.node_stack()
-                     .PopForSoloParseNode<ParseNodeKind::FunctionIntroducer>();
+  auto fn_node =
+      context.node_stack()
+          .PopForSoloParseNode<Parse::NodeKind::FunctionIntroducer>();
 
   // 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<ParseNodeKind::FunctionDefinitionStart>();
+      context.node_stack().Pop<Parse::NodeKind::FunctionDefinitionStart>();
 
   // 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();

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<ParseNodeKind::IfExpressionThen>();
+      context.node_stack()
+          .PopWithParseNode<Parse::NodeKind::IfExpressionThen>();
   auto then_value_id = context.node_stack().PopExpression();
-  auto if_node =
-      context.node_stack().PopForSoloParseNode<ParseNodeKind::IfExpressionIf>();
+  auto if_node = context.node_stack()
+                     .PopForSoloParseNode<Parse::NodeKind::IfExpressionIf>();
 
   // Convert the `else` value to the `then` value's type, and finish the `else`
   // block.

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<ParseNodeKind::IfCondition>();
+auto HandleIfStatementElse(Context& context, Parse::Node parse_node) -> bool {
+  context.node_stack()
+      .PopAndDiscardSoloParseNode<Parse::NodeKind::IfCondition>();
 
   // 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<ParseNodeKind::IfCondition>();
+          .PopAndDiscardSoloParseNode<Parse::NodeKind::IfCondition>();
       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<ParseNodeKind::IfStatementElse>();
+          context.node_stack().Pop<Parse::NodeKind::IfStatementElse>();
       context.AddConvergenceBlockAndPush(parse_node,
                                          {then_block_id, sub_block_id});
       break;

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();

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");
 }

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:

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");
 }
 

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<ParseNodeKind::Name>();
+  SemIR::StringId name_id = context.node_stack().Pop<Parse::NodeKind::Name>();
 
   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<ParseNodeKind::Name>();
+  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<Parse::NodeKind::Name>();
     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");
 }
 

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");
 }
 

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()));

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");
 }
 

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();

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");
 }
 

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<ParseNodeKind::ParameterListStart>();
+      .PopAndDiscardSoloParseNode<Parse::NodeKind::ParameterListStart>();
   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);

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<SemIR::TypeId> type_ids;
   type_ids.reserve(node_block.size());

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<ParseNodeKind::Name>();
+      context.node_stack().PopWithParseNode<Parse::NodeKind::Name>();
 
   // 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");
 }
 

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<ParseNodeKind::ReturnStatementStart>();
+        .PopAndDiscardSoloParseNode<Parse::NodeKind::ReturnStatementStart>();
 
     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<ParseNodeKind::ReturnStatementStart>();
+        .PopAndDiscardSoloParseNode<Parse::NodeKind::ReturnStatementStart>();
 
     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);

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<ParseNodeKind::Name>();
+      context.node_stack().PopWithParseNode<Parse::NodeKind::Name>();
 
   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<ParseNodeKind::Name>();
+  SemIR::StringId name_id = context.node_stack().Pop<Parse::NodeKind::Name>();
 
   // 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();
 

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<ParseNodeKind::VariableInitializer>();
+        .PopAndDiscardSoloParseNode<Parse::NodeKind::VariableInitializer>();
   }
 
   // Get the storage and add it to name lookup.
   SemIR::NodeId var_id =
-      context.node_stack().Pop<ParseNodeKind::PatternBinding>();
+      context.node_stack().Pop<Parse::NodeKind::PatternBinding>();
   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<ParseNodeKind::VariableIntroducer>();
+      .PopAndDiscardSoloParseNode<Parse::NodeKind::VariableIntroducer>();
 
   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);

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<ParseTree::Node> emitter(translator, err_tracker);
+  DiagnosticEmitter<Parse::Node> 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;                           \

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;
 

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();
 }

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

toolchain/semantics/semantics_node.h

@@ -239,7 +239,7 @@ class Node {
   template <NodeKind::RawEnumType Kind, typename... ArgTypes>
   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 <NodeKind::RawEnumType Kind, typename... ArgTypes>
   class FactoryNoType : public FactoryBase<Kind, ArgTypes...> {
    public:
-    static auto Make(ParseTree::Node parse_node, ArgTypes... args) {
+    static auto Make(Parse::Node parse_node, ArgTypes... args) {
       return FactoryBase<Kind, ArgTypes...>::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<NodeKind::VarStorage, StringId /*name_id*/>;
 
   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_;
 

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()) {

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 <typename IdT>
-  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<IdT>())
         << "Parse kind expected a different IdT: "
@@ -67,33 +67,32 @@ class NodeStack {
   auto PopAndIgnore() -> void { PopEntry<SemIR::NodeId>(); }
 
   // Pops the top of the stack and returns the parse_node.
-  template <ParseNodeKind::RawEnumType RequiredParseKind>
-  auto PopForSoloParseNode() -> ParseTree::Node {
+  template <Parse::NodeKind::RawEnumType RequiredParseKind>
+  auto PopForSoloParseNode() -> Parse::Node {
     Entry back = PopEntry<SemIR::NodeId>();
-    RequireIdKind(ParseNodeKind::Create(RequiredParseKind),
+    RequireIdKind(Parse::NodeKind::Create(RequiredParseKind),
                   IdKind::SoloParseNode);
     RequireParseKind<RequiredParseKind>(back.parse_node);
     return back.parse_node;
   }
 
   // Pops the top of the stack.
-  template <ParseNodeKind::RawEnumType RequiredParseKind>
+  template <Parse::NodeKind::RawEnumType RequiredParseKind>
   auto PopAndDiscardSoloParseNode() -> void {
     PopForSoloParseNode<RequiredParseKind>();
   }
 
   // Pops an expression from the top of the stack and returns the parse_node and
   // the ID.
-  auto PopExpressionWithParseNode()
-      -> std::pair<ParseTree::Node, SemIR::NodeId> {
+  auto PopExpressionWithParseNode() -> std::pair<Parse::Node, SemIR::NodeId> {
     return PopWithParseNode<SemIR::NodeId>();
   }
 
   // Pops the top of the stack and returns the parse_node and the ID.
-  template <ParseNodeKind::RawEnumType RequiredParseKind>
+  template <Parse::NodeKind::RawEnumType RequiredParseKind>
   auto PopWithParseNode() -> auto {
     constexpr IdKind RequiredIdKind =
-        ParseNodeKindToIdKind(ParseNodeKind::Create(RequiredParseKind));
+        ParseNodeKindToIdKind(Parse::NodeKind::Create(RequiredParseKind));
     if constexpr (RequiredIdKind == IdKind::NodeId) {
       auto back = PopWithParseNode<SemIR::NodeId>();
       RequireParseKind<RequiredParseKind>(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 <ParseNodeKind::RawEnumType RequiredParseKind>
+  template <Parse::NodeKind::RawEnumType RequiredParseKind>
   auto Pop() -> auto {
     return PopWithParseNode<RequiredParseKind>().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 <ParseNodeKind::RawEnumType RequiredParseKind>
+  template <Parse::NodeKind::RawEnumType RequiredParseKind>
   auto Peek() -> auto {
     Entry back = stack_.back();
     RequireParseKind<RequiredParseKind>(back.parse_node);
     constexpr IdKind RequiredIdKind =
-        ParseNodeKindToIdKind(ParseNodeKind::Create(RequiredParseKind));
+        ParseNodeKindToIdKind(Parse::NodeKind::Create(RequiredParseKind));
     if constexpr (RequiredIdKind == IdKind::NodeId) {
       return back.id<SemIR::NodeId>();
     }
@@ -162,7 +161,7 @@ class NodeStack {
       return back.id<SemIR::TypeId>();
     }
     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 <typename IdT>
-  auto PopWithParseNode() -> std::pair<ParseTree::Node, IdT> {
+  auto PopWithParseNode() -> std::pair<Parse::Node, IdT> {
     Entry back = PopEntry<IdT>();
     RequireIdKind(parse_tree_->node_kind(back.parse_node),
                   IdTypeToIdKind<IdT>());
     return {back.parse_node, back.id<IdT>()};
   }
 
-  // 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 <ParseNodeKind::RawEnumType RequiredParseKind>
-  auto RequireParseKind(ParseTree::Node parse_node) -> void {
+  // Require an entry to have the given Parse::NodeKind.
+  template <Parse::NodeKind::RawEnumType RequiredParseKind>
+  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_;