mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 21:40:12 +01:00
Chandler CarruthandJon Ross-Perkins
a1ad39fa29
The goal here is to (significantly) reduce the boilerplate needed when defining classes that wrap enums, especially those managed with the `.def`-file style X-macros that are common in the toolchain. This should also provide both better and more consistent functionality to those classes once ported over to it. Initially, only `ParserState`, `SemanticsNodeKind`, and `SemanticsBuiltinKind` are ported as these were also the three that JonMeow ported in his original pull/2453 "option 5". This is heavily based on that version of the code. Goals I was considering that influenced the design: - Keep the individual enum-wrapping classes as simple and easy to read as possible. Especially important is keeping the `.def` files that are often filled with really important documentation clean and easy to maintain over time. - Don't rely on computed `#include`s as that is an especially dark corner of the preprocessor and breaks some build systems. - Have a really good API of the enum-wrapping class, including nice constant names for the values, easy printing, and even easy debugger-callable methods to get the name (as opposed to the integer value). - Keep the API that users interact with in the base class as clean and easy to read as possible. - Reduce the boiler plate for each instance of these as much as possible. - Avoid excessive inline generated code or constants that would result in steady growth in object file sizes and linker effort doing deduplication. These goals aren't always compatible, so we end up needing to pick a compromise between them when in tension. I think this version is a pretty good compromise. The original version I started with already pull most of the API into a CRTP-style base class. This version pulls *all* of the common API. This is the main tool for getting consistency and avoiding duplication. However, connecting this base class to the individual enum wrappers is still difficult. Some specific changes here that try to do as much as possible there: - Use a slightly fancier macro pattern to reduce the boilerplate of defining the raw `enum class` prior to the wrapper class. - Use a macro to simplify naming the base class. - Move the name table to a `.cpp` file to avoid every inclusion generating a complete copy of the strings (that the linker has to deduplicate). This is done with some care to sharply reduce the boilerplate needed in that `.cpp` file. - Sink the name _API_ fully into the CRTP base class. This requires some significant complexity in the implementation, but all of that is hidden behind a single implementation detail macro, and the API itself is simple and readable. This also makes it much more reasonable to test the entire system a single time next to the base class. This version also moves from constant factory functions to normal constants. This requires two batches -- first a declaration, and then a definition -- but the API result is significantly better and similar to the original option, the macro structure reduces the cost of these. Unfortunately that makes the adoption a bit noisy, but I think its worth the churn. Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
15 lines
480 B
C++
15 lines
480 B
C++
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
|
|
// Exceptions. See /LICENSE for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#include "toolchain/semantics/semantics_node_kind.h"
|
|
|
|
namespace Carbon {
|
|
|
|
CARBON_DEFINE_ENUM_CLASS_NAMES(SemanticsNodeKind) = {
|
|
#define CARBON_SEMANTICS_NODE_KIND(Name) CARBON_ENUM_CLASS_NAME_STRING(Name)
|
|
#include "toolchain/semantics/semantics_node_kind.def"
|
|
};
|
|
|
|
} // namespace Carbon
|