r/cpp • u/khaled-Ahmed-- • 7d ago
Misleading Token Sequence Injection & Modern Macros: The Most Game-Changing Compile-Time Feature in C++29 (Try it on Compiler Explorer with Barry's Clang Compiler!)
open-std.orgNote: This feature is targeted at the C++29 standard and is not actually included in the standard in the original language prepared for the publication. I didn't mention that it was a feature within the standard, and that was that. However, when I asked the AI to translate and organize the text, it made this incorrect edit to the title, thinking it was a good hoke. I apologize for this.
introduces Token Sequence Injection (std::meta::tokensequence) and Hygienic Language Macros (_macro) for C++29. It allows building, manipulating, and injecting C++ tokens at compile time with full type-awareness, context inspection, and zero preprocessor bugs!
. Token Sequence Injection (std::meta::token_sequence)
Instead of string manipulation or macro hacks, code is treated as a sequence of tokens stored in std::meta::token_sequence.
Acts as a random-access range (std::meta::size(seq), indexing seq[i] like array, concatenation +, += , == , =)
Features Token Interpolation (...) to splice expressions, variables, or types inside token literals { ... }.
Provides standard utilities like std::meta::id("arg", i) to generate unique identifiers, std::meta::tokenize to turns the string or array of chars to array of tokens with type std::meta::token_sequence, std::meta::stringize to turn array of tokens with type std::meta::token_sequence to string, and std::meta::queue_injection For indirect injection, such as injecting tokens into the current domain or a specific namespace.
Quick code example: ```
constexpr auto make_getter(std::meta::info member) -> std::meta::token_sequence {
auto name = std::meta::id("get_", name_of(member));
return {
auto (name)() const -> decltype((member)) {
return (member);
}
};
}
```
- Modern Hygienic Macros (__macro)
Replacing #define, the new __macro feature runs at consteval time and returns a std::meta::token_sequence injected directly at the call-site:
Invoked with !: Called as macro!(...) , check!(a == b).
Receives Expression Reflections: Arguments are passed as expression handles (std::meta::info), preserving expression identity, source text, and value categories.
Prevents Double Evaluation: Injecting the same un-stored expression twice is a compile-time safety violation, eliminating bugs like MIN(x++, y).
Context-Aware (macro_expansion_context()): Can inspect the caller's scope (enclosing function, class, or return type) to validate syntactic and logical rules before injecting.
Module & Namespace Friendly: Fully scoped, exportable in modules, and can be class/namespace members.
Quick code example :
```
template <class T> __macro check(T&&expr) {
return {
if (!((expr))) {
std::println("Check failed: {}", source_text_of(expr));
}
};
}
```
You can test the full implementation on Compiler Explorer today using Barry Revzin's Clang prototype fork!
Paper link: https://open-std.org/JTC1/SC22/WG21/docs/papers/2026/p4380r0.html