不足していた関数is_string_literal, reflect_constant_array, reflect_constant_stringを追加

Author: faithandbrave

lang/cpp26/reflection.md

@@ -256,7 +256,7 @@ template for (constexpr auto m :
 
 
 ## `define_static_string` / `define_static_array` / `define_static_object`
-これらは、コンパイル時に計算した値を静的ストレージに配置し、実行時に使用可能にするための関数群である。[`std::meta::define_static_string()`](/reference/meta/define_static_string.md)は文字列を、[`std::meta::define_static_array()`](/reference/meta/define_static_array.md)は配列を、[`std::meta::define_static_object()`](/reference/meta/define_static_object.md)はオブジェクトをそれぞれ静的ストレージに配置する。
+これらは、コンパイル時に計算した値を静的ストレージに配置し、実行時に使用可能にするための関数群である。[`std::define_static_string()`](/reference/meta/define_static_string.md)は文字列を、[`std::define_static_array()`](/reference/meta/define_static_array.md)は配列を、[`std::define_static_object()`](/reference/meta/define_static_object.md)はオブジェクトをそれぞれ静的ストレージに配置する。これらは`<meta>`ヘッダで提供されるが、`std`名前空間に定義される（`std::meta`名前空間ではない）。
 
 ```cpp
 // コンパイル時に計算した文字列を実行時に使用する
@@ -265,15 +265,15 @@ template <typename E>
 constexpr std::string_view enum_to_string(E value) {
   template for (constexpr auto e : std::meta::enumerators_of(^^E)) {
     if (value == [:e:]) {
-      return std::meta::define_static_string(std::meta::identifier_of(e));
+      return std::define_static_string(std::meta::identifier_of(e));
     }
   }
   return "<unknown>";
 }
 ```
 * std::meta::enumerators_of[link /reference/meta/enumerators_of.md]
 * std::meta::identifier_of[link /reference/meta/identifier_of.md]
-* std::meta::define_static_string[link /reference/meta/define_static_string.md]
+* std::define_static_string[link /reference/meta/define_static_string.md]
 
 
 ## リフレクションのエラー処理

reference/meta.md

@@ -231,11 +231,16 @@
 
 ## 静的ストレージへの配置
 
+以下の`define_static_*`と`is_string_literal`は`std`名前空間に定義される（`std::meta`名前空間ではない）。`reflect_constant_*`は`std::meta`名前空間に定義される。
+
 | 名前 | 説明 | 対応バージョン |
 |------|------|-------|
 | [`define_static_string`](meta/define_static_string.md) | コンパイル時文字列を静的ストレージに配置し`const CharT*`を返す | C++26 |
 | [`define_static_array`](meta/define_static_array.md) | コンパイル時配列を静的ストレージに配置し`span<const T>`を返す | C++26 |
 | [`define_static_object`](meta/define_static_object.md) | コンパイル時オブジェクトを静的ストレージに配置し`const T*`を返す | C++26 |
+| [`reflect_constant_string`](meta/reflect_constant_string.md) | コンパイル時文字列のリフレクションを生成する | C++26 |
+| [`reflect_constant_array`](meta/reflect_constant_array.md) | コンパイル時配列のリフレクションを生成する | C++26 |
+| [`is_string_literal`](meta/is_string_literal.md) | ポインタが文字列リテラルを指しているかを判定する | C++26 |
 
 
 ## アノテーション

reference/meta/define_static_array.md

@@ -1,11 +1,11 @@
 # define_static_array
 * meta[meta header]
-* std::meta[meta namespace]
+* std[meta namespace]
 * function template[meta id-type]
 * cpp26[meta cpp]
 
 ```cpp
-namespace std::meta {
+namespace std {
   template <ranges::input_range R>
   consteval std::span<const ranges::range_value_t<R>> define_static_array(R&& r);
 }
@@ -26,7 +26,7 @@ namespace std::meta {
 #include <array>
 
 int main() {
-  constexpr auto arr = std::meta::define_static_array(std::array{1, 2, 3, 4, 5});
+  constexpr auto arr = std::define_static_array(std::array{1, 2, 3, 4, 5});
   for (auto v : arr) {
     std::println("{}", v);
   }

reference/meta/define_static_object.md

@@ -1,13 +1,13 @@
 # define_static_object
 * meta[meta header]
-* std::meta[meta namespace]
+* std[meta namespace]
 * function template[meta id-type]
 * cpp26[meta cpp]
 
 ```cpp
-namespace std::meta {
+namespace std {
   template <class T>
-  consteval const T* define_static_object(T&& t);
+  consteval const remove_cvref_t<T>* define_static_object(T&& t);
 }
 ```
 
@@ -30,7 +30,7 @@ struct Config {
 };
 
 int main() {
-  constexpr auto* p = std::meta::define_static_object(Config{1920, 1080});
+  constexpr auto* p = std::define_static_object(Config{1920, 1080});
   std::println("{}x{}", p->width, p->height);
 }
 ```

reference/meta/define_static_string.md

@@ -1,11 +1,11 @@
 # define_static_string
 * meta[meta header]
-* std::meta[meta namespace]
+* std[meta namespace]
 * function template[meta id-type]
 * cpp26[meta cpp]
 
 ```cpp
-namespace std::meta {
+namespace std {
   template <ranges::input_range R>
   consteval const ranges::range_value_t<R>* define_static_string(R&& r);
 }
@@ -30,7 +30,7 @@ template <typename E>
 constexpr std::string_view to_string(E value) {
   template for (constexpr auto e : std::meta::enumerators_of(^^E)) {
     if (value == [:e:]) {
-      return std::meta::define_static_string(std::meta::identifier_of(e));
+      return std::define_static_string(std::meta::identifier_of(e));
     }
   }
   return "<unknown>";

reference/meta/is_string_literal.md

@@ -0,0 +1,84 @@
+# is_string_literal
+* meta[meta header]
+* std[meta namespace]
+* function[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std {
+  consteval bool is_string_literal(const char* p);      // (1) C++26
+  consteval bool is_string_literal(const wchar_t* p);   // (2) C++26
+  consteval bool is_string_literal(const char8_t* p);   // (3) C++26
+  consteval bool is_string_literal(const char16_t* p);  // (4) C++26
+  consteval bool is_string_literal(const char32_t* p);  // (5) C++26
+}
+```
+
+## 概要
+ポインタが文字列リテラル（またはそのサブオブジェクト）を指しているかどうかを判定する。
+
+主に[`reflect_constant_string()`](reflect_constant_string.md)の内部実装で使用される。`reflect_constant_string()`は入力が既にヌル終端された文字列リテラルであればヌル終端文字を追加せず、そうでなければ追加する必要があるため、この関数で文字列リテラルかどうかを判定する。
+
+ユーザーが直接使用する場合は、`const char*`の出自をコンパイル時に検査して、文字列リテラルに由来するポインタとそうでないポインタを区別する用途が考えられる。
+
+- (1) : 通常の文字列リテラル（`"hello"`）を判定する
+- (2) : ワイド文字列リテラル（`L"hello"`）を判定する
+- (3) : UTF-8文字列リテラル（`u8"hello"`）を判定する
+- (4) : UTF-16文字列リテラル（`u"hello"`）を判定する
+- (5) : UTF-32文字列リテラル（`U"hello"`）を判定する
+
+
+## 戻り値
+`p`が文字列リテラルまたはそのサブオブジェクトを指している場合に`true`を返す。そうでなければ`false`を返す。
+
+
+## 備考
+この関数は`std`名前空間に定義される（`std::meta`名前空間ではない）。
+
+
+## 例
+```cpp example
+#include <meta>
+#include <print>
+
+// 文字列リテラルならそのまま使い、そうでなければコピーして使う
+consteval const char* ensure_static(const char* p) {
+  if (std::is_string_literal(p)) {
+    return p;  // 文字列リテラルは静的ストレージに既に存在する
+  }
+  return std::define_static_string(std::string_view(p));
+}
+
+int main() {
+  // 文字列リテラル
+  constexpr auto s1 = ensure_static("hello");
+  std::println("{}", s1);
+
+  // 文字列リテラルの部分文字列（サブオブジェクト）
+  static_assert(std::is_string_literal("hello" + 2));  // "llo"を指す
+}
+```
+* std::is_string_literal[color ff0000]
+* std::define_static_string[link define_static_string.md]
+
+### 出力
+```
+hello
+```
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`define_static_string`](define_static_string.md)
+
+
+## 参照
+- [P3491R3 `define_static_{string,object,array}`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3491r3.html)

reference/meta/reflect_constant_array.md

@@ -0,0 +1,65 @@
+# reflect_constant_array
+* meta[meta header]
+* std::meta[meta namespace]
+* function template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::meta {
+  template <ranges::input_range R>
+  consteval info reflect_constant_array(R&& r);
+}
+```
+* info[link info.md]
+
+## 概要
+構造的型の要素を持つRangeから、静的配列のリフレクションを生成する。
+
+[`define_static_array()`](define_static_array.md)は[`span`](/reference/span/span.md)を返すため実行時のアクセスには便利だが、`span`は構造化束縛によるパック展開ができない。この関数は配列のリフレクションを返すため、スプライスして構造化束縛でパック展開する用途に使用できる。
+
+また、[`define_static_array()`](define_static_array.md)はこの関数を内部で使用して実装されている。
+
+
+## 戻り値
+`r`の要素をコピーした`const T[N]`のテンプレートパラメータオブジェクトのリフレクションを返す。
+
+
+## 例
+```cpp example
+#include <meta>
+#include <array>
+
+consteval int sum() {
+  // 配列のリフレクションをスプライスし、構造化束縛でパック展開
+  constexpr auto [...elems] =
+      [:std::meta::reflect_constant_array(std::array{1, 2, 3}):];
+  return (... + elems);
+}
+
+int main() {
+  static_assert(sum() == 6);
+}
+```
+* std::meta::reflect_constant_array[color ff0000]
+
+### 出力
+```
+```
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`define_static_array`](define_static_array.md)
+- [`reflect_constant_string`](reflect_constant_string.md)
+
+
+## 参照
+- [P3491R3 `define_static_{string,object,array}`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3491r3.html)

reference/meta/reflect_constant_string.md

@@ -0,0 +1,74 @@
+# reflect_constant_string
+* meta[meta header]
+* std::meta[meta namespace]
+* function template[meta id-type]
+* cpp26[meta cpp]
+
+```cpp
+namespace std::meta {
+  template <ranges::input_range R>
+  consteval info reflect_constant_string(R&& r);
+}
+```
+* info[link info.md]
+
+## 概要
+文字のRangeからヌル終端文字配列のリフレクションを生成する。
+
+[`define_static_string()`](define_static_string.md)は`const CharT*`を返すため配列のサイズ情報が失われるが、この関数はサイズ情報を保持した配列のリフレクションを返す。そのため、サイズをテンプレートパラメータとして推論する必要がある型（`FixedString<N>`など）にスプライスで渡すことができる。
+
+また、[`define_static_string()`](define_static_string.md)はこの関数を内部で使用して実装されている。
+
+
+## 戻り値
+`r`の要素をコピーしたヌル終端文字配列`const CharT[sizeof...(V)+1]`のテンプレートパラメータオブジェクトのリフレクションを返す。
+
+
+## 例
+```cpp example
+#include <meta>
+#include <algorithm>
+#include <cstddef>
+
+template <std::size_t N>
+struct FixedString {
+  char data[N] = {};
+  constexpr FixedString(const char (&str)[N]) {
+    std::ranges::copy(str, str + N, data);
+  }
+};
+
+template <FixedString S>
+struct Named {};
+
+int main() {
+  // define_static_stringはconst char*を返すためFixedStringのサイズを推論できない
+  // using Err = Named<std::define_static_string("hello")>;  // エラー
+
+  // reflect_constant_stringはサイズ付き配列のリフレクションを返すため推論できる
+  using Ok = Named<[:std::meta::reflect_constant_string("hello"):]>;
+}
+```
+* std::meta::reflect_constant_string[color ff0000]
+
+### 出力
+```
+```
+
+## バージョン
+### 言語
+- C++26
+
+### 処理系
+- [Clang](/implementation.md#clang): ??
+- [GCC](/implementation.md#gcc): ??
+- [Visual C++](/implementation.md#visual_cpp): ??
+
+
+## 関連項目
+- [`define_static_string`](define_static_string.md)
+- [`reflect_constant_array`](reflect_constant_array.md)
+
+
+## 参照
+- [P3491R3 `define_static_{string,object,array}`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3491r3.html)