mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 20:00:12 +01:00
Jon Ross-PerkinsandDana Jansens
93dc369ebd
This is just reducing boilerplate in `typed_insts.h` because we have a number of singleton types, and keep adding more. The changes to `TemplateString` allow `TemplateString IrName` to be used as a `StringLiteral`. --------- Co-authored-by: Dana Jansens <danakj@orodu.net>
80 lines
3.0 KiB
C++
80 lines
3.0 KiB
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
|
|
|
|
#ifndef CARBON_COMMON_TEMPLATE_STRING_H_
|
|
#define CARBON_COMMON_TEMPLATE_STRING_H_
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
|
|
|
namespace Carbon {
|
|
|
|
// Represents a compile-time string in a form suitable for use as a non-type
|
|
// template argument.
|
|
//
|
|
// These arguments are required to be a "structural type", and so we copy the
|
|
// string contents into a public array of `char`s. For details, see:
|
|
// https://en.cppreference.com/w/cpp/language/template_parameters#Non-type_template_parameter
|
|
//
|
|
// Designed to support implicitly deduced construction from a string literal
|
|
// template argument. This type will implicitly convert to an `llvm::StringRef`
|
|
// for accessing the string contents, and also provides a dedicated `c_str()`
|
|
// method to access the string as a C string.
|
|
//
|
|
// Example usage:
|
|
// ```cpp
|
|
// template <TemplateString Str> auto F() -> void {
|
|
// llvm::cout() << Str;
|
|
// }
|
|
//
|
|
// auto Example() -> void {
|
|
// F<"string contents here">();
|
|
// }
|
|
// ```
|
|
template <int N>
|
|
struct TemplateString {
|
|
// Constructs the template string from a string literal.
|
|
//
|
|
// Intentionally allows implicit conversion from string literals for use as a
|
|
// non-type template parameter.
|
|
//
|
|
// The closest we can get to explicitly accepting a string literal is to
|
|
// accept an array of `const char`s, so we additionally use Clang's constexpr
|
|
// `enable_if` attribute to require the array to be usable as a C string with
|
|
// the expected length. This checks both for null-termination and no embedded
|
|
// `0` bytes.
|
|
explicit(false) constexpr TemplateString(const char (&str)[N + 1])
|
|
__attribute__((
|
|
enable_if(__builtin_strlen(str) == N,
|
|
"character array is not null-terminated valid C string"))) {
|
|
// Rely on Clang's constexpr `__builtin_memcpy` to minimize compile time
|
|
// overhead copying the string contents around.
|
|
__builtin_memcpy(storage_, str, N + 1);
|
|
}
|
|
|
|
// This type is designed to act as a `StringLiteral` implicitly while having
|
|
// the storage necessary to be used as a template parameter.
|
|
//
|
|
// NOLINTNEXTLINE(google-explicit-constructor)
|
|
explicit(false) constexpr operator llvm::StringLiteral() const {
|
|
return llvm::StringLiteral::withInnerNUL(storage_);
|
|
}
|
|
|
|
// Accesses the string data directly as a compile-time C string.
|
|
constexpr auto c_str() const -> const char* { return storage_; }
|
|
|
|
// Note that this must be public for the type to be structural and available
|
|
// as a template argument, but this is not part of the public API.
|
|
char storage_[N + 1];
|
|
};
|
|
|
|
// Allow deducing `N` when implicitly constructing these so that we can directly
|
|
// use a string literal in a template argument. The array needs an extra char
|
|
// for the null terminator.
|
|
template <int M>
|
|
TemplateString(const char (&str)[M]) -> TemplateString<M - 1>;
|
|
|
|
} // namespace Carbon
|
|
|
|
#endif // CARBON_COMMON_TEMPLATE_STRING_H_
|