attempt to fix reference section collapse (refs https://github.com/boostorg/any/issues/27 )

Fix an unused parameter warning
Merge branch 'master' into develop
2026-01-20 04:42:22 +00:00 · 2023-10-11 10:13:39 +03:00 · 2023-09-28 10:00:01 +03:00 · 2023-09-28 09:44:35 +03:00 · 2023-09-27 11:36:22 +03:00 · 2023-09-27 11:36:22 +03:00
131 changed files with 4878 additions and 567 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -17,29 +17,41 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: gcc-7
-            cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
-          - toolset: gcc-9  # Do not remove! It is the only toolset that tests misc/strip_boost_namespace.sh
+          - toolset: gcc-12 # Do not remove! It is the only toolset that tests misc/strip_boost_namespace.sh
            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-22.04
+            cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
+            linkflags: "linkflags=--coverage -lasan -lubsan"
+            gcov_tool: "gcov-12"
+          - toolset: gcc-11
+            cxxstd: "03,11,14,17,2a"
+            os: ubuntu-22.04
+            cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
+            linkflags: "linkflags=--coverage -lasan -lubsan"
+            gcov_tool: "gcov-11"
          - toolset: gcc-10
            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-22.04
            cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
            linkflags: "linkflags=--coverage -lasan -lubsan"
            gcov_tool: "gcov-10"
-          - toolset: clang
-            compiler: clang++-10
+          - toolset: gcc-9
            cxxstd: "03,11,14,17,2a"
-            os: ubuntu-20.04
-            cxxflags: "cxxflags=-fsanitize=address,undefined,integer -fno-sanitize-recover=undefined"
-            linkflags: "linkflags=-fsanitize=address,undefined,integer"
-          - toolset: clang
-            cxxstd: "03,11,14,17,2a"
-            os: macos-10.15
-            cxxflags: "cxxflags=-fsanitize=address,undefined -fno-sanitize-recover=undefined"
-            linkflags: "linkflags=-fsanitize=address,undefined"
+            os: ubuntu-22.04
+            cxxflags: "cxxflags=--coverage -fsanitize=address,leak,undefined -fno-sanitize-recover=undefined"
+            linkflags: "linkflags=--coverage -lasan -lubsan"
+            gcov_tool: "gcov-9"
+          - toolset: clang-14
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-22.04
+          - toolset: clang-13
+            cxxstd: "03,11,14,17,20"
+            os: ubuntu-22.04
+          # - toolset: clang
+          #   cxxstd: "03,11,14,17,2a"
+          #   os: macos-10.15
+          #   cxxflags: "cxxflags=-fsanitize=address,undefined -fno-sanitize-recover=undefined"
+          #   linkflags: "linkflags=-fsanitize=address,undefined"

    runs-on: ${{matrix.os}}

@@ -75,11 +87,6 @@ jobs:
          ./b2 -d0 headers
          ./b2 -j4 variant=debug tools/inspect/build

-      - name: Create user-config.jam
-        if: matrix.compiler
-        run: |
-          echo "using ${{matrix.toolset}} : : ${{matrix.compiler}} ;" > ~/user-config.jam
-
      - name: Run tests
        run: |
          cd ../boost-root
@@ -87,7 +94,7 @@ jobs:
          dist/bin/inspect libs/$LIBRARY

      - name: Test boost namespace stripping
-        if: ${{matrix.toolset == 'gcc-9'}}
+        if: ${{matrix.toolset == 'gcc-12'}}
        run: ../boost-root/libs/$LIBRARY/misc/strip_boost_namespace.sh

      - name: Prepare coverage data
@@ -97,9 +104,9 @@ jobs:

          echo -e "#!/bin/bash\nexec ${{matrix.gcov_tool}} \"\$@\"" > $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
          chmod +x $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh
-          wget https://github.com/linux-test-project/lcov/archive/v1.15.zip
-          unzip v1.15.zip
-          LCOV="`pwd`/lcov-1.15/bin/lcov --gcov-tool $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh"
+          wget https://github.com/linux-test-project/lcov/archive/v1.16.zip
+          unzip v1.16.zip
+          LCOV="`pwd`/lcov-1.16/bin/lcov --gcov-tool $GITHUB_WORKSPACE/coveralls/gcov_wrapper.sh"

          echo "$LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory `pwd`/libs/$LIBRARY/test --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info"
          $LCOV --directory ../boost-root/bin.v2/libs/$LIBRARY/ --base-directory ../boost-root/ --capture --output-file $GITHUB_WORKSPACE/coveralls/coverage.info
@@ -123,19 +130,21 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: msvc-14.1
-            cxxstd: "14,17,latest"
+          - toolset: msvc-14.0
+            cxxstd: "14,latest"
            addrmd: 32,64
-            os: windows-2016
-          # TODO: fails the loophole tests
-          #- toolset: msvc-14.2
-          #  cxxstd: "14,17,latest"
-          #  addrmd: 32,64
-          #  os: windows-2019
+            os: windows-2019
+            threads: "-j3"
          - toolset: gcc
            cxxstd: "03,11,14,17,2a"
            addrmd: 64
            os: windows-2019
+            threads: "-j3"
+          - toolset: msvc-14.3
+            cxxstd: "20,latest"
+            addrmd: 64
+            os: windows-2022
+            threads: "-j1"

    runs-on: ${{matrix.os}}

@@ -168,7 +177,7 @@ jobs:
        shell: cmd
        run: |
          cd ../boost-root
-          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+          b2 ${{matrix.threads}} libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release

  finish:
    needs: posix
--- a/README.md
+++ b/README.md
@@ -45,11 +45,13 @@ Outputs:
 Edgar Allan Poe was born in 1809
 ```

+[Run the above sample](https://godbolt.org/z/PfYsWKb7v)
+

 ### Motivating Example #1
 ```c++
 #include <iostream>
-#include "boost/pfr/precise.hpp"
+#include "boost/pfr.hpp"

 struct my_struct { // no ostream operator defined!
    int i;
@@ -74,7 +76,7 @@ my_struct has 3 fields: {100, H, 3.14159}

 ```c++
 #include <iostream>
-#include "boost/pfr/precise.hpp"
+#include "boost/pfr.hpp"

 struct my_struct { // no ostream operator defined!
    std::string s;
@@ -94,6 +96,58 @@ Outputs:
 my_struct has 2 fields: {"Das ist fantastisch!", 100}
 ```

+### Motivating Example #3
+
+```c++
+#include <iostream>
+#include <string>
+
+#include <boost/config/warning_disable.hpp>
+#include <boost/spirit/home/x3.hpp>
+#include <boost/fusion/include/adapt_boost_pfr.hpp>
+
+#include "boost/pfr/io.hpp"
+
+namespace x3 = boost::spirit::x3;
+
+struct ast_employee { // No BOOST_FUSION_ADAPT_STRUCT defined
+    int age;
+    std::string forename;
+    std::string surname;
+    double salary;
+};
+
+auto const quoted_string = x3::lexeme['"' >> +(x3::ascii::char_ - '"') >> '"'];
+
+x3::rule<class employee, ast_employee> const employee = "employee";
+auto const employee_def =
+    x3::lit("employee")
+    >> '{'
+    >>  x3::int_ >> ','
+    >>  quoted_string >> ','
+    >>  quoted_string >> ','
+    >>  x3::double_
+    >>  '}'
+    ;
+BOOST_SPIRIT_DEFINE(employee);
+
+int main() {
+    std::string str = R"(employee{34, "Chip", "Douglas", 2500.00})";
+    ast_employee emp;
+    x3::phrase_parse(str.begin(),
+                     str.end(),
+                     employee,
+                     x3::ascii::space,
+                     emp);
+    std::cout << boost::pfr::io(emp) << std::endl;
+}
+
+```
+Outputs:
+```
+(34 Chip Douglas 2500)
+```
+

 ### Requirements and Limitations

--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -32,9 +32,12 @@ local doxygen_params =
        <doxygen:param>"ALIASES= \\
            \"forcedlink{1}=\\xmlonly<link linkend='boost.pfr.\\1'>\\endxmlonly boost::pfr::\\1\\xmlonly</link>\\endxmlonly\" \\
            \"podops=\\b See \\b Also : \\xmlonly<link linkend='boost_pfr.tutorial.three_ways_of_getting_operators'>\\endxmlonly 'Three ways of getting operators' \\xmlonly</link>\\endxmlonly\" \\
+            \"fnrefl=\\b See \\b Also : \\xmlonly<link linkend='boost_pfr.tutorial.reflection_of_field_name'>\\endxmlonly 'Reflection of field names' \\xmlonly</link>\\endxmlonly\" \\
            \"customio=\\b See \\b Also : \\xmlonly<link linkend='boost_pfr.tutorial.custom_printing_of_aggregates'>\\endxmlonly 'Custom printing of aggregates' \\xmlonly</link>\\endxmlonly for info on how to implement your own manipulator with custom format.\" \\
            \"aggregate=\\xmlonly<link linkend='boost_pfr.limitations_and_configuration'>\\endxmlonly simple aggregate \\xmlonly</link>\\endxmlonly\" \\
-            \"BOOST_PFR_DOXYGEN_INVOKED\" \\
+        "
+        <doxygen:param>"PREDEFINED= \\
+            \"BOOST_PFR_DOXYGEN_INVOKED=1\" \\
        "
    ;

@@ -44,7 +47,7 @@ doxygen autodoc_pfr
        [ glob ../../../boost/pfr/*.hpp ]
    :
        $(doxygen_params)
-        <xsl:param>"boost.doxygen.reftitle=Reference Section"
+        <xsl:param>"boost.doxygen.reftitle=Reference Section of PFR"
    ;

 boostbook pfr-doc
@@ -52,7 +55,7 @@ boostbook pfr-doc
        pfr.qbk
    :
        <dependency>autodoc_pfr
-        <xsl:param>boost.root=https://www.boost.org/doc/libs/1_72_0
+        <xsl:param>boost.root=https://www.boost.org/doc/libs/1_81_0
        #<xsl:param>boost.root=../../../.
        <xml:param>html.stylesheet=../../../../doc/src/boostbook.css
    ;
--- a/doc/pfr.qbk
+++ b/doc/pfr.qbk
@@ -1,7 +1,7 @@
 [library Boost.PFR
    [quickbook 1.6]
-    [version 2.0]
-    [copyright 2016-2021 Antony Polukhin]
+    [version 2.2]
+    [copyright 2016-2023 Antony Polukhin]
    [category Language Features Emulation]
    [license
        Distributed under the Boost Software License, Version 1.0.
@@ -17,6 +17,7 @@ Boost.PFR is a C++14 library for a very basic reflection. It gives you access to
 [import ../example/motivating_example0.cpp]
 [pfr_motivating_example]

+Experiment with the sample [@https://godbolt.org/z/PfYsWKb7v online].
 See [link boost_pfr.limitations_and_configuration [*limitations]].


@@ -42,20 +43,20 @@ user_info retrieve_friend(std::string_view name) {
        name
    );

-    ////////////////////////////////////////////////////////////////////////////////
+    /////////////////////////////////////////////////////////////////////////////
    user_info info {
        std::move(std::get<0>(info_tuple)),
        std::move(std::get<1>(info_tuple)),
        std::move(std::get<2>(info_tuple)),
        std::move(std::get<3>(info_tuple)),
    }
-    ////////////////////////////////////////////////////////////////////////////////
+    /////////////////////////////////////////////////////////////////////////////

    auto friend_info = ask_user_for_friend(std::move(info));

    db::insert(
        "INSERT INTO user_infos(id, name, email, login) VALUES ($0, $1, $2, $3)",
-        friend_info.id,    /////////////////////////////////////////////////////////
+        friend_info.id,    //////////////////////////////////////////////////////
        friend_info.name,  // Users are forced to enumerate fields because your
        friend_info.email, // library can not iterate over the fields of a user
        friend_info.login  // provided structure
@@ -80,20 +81,20 @@ user_info retrieve_friend(std::string_view name) {
        name
    );

-    ////////////////// No boilerplate code to move data around /////////////////////
+    ////////////////// No boilerplate code to move data around //////////////////






-    ////////////////////////////////////////////////////////////////////////////////
+    /////////////////////////////////////////////////////////////////////////////

    auto friend_info = ask_user_for_friend(std::move(info));

    db::insert(
        "INSERT INTO user_infos(id, name, email, login) VALUES ($0, $1, $2, $3)",
-        friend_info     ////////////////////////////////////////////////////////////
+        friend_info     /////////////////////////////////////////////////////////
                        // Boost.PFR allows you to iterate over all the fields
                        // of a user provided structure
                        //
@@ -119,7 +120,7 @@ struct user_info {
    std::string name, email, login;
 };

-/// Customizations via hand-written code or macro like BOOST_FUSION_ADAPT_STRUCT ///
+/// Customizations via hand-written code ////////////////////////////////////////
 auto db_api_tie(user_info& ui) noexcept {
    return std::tie(ui.id, ui.name, ui.email, ui.login);
 }
@@ -127,7 +128,7 @@ auto db_api_tie(user_info& ui) noexcept {
 auto db_api_tie(const user_info& ui) noexcept {
    return std::tie(ui.id, ui.name, ui.email, ui.login);
 }
-////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////
 ```
 ][
 ```
@@ -138,7 +139,7 @@ struct user_info {
    std::string name, email, login;
 };

-//////// With Boost.PFR there's no need in hand written customizations /////////////
+//////// With Boost.PFR there's no need in hand written customizations //////////



@@ -146,14 +147,29 @@ struct user_info {



-////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////
 ```
 ]]
 ]


+Imagine that you are writing a serialization library. Serialization of user
+provided structures (and nested structures) with Boost.PFR it is just as simple as:
+
+```
+void Write(Writer& writer, int value);
+void Write(Writer& writer, std::string_view value);
+
+template <typename T>
+std::enable_if_t<std::is_aggregate_v<T>> Write(Writer& writer, const T& value) {
+  boost::pfr::for_each_field(
+      value, [&writer](const auto& field) { Write(writer, field); });
+}
+```
+
 With Boost.PFR the code is shorter, more readable and more pleasant to write.

+[note All the above examples were inspired by the Boost.PFR usage in [@https://github.com/userver-framework/userver 🐙 userver framework].]


 [h2 Out of the box functionality ]
@@ -164,14 +180,17 @@ Boost.PFR adds the following out-of-the-box functionality for aggregate initiali
 * heterogeneous comparators
 * hash
 * IO streaming
-* access to members by index
+* access to members by index or type
+* access to member's names by index
 * member type retrieval
-* methods for cooperation with `std::tuple`
+* methods for cooperation with `std::tuple` for members
+* methods for cooperation with `std::array` for member's names
 * methods to visit each field of the structure
+* trait to detect potential ability to reflect type, and ability to override trait's decision in user-side code

 Boost.PFR is a header only library that does not depend on Boost. You can just copy the content of the "include" folder [@https://github.com/boostorg/pfr from the Boost.PFR github] into your project, and the library will work fine. For a version of the library without `boost::` namespace see [@https://github.com/apolukhin/pfr_non_boost PFR].

-[caution Recommended C++ Standards are C++17 and above. Library requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported]
+[caution Recommended C++ Standards are C++20 and above. C++17 completely enough for a user who doesn't want accessing name of structure member. Library requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported]

 [endsect]

@@ -186,6 +205,9 @@ Boost.PFR is a header only library that does not depend on Boost. You can just c
 [
    [ [pfr_quick_examples_get] ]
    [ [funcref boost::pfr::get] ]
+][
+    [ [pfr_quick_examples_get_name] ]
+    [ [funcref boost::pfr::get_name] ]
 ][
    [ [pfr_quick_examples_ops] ]
    [
@@ -252,6 +274,7 @@ Boost.PFR is a header only library that does not depend on Boost. You can just c

 [import ../example/sample_printing.cpp]
 [import ../example/get.cpp]
+[import ../example/get_name.cpp]


 [section Why tuples are bad and aggregates are more preferable?]
@@ -431,12 +454,21 @@ error: static_assert failed "====================> Boost.PFR: For safety reasons

 [endsect]

+
+[section Reflection of field name ]
+
+[pfr_example_get_name]
+
+See [link boost_pfr.limitations_and_configuration [*Limitations and Configuration]].
+
+[endsect]
+
 [endsect]


 [section Limitations and Configuration]

-[caution Recommended C++ Standards are C++17 and above. Library requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported. ]
+[caution Recommended C++ Standards are C++20 and above. C++17 completely enough for a user who doesn't want accessing name of structure member. Library requires at least C++14! Pre C++14 compilers (C++11, C++03...) are not supported. ]

 Boost.PFR library works with types that satisfy the requirements of `SimpleAggregate`: aggregate types without base classes, `const` fields, references, or C arrays:

@@ -458,6 +490,11 @@ struct aggregate : empty { // not a SimpleAggregate
 ```
 The library may work with aggregates that don't satisfy the requirements of `SimpleAggregate`, but the behavior tends to be non-portable.

+Boost.PFRs extraction of field name works with a `SimpleAggregate` with non-internal linkage (with aggregats that could be used as `extern T t;`).
+Do not use this functionality with anonymous structures, local structures
+or a structure defined inside anonymous namespace as the behavior tends to be non-portable.
+
+
 [h2 Configuration Macro]

 By default Boost.PFR [*auto-detects your compiler abilities] and automatically defines the configuration macro into appropriate values. If you wish to override that behavior, just define:
@@ -467,6 +504,11 @@ By default Boost.PFR [*auto-detects your compiler abilities] and automatically d
    [[*BOOST_PFR_USE_LOOPHOLE*] [Define to `1` if you wish to override Boost.PFR choice and exploit [@http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2118 CWG 2118] for reflection. Define to `0` to override Boost.PFR choice and disable CWG 2118 usage.]]
    [[*BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE*] [Define to `0` if you are hit by the template instantiation depth issues with `std::make_integer_sequence` and wish to use Boost.PFR version of that metafunction. Define to `1` to override Boost.PFR detection logic. ]]
    [[*BOOST_PFR_HAS_GUARANTEED_COPY_ELISION*] [Define to `0` if your compiler does not implement C++17 guaranteed copy elision properly and fails to reflect aggregates with non-movable fields. Define to `1` to override Boost.PFR detection logic. ]]
+    [[*BOOST_PFR_ENABLE_IMPLICIT_REFLECTION*] [Define to `0` if you are hit by lots of non-effective choices made by implicitly reflection. Define to `1` to override Boost.PFR detection logic. ]]
+    [[*BOOST_PFR_CORE_NAME_ENABLED*] [On platforms where field name extraction is not supported, the 'boost/pfr/config.hpp' header defines the BOOST_PFR_CORE_NAME_ENABLED macro equal to 0. Defining this macro as 0 before including the header disables the ability to get a field name. ]]
+    [[*BOOST_PFR_FUNCTION_SIGNATURE*] [For known compilers defined to a compiler specific macro, that outputs the whole function signature including non-type template parameters. ]]
+    [[*BOOST_PFR_CORE_NAME_PARSING*] [Describes extraction of field name from BOOST_PFR_FUNCTION_SIGNATURE macro. See details below. ]]
+    [[*BOOST_PFR_ENABLED*] [On platforms where Boost.PFR is not supported, the `boost/pfr/config.hpp` header defines the BOOST_PFR_ENABLED macro equal to 0. Defining this macro as 0 before including the header disables the Boost.PFR library. ]]
 ]


@@ -475,14 +517,37 @@ By default Boost.PFR [*auto-detects your compiler abilities] and automatically d
 The Boost.PFRs reflection has some limitations that depend on a C++ Standard and compiler capabilities:

 * Static variables are ignored
-* T must be aggregate initializable without empty base classes
-* if T contains C arrays or it is inherited from non-empty type then the result of reflection may differ depending on the C++ version and library configuration
+* T must be aggregate initializable without base classes
+* if T contains C arrays then the result of reflection may differ depending on the C++ version and library configuration
 * Additional limitations if [*BOOST_PFR_USE_CPP17 == 0]:
    * Non of the member fields should have a template constructor from one parameter.
    * Additional limitations if [*BOOST_PFR_USE_LOOPHOLE == 0]:
        * T must be constexpr aggregate initializable and all its fields must be constexpr default constructible
        * [funcref boost::pfr::get], [funcref boost::pfr::structure_to_tuple], [funcref boost::pfr::structure_tie], [headerref boost/pfr/core.hpp boost::pfr::tuple_element] require T to be a POD type with built-in types only.

+The Boost.PFRs extraction of field name has some limitations that depend on a C++ Standard and compiler capabilities:
+
+* T should be usable like `extern T t;`, i.e. has a non-internal linkage.
+
+[h2 Adjusting BOOST_PFR_CORE_NAME_PARSING]
+
+`BOOST_PFR_CORE_NAME_PARSING` is already set up for most of the popular compilers. You need to adjust it only
+if some static_assert in the library complained on `BOOST_PFR_CORE_NAME_PARSING`.
+
+To do that:
+
+# Build `test/core_name/print_name.cpp` with your compiler and run it
+# Define BOOST_PFR_CORE_NAME_PARSING to `(skip_at_begin, skip_at_end, "")`, where
+    * `skip_at_begin` is equal to characters count before the first occurrence of `user_defined_field` in output
+    * `skip_at_end` is equal to characters count after last occurrence of `user_defined_field` in output
+# Check that `test/core_name/print_name.cpp` returns "user_defined_field"
+# If it does not return `user_defined_field`, then define BOOST_PFR_CORE_NAME_PARSING to `(skip_at_begin, skip_at_end, "T = ")`, where
+    * `skip_at_begin` is equal to `skip_at_begin` at step 2
+    * `skip_at_end` is equal to `skip_at_end` at step 2
+    * `"T = "` is equal to characters that are right before the `user_defined_field` in output, use `backward("T = ")` to search for the occurange in the string from the right
+# (optional, but highly recommended) [@https://github.com/boostorg/pfr/issues create ticket] with
+feature request to add your compiler to supported compilers list. Include
+parameters provided to `BOOST_PFR_CORE_NAME_PARSING` macro [*and] the initial output of `test/core_name/print_name.cpp`.

 [endsect]

@@ -518,7 +583,7 @@ Description of the [*BOOST_PFR_USE_LOOPHOLE == 1] technique by its inventor Alex

 [section Acknowledgements]

-Many thanks to Bruno Dutra for showing the technique to precisely reflect aggregate initializable type in C++14 [@https://github.com/apolukhin/magic_get/issues/5 Manual type registering/structured bindings might be unnecessary].
+Many thanks to Bruno Dutra for showing the technique to precisely reflect aggregate initializable type in C++14 [@https://github.com/boostorg/pfr/issues/5 Manual type registering/structured bindings might be unnecessary].

 Many thanks to Alexandr Poltavsky for initial implementation the [*BOOST_PFR_USE_LOOPHOLE == 1] technique and for describing it [@http://alexpolt.github.io/type-loophole.html in his blog].

--- a/example/get.cpp
+++ b/example/get.cpp
@@ -1,4 +1,4 @@
-// Copyright 2016-2021 Antony Polukhin
+// Copyright 2016-2023 Antony Polukhin

 // Distributed under the Boost Software License, Version 1.0.
 // (See the accompanying file LICENSE_1_0.txt
--- a/example/get_name.cpp
+++ b/example/get_name.cpp
@@ -0,0 +1,43 @@
+// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// Initial implementation by Bela Schaum, https://github.com/schaumb
+// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
+//
+
+#include <boost/pfr/config.hpp>
+
+#if BOOST_PFR_CORE_NAME_ENABLED && BOOST_PFR_USE_CPP17
+//[pfr_example_get_name
+/*`
+    Since C++20 it's possible to read name of a structure field by index using Boost.PFR library.
+    The following example shows how to do it using [funcref boost::pfr::get_name].
+
+    Let's define some structure:
+*/
+#include <boost/pfr/core_name.hpp>
+
+struct foo {            // defining structure
+    int some_integer;
+    char c;
+};
+
+/*`
+    We can access field's names of that structure by index:
+*/
+constexpr std::string_view n1 = boost::pfr::get_name<0, foo>(); // returns "some_integer"
+constexpr std::string_view n2 = boost::pfr::get_name<1, foo>(); // returns "c"
+//] [/pfr_example_get_name]
+#endif
+
+int main() {
+#if BOOST_PFR_CORE_NAME_ENABLED && BOOST_PFR_USE_CPP17
+    if (n1 != "some_integer") return 1;
+    if (n2 != "c") return 2;
+#endif
+
+    return 0;
+}
--- a/example/motivating_example0.cpp
+++ b/example/motivating_example0.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/example/quick_examples.cpp
+++ b/example/quick_examples.cpp
@@ -1,4 +1,4 @@
-// Copyright 2016-2021 Antony Polukhin
+// Copyright 2016-2023 Antony Polukhin

 // Distributed under the Boost Software License, Version 1.0.
 // (See the accompanying file LICENSE_1_0.txt
@@ -91,7 +91,7 @@ void test_examples() {

  {
 //[pfr_quick_examples_get
-    // Get field by index and assign new value to that field
+    // Get field by index/type and assign new value to that field

    struct sample {
        char c;
@@ -100,11 +100,29 @@ void test_examples() {

    sample var{};
    boost::pfr::get<1>(var) = 42.01f;
+    boost::pfr::get<char>(var) = 'A';

-    std::cout << var.f; // Outputs: 42.01
+    std::cout << var.c << var.f; // Outputs: A 42.01
 //]
  }

+  // Disabled from testing since it's unportable
+#if 0
+  {
+//[pfr_quick_examples_get_name
+    // Get name of field by index
+
+    struct sample {
+        int f1;
+        long f2;
+    };
+
+    std::cout << boost::pfr::get_name<0, sample>()
+              << boost::pfr::get_name<1, sample>(); // Outputs: f1 f2
+//]
+  }
+#endif
+
 #if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
  {
 //[pfr_quick_examples_structure_to_tuple
--- a/example/sample_printing.cpp
+++ b/example/sample_printing.cpp
@@ -1,4 +1,4 @@
-// Copyright 2016-2021 Antony Polukhin
+// Copyright 2016-2023 Antony Polukhin

 // Distributed under the Boost Software License, Version 1.0.
 // (See the accompanying file LICENSE_1_0.txt
--- a/include/boost/pfr.hpp
+++ b/include/boost/pfr.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -9,7 +9,9 @@
 /// \file boost/pfr.hpp
 /// Includes all the Boost.PFR headers

+#include <boost/pfr/config.hpp>
 #include <boost/pfr/core.hpp>
+#include <boost/pfr/core_name.hpp>
 #include <boost/pfr/functions_for.hpp>
 #include <boost/pfr/functors.hpp>
 #include <boost/pfr/io.hpp>
@@ -17,5 +19,7 @@
 #include <boost/pfr/ops.hpp>
 #include <boost/pfr/ops_fields.hpp>
 #include <boost/pfr/tuple_size.hpp>
+#include <boost/pfr/traits_fwd.hpp>
+#include <boost/pfr/traits.hpp>

 #endif // BOOST_PFR_HPP
--- a/include/boost/pfr/config.hpp
+++ b/include/boost/pfr/config.hpp
@@ -0,0 +1,148 @@
+// Copyright (c) 2016-2023 Antony Polukhin
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_CONFIG_HPP
+#define BOOST_PFR_CONFIG_HPP
+#pragma once
+
+#if __cplusplus >= 201402L || (defined(_MSC_VER) && defined(_MSVC_LANG) && _MSC_VER > 1900)
+#include <type_traits> // to get non standard platform macro definitions (__GLIBCXX__ for example)
+#endif
+
+/// \file boost/pfr/config.hpp
+/// Contains all the macros that describe Boost.PFR configuration, like BOOST_PFR_ENABLED
+///
+/// \note This header file doesn't require C++14 Standard and supports all C++ compilers, even pre C++14 compilers (C++11, C++03...).
+
+// Reminder:
+//  * MSVC++ 14.2 _MSC_VER == 1927 <- Loophole is known to work (Visual Studio ????)
+//  * MSVC++ 14.1 _MSC_VER == 1916 <- Loophole is known to NOT work (Visual Studio 2017)
+//  * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
+//  * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
+
+#ifdef BOOST_PFR_NOT_SUPPORTED
+#   error Please, do not set BOOST_PFR_NOT_SUPPORTED value manually, use '-DBOOST_PFR_ENABLED=0' instead of it
+#endif
+
+#if defined(_MSC_VER)
+#   if !defined(_MSVC_LANG) || _MSC_VER <= 1900
+#       define BOOST_PFR_NOT_SUPPORTED 1
+#   endif
+#elif __cplusplus < 201402L
+#   define BOOST_PFR_NOT_SUPPORTED 1
+#endif
+
+#ifndef BOOST_PFR_USE_LOOPHOLE
+#   if defined(_MSC_VER)
+#       if _MSC_VER >= 1927
+#           define BOOST_PFR_USE_LOOPHOLE 1
+#       else
+#           define BOOST_PFR_USE_LOOPHOLE 0
+#       endif
+#   elif defined(__clang_major__) && __clang_major__ >= 8
+#       define BOOST_PFR_USE_LOOPHOLE 0
+#   else
+#       define BOOST_PFR_USE_LOOPHOLE 1
+#   endif
+#endif
+
+#ifndef BOOST_PFR_USE_CPP17
+#   ifdef __cpp_structured_bindings
+#       define BOOST_PFR_USE_CPP17 1
+#   elif defined(_MSVC_LANG)
+#       if _MSVC_LANG >= 201703L
+#           define BOOST_PFR_USE_CPP17 1
+#       else
+#           define BOOST_PFR_USE_CPP17 0
+#       endif
+#   else
+#       define BOOST_PFR_USE_CPP17 0
+#   endif
+#endif
+
+#if (!BOOST_PFR_USE_CPP17 && !BOOST_PFR_USE_LOOPHOLE)
+#   if (defined(_MSC_VER) && _MSC_VER < 1916) ///< in Visual Studio 2017 v15.9 PFR library with classic engine normally works
+#      define BOOST_PFR_NOT_SUPPORTED 1
+#   endif
+#endif
+
+#ifndef BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE
+// Assume that libstdc++ since GCC-7.3 does not have linear instantiation depth in std::make_integral_sequence
+#   if defined( __GLIBCXX__) && __GLIBCXX__ >= 20180101
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
+#   elif defined(_MSC_VER)
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
+//# elif other known working lib
+#   else
+#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 0
+#   endif
+#endif
+
+#ifndef BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
+#   if  defined(__cpp_guaranteed_copy_elision) && (!defined(_MSC_VER) || _MSC_VER > 1928)
+#       define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 1
+#   else
+#       define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 0
+#   endif
+#endif
+
+#ifndef BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+#   if  defined(__cpp_lib_is_aggregate)
+#       define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION 1
+#   else
+// There is no way to detect potential ability to be reflectable without std::is_aggregare
+#       define BOOST_PFR_ENABLE_IMPLICIT_REFLECTION 0
+#   endif
+#endif
+
+#ifndef BOOST_PFR_CORE_NAME_ENABLED
+#   if  (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L))
+#       if (defined(__cpp_nontype_template_args) && __cpp_nontype_template_args >= 201911) \
+         || (defined(__clang_major__) && __clang_major__ >= 12)
+#           define BOOST_PFR_CORE_NAME_ENABLED 1
+#       else
+#           define BOOST_PFR_CORE_NAME_ENABLED 0
+#       endif
+#   else
+#       define BOOST_PFR_CORE_NAME_ENABLED 0
+#   endif
+#endif
+
+
+#ifndef BOOST_PFR_CORE_NAME_PARSING
+#   if defined(_MSC_VER)
+#       define BOOST_PFR_CORE_NAME_PARSING (sizeof("auto __cdecl boost::pfr::detail::name_of_field_impl<") - 1, sizeof(">(void) noexcept") - 1, backward("->"))
+#   elif defined(__clang__)
+#       define BOOST_PFR_CORE_NAME_PARSING (sizeof("auto boost::pfr::detail::name_of_field_impl() [MsvcWorkaround = ") - 1, sizeof("}]") - 1, backward("."))
+#   elif defined(__GNUC__)
+#       define BOOST_PFR_CORE_NAME_PARSING (sizeof("consteval auto boost::pfr::detail::name_of_field_impl() [with MsvcWorkaround = ") - 1, sizeof(")]") - 1, backward("::"))
+#   else
+// Default parser for other platforms... Just skip nothing!
+#       define BOOST_PFR_CORE_NAME_PARSING (0, 0, "")
+#   endif
+#endif
+
+#if defined(__has_cpp_attribute)
+#   if __has_cpp_attribute(maybe_unused)
+#       define BOOST_PFR_MAYBE_UNUSED [[maybe_unused]]
+#   endif
+#endif
+
+#ifndef BOOST_PFR_MAYBE_UNUSED
+#   define BOOST_PFR_MAYBE_UNUSED
+#endif
+
+#ifndef BOOST_PFR_ENABLED
+#   ifdef BOOST_PFR_NOT_SUPPORTED
+#       define BOOST_PFR_ENABLED 0
+#   else
+#       define BOOST_PFR_ENABLED 1
+#   endif
+#endif
+
+#undef BOOST_PFR_NOT_SUPPORTED
+
+#endif // BOOST_PFR_CONFIG_HPP
--- a/include/boost/pfr/core.hpp
+++ b/include/boost/pfr/core.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -30,20 +30,25 @@
 namespace boost { namespace pfr {

 /// \brief Returns reference or const reference to a field with index `I` in \aggregate `val`.
+/// Overload taking the type `U` returns reference or const reference to a field
+/// with provided type `U` in \aggregate `val` if there's only one field of such type in `val`.
 ///
 /// \b Example:
 /// \code
 ///     struct my_struct { int i, short s; };
 ///     my_struct s {10, 11};
+///
 ///     assert(boost::pfr::get<0>(s) == 10);
 ///     boost::pfr::get<1>(s) = 0;
+///
+///     assert(boost::pfr::get<int>(s) == 10);
+///     boost::pfr::get<short>(s) = 11;
 /// \endcode
 template <std::size_t I, class T>
 constexpr decltype(auto) get(const T& val) noexcept {
    return detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) );
 }

-
 /// \overload get
 template <std::size_t I, class T>
 constexpr decltype(auto) get(T& val
@@ -66,11 +71,45 @@ constexpr auto get(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nul

 /// \overload get
 template <std::size_t I, class T>
-constexpr auto get(T&& val, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = 0) noexcept {
+constexpr auto get(T&& val, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
    return std::move(detail::sequence_tuple::get<I>( detail::tie_as_tuple(val) ));
 }


+/// \overload get
+template <class U, class T>
+constexpr const U& get(const T& val) noexcept {
+    return detail::sequence_tuple::get_by_type_impl<const U&>( detail::tie_as_tuple(val) );
+}
+
+
+/// \overload get
+template <class U, class T>
+constexpr U& get(T& val
+#if !BOOST_PFR_USE_CPP17
+    , std::enable_if_t<std::is_assignable<T, T>::value>* = nullptr
+#endif
+) noexcept {
+    return detail::sequence_tuple::get_by_type_impl<U&>( detail::tie_as_tuple(val) );
+}
+
+#if !BOOST_PFR_USE_CPP17
+/// \overload get
+template <class U, class T>
+constexpr U& get(T&, std::enable_if_t<!std::is_assignable<T, T>::value>* = nullptr) noexcept {
+    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::get on non const non assignable type is allowed only in C++17");
+    return 0;
+}
+#endif
+
+
+/// \overload get
+template <class U, class T>
+constexpr U&& get(T&& val, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
+    return std::move(detail::sequence_tuple::get_by_type_impl<U&>( detail::tie_as_tuple(val) ));
+}
+
+
 /// \brief `tuple_element` has a member typedef `type` that returns the type of a field with index I in \aggregate T.
 ///
 /// \b Example:
@@ -97,7 +136,7 @@ using tuple_element_t = typename tuple_element<I, T>::type;
 /// \code
 ///     struct my_struct { int i, short s; };
 ///     my_struct s {10, 11};
-///     std::tuple<int, short> t = make_tuple(s);
+///     std::tuple<int, short> t = boost::pfr::structure_to_tuple(s);
 ///     assert(get<0>(t) == 10);
 /// \endcode
 template <class T>
@@ -119,10 +158,10 @@ constexpr auto structure_to_tuple(const T& val) noexcept {
 ///     struct my_struct { int i, short s; };
 ///
 ///     const my_struct const_s{1, 2};
-///     std::apply(foo, structure_tie(const_s));
+///     std::apply(foo, boost::pfr::structure_tie(const_s));
 ///
 ///     my_struct s;
-///     structure_tie(s) = std::tuple<int, short>{10, 11};
+///     boost::pfr::structure_tie(s) = std::tuple<int, short>{10, 11};
 ///     assert(s.s == 11);
 /// \endcode
 template <class T>
@@ -159,7 +198,7 @@ constexpr auto structure_tie(T&, std::enable_if_t<!std::is_assignable<T, T>::val

 /// \overload structure_tie
 template <class T>
-constexpr auto structure_tie(T&&, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = 0) noexcept {
+constexpr auto structure_tie(T&&, std::enable_if_t< std::is_rvalue_reference<T&&>::value>* = nullptr) noexcept {
    static_assert(sizeof(T) && false, "====================> Boost.PFR: Calling boost::pfr::structure_tie on rvalue references is forbidden");
    return 0;
 }
@@ -177,11 +216,11 @@ constexpr auto structure_tie(T&&, std::enable_if_t< std::is_rvalue_reference<T&&
 /// \code
 ///     struct my_struct { int i, short s; };
 ///     int sum = 0;
-///     for_each_field(my_struct{20, 22}, [&sum](const auto& field) { sum += field; });
+///     boost::pfr::for_each_field(my_struct{20, 22}, [&sum](const auto& field) { sum += field; });
 ///     assert(sum == 42);
 /// \endcode
 template <class T, class F>
-void for_each_field(T&& value, F&& func) {
+constexpr void for_each_field(T&& value, F&& func) {
    constexpr std::size_t fields_count_val = boost::pfr::detail::fields_count<std::remove_reference_t<T>>();

    ::boost::pfr::detail::for_each_field_dispatcher(
@@ -214,7 +253,7 @@ void for_each_field(T&& value, F&& func) {
 ///       return res;
 ///     }
 ///     auto [p, s] = f();
-///     tie_from_structure(p, s) = f();
+///     boost::pfr::tie_from_structure(p, s) = f();
 /// \endcode
 template <typename... Elements>
 constexpr detail::tie_from_structure_tuple<Elements...> tie_from_structure(Elements&... args) noexcept {
--- a/include/boost/pfr/core_name.hpp
+++ b/include/boost/pfr/core_name.hpp
@@ -0,0 +1,88 @@
+// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// Initial implementation by Bela Schaum, https://github.com/schaumb
+// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
+//
+
+#ifndef BOOST_PFR_CORE_NAME_HPP
+#define BOOST_PFR_CORE_NAME_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/core_name.hpp>
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/stdarray.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+
+#include <cstddef> // for std::size_t
+
+#include <boost/pfr/tuple_size.hpp>
+
+/// \file boost/pfr/core_name.hpp
+/// Contains functions \forcedlink{get_name} and \forcedlink{names_as_array} to know which names each field of any \aggregate has.
+///
+/// \fnrefl for details.
+///
+/// \b Synopsis:
+
+namespace boost { namespace pfr {
+
+/// \brief Returns name of a field with index `I` in \aggregate `T`.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i, short s; };
+///
+///     assert(boost::pfr::get_name<0, my_struct>() == "i");
+///     assert(boost::pfr::get_name<1, my_struct>() == "s");
+/// \endcode
+template <std::size_t I, class T>
+constexpr
+#ifdef BOOST_PFR_DOXYGEN_INVOKED
+std::string_view
+#else
+auto
+#endif
+get_name() noexcept {
+    return detail::get_name<T, I>();
+}
+
+// FIXME: implement this
+// template<class U, class T>
+// constexpr auto get_name() noexcept {
+//     return detail::sequence_tuple::get_by_type_impl<U>( detail::tie_as_names_tuple<T>() );
+// }
+
+/// \brief Creates a `std::array` from names of fields of an \aggregate `T`.
+///
+/// \b Example:
+/// \code
+///     struct my_struct { int i, short s; };
+///     std::array<std::string_view, 2> a = boost::pfr::names_as_array<my_struct>();
+///     assert(a[0] == "i");
+/// \endcode
+template <class T>
+constexpr
+#ifdef BOOST_PFR_DOXYGEN_INVOKED
+std::array<std::string_view, boost::pfr::tuple_size_v<T>>
+#else
+auto
+#endif
+names_as_array() noexcept {
+    return detail::make_stdarray_from_tietuple(
+        detail::tie_as_names_tuple<T>(),
+        detail::make_index_sequence< tuple_size_v<T> >(),
+        1L
+    );
+}
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_CORE_NAME_HPP
+
--- a/include/boost/pfr/detail/cast_to_layout_compatible.hpp
+++ b/include/boost/pfr/detail/cast_to_layout_compatible.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/config.hpp
+++ b/include/boost/pfr/detail/config.hpp
@@ -1,4 +1,5 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
+// Copyright (c) 2022 Denis Mikhailov
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -7,85 +8,19 @@
 #define BOOST_PFR_DETAIL_CONFIG_HPP
 #pragma once

-#include <type_traits> // to get non standard platform macro definitions (__GLIBCXX__ for example)
+#include <boost/pfr/config.hpp>

-// Reminder:
-//  * MSVC++ 14.2 _MSC_VER == 1927 <- Loophole is known to work (Visual Studio ????)
-//  * MSVC++ 14.1 _MSC_VER == 1916 <- Loophole is known to NOT work (Visual Studio 2017)
-//  * MSVC++ 14.0 _MSC_VER == 1900 (Visual Studio 2015)
-//  * MSVC++ 12.0 _MSC_VER == 1800 (Visual Studio 2013)
+#if !BOOST_PFR_ENABLED

-#if defined(_MSC_VER)
-#   if !defined(_MSVC_LANG) || _MSC_VER <= 1900
-#       error Boost.PFR library requires more modern MSVC compiler.
-#   endif
-#elif __cplusplus < 201402L
-#   error Boost.PFR library requires at least C++14.
-#endif
-
-#ifndef BOOST_PFR_USE_LOOPHOLE
-#   if defined(_MSC_VER)
-#       if _MSC_VER >= 1927
-#           define BOOST_PFR_USE_LOOPHOLE 1
-#       else
-#           define BOOST_PFR_USE_LOOPHOLE 0
-#       endif
-#   elif defined(__clang_major__) && __clang_major__ >= 8
-#       define BOOST_PFR_USE_LOOPHOLE 0
-#   else
-#       define BOOST_PFR_USE_LOOPHOLE 1
-#   endif
-#endif
-
-#ifndef BOOST_PFR_USE_CPP17
-#   ifdef __cpp_structured_bindings
-#       define BOOST_PFR_USE_CPP17 1
-#   elif defined(_MSVC_LANG)
-#       if _MSVC_LANG >= 201703L
-#           define BOOST_PFR_USE_CPP17 1
-#       else
-#           define BOOST_PFR_USE_CPP17 0
-#       endif
-#   else
-#       define BOOST_PFR_USE_CPP17 0
-#   endif
-#endif
-
-#if (!BOOST_PFR_USE_CPP17 && !BOOST_PFR_USE_LOOPHOLE)
-#   if (defined(_MSC_VER) && _MSC_VER < 1916) ///< in Visual Studio 2017 v15.9 PFR library with classic engine normally works
-#      error Boost.PFR requires /std:c++latest or /std:c++17 flags on your compiler.
-#   endif
-#endif
-
-#ifndef BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE
-// Assume that libstdc++ since GCC-7.3 does not have linear instantiation depth in std::make_integral_sequence
-#   if defined( __GLIBCXX__) && __GLIBCXX__ >= 20180101
-#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
-#   elif defined(_MSC_VER)
-#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 1
-//# elif other known working lib
-#   else
-#       define BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE 0
-#   endif
-#endif
-
-#ifndef BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
-#   if  defined(__cpp_guaranteed_copy_elision) && (!defined(_MSC_VER) || _MSC_VER > 1928)
-#       define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 1
-#   else
-#       define BOOST_PFR_HAS_GUARANTEED_COPY_ELISION 0
-#   endif
-#endif
-
-#if defined(__has_cpp_attribute)
-#   if __has_cpp_attribute(maybe_unused)
-#       define BOOST_PFR_MAYBE_UNUSED [[maybe_unused]]
-#   endif
-#endif
-
-#ifndef BOOST_PFR_MAYBE_UNUSED
-#   define BOOST_PFR_MAYBE_UNUSED
-#endif
+#error Boost.PFR library is not supported in your environment.             \
+       Try one of the possible solutions:                                  \
+       1. try to take away an '-DBOOST_PFR_ENABLED=0', if it exists        \
+       2. enable C++14;                                                    \
+       3. enable C++17;                                                    \
+       4. update your compiler;                                            \
+       or disable this error by '-DBOOST_PFR_ENABLED=1' if you really know what are you doing.

+#endif // !BOOST_PFR_ENABLED

 #endif // BOOST_PFR_DETAIL_CONFIG_HPP
+
--- a/include/boost/pfr/detail/core.hpp
+++ b/include/boost/pfr/detail/core.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/core14_classic.hpp
+++ b/include/boost/pfr/detail/core14_classic.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -53,7 +53,7 @@ namespace typeid_conversions {
 #ifdef _MSC_VER
 #   pragma warning( push )
    // '<<': check operator precedence for possible error; use parentheses to clarify precedence
-#   pragma warning( disable : 4554 ) 
+#   pragma warning( disable : 4554 )
 #endif

 constexpr std::size_t native_types_mask = 31;
@@ -118,16 +118,16 @@ template <class Type> constexpr std::size_t type_to_id(identity<const Type*>) no
 template <class Type> constexpr std::size_t type_to_id(identity<const volatile Type*>) noexcept;
 template <class Type> constexpr std::size_t type_to_id(identity<volatile Type*>) noexcept;
 template <class Type> constexpr std::size_t type_to_id(identity<Type&>) noexcept;
-template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_enum<Type>::value>* = 0) noexcept;
-template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_empty<Type>::value>* = 0) noexcept;
-template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_union<Type>::value>* = 0) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_enum<Type>::value>* = nullptr) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_empty<Type>::value>* = nullptr) noexcept;
+template <class Type> constexpr std::size_t type_to_id(identity<Type>, std::enable_if_t<std::is_union<Type>::value>* = nullptr) noexcept;
 template <class Type> constexpr size_array<sizeof(Type) * 3> type_to_id(identity<Type>, std::enable_if_t<!std::is_enum<Type>::value && !std::is_empty<Type>::value && !std::is_union<Type>::value>* = 0) noexcept;

-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_ptr_type> = 0) noexcept;
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ptr_type> = 0) noexcept;
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_volatile_ptr_type> = 0) noexcept;
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_volatile_ptr_type> = 0) noexcept;
-template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ref_type> = 0) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_ptr_type> = nullptr) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ptr_type> = nullptr) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_const_volatile_ptr_type> = nullptr) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_volatile_ptr_type> = nullptr) noexcept;
+template <std::size_t Index> constexpr auto id_to_type(size_t_<Index >, if_extension<Index, native_ref_type> = nullptr) noexcept;


 ///////////////////// Definitions of type_to_id and id_to_type for fundamental types
@@ -346,7 +346,7 @@ constexpr size_array<N> get_type_offsets() noexcept {
    return offsets;
 }

-///////////////////// Returns array of typeids and zeros if construtor of a type accepts sizeof...(I) parameters
+///////////////////// Returns array of typeids and zeros if constructor of a type accepts sizeof...(I) parameters
 template <class T, std::size_t N, std::size_t... I>
 constexpr void* flat_type_to_array_of_type_ids(std::size_t* types, std::index_sequence<I...>) noexcept
 {
@@ -599,13 +599,20 @@ struct ubiq_constructor_constexpr_copy {
 /////////////////////

 template <class T, std::size_t... I>
-struct is_constexpr_aggregate_initializable { // TODO: try to fix it
-    template <T = T{ ubiq_constructor_constexpr_copy{I}... } >
+struct is_constexpr_aggregate_initializable {
+    template<class T2, std::size_t... I2>
+    static constexpr void* constexpr_aggregate_initializer() noexcept {
+        T2 tmp{ ubiq_constructor_constexpr_copy{I2}... };
+        (void)tmp;
+        return nullptr;
+    }
+
+    template <void* = constexpr_aggregate_initializer<T, I...>() >
    static std::true_type test(long) noexcept;

    static std::false_type test(...) noexcept;

-    static constexpr decltype( test(0) ) value{};
+    static constexpr bool value = decltype(test(0)){};
 };


@@ -676,16 +683,7 @@ void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
        !std::is_union<T>::value,
        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
    );
-
-    /// Compile time error at this point means that you have called `for_each_field` or some other non-flat function or operator for a
-    /// type that is not constexpr aggregate initializable.
-    ///
-    /// Make sure that all the fields of your type have constexpr default construtors and trivial destructors.
-    /// Or compile in C++17 mode.
-    constexpr T tmp{ ubiq_constructor_constexpr_copy{I}... };
-    (void)tmp;
-
-    //static_assert(is_constexpr_aggregate_initializable<T, I...>::value, "====================> Boost.PFR: T must be a constexpr initializable type");
+    static_assert(is_constexpr_aggregate_initializable<T, I...>::value, "====================> Boost.PFR: T must be a constexpr initializable type");

    constexpr bool is_flat_refelectable_val = detail::is_flat_refelectable<T>( std::index_sequence<I...>{} );
    detail::for_each_field_dispatcher_1(
--- a/include/boost/pfr/detail/core14_loophole.hpp
+++ b/include/boost/pfr/detail/core14_loophole.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2017-2018 Alexandr Poltavsky, Antony Polukhin.
-// Copyright (c) 2019-2021 Antony Polukhin.
+// Copyright (c) 2019-2023 Antony Polukhin.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -8,7 +8,7 @@
 // The Great Type Loophole (C++14)
 // Initial implementation by Alexandr Poltavsky, http://alexpolt.github.io
 //
-// Description: 
+// Description:
 //  The Great Type Loophole is a technique that allows to exchange type information with template
 //  instantiations. Basically you can assign and read type information during compile time.
 //  Here it is used to detect data members of a data type. I described it for the first time in
@@ -20,6 +20,7 @@

 #ifndef BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP
 #define BOOST_PFR_DETAIL_CORE14_LOOPHOLE_HPP
+#pragma once

 #include <boost/pfr/detail/config.hpp>

--- a/include/boost/pfr/detail/core17.hpp
+++ b/include/boost/pfr/detail/core17.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -6,6 +6,7 @@

 #ifndef BOOST_PFR_DETAIL_CORE17_HPP
 #define BOOST_PFR_DETAIL_CORE17_HPP
+#pragma once

 #include <boost/pfr/detail/core17_generated.hpp>
 #include <boost/pfr/detail/fields_count.hpp>
@@ -22,7 +23,7 @@ struct do_not_define_std_tuple_size_for_me {
 template <class T>
 constexpr bool do_structured_bindings_work() noexcept { // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
    T val{};
-    const auto& [a] = val; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:
+    auto& [a] = val; // ******************************************* IN CASE OF ERROR READ THE FOLLOWING LINES IN boost/pfr/detail/core17.hpp FILE:

    /****************************************************************************
    *
@@ -56,7 +57,7 @@ constexpr auto tie_as_tuple(T& val) noexcept {
 }

 template <class T, class F, std::size_t... I>
-void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
+constexpr void for_each_field_dispatcher(T& t, F&& f, std::index_sequence<I...>) {
    static_assert(
        !std::is_union<T>::value,
        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
--- a/include/boost/pfr/detail/core17_generated.hpp
+++ b/include/boost/pfr/detail/core17_generated.hpp
--- a/include/boost/pfr/detail/core_name.hpp
+++ b/include/boost/pfr/detail/core_name.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// Initial implementation by Bela Schaum, https://github.com/schaumb
+// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
+//
+
+#ifndef BOOST_PFR_DETAIL_CORE_NAME_HPP
+#define BOOST_PFR_DETAIL_CORE_NAME_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+// Each core_name provides `boost::pfr::detail::get_name` and
+// `boost::pfr::detail::tie_as_names_tuple` functions.
+//
+// The whole functional of extracting field's names is build on top of those
+// two functions.
+#if BOOST_PFR_CORE_NAME_ENABLED
+#include <boost/pfr/detail/core_name20_static.hpp>
+#else
+#include <boost/pfr/detail/core_name14_disabled.hpp>
+#endif
+
+#endif // BOOST_PFR_DETAIL_CORE_NAME_HPP
+
--- a/include/boost/pfr/detail/core_name14_disabled.hpp
+++ b/include/boost/pfr/detail/core_name14_disabled.hpp
@@ -0,0 +1,43 @@
+// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// Initial implementation by Bela Schaum, https://github.com/schaumb
+// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
+//
+
+#ifndef BOOST_PFR_DETAIL_CORE_NAME14_DISABLED_HPP
+#define BOOST_PFR_DETAIL_CORE_NAME14_DISABLED_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+#include <boost/pfr/detail/sequence_tuple.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+
+template <class T, std::size_t I>
+constexpr auto get_name() noexcept {
+    static_assert(
+        sizeof(T) && false,
+        "====================> Boost.PFR: Field's names extracting functionality requires C++20."
+    );
+
+    return nullptr;
+}
+
+template <class T>
+constexpr auto tie_as_names_tuple() noexcept {
+    static_assert(
+        sizeof(T) && false,
+        "====================> Boost.PFR: Field's names extracting functionality requires C++20."
+    );
+
+    return detail::sequence_tuple::make_sequence_tuple();
+}
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_CORE_NAME14_DISABLED_HPP
+
--- a/include/boost/pfr/detail/core_name20_static.hpp
+++ b/include/boost/pfr/detail/core_name20_static.hpp
@@ -0,0 +1,242 @@
+// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// Initial implementation by Bela Schaum, https://github.com/schaumb
+// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
+//
+
+#ifndef BOOST_PFR_DETAIL_CORE_NAME20_STATIC_HPP
+#define BOOST_PFR_DETAIL_CORE_NAME20_STATIC_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+#include <boost/pfr/detail/core.hpp>
+#include <boost/pfr/detail/sequence_tuple.hpp>
+#include <boost/pfr/detail/make_integer_sequence.hpp>
+#include <boost/pfr/detail/fields_count.hpp>
+#include <boost/pfr/detail/stdarray.hpp>
+#include <boost/pfr/detail/fake_object.hpp>
+#include <type_traits>
+#include <string_view>
+#include <array>
+#include <memory> // for std::addressof
+
+namespace boost { namespace pfr { namespace detail {
+
+struct core_name_skip {
+    std::size_t size_at_begin;
+    std::size_t size_at_end;
+    bool is_backward;
+    std::string_view until_runtime;
+
+    consteval std::string_view apply(std::string_view sv) const noexcept {
+        // We use std::min here to make the compiler diagnostic shorter and
+        // cleaner in case of misconfigured BOOST_PFR_CORE_NAME_PARSING
+        sv.remove_prefix((std::min)(size_at_begin, sv.size()));
+        sv.remove_suffix((std::min)(size_at_end, sv.size()));
+        if (until_runtime.empty()) {
+            return sv;
+        }
+
+        const auto found = is_backward ? sv.rfind(until_runtime)
+                                       : sv.find(until_runtime);
+
+        const auto cut_until = found + until_runtime.size();
+        const auto safe_cut_until = (std::min)(cut_until, sv.size());
+        return sv.substr(safe_cut_until);
+    }
+};
+
+struct backward {
+    explicit consteval backward(std::string_view value) noexcept
+        : value(value)
+    {}
+
+    std::string_view value;
+};
+
+consteval core_name_skip make_core_name_skip(std::size_t size_at_begin,
+                                             std::size_t size_at_end,
+                                             std::string_view until_runtime) noexcept
+{
+    return core_name_skip{size_at_begin, size_at_end, false, until_runtime};
+}
+
+consteval core_name_skip make_core_name_skip(std::size_t size_at_begin,
+                                             std::size_t size_at_end,
+                                             backward until_runtime) noexcept
+{
+    return core_name_skip{size_at_begin, size_at_end, true, until_runtime.value};
+}
+
+// it might be compilation failed without this workaround sometimes
+// See https://github.com/llvm/llvm-project/issues/41751 for details
+template <class>
+consteval std::string_view clang_workaround(std::string_view value) noexcept
+{
+    return value;
+}
+
+template <class MsvcWorkaround, auto ptr>
+consteval auto name_of_field_impl() noexcept {
+    // Some of the following compiler specific macro may be defined only
+    // inside the function body:
+
+#ifndef BOOST_PFR_FUNCTION_SIGNATURE
+#   if defined(__FUNCSIG__)
+#       define BOOST_PFR_FUNCTION_SIGNATURE __FUNCSIG__
+#   elif defined(__PRETTY_FUNCTION__) || defined(__GNUC__) || defined(__clang__)
+#       define BOOST_PFR_FUNCTION_SIGNATURE __PRETTY_FUNCTION__
+#   else
+#       define BOOST_PFR_FUNCTION_SIGNATURE ""
+#   endif
+#endif
+
+    constexpr std::string_view sv = detail::clang_workaround<MsvcWorkaround>(BOOST_PFR_FUNCTION_SIGNATURE);
+    static_assert(!sv.empty(),
+        "====================> Boost.PFR: Field reflection parser configured in a wrong way. "
+        "Please define the BOOST_PFR_FUNCTION_SIGNATURE to a compiler specific macro, "
+        "that outputs the whole function signature including non-type template parameters."  
+    );
+
+    constexpr auto skip = detail::make_core_name_skip BOOST_PFR_CORE_NAME_PARSING;
+    static_assert(skip.size_at_begin + skip.size_at_end + skip.until_runtime.size() < sv.size(),
+        "====================> Boost.PFR: Field reflection parser configured in a wrong way. "
+        "It attempts to skip more chars than available. "
+        "Please define BOOST_PFR_CORE_NAME_PARSING to correct values. See documentation section "
+        "'Limitations and Configuration' for more information."
+    );
+    constexpr auto fn = skip.apply(sv);
+    static_assert(
+        !fn.empty(),
+        "====================> Boost.PFR: Extraction of field name is misconfigured for your compiler. "
+        "It skipped all the input, leaving the field name empty. "
+        "Please define BOOST_PFR_CORE_NAME_PARSING to correct values. See documentation section "
+        "'Limitations and Configuration' for more information."
+    );
+    auto res = std::array<char, fn.size()+1>{};
+
+    auto* out = res.data();
+    for (auto x: fn) {
+        *out = x;
+        ++out;
+    }
+
+    return res;
+}
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wundefined-var-template"
+
+// clang 16 and earlier don't support address of non-static member as template parameter
+// but fortunately it's possible to use C++20 non-type template parameters in another way
+// even in clang 16 and more older clangs
+// all we need is to wrap pointer into 'clang_wrapper_t' and then pass it into template
+template <class T>
+struct clang_wrapper_t {
+    T v;
+};
+template <class T>
+clang_wrapper_t(T) -> clang_wrapper_t<T>;
+
+template <class T>
+constexpr auto make_clang_wrapper(const T& arg) noexcept {
+    return clang_wrapper_t{arg};
+}
+
+#else
+
+template <class T>
+constexpr const T& make_clang_wrapper(const T& arg) noexcept {
+    // It's everything OK with address of non-static member as template parameter support on this compiler
+    // so we don't need a wrapper here, just pass the pointer into template
+    return arg;
+}
+
+#endif
+
+template <class MsvcWorkaround, auto ptr>
+consteval auto name_of_field() noexcept {
+    // Sanity check: known field name must match the deduced one
+    static_assert(
+        sizeof(MsvcWorkaround)  // do not trigger if `name_of_field()` is not used
+        && std::string_view{
+            detail::name_of_field_impl<
+                core_name_skip, detail::make_clang_wrapper(std::addressof(
+                    fake_object<core_name_skip>.size_at_begin
+                ))
+            >().data()
+        } == "size_at_begin",
+        "====================> Boost.PFR: Extraction of field name is misconfigured for your compiler. "
+        "It does not return the proper field name. "
+        "Please define BOOST_PFR_CORE_NAME_PARSING to correct values. See documentation section "
+        "'Limitations and Configuration' for more information."
+    );
+
+    return detail::name_of_field_impl<MsvcWorkaround, ptr>();
+}
+
+// Storing part of a string literal into an array minimizes the binary size.
+//
+// Without passing 'T' into 'name_of_field' different fields from different structures might have the same name!
+// See https://developercommunity.visualstudio.com/t/__FUNCSIG__-outputs-wrong-value-with-C/10458554 for details
+template <class T, std::size_t I>
+inline constexpr auto stored_name_of_field = detail::name_of_field<T,
+    detail::make_clang_wrapper(std::addressof(detail::sequence_tuple::get<I>(
+        detail::tie_as_tuple(detail::fake_object<T>)
+    )))
+>();
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+template <class T, std::size_t... I>
+constexpr auto tie_as_names_tuple_impl(std::index_sequence<I...>) noexcept {
+    return detail::sequence_tuple::make_sequence_tuple(std::string_view{stored_name_of_field<T, I>.data()}...);
+}
+
+template <class T, std::size_t I>
+constexpr std::string_view get_name() noexcept {
+    static_assert(
+        !std::is_union<T>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+    static_assert(
+        !std::is_array<T>::value,
+        "====================> Boost.PFR: It is impossible to extract name from old C array since it doesn't have named members"
+    );
+    static_assert(
+        sizeof(T) && BOOST_PFR_USE_CPP17,
+        "====================> Boost.PFR: Extraction of field's names is allowed only when the BOOST_PFR_USE_CPP17 macro enabled."
+   );
+
+   return stored_name_of_field<T, I>.data();
+}
+
+template <class T>
+constexpr auto tie_as_names_tuple() noexcept {
+    static_assert(
+        !std::is_union<T>::value,
+        "====================> Boost.PFR: For safety reasons it is forbidden to reflect unions. See `Reflection of unions` section in the docs for more info."
+    );
+    static_assert(
+        !std::is_array<T>::value,
+        "====================> Boost.PFR: It is impossible to extract name from old C array since it doesn't have named members"
+    );
+    static_assert(
+        sizeof(T) && BOOST_PFR_USE_CPP17,
+        "====================> Boost.PFR: Extraction of field's names is allowed only when the BOOST_PFR_USE_CPP17 macro enabled."
+    );
+
+    return detail::tie_as_names_tuple_impl<T>(detail::make_index_sequence<detail::fields_count<T>()>{});
+}
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_CORE_NAME20_STATIC_HPP
+
--- a/include/boost/pfr/detail/detectors.hpp
+++ b/include/boost/pfr/detail/detectors.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/fake_object.hpp
+++ b/include/boost/pfr/detail/fake_object.hpp
@@ -0,0 +1,25 @@
+// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+// Initial implementation by Bela Schaum, https://github.com/schaumb
+// The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
+//
+
+#ifndef BOOST_PFR_DETAIL_FAKE_OBJECT_HPP
+#define BOOST_PFR_DETAIL_FAKE_OBJECT_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+
+template <class T>
+extern const T fake_object;
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_FAKE_OBJECT_HPP
+
--- a/include/boost/pfr/detail/fields_count.hpp
+++ b/include/boost/pfr/detail/fields_count.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/for_each_field_impl.hpp
+++ b/include/boost/pfr/detail/for_each_field_impl.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -20,17 +20,18 @@ template <std::size_t Index>
 using size_t_ = std::integral_constant<std::size_t, Index >;

 template <class T, class F, class I, class = decltype(std::declval<F>()(std::declval<T>(), I{}))>
-void for_each_field_impl_apply(T&& v, F&& f, I i, long) {
+constexpr void for_each_field_impl_apply(T&& v, F&& f, I i, long) {
    std::forward<F>(f)(std::forward<T>(v), i);
 }

 template <class T, class F, class I>
-void for_each_field_impl_apply(T&& v, F&& f, I /*i*/, int) {
+constexpr void for_each_field_impl_apply(T&& v, F&& f, I /*i*/, int) {
    std::forward<F>(f)(std::forward<T>(v));
 }

+#if !defined(__cpp_fold_expressions) || __cpp_fold_expressions < 201603
 template <class T, class F, std::size_t... I>
-void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
+constexpr void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
     const int v[] = {0, (
         detail::for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L),
         0
@@ -40,13 +41,24 @@ void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type


 template <class T, class F, std::size_t... I>
-void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
+constexpr void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
     const int v[] = {0, (
         detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L),
         0
     )...};
     (void)v;
 }
+#else
+template <class T, class F, std::size_t... I>
+constexpr void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::false_type /*move_values*/) {
+     (detail::for_each_field_impl_apply(sequence_tuple::get<I>(t), std::forward<F>(f), size_t_<I>{}, 1L), ...);
+}
+
+template <class T, class F, std::size_t... I>
+constexpr void for_each_field_impl(T& t, F&& f, std::index_sequence<I...>, std::true_type /*move_values*/) {
+     (detail::for_each_field_impl_apply(sequence_tuple::get<I>(std::move(t)), std::forward<F>(f), size_t_<I>{}, 1L), ...);
+}
+#endif

 }}} // namespace boost::pfr::detail

--- a/include/boost/pfr/detail/functional.hpp
+++ b/include/boost/pfr/detail/functional.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/io.hpp
+++ b/include/boost/pfr/detail/io.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/make_flat_tuple_of_references.hpp
+++ b/include/boost/pfr/detail/make_flat_tuple_of_references.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/make_integer_sequence.hpp
+++ b/include/boost/pfr/detail/make_integer_sequence.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2018 Sergei Fedorov
-// Copyright (c) 2019-2021 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/offset_based_getter.hpp
+++ b/include/boost/pfr/detail/offset_based_getter.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2017-2018 Chris Beck
-// Copyright (c) 2019-2021 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -42,7 +42,7 @@ struct tuple_of_aligned_storage<sequence_tuple::tuple<Ts...>> {
  using type = sequence_tuple::tuple<internal_aligned_storage<sizeof(Ts),
 #if defined(__GNUC__) && __GNUC__ < 8 && !defined(__x86_64__) && !defined(__CYGWIN__)
      // Before GCC-8 the `alignof` was returning the optimal alignment rather than the minimal one.
-      // We have to adjust the alignemnt because otherwise we get the wrong offset.
+      // We have to adjust the alignment because otherwise we get the wrong offset.
      (alignof(Ts) > 4 ? 4 : alignof(Ts))
 #else
      alignof(Ts)
--- a/include/boost/pfr/detail/possible_reflectable.hpp
+++ b/include/boost/pfr/detail/possible_reflectable.hpp
@@ -0,0 +1,49 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
+#define BOOST_PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+#include <boost/pfr/traits_fwd.hpp>
+
+#include <type_traits> // for std::is_aggregate
+
+namespace boost { namespace pfr { namespace detail {
+
+///////////////////// Returns false when the type exactly wasn't be reflectable
+template <class T, class WhatFor>
+constexpr decltype(is_reflectable<T, WhatFor>::value) possible_reflectable(long) noexcept {
+    return is_reflectable<T, WhatFor>::value;
+}
+
+#if BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+
+template <class T, class WhatFor>
+constexpr bool possible_reflectable(int) noexcept {
+#   if  defined(__cpp_lib_is_aggregate)
+    using type = std::remove_cv_t<T>;
+    return std::is_aggregate<type>();
+#   else
+    return true;
+#   endif
+}
+
+#else
+
+template <class T, class WhatFor>
+constexpr bool possible_reflectable(int) noexcept {
+    // negative answer here won't change behaviour in PFR-dependent libraries(like Fusion)
+    return false;
+}
+
+#endif
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_POSSIBLE_REFLECTABLE_HPP
+
+
--- a/include/boost/pfr/detail/rvalue_t.hpp
+++ b/include/boost/pfr/detail/rvalue_t.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/sequence_tuple.hpp
+++ b/include/boost/pfr/detail/sequence_tuple.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -50,30 +50,74 @@ struct tuple_base<std::index_sequence<> > {

 template <std::size_t N, class T>
 constexpr T& get_impl(base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
    return t.value;
 }

 template <std::size_t N, class T>
 constexpr const T& get_impl(const base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
    return t.value;
 }

 template <std::size_t N, class T>
 constexpr volatile T& get_impl(volatile base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
    return t.value;
 }

 template <std::size_t N, class T>
 constexpr const volatile T& get_impl(const volatile base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
    return t.value;
 }

 template <std::size_t N, class T>
 constexpr T&& get_impl(base_from_member<N, T>&& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
    return std::forward<T>(t.value);
 }


+template <class T, std::size_t N>
+constexpr T& get_by_type_impl(base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return t.value;
+}
+
+template <class T, std::size_t N>
+constexpr const T& get_by_type_impl(const base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return t.value;
+}
+
+template <class T, std::size_t N>
+constexpr volatile T& get_by_type_impl(volatile base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return t.value;
+}
+
+template <class T, std::size_t N>
+constexpr const volatile T& get_by_type_impl(const volatile base_from_member<N, T>& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return t.value;
+}
+
+template <class T, std::size_t N>
+constexpr T&& get_by_type_impl(base_from_member<N, T>&& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return std::forward<T>(t.value);
+}
+
+template <class T, std::size_t N>
+constexpr const T&& get_by_type_impl(const base_from_member<N, T>&& t) noexcept {
+    // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+    return std::forward<T>(t.value);
+}
+
+
+
+
 template <class ...Values>
 struct tuple: tuple_base<
    detail::index_sequence_for<Values...>,
@@ -83,6 +127,9 @@ struct tuple: tuple_base<
        detail::index_sequence_for<Values...>,
        Values...
    >::tuple_base;
+
+    constexpr static std::size_t size() noexcept { return sizeof...(Values); }
+    constexpr static bool empty() noexcept { return size() == 0; }
 };


@@ -121,6 +168,10 @@ using tuple_element = std::remove_reference< decltype(
        ::boost::pfr::detail::sequence_tuple::get<I>( std::declval<T>() )
    ) >;

+template <class... Args>
+constexpr auto make_sequence_tuple(Args... args) noexcept {
+    return ::boost::pfr::detail::sequence_tuple::tuple<Args...>{ args... };
+}

 }}}} // namespace boost::pfr::detail::sequence_tuple

--- a/include/boost/pfr/detail/size_array.hpp
+++ b/include/boost/pfr/detail/size_array.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/size_t_.hpp
+++ b/include/boost/pfr/detail/size_t_.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/stdarray.hpp
+++ b/include/boost/pfr/detail/stdarray.hpp
@@ -0,0 +1,41 @@
+// Copyright (c) 2023 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_STDARRAY_HPP
+#define BOOST_PFR_DETAIL_STDARRAY_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <utility> // metaprogramming stuff
+#include <array>
+#include <type_traits> // for std::common_type_t
+#include <cstddef>
+
+#include <boost/pfr/detail/sequence_tuple.hpp>
+
+namespace boost { namespace pfr { namespace detail {
+
+template <class... Types>
+constexpr auto make_stdarray(const Types&... t) noexcept {
+    return std::array<std::common_type_t<Types...>, sizeof...(Types)>{t...};
+}
+
+template <class T, std::size_t... I>
+constexpr auto make_stdarray_from_tietuple(const T& t, std::index_sequence<I...>, int) noexcept {
+    return detail::make_stdarray(
+        boost::pfr::detail::sequence_tuple::get<I>(t)...
+    );
+}
+
+template <class T>
+constexpr auto make_stdarray_from_tietuple(const T&, std::index_sequence<>, long) noexcept {
+    return std::array<std::nullptr_t, 0>{};
+}
+
+}}} // namespace boost::pfr::detail
+
+#endif // BOOST_PFR_DETAIL_STDARRAY_HPP
+
--- a/include/boost/pfr/detail/stdtuple.hpp
+++ b/include/boost/pfr/detail/stdtuple.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/tie_from_structure_tuple.hpp
+++ b/include/boost/pfr/detail/tie_from_structure_tuple.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2018 Adam Butcher, Antony Polukhin
-// Copyright (c) 2019-2021 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/detail/unsafe_declval.hpp
+++ b/include/boost/pfr/detail/unsafe_declval.hpp
@@ -1,10 +1,11 @@
-// Copyright (c) 2019-2021 Antony Polukhin.
+// Copyright (c) 2019-2023 Antony Polukhin.
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

 #ifndef BOOST_PFR_DETAIL_UNSAFE_DECLVAL_HPP
 #define BOOST_PFR_DETAIL_UNSAFE_DECLVAL_HPP
+#pragma once

 #include <boost/pfr/detail/config.hpp>

@@ -24,7 +25,7 @@ template <class T>
 constexpr T unsafe_declval() noexcept {
    report_if_you_see_link_error_with_this_function();

-    typename std::remove_reference<T>::type* ptr = 0;
+    typename std::remove_reference<T>::type* ptr = nullptr;
    ptr += 42; // suppresses 'null pointer dereference' warnings
    return static_cast<T>(*ptr);
 }
--- a/include/boost/pfr/functions_for.hpp
+++ b/include/boost/pfr/functions_for.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/functors.hpp
+++ b/include/boost/pfr/functors.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/io.hpp
+++ b/include/boost/pfr/io.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -89,17 +89,17 @@ enable_istreamable_t<std::basic_istream<Char, Traits>, T> operator>>(std::basic_

 } // namespace detail

-/// IO manupulator to read/write \aggregate `value` using its IO stream operators or using \forcedlink{io_fields} if operators are not awailable.
+/// IO manipulator to read/write \aggregate `value` using its IO stream operators or using \forcedlink{io_fields} if operators are not available.
 ///
 /// \b Example:
 /// \code
 ///     struct my_struct { int i; short s; };
-///     my_struct s;
+///     my_struct x;
 ///     std::stringstream ss;
 ///     ss << "{ 12, 13 }";
-///     ss >> boost::pfr::io(s);
-///     assert(s.i == 12);
-///     assert(s.i == 13);
+///     ss >> boost::pfr::io(x);
+///     assert(x.i == 12);
+///     assert(x.s == 13);
 /// \endcode
 ///
 /// \customio
--- a/include/boost/pfr/io_fields.hpp
+++ b/include/boost/pfr/io_fields.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -21,7 +21,7 @@
 #include <boost/pfr/tuple_size.hpp>

 /// \file boost/pfr/io_fields.hpp
-/// Contains IO manupulator \forcedlink{io_fields} to read/write \aggregate `value` field-by-field.
+/// Contains IO manipulator \forcedlink{io_fields} to read/write any \aggregate field-by-field.
 ///
 /// \b Example:
 /// \code
@@ -132,7 +132,7 @@ std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& i

 } // namespace detail

-/// IO manupulator to read/write \aggregate `value` field-by-field.
+/// IO manipulator to read/write \aggregate `value` field-by-field.
 ///
 /// \b Example:
 /// \code
--- a/include/boost/pfr/ops.hpp
+++ b/include/boost/pfr/ops.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -78,7 +78,7 @@ namespace detail {
 } // namespace detail


-/// \brief Compares lhs and rhs for equality using their own comparison and conversion operators; if no operators avalable returns \forcedlink{eq_fields}(lhs, rhs).
+/// \brief Compares lhs and rhs for equality using their own comparison and conversion operators; if no operators available returns \forcedlink{eq_fields}(lhs, rhs).
 ///
 /// \returns true if lhs is equal to rhs; false otherwise
 template <class T, class U>
@@ -93,7 +93,7 @@ constexpr detail::enable_eq_comp_t<T, U> eq(const T& lhs, const U& rhs) {
 }


-/// \brief Compares lhs and rhs for inequality using their own comparison and conversion operators; if no operators avalable returns \forcedlink{ne_fields}(lhs, rhs).
+/// \brief Compares lhs and rhs for inequality using their own comparison and conversion operators; if no operators available returns \forcedlink{ne_fields}(lhs, rhs).
 ///
 /// \returns true if lhs is not equal to rhs; false otherwise
 template <class T, class U>
@@ -108,7 +108,7 @@ constexpr detail::enable_ne_comp_t<T, U> ne(const T& lhs, const U& rhs) {
 }


-/// \brief Compares lhs and rhs for less-than using their own comparison and conversion operators; if no operators avalable returns \forcedlink{lt_fields}(lhs, rhs).
+/// \brief Compares lhs and rhs for less-than using their own comparison and conversion operators; if no operators available returns \forcedlink{lt_fields}(lhs, rhs).
 ///
 /// \returns true if lhs is less than rhs; false otherwise
 template <class T, class U>
@@ -123,7 +123,7 @@ constexpr detail::enable_lt_comp_t<T, U> lt(const T& lhs, const U& rhs) {
 }


-/// \brief Compares lhs and rhs for greater-than using their own comparison and conversion operators; if no operators avalable returns \forcedlink{lt_fields}(lhs, rhs).
+/// \brief Compares lhs and rhs for greater-than using their own comparison and conversion operators; if no operators available returns \forcedlink{lt_fields}(lhs, rhs).
 ///
 /// \returns true if lhs is greater than rhs; false otherwise
 template <class T, class U>
@@ -138,7 +138,7 @@ constexpr detail::enable_gt_comp_t<T, U> gt(const T& lhs, const U& rhs) {
 }


-/// \brief Compares lhs and rhs for less-equal using their own comparison and conversion operators; if no operators avalable returns \forcedlink{le_fields}(lhs, rhs).
+/// \brief Compares lhs and rhs for less-equal using their own comparison and conversion operators; if no operators available returns \forcedlink{le_fields}(lhs, rhs).
 ///
 /// \returns true if lhs is less or equal to rhs; false otherwise
 template <class T, class U>
@@ -153,7 +153,7 @@ constexpr detail::enable_le_comp_t<T, U> le(const T& lhs, const U& rhs) {
 }


-/// \brief Compares lhs and rhs for greater-equal using their own comparison and conversion operators; if no operators avalable returns \forcedlink{ge_fields}(lhs, rhs).
+/// \brief Compares lhs and rhs for greater-equal using their own comparison and conversion operators; if no operators available returns \forcedlink{ge_fields}(lhs, rhs).
 ///
 /// \returns true if lhs is greater or equal to rhs; false otherwise
 template <class T, class U>
@@ -168,7 +168,7 @@ constexpr detail::enable_ge_comp_t<T, U> ge(const T& lhs, const U& rhs) {
 }


-/// \brief Hashes value using its own std::hash specialization; if no std::hash specialization avalable returns \forcedlink{hash_fields}(value).
+/// \brief Hashes value using its own std::hash specialization; if no std::hash specialization available returns \forcedlink{hash_fields}(value).
 ///
 /// \returns std::size_t with hash of the value
 template <class T>
--- a/include/boost/pfr/ops_fields.hpp
+++ b/include/boost/pfr/ops_fields.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/include/boost/pfr/traits.hpp
+++ b/include/boost/pfr/traits.hpp
@@ -0,0 +1,60 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_TRAITS_HPP
+#define BOOST_PFR_TRAITS_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+#include <boost/pfr/detail/possible_reflectable.hpp>
+#include <type_traits>
+
+/// \file boost/pfr/traits.hpp
+/// Contains traits \forcedlink{is_reflectable} and \forcedlink{is_implicitly_reflectable} for detecting an ability to reflect type.
+///
+/// \b Synopsis:
+
+namespace boost { namespace pfr {
+
+/// Has a static const member variable `value` when it is known that type T can or can't be reflected using Boost.PFR; otherwise, there is no member variable.
+/// Every user may (and in some difficult cases - should) specialize is_reflectable on his own.
+///
+/// \b Example:
+/// \code
+///     namespace boost { namespace pfr {
+///         template<class All> struct is_reflectable<A, All> : std::false_type {};       // 'A' won't be interpreted as reflectable everywhere
+///         template<> struct is_reflectable<B, boost_fusion_tag> : std::false_type {};   // 'B' won't be interpreted as reflectable in only Boost Fusion
+///     }}
+/// \endcode
+/// \note is_reflectable affects is_implicitly_reflectable, the decision made by is_reflectable is used by is_implicitly_reflectable.
+template<class T, class WhatFor>
+struct is_reflectable { /*  does not have 'value' because value is unknown */ };
+
+// these specs can't be inherited from 'std::integral_constant< bool, boost::pfr::is_reflectable<T, WhatFor>::value >',
+// because it will break the sfinae-friendliness
+template<class T, class WhatFor>
+struct is_reflectable<const T, WhatFor> : boost::pfr::is_reflectable<T, WhatFor> {};
+
+template<class T, class WhatFor>
+struct is_reflectable<volatile T, WhatFor> : boost::pfr::is_reflectable<T, WhatFor> {};
+
+template<class T, class WhatFor>
+struct is_reflectable<const volatile T, WhatFor> : boost::pfr::is_reflectable<T, WhatFor> {};
+
+/// Checks the input type for the potential to be reflected.
+/// Specialize is_reflectable if you disagree with is_implicitly_reflectable's default decision.
+template<class T, class WhatFor>
+using is_implicitly_reflectable = std::integral_constant< bool, boost::pfr::detail::possible_reflectable<T, WhatFor>(1L) >;
+
+/// Checks the input type for the potential to be reflected.
+/// Specialize is_reflectable if you disagree with is_implicitly_reflectable_v's default decision.
+template<class T, class WhatFor>
+constexpr bool is_implicitly_reflectable_v = is_implicitly_reflectable<T, WhatFor>::value;
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_TRAITS_HPP
+
--- a/include/boost/pfr/traits_fwd.hpp
+++ b/include/boost/pfr/traits_fwd.hpp
@@ -0,0 +1,21 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_PFR_DETAIL_TRAITS_FWD_HPP
+#define BOOST_PFR_DETAIL_TRAITS_FWD_HPP
+#pragma once
+
+#include <boost/pfr/detail/config.hpp>
+
+namespace boost { namespace pfr {
+
+template<class T, class WhatFor>
+struct is_reflectable;
+
+}} // namespace boost::pfr
+
+#endif // BOOST_PFR_DETAIL_TRAITS_FWD_HPP
+
+
--- a/include/boost/pfr/tuple_size.hpp
+++ b/include/boost/pfr/tuple_size.hpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -23,7 +23,7 @@
 namespace boost { namespace pfr {

 /// Has a static const member variable `value` that contains fields count in a T.
-/// Works for any T that supports aggregate initialization.
+/// Works for any T that satisfies \aggregate.
 ///
 /// \b Example:
 /// \code
@@ -34,7 +34,7 @@ using tuple_size = detail::size_t_< boost::pfr::detail::fields_count<T>() >;


 /// `tuple_size_v` is a template variable that contains fields count in a T and
-/// works for any T that supports aggregate initialization.
+/// works for any T that satisfies \aggregate.
 ///
 /// \b Example:
 /// \code
--- a/index.html
+++ b/index.html
@@ -1,16 +1,18 @@
 <!DOCTYPE html>
 <!--
- Copyright (c) 2014-2021 Antony Polukhin
+ Copyright (c) 2014-2023 Antony Polukhin
 antoshkka at gmail dot com

 Distributed under the Boost Software License,
 Version 1.0. (See accompanying file LICENSE_1_0.txt
 or copy at http://boost.org/LICENSE_1_0.txt)
+
+boost-no-inspect
 -->
 <html>
 <head>
 <meta charset="utf-8">
-<meta http-equiv="refresh" content="0; url=https://www.boost.org/doc/libs/master/doc/html/boost_pfr.html">
+<meta http-equiv="refresh" content="0; url=../../doc/html/boost_pfr.html">
 <title>Boost.Stacktrace</title>
 <style>
  body {
@@ -26,10 +28,10 @@
 <body>
  <p>
    Automatic redirection failed, please go to
-    <a href="https://www.boost.org/doc/libs/master/doc/html/boost_pfr.html">https://www.boost.org/doc/libs/master/doc/html/boost_pfr.html</a>
+    <a href="../../doc/html/boost_pfr.html">../../doc/html/boost_pfr.html</a>
  </p>
  <p>
-    &copy; 2014-2021 Antony Polukhin
+    &copy; 2014-2023 Antony Polukhin
  </p>
 </body>
 </html>
--- a/misc/generate_cpp17.py
+++ b/misc/generate_cpp17.py
@@ -1,6 +1,7 @@
 #!/usr/bin/python

-# Copyright (c) 2016-2021 Antony Polukhin
+# Copyright (c) 2016-2023 Antony Polukhin
+# Copyright (c) 2023 Denis Mikhailov
 #
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -12,8 +13,10 @@ import string

 # Skipping some letters that may produce keywords or are hard to read, or shadow template parameters
 ascii_letters = string.ascii_letters.replace("o", "").replace("O", "").replace("i", "").replace("I", "").replace("T", "")
+WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE = 3

-PROLOGUE = """// Copyright (c) 2016-2020 Antony Polukhin
+PROLOGUE = """// Copyright (c) 2016-2023 Antony Polukhin
+// Copyright (c) 2023 Denis Mikhailov
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -35,6 +38,7 @@ PROLOGUE = """// Copyright (c) 2016-2020 Antony Polukhin

 #include <boost/pfr/detail/sequence_tuple.hpp>
 #include <boost/pfr/detail/size_t_.hpp>
+#include <type_traits> // for std::conditional_t, std::is_reference

 namespace boost { namespace pfr { namespace detail {

@@ -43,20 +47,43 @@ constexpr auto make_tuple_of_references(Args&&... args) noexcept {
  return sequence_tuple::tuple<Args&...>{ args... };
 }

+template<typename T, typename Arg>
+constexpr decltype(auto) add_cv_like(Arg& arg) noexcept {
+    if constexpr (std::is_const<T>::value && std::is_volatile<T>::value) {
+        return const_cast<const volatile Arg&>(arg);
+    }
+    else if constexpr (std::is_const<T>::value) {
+        return const_cast<const Arg&>(arg);
+    }
+    else if constexpr (std::is_volatile<T>::value) {
+        return const_cast<volatile Arg&>(arg);
+    }
+    else {
+        return const_cast<Arg&>(arg);
+    }
+}
+
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78939
+template<typename T, typename Sb, typename Arg>
+constexpr decltype(auto) workaround_cast(Arg& arg) noexcept {
+    using output_arg_t = std::conditional_t<!std::is_reference<Sb>(), decltype(detail::add_cv_like<T>(arg)), Sb>;
+    return const_cast<output_arg_t>(arg);
+}
+
 template <class T>
 constexpr auto tie_as_tuple(T& /*val*/, size_t_<0>) noexcept {
  return sequence_tuple::tuple<>{};
 }

 template <class T>
-constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
-  auto& [a] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
-  return ::boost::pfr::detail::make_tuple_of_references(a);
+constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<std::is_class< std::remove_cv_t<T> >::value>* = nullptr) noexcept {
+  auto& [a] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.
+  return ::boost::pfr::detail::make_tuple_of_references(detail::workaround_cast<T, decltype(a)>(a));
 }


 template <class T>
-constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = 0) noexcept {
+constexpr auto tie_as_tuple(T& val, size_t_<1>, std::enable_if_t<!std::is_class< std::remove_cv_t<T> >::value>* = nullptr) noexcept {
  return ::boost::pfr::detail::make_tuple_of_references( val );
 }

@@ -77,6 +104,33 @@ constexpr void tie_as_tuple(T& /*val*/, size_t_<I>) noexcept {

 ############################################################################################################################

+def fold_workaround_cast(indexes, divider):
+    WORKAROUND_CAST_TEMPLATE = """
+detail::workaround_cast<T, decltype({arg})>({arg})
+"""
+    lines = []
+    div = ''
+    tokens = [x.strip() for x in indexes.split(',')]
+    casts = [WORKAROUND_CAST_TEMPLATE.strip().format(arg=tok)
+             for tok in tokens]
+    for i in range(0, len(casts)):
+        if i%WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE==0:
+            div = ''
+            lines.append('')
+        lines[-1] += div + casts[i]
+        div = ','
+    return divider.join(lines)
+
+def calc_indexes_count(indexes):
+    tokens = [x.strip() for x in indexes.split(',')]
+    return len(tokens)
+
+class EmptyLinePrinter:
+    def print_once(self):
+        if not self.printed:
+            print("")
+            self.printed = True
+    printed = False

 indexes = "    a"
 print(PROLOGUE)
@@ -92,18 +146,26 @@ for i in range(1, funcs_count):
        indexes += ascii_letters[i // max_args_on_a_line - 1]
    indexes += ascii_letters[i % max_args_on_a_line]

+    printed_casts = fold_workaround_cast(indexes.strip(), ",\n    ")
+    indexes_count = calc_indexes_count(indexes.strip())
+    empty_printer = EmptyLinePrinter()
+
    print("template <class T>")
    print("constexpr auto tie_as_tuple(T& val, size_t_<" + str(i + 1) + ">) noexcept {")
    if i < max_args_on_a_line:
-        print("  auto& [" + indexes.strip() + "] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.")
-        print("  return ::boost::pfr::detail::make_tuple_of_references(" + indexes.strip() + ");")
+        print("  auto& [" + indexes.strip() + "] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.")
    else:
        print("  auto& [")
        print(indexes)
-        print("  ] = val; // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.")
-        print("")
+        print("  ] = const_cast<std::remove_cv_t<T>&>(val); // ====================> Boost.PFR: User-provided type is not a SimpleAggregate.")
+        empty_printer.print_once()
+ 
+    if indexes_count < WORKAROUND_CAST_EXPRESSIONS_LIMIT_PER_LINE:
+        print("  return ::boost::pfr::detail::make_tuple_of_references(" + printed_casts + ");")
+    else:
+        empty_printer.print_once()
        print("  return ::boost::pfr::detail::make_tuple_of_references(")
-        print(indexes)
+        print("    " + printed_casts)
        print("  );")

    print("}\n")
--- a/misc/generate_fields_names_big.cpp.py
+++ b/misc/generate_fields_names_big.cpp.py
@@ -0,0 +1,267 @@
+# Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov.
+#
+# Distributed under the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+# Initial implementation by Bela Schaum, https://github.com/schaumb
+# The way to make it union and UB free by X-Ryl669, https://github.com/X-Ryl669
+#
+
+############################################################################################################################
+
+import sys
+import string
+import random
+
+# a bigger value might lead to compiler out of heap space error on MSVC
+STRUCT_COUNT = 50
+MAX_FIELD_COUNT = 50
+
+MAIN_TEMPLATE = """// Copyright (c) 2023 Bela Schaum, X-Ryl669, Denis Mikhailov, Antony Polukhin.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+// Generated by misc/generate_fields_names_big.cpp.py
+
+#include <boost/pfr/core_name.hpp>
+#include <type_traits>
+
+#include <boost/core/lightweight_test.hpp>
+
+namespace testing {
+
+template <class... Types>
+auto make_stdarray(const Types&... t) {
+    return std::array<std::common_type_t<Types...>, sizeof...(Types)>{t...};
+}
+
+%STRUCTS_LIST%
+
+%TEST_GET_NAME_DEFINITIONS_LIST%
+
+%TEST_GET_NAMES_AS_ARRAY_DEFINITIONS_LIST%
+
+
+} // namespace testing
+
+int main() {
+    %TEST_GET_NAME_CALLS_LIST%
+    %TEST_GET_NAMES_AS_ARRAY_CALLS_LIST%
+
+    return boost::report_errors();
+}
+"""
+
+STRUCT_TEMPLATE = """struct Aggregate%STRUCT_ID% {
+    %FIELD_DEFINITIONS_LIST%
+};
+"""
+
+STRUCT_FIELD_DEFINITION_TEMPLATE = """int %FIELD_NAME%;
+"""
+
+TEST_GET_NAME_TEMPLATE = """void test_get_name_%TEST_ID%() {
+    %CHECKERS_LIST%
+}
+"""
+
+TEST_GET_NAME_CHECKER_TEMPLATE = """BOOST_TEST_EQ( ((boost::pfr::get_name<%FIELD_ID%, Aggregate%STRUCT_ID%>())), "%FIELD_NAME%");
+"""
+
+TEST_GET_NAMES_AS_ARRAY_TEMPLATE = """void test_names_as_array_%TEST_ID%() {
+    const auto expected = make_stdarray(
+        %FIELD_NAMES_LIST%
+    );
+    const auto value = boost::pfr::names_as_array<Aggregate%STRUCT_ID%>();
+    BOOST_TEST_EQ(expected.size(), value.size());
+    for (std::size_t i=0;i<expected.size();++i) {
+        BOOST_TEST_EQ(value[i], expected[i]);
+    }
+}
+"""
+
+FIELD_NAME_TEMPLATE = """std::string_view{"%FIELD_NAME%"}
+"""
+
+TEST_GET_NAME_CALL_TEMPLATE = """testing::test_get_name_%TEST_ID%();
+"""
+
+TEST_GET_NAMES_AS_ARRAY_CALL_TEMPLATE = """testing::test_names_as_array_%TEST_ID%();
+"""
+
+############################################################################################################################
+
+field_names = {
+    "alignas": True,
+    "alignof": True,
+    "and": True,
+    "and_eq": True,
+    "asm": True,
+    "atomic_cancel": True,
+    "atomic_commit": True,
+    "atomic_noexcept": True,
+    "auto": True,
+    "bitand": True,
+    "bitor": True,
+    "bool": True,
+    "break": True,
+    "case": True,
+    "catch": True,
+    "char": True,
+    "char8_t": True,
+    "char16_t": True,
+    "char32_t": True,
+    "class": True,
+    "compl": True,
+    "concept": True,
+    "const": True,
+    "consteval": True,
+    "constexpr": True,
+    "constinit": True,
+    "const_cast": True,
+    "continue": True,
+    "co_await": True,
+    "co_return": True,
+    "co_yield": True,
+    "decltype": True,
+    "default": True,
+    "delete": True,
+    "do": True,
+    "double": True,
+    "dynamic_cast": True,
+    "else": True,
+    "enum": True,
+    "explicit": True,
+    "export": True,
+    "extern": True,
+    "false": True,
+    "float": True,
+    "for": True,
+    "friend": True,
+    "goto": True,
+    "if": True,
+    "inline": True,
+    "int": True,
+    "long": True,
+    "mutable": True,
+    "namespace": True,
+    "new": True,
+    "noexcept": True,
+    "not": True,
+    "not_eq": True,
+    "nullptr": True,
+    "operator": True,
+    "or": True,
+    "or_eq": True,
+    "private": True,
+    "protected": True,
+    "public": True,
+    "reflexpr": True,
+    "register": True,
+    "reinterpret_cast": True,
+    "requires": True,
+    "return": True,
+    "short": True,
+    "signed": True,
+    "sizeof": True,
+    "static": True,
+    "static_assert": True,
+    "static_cast": True,
+    "struct": True,
+    "switch": True,
+    "synchronized": True,
+    "template": True,
+    "this": True,
+    "thread_local": True,
+    "throw": True,
+    "true": True,
+    "try": True,
+    "typedef": True,
+    "typeid": True,
+    "typename": True,
+    "union": True,
+    "unsigned": True,
+    "using": True,
+    "virtual": True,
+    "void": True,
+    "volatile": True,
+    "wchar_t": True,
+    "while": True,
+    "xor": True,
+    "xor_eq": True
+}
+field_names_by_id = {}
+
+def generate_new_field_name():
+    result = ''
+    name_len = random.randint(1,100)
+    result += random.choice("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_")
+    for i in range(name_len-1):
+        result += random.choice("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789")
+    return result
+
+def generate_field_name(struct_id, field_id):
+    key = (struct_id, field_id)
+    if not key in field_names_by_id:
+        new_name = generate_new_field_name()
+        while new_name in field_names:
+            new_name = generate_new_field_name()
+        field_names[new_name] = True
+        field_names_by_id[key] = new_name
+    return field_names_by_id[key]
+
+def generate_struct(struct_id):
+    field_definitions = ''
+    fields_count = struct_id
+    for i in range(fields_count):
+        field_definitions += STRUCT_FIELD_DEFINITION_TEMPLATE.replace('%FIELD_NAME%', generate_field_name(struct_id, i))
+    return STRUCT_TEMPLATE.replace('%FIELD_DEFINITIONS_LIST%', field_definitions).replace('%STRUCT_ID%', str(struct_id))
+
+def generate_structs_list():
+    result = ''
+    for i in range(STRUCT_COUNT):
+        result += generate_struct(i+1)
+    return result
+
+def generate_test_get_name_definition(struct_id):
+    checkers_list = ''
+    fields_count = struct_id
+    for i in range(fields_count):
+        checkers_list += TEST_GET_NAME_CHECKER_TEMPLATE.replace('%FIELD_ID%', str(i)).replace('%STRUCT_ID%', str(struct_id)).replace('%FIELD_NAME%', generate_field_name(struct_id, i))
+    return TEST_GET_NAME_TEMPLATE.replace('%TEST_ID%', str(struct_id)).replace('%CHECKERS_LIST%', checkers_list)
+
+def generate_test_get_name_definitions_list():
+    result = ''
+    for i in range(STRUCT_COUNT):
+        result += generate_test_get_name_definition(i+1)
+    return result
+
+def generate_test_names_as_array_definition(struct_id):
+    field_names_list = FIELD_NAME_TEMPLATE.replace('%FIELD_NAME%', generate_field_name(struct_id, 0))
+    fields_count = struct_id
+    for i in range(1, fields_count):
+        field_names_list += ', ' + FIELD_NAME_TEMPLATE.replace('%FIELD_NAME%', generate_field_name(struct_id, i))
+    return TEST_GET_NAMES_AS_ARRAY_TEMPLATE.replace('%TEST_ID%', str(struct_id)).replace('%FIELD_NAMES_LIST%', field_names_list).replace('%STRUCT_ID%', str(struct_id))
+
+def generate_test_names_as_array_definitions_list():
+    result = ''
+    for i in range(STRUCT_COUNT):
+        result += generate_test_names_as_array_definition(i+1)
+    return result
+
+def generate_test_get_name_calls_list():
+    result = ''
+    for i in range(STRUCT_COUNT):
+        result += TEST_GET_NAME_CALL_TEMPLATE.replace('%TEST_ID%', str(i+1))
+    return result
+
+def generate_test_names_as_array_calls_list():
+    result = ''
+    for i in range(STRUCT_COUNT):
+        result += TEST_GET_NAMES_AS_ARRAY_CALL_TEMPLATE.replace('%TEST_ID%', str(i+1))
+    return result
+
+print(MAIN_TEMPLATE.replace('%STRUCTS_LIST%', generate_structs_list()).replace('%TEST_GET_NAME_DEFINITIONS_LIST%', generate_test_get_name_definitions_list()).replace('%TEST_GET_NAMES_AS_ARRAY_DEFINITIONS_LIST%', generate_test_names_as_array_definitions_list()).replace('%TEST_GET_NAME_CALLS_LIST%', generate_test_get_name_calls_list()).replace('%TEST_GET_NAMES_AS_ARRAY_CALLS_LIST%', generate_test_names_as_array_calls_list()))
+
--- a/misc/strip_boost_namespace.sh
+++ b/misc/strip_boost_namespace.sh
@@ -39,26 +39,46 @@ find ${TARGET_PATH}/doc -type f | xargs sed -i 's|Boost.PFR|PFR|g'
 sed -i  's|# \[Boost.PFR\](https://boost.org/libs/pfr)|# [PFR](https://apolukhin.github.io/pfr_non_boost/)|g' ${TARGET_PATH}/README.md

 echo -n "***** Testing: "
-if g++-9 -std=c++17 -DPFR_USE_LOOPHOLE=0 -DPFR_USE_CPP17=1 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/motivating_example0.cpp && ./a.out > /dev/null; then
+if g++-12 -std=c++2a -DPFR_ENABLE_GET_NAME_STATIC=1 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/motivating_example0.cpp && ./a.out > /dev/null; then
    echo -n "OK"
 else
    echo -n "FAIL"
    exit 2
 fi
-if g++-9 -std=c++17 -DPFR_USE_LOOPHOLE=1 -DPFR_USE_CPP17=0 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/motivating_example0.cpp && ./a.out > /dev/null; then
-    echo -n ", OK"
+if g++-12 -std=c++2a -DPFR_ENABLE_GET_NAME_STATIC=0 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/motivating_example0.cpp && ./a.out > /dev/null; then
+    echo -n "OK"
 else
-    echo -n ", FAIL"
+    echo -n "FAIL"
    exit 3
 fi

-if g++-9 -std=c++17 -DPFR_USE_LOOPHOLE=0 -DPFR_USE_CPP17=0 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/get.cpp && ./a.out > /dev/null; then
+if g++-12 -std=c++2a -DPFR_ENABLE_GET_NAME_STATIC=1 -DBOOST_PFR_USE_CPP17=1 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/get_name.cpp && ./a.out > /dev/null; then
    echo -e ", OK"
 else
    echo -e ", FAIL"
    exit 4
 fi

+if g++-12 -std=c++2a -DPFR_USE_LOOPHOLE=0 -DPFR_USE_CPP17=1 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/motivating_example0.cpp && ./a.out > /dev/null; then
+    echo -n "OK"
+else
+    echo -n "FAIL"
+    exit 5
+fi
+if g++-12 -std=c++2a -DPFR_USE_LOOPHOLE=1 -DPFR_USE_CPP17=0 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/motivating_example0.cpp && ./a.out > /dev/null; then
+    echo -n ", OK"
+else
+    echo -n ", FAIL"
+    exit 6
+fi
+
+if g++-12 -std=c++2a -DPFR_USE_LOOPHOLE=0 -DPFR_USE_CPP17=0 -I ${TARGET_PATH}/include/ ${TARGET_PATH}/example/get.cpp && ./a.out > /dev/null; then
+    echo -e ", OK"
+else
+    echo -e ", FAIL"
+    exit 7
+fi
+
 rm a.out || :

 echo "***** Done"
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -0,0 +1,10 @@
+#  Copyright (C) 2023 Denis Mikhailov
+#
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+build-project config ;
+build-project core ;
+build-project core_name ;
--- a/test/appveyor.yml
+++ b/test/appveyor.yml
@@ -32,6 +32,10 @@ skip_tags: true

 environment:
  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-9.0
+      ADDRMD: 32
+      CXXSTD: latest # fake
 #    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
 #      TOOLSET: msvc # TODO: clang-win ???
 #      ADDRMD: 32,64
--- a/test/config/Jamfile.v2
+++ b/test/config/Jamfile.v2
@@ -0,0 +1,22 @@
+#  Copyright (C) 2023 Denis Mikhailov
+#
+# Use, modification and distribution is subject to the Boost Software License,
+# Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import python ;
+import testing ;
+import ../../config/checks/config : requires ;
+
+project
+    : source-location .
+    : requirements
+        <define>BOOST_PFR_DETAIL_STRICT_RVALUE_TESTING=1
+    ;
+
+
+test-suite pfr_tests
+  :
+    [ run print_config.cpp : : : <test-info>always_show_run_output : auto_engine_config ]
+  ;
--- a/test/config/print_config.cpp
+++ b/test/config/print_config.cpp
@@ -1,9 +1,13 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-#include <boost/pfr/core.hpp>
+#include <boost/pfr/config.hpp>
+#if BOOST_PFR_ENABLED
+#include <boost/pfr.hpp>
+#endif
+#include <boost/preprocessor/stringize.hpp>

 #include <iostream>

@@ -13,6 +17,11 @@ int main() {
        << "BOOST_PFR_USE_LOOPHOLE == " << BOOST_PFR_USE_LOOPHOLE << '\n'
        << "BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE == " << BOOST_PFR_USE_STD_MAKE_INTEGRAL_SEQUENCE << '\n'
        << "BOOST_PFR_HAS_GUARANTEED_COPY_ELISION == " << BOOST_PFR_HAS_GUARANTEED_COPY_ELISION << '\n'
+        << "BOOST_PFR_ENABLE_IMPLICIT_REFLECTION == " << BOOST_PFR_ENABLE_IMPLICIT_REFLECTION << '\n'
+        << "BOOST_PFR_CORE_NAME_ENABLED == " << BOOST_PFR_CORE_NAME_ENABLED << '\n'
+        << "BOOST_PFR_FUNCTION_SIGNATURE == " << BOOST_PP_STRINGIZE(BOOST_PFR_FUNCTION_SIGNATURE) << '\n'
+        << "BOOST_PFR_CORE_NAME_PARSING == " << BOOST_PP_STRINGIZE(BOOST_PFR_CORE_NAME_PARSING) << '\n'
+        << "BOOST_PFR_ENABLED == " << BOOST_PFR_ENABLED << '\n'
        << "__cplusplus == " << __cplusplus << '\n'
 #ifdef __cpp_structured_bindings
        << "__cpp_structured_bindings == " << __cpp_structured_bindings << '\n'
--- a/test/core/Jamfile.v2
+++ b/test/core/Jamfile.v2
@@ -1,4 +1,4 @@
-#  Copyright (C) 2016-2021 Antony Polukhin.
+#  Copyright (C) 2016-2023 Antony Polukhin.
 #
 # Use, modification and distribution is subject to the Boost Software License,
 # Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -40,7 +40,7 @@ explicit compiler_supports_loophole ;

 local DISABLE_ON_MSVC = ; #<toolset>msvc:<build>no ;
 local REQUIRE_LOOPHOLE =
-    [ check-target-builds ../test//compiler_supports_loophole : : <build>no ]
+    [ check-target-builds ../core//compiler_supports_loophole : : <build>no ]
  ;

 local STRUCTURED_BINDING_ENGINE = <define>BOOST_PFR_USE_LOOPHOLE=0 <define>BOOST_PFR_USE_CPP17=1 [ requires cxx17_structured_bindings ] ;
@@ -49,10 +49,10 @@ local CLASSIC_ENGINE = <define>BOOST_PFR_USE_LOOPHOLE=0 <define>BOOST_PFR_USE_CP

 test-suite pfr_tests
  :
-    [ run print_config.cpp : : : <test-info>always_show_run_output : auto_engine_config ]
-
    [ run offset_based_getter.cpp ]

+    [ run can_be_as_fallback_in_the_fusion.cpp ]
+
    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON=char : test_tuple_sizes_on_chars ]
    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON=int : test_tuple_sizes_on_ints ]
    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON=short : test_tuple_sizes_on_shorts ]
@@ -60,9 +60,9 @@ test-suite pfr_tests
    [ run test_tuple_sizes_on.cpp : : : <define>BOOST_PFR_RUN_TEST_ON="std::size_t" : test_tuple_sizes_on_size_ts ]

    [ run run/motivating_example.cpp      : : : : auto_engine_motivating ]
-    [ run ../example/sample_printing.cpp  : : : : auto_engine_sample_printing ]
-    [ run ../example/get.cpp              : : : : auto_engine_get ]
-    [ run ../example/quick_examples.cpp   : : : : auto_engine_quick ]
+    [ run ../../example/sample_printing.cpp  : : : : auto_engine_sample_printing ]
+    [ run ../../example/get.cpp              : : : : auto_engine_get ]
+    [ run ../../example/quick_examples.cpp   : : : : auto_engine_quick ]
  ;

 local BLACKLIST_TESTS_FOR_LOOPHOLE =
@@ -95,7 +95,7 @@ local BLACKLIST_TESTS_FOR_CLASSIC =
    tie_anonymous_const_field
  ;

-for local source_file in [ glob ./run/*.cpp ] [ glob ../example/*.cpp ]
+for local source_file in [ glob ./run/*.cpp ] [ glob ../../example/*.cpp ]
 {
    local target_name = $(source_file[1]:B) ;
    pfr_tests += [ run $(source_file) : : : $(STRUCTURED_BINDING_ENGINE) : $(target_name)_sb ] ;
@@ -129,5 +129,5 @@ for local source_file in [ glob ./compile-fail/*.cpp ]

 if [ python.configured ]
 {
-    testing.make-test run-pyd : ../misc/generate_cpp17.py ;
+    testing.make-test run-pyd : ../../misc/generate_cpp17.py ;
 }
--- a/test/core/can_be_as_fallback_in_the_fusion.cpp
+++ b/test/core/can_be_as_fallback_in_the_fusion.cpp
@@ -0,0 +1,37 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <type_traits>
+
+struct Aggregate {};
+using NonAggregate = int;
+
+template<class T>
+struct is_implicitly_reflectable : std::false_type
+{};
+
+template<>
+struct is_implicitly_reflectable<Aggregate> : std::true_type
+{};
+
+template<class T, class E=void>
+struct tag_of_fallback {
+    using type = int; // unknown
+};
+
+template<class T>
+struct tag_of_fallback<T, std::enable_if_t<std::is_same<T,T>::value>>
+{
+    using type = std::conditional_t<
+        is_implicitly_reflectable<T>::value
+      , std::true_type
+      , std::false_type
+    >;
+};
+
+static_assert(tag_of_fallback<Aggregate>::type::value == true, "");
+static_assert(tag_of_fallback<NonAggregate>::type::value == false, "");
+
+int main() { }
--- a/test/core/compile-fail/boost_pfr_disabled_via_macro.cpp
+++ b/test/core/compile-fail/boost_pfr_disabled_via_macro.cpp
@@ -0,0 +1,10 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_PFR_ENABLED 0
+#include <boost/pfr/core.hpp>
+
+int main() { }
+
--- a/test/core/compile-fail/fields_count_on_reference.cpp
+++ b/test/core/compile-fail/fields_count_on_reference.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/inherited.cpp
+++ b/test/core/compile-fail/inherited.cpp
--- a/test/core/compile-fail/inherited_nonempty.cpp
+++ b/test/core/compile-fail/inherited_nonempty.cpp
--- a/test/core/compile-fail/movable_and_lvalue_references.cpp
+++ b/test/core/compile-fail/movable_and_lvalue_references.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/non_aggregate.cpp
+++ b/test/core/compile-fail/non_aggregate.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/ops_on_union.cpp
+++ b/test/core/compile-fail/ops_on_union.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/ops_unions.cpp
+++ b/test/core/compile-fail/ops_unions.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/ops_unrestricted_unions.cpp
+++ b/test/core/compile-fail/ops_unrestricted_unions.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/pfr_review_test2.cpp
+++ b/test/core/compile-fail/pfr_review_test2.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 Antony Polukhin
+// Copyright (c) 2020-2023 Antony Polukhin
 // Copyright (c) 2020 Richard Hodges
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
--- a/test/core/compile-fail/private_fields.cpp
+++ b/test/core/compile-fail/private_fields.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/protected_fields.cpp
+++ b/test/core/compile-fail/protected_fields.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/rvalue_tie.cpp
+++ b/test/core/compile-fail/rvalue_tie.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 Antony Polukhin
+// Copyright (c) 2020-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/compile-fail/virtual_functions.cpp
+++ b/test/core/compile-fail/virtual_functions.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/loophole_detection.cpp
+++ b/test/core/loophole_detection.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 Antony Polukhin
+// Copyright (c) 2020-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/offset_based_getter.cpp
+++ b/test/core/offset_based_getter.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2019 Ilya Kiselev
-// Copyright (c) 2019-2021 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/bitfields_count.cpp
+++ b/test/core/run/bitfields_count.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/constexpr_ops.cpp
+++ b/test/core/run/constexpr_ops.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/core17_generated.cpp
+++ b/test/core/run/core17_generated.cpp
@@ -0,0 +1,125 @@
+// Copyright (c) 2023 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pfr/core.hpp>
+#include <type_traits> // for std::is_same
+
+struct A {
+    const volatile int cv_value = 0;
+    volatile int v_value = 0;
+    const int c_value = 0;
+    int value = 0;
+
+    const volatile int& cv_ref;
+    volatile int& v_ref;
+    const int& c_ref;
+    int& ref;
+
+    const volatile int&& cv_rref;
+    volatile int&& v_rref;
+    const int&& c_rref;
+    int&& rref;
+};
+
+int main() {
+#if BOOST_PFR_USE_CPP17
+    const volatile int cv_value = 0;
+    volatile int v_value = 0;
+    const int c_value = 0;
+    int value = 0;
+
+    typedef boost::pfr::detail::size_t_<12> fields_count_tag;
+
+    {
+        A a {cv_value, v_value, c_value, value,
+             cv_value, v_value, c_value, value,
+             std::move(cv_value), std::move(v_value), std::move(c_value), std::move(value)};
+
+        const auto t = boost::pfr::detail::tie_as_tuple(a, fields_count_tag{});
+
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<0>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<1>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<2>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<3>(t)), int&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<4>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<5>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<6>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<7>(t)), int&>());
+        // FIXME implement rvalue references as a field support
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<8>(t)), int const volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<9>(t)), int volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<10>(t)), int const&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<11>(t)), int&&>());
+    }
+
+    {
+        const A a {cv_value, v_value, c_value, value,
+                   cv_value, v_value, c_value, value,
+                   std::move(cv_value), std::move(v_value), std::move(c_value), std::move(value)};
+
+        const auto t = boost::pfr::detail::tie_as_tuple(a, fields_count_tag{});
+
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<0>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<1>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<2>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<3>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<4>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<5>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<6>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<7>(t)), int&>());
+        // FIXME implement rvalue references as a field support
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<8>(t)), int const volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<9>(t)), int volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<10>(t)), int const&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<11>(t)), int&&>());
+    }
+
+    {
+        volatile A a {cv_value, v_value, c_value, value,
+                      cv_value, v_value, c_value, value,
+                      std::move(cv_value), std::move(v_value), std::move(c_value), std::move(value)};
+
+        const auto t = boost::pfr::detail::tie_as_tuple(a, fields_count_tag{});
+
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<0>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<1>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<2>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<3>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<4>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<5>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<6>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<7>(t)), int&>());
+        // FIXME implement rvalue references as a field support
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<8>(t)), int const volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<9>(t)), int volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<10>(t)), int const&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<11>(t)), int&&>());
+    }
+
+    {
+        const volatile A a {cv_value, v_value, c_value, value,
+                            cv_value, v_value, c_value, value,
+                            std::move(cv_value), std::move(v_value), std::move(c_value), std::move(value)};
+
+        const auto t = boost::pfr::detail::tie_as_tuple(a, fields_count_tag{});
+
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<0>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<1>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<2>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<3>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<4>(t)), int const volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<5>(t)), int volatile&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<6>(t)), int const&>());
+        static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<7>(t)), int&>());
+        // FIXME implement rvalue references as a field support
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<8>(t)), int const volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<9>(t)), int volatile&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<10>(t)), int const&&>());
+        // static_assert(std::is_same<decltype(boost::pfr::detail::sequence_tuple::get<11>(t)), int&&>());
+    }
+
+#endif
+}
+
--- a/test/core/run/destructuring_tie.cpp
+++ b/test/core/run/destructuring_tie.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2018 Adam Butcher, Antony Polukhin
-// Copyright (c) 2019-2021 Antony Polukhin
+// Copyright (c) 2019-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/error_pfr_c1202.cpp
+++ b/test/core/run/error_pfr_c1202.cpp
@@ -1,9 +1,9 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-// Example from https://github.com/apolukhin/magic_get/issues/21
+// Example from https://github.com/boostorg/pfr/issues/21


 // boost::pfr::for_each_field crashes when sizeof(MyConfig) > 248 (probably >= 256)
--- a/test/core/run/fields_count_on_const.cpp
+++ b/test/core/run/fields_count_on_const.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/for_each_field.cpp
+++ b/test/core/run/for_each_field.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -56,6 +56,21 @@ struct simple {

 struct empty{};

+#if BOOST_PFR_USE_CPP17
+constexpr std::size_t get_field_count_through_for_each_field() {
+    std::size_t counter = 0;
+    boost::pfr::for_each_field(simple{}, [&counter](auto&& /*val*/, std::size_t /*i*/) {
+        ++ counter;
+    });
+    return counter;
+}
+
+// MSVC-14.1 fails to compile the following code
+#if !defined(_MSC_VER) || _MSC_VER > 1916
+static_assert(3 == get_field_count_through_for_each_field());
+#endif
+
+#endif

 int main () {
    std::size_t control = 0;
--- a/test/core/run/functions_for.cpp
+++ b/test/core/run/functions_for.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/get_by_type.cpp
+++ b/test/core/run/get_by_type.cpp
@@ -0,0 +1,67 @@
+// Copyright (c) 2020-2023 Antony Polukhin
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+
+#include <boost/pfr/core.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+
+namespace testing {
+
+namespace {
+
+struct Aggregate {
+    int a;
+    const int b;
+    double c;
+    double d;
+    short e;
+};
+
+void test_get_by_type() {
+#if BOOST_PFR_USE_CPP17
+    Aggregate t{1, 2, 3.4, 5.6, 7};
+
+    BOOST_TEST_EQ(boost::pfr::get<int>(t), 1);
+    BOOST_TEST_EQ(boost::pfr::get<const int>(t), 2);
+    BOOST_TEST_EQ(boost::pfr::get<short>(t), 7);
+
+    boost::pfr::get<int>(t) = 11;
+    boost::pfr::get<short>(t) = 77;
+#endif
+}
+
+void test_const_get_by_type() {
+#if BOOST_PFR_USE_CPP17 || BOOST_PFR_USE_LOOPHOLE
+    const Aggregate t{1, 2, 3.4, 5.6, 7};
+    BOOST_TEST_EQ(boost::pfr::get<short>(t), 7);
+#endif
+}
+
+void test_get_by_type_pod() {
+    struct PodAggregate {
+      int i;
+      short s;
+    };
+
+    PodAggregate pod{1, 2};
+    BOOST_TEST_EQ(boost::pfr::get<int>(pod), 1);
+    BOOST_TEST_EQ(boost::pfr::get<short>(pod), 2);
+}
+
+} // anonymous namespace
+
+
+} // namespace testing
+
+int main() {
+    testing::test_get_by_type();
+    testing::test_const_get_by_type();
+    testing::test_get_by_type_pod();
+
+    return boost::report_errors();
+}
+
+
--- a/test/core/run/get_const_field.cpp
+++ b/test/core/run/get_const_field.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 Antony Polukhin
+// Copyright (c) 2020-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/get_non_default_constructible.cpp
+++ b/test/core/run/get_non_default_constructible.cpp
--- a/test/core/run/get_rvalue.cpp
+++ b/test/core/run/get_rvalue.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2020-2021 Antony Polukhin
+// Copyright (c) 2020-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/is_implicitly_reflectable.cpp
+++ b/test/core/run/is_implicitly_reflectable.cpp
@@ -0,0 +1,83 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <iostream>
+#include <boost/pfr/traits.hpp>
+#include <type_traits>  // for std::true_type, std::false_type and std::is_aggregate
+
+namespace boost { namespace pfr {
+    struct boost_fusion_tag;
+    struct boost_json_tag;
+}}
+
+struct Aggregate {};
+using Nonaggregate = int;
+
+#if defined(__cpp_lib_is_aggregate)
+static_assert(std::is_aggregate<Aggregate>::value && !std::is_aggregate<Nonaggregate>::value, "");
+#endif
+
+using Reflectable = short;
+struct Nonrefrectable {};
+
+using ReflectableBoostFusion = short;
+struct NonrefrectableBoostFusion {};
+
+using ReflectableBoostJson = short;
+struct NonrefrectableBoostJson {};
+
+namespace boost { namespace pfr {
+    template<class All> struct is_reflectable<Reflectable, All> : std::true_type {};
+    template<class All> struct is_reflectable<Nonrefrectable, All> : std::false_type {};
+    template<> struct is_reflectable<ReflectableBoostFusion, boost_fusion_tag> : std::true_type {};
+    template<> struct is_reflectable<NonrefrectableBoostFusion, boost_fusion_tag> : std::false_type {};
+    template<> struct is_reflectable<ReflectableBoostJson, boost_json_tag> : std::true_type {};
+    template<> struct is_reflectable<NonrefrectableBoostJson, boost_json_tag> : std::false_type {};
+}}
+
+
+#if BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+template<class T, class Tag>
+void assert_reflectable() {
+    static_assert(boost::pfr::is_implicitly_reflectable_v<T, Tag>, "");
+    static_assert(boost::pfr::is_implicitly_reflectable_v<const T, Tag>, "");
+    static_assert(boost::pfr::is_implicitly_reflectable_v<volatile T, Tag>, "");
+    static_assert(boost::pfr::is_implicitly_reflectable_v<const volatile T, Tag>, "");
+}
+
+template<class T, class Tag>
+void assert_non_reflectable() {
+    static_assert(!boost::pfr::is_implicitly_reflectable_v<T, Tag>, "");
+    static_assert(!boost::pfr::is_implicitly_reflectable_v<const T, Tag>, "");
+    static_assert(!boost::pfr::is_implicitly_reflectable_v<volatile T, Tag>, "");
+    static_assert(!boost::pfr::is_implicitly_reflectable_v<const volatile T, Tag>, "");
+}
+#endif  // #if BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+
+int main() {
+#if BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+    std::cout << "Implicit reflection is available in this platform.." << std::endl;
+    {
+        using tag = boost::pfr::boost_json_tag;
+        assert_reflectable<Aggregate, tag>();
+        assert_non_reflectable<Nonaggregate, tag>();
+        assert_reflectable<Reflectable, tag>();
+        assert_non_reflectable<Nonrefrectable, tag>();
+        assert_reflectable<ReflectableBoostJson, tag>();
+        assert_non_reflectable<NonrefrectableBoostJson, tag>();
+    }
+
+    {
+        using tag = boost::pfr::boost_fusion_tag;
+        assert_reflectable<Aggregate, tag>();
+        assert_non_reflectable<Nonaggregate, tag>();
+        assert_reflectable<Reflectable, tag>();
+        assert_non_reflectable<Nonrefrectable, tag>();
+        assert_reflectable<ReflectableBoostFusion, tag>();
+        assert_non_reflectable<NonrefrectableBoostFusion, tag>();
+    }
+#endif  // #if BOOST_PFR_ENABLE_IMPLICIT_REFLECTION
+}
+
--- a/test/core/run/is_reflectable.cpp
+++ b/test/core/run/is_reflectable.cpp
@@ -0,0 +1,112 @@
+// Copyright (c) 2022 Denis Mikhailov
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/pfr/traits.hpp>
+#include <type_traits>  // for std::true_type, std::false_type
+
+namespace boost { namespace pfr {
+    struct boost_fusion_tag;
+    struct boost_json_tag;
+}}
+
+struct Reflectable {};
+struct Nonrefrectable {};
+struct Unknown {};
+
+struct ReflectableBoostFusion {};
+struct NonrefrectableBoostFusion {};
+
+struct ReflectableBoostJson {};
+struct NonrefrectableBoostJson {};
+
+namespace boost { namespace pfr {
+    template<class All> struct is_reflectable<Reflectable, All> : std::true_type {};
+    template<class All> struct is_reflectable<Nonrefrectable, All> : std::false_type {};
+    template<> struct is_reflectable<ReflectableBoostFusion, boost_fusion_tag> : std::true_type {};
+    template<> struct is_reflectable<NonrefrectableBoostFusion, boost_fusion_tag> : std::false_type {};
+    template<> struct is_reflectable<ReflectableBoostJson, boost_json_tag> : std::true_type {};
+    template<> struct is_reflectable<NonrefrectableBoostJson, boost_json_tag> : std::false_type {};
+}}
+
+
+
+
+namespace helpers {
+template <class T, class Tag>
+constexpr decltype(boost::pfr::is_reflectable<T, Tag>::value) is_reflectability_known(long) {
+    return true;
+}
+
+template <class T, class Tag>
+constexpr bool is_reflectability_known(int) {
+    return false;
+}
+}
+
+template<class T, class Tag>
+void assert_reflectable_impl() {
+    static_assert(helpers::is_reflectability_known<T, Tag>(1L), "");
+    static_assert(boost::pfr::is_reflectable<T, Tag>::value, "");
+}
+
+template<class T, class Tag>
+void assert_non_reflectable_impl() {
+    static_assert(helpers::is_reflectability_known<T, Tag>(1L), "");
+    static_assert(!boost::pfr::is_reflectable<T, Tag>::value, "");
+}
+
+template<class T, class Tag>
+void assert_unknown_impl() {
+    static_assert(!helpers::is_reflectability_known<T, Tag>(1L), "");
+}
+
+template<class T, class Tag>
+void assert_reflectable() {
+    assert_reflectable_impl<T, Tag>();
+    assert_reflectable_impl<const T, Tag>();
+    assert_reflectable_impl<volatile T, Tag>();
+    assert_reflectable_impl<const volatile T, Tag>();
+}
+
+template<class T, class Tag>
+void assert_non_reflectable() {
+    assert_non_reflectable_impl<T, Tag>();
+    assert_non_reflectable_impl<const T, Tag>();
+    assert_non_reflectable_impl<volatile T, Tag>();
+    assert_non_reflectable_impl<const volatile T, Tag>();
+}
+
+template<class T, class Tag>
+void assert_unknown() {
+    assert_unknown_impl<T, Tag>();
+    assert_unknown_impl<const T, Tag>();
+    assert_unknown_impl<volatile T, Tag>();
+    assert_unknown_impl<const volatile T, Tag>();
+}
+
+int main() {
+    {
+        using tag = boost::pfr::boost_json_tag;
+        assert_reflectable<Reflectable, tag>();
+        assert_non_reflectable<Nonrefrectable, tag>();
+        assert_unknown<Unknown, tag>();
+        assert_unknown<ReflectableBoostFusion, tag>();
+        assert_unknown<NonrefrectableBoostFusion, tag>();
+        assert_reflectable<ReflectableBoostJson, tag>();
+        assert_non_reflectable<NonrefrectableBoostJson, tag>();
+    }
+
+    {
+        using tag = boost::pfr::boost_fusion_tag;
+        assert_reflectable<Reflectable, tag>();
+        assert_non_reflectable<Nonrefrectable, tag>();
+        assert_unknown<Unknown, tag>();
+        assert_reflectable<ReflectableBoostFusion, tag>();
+        assert_non_reflectable<NonrefrectableBoostFusion, tag>();
+        assert_unknown<ReflectableBoostJson, tag>();
+        assert_unknown<NonrefrectableBoostJson, tag>();
+    }
+}
+
--- a/test/core/run/issue30.cpp
+++ b/test/core/run/issue30.cpp
@@ -1,9 +1,9 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-// Test case for https://github.com/apolukhin/magic_get/issues/30
+// Test case for https://github.com/boostorg/pfr/issues/30

 #include <memory>
 #include <boost/pfr.hpp>
--- a/test/core/run/issue33.cpp
+++ b/test/core/run/issue33.cpp
@@ -1,11 +1,12 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

-// Test case for https://github.com/apolukhin/magic_get/issues/33
+// Test case for https://github.com/boostorg/pfr/issues/33

 #include <iostream>
+#include <memory>
 #include <vector>
 #include <boost/pfr.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -14,13 +15,23 @@ struct TestStruct {
    std::vector<std::unique_ptr<int>> vec;
 };

+
 int main() {
    TestStruct temp;
    temp.vec.emplace_back();

+// FIXME: https://github.com/boostorg/pfr/issues/131
+#if defined(__clang__) && __cplusplus >= 202002L
+
+# if BOOST_PFR_USE_LOOPHOLE == 0 && BOOST_PFR_USE_CPP17 == 0
+#   error This test should fail on classic engine
+#endif
+
+#else
    boost::pfr::for_each_field(temp, [](const auto& value) {
        BOOST_TEST_EQ(value.size(), 1);
    });
+#endif

    return boost::report_errors();
 }
--- a/test/core/run/motivating_example.cpp
+++ b/test/core/run/motivating_example.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/motivating_example2.cpp
+++ b/test/core/run/motivating_example2.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/non_copyable_but_movable.cpp
+++ b/test/core/run/non_copyable_but_movable.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/non_dc_non_cop_but_mov.cpp
+++ b/test/core/run/non_dc_non_cop_but_mov.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/non_default_constructible.cpp
+++ b/test/core/run/non_default_constructible.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/non_movable.cpp
+++ b/test/core/run/non_movable.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -18,7 +18,11 @@ struct X {
 struct S { X x0; X x1; int x2; X x3; };

 int main() {
+
 #if BOOST_PFR_HAS_GUARANTEED_COPY_ELISION
+
+// MSVC-14.3 fails this test
+#if !defined(_MSC_VER) || _MSC_VER < 1930 || _MSC_VER > 1939
    static_assert(boost::pfr::tuple_size_v<S> == 4, "");

    struct S5_0 { int x0; int x1; int x2; int x3; X x4; };
@@ -38,6 +42,8 @@ int main() {

    struct S6 { X x0; X x1; X x2; X x3; X x4;  X x5;};
    static_assert(boost::pfr::tuple_size_v<S6> == 6, "");
+#endif
+
 #endif  // #if BOOST_PFR_HAS_GUARANTEED_COPY_ELISION

    return boost::report_errors();
--- a/test/core/run/non_std_layout.cpp
+++ b/test/core/run/non_std_layout.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2018-2021 Antony Polukhin
+// Copyright (c) 2018-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/test/core/run/ops.cpp
+++ b/test/core/run/ops.cpp
@@ -1,4 +1,4 @@
-// Copyright (c) 2016-2021 Antony Polukhin
+// Copyright (c) 2016-2023 Antony Polukhin
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Antony Polukhin	294a4976bd	attempt to fix reference section collapse (refs https://github.com/boostorg/any/issues/27 )	2023-10-11 10:13:39 +03:00
Antony Polukhin	2c79036816	Fix an unused parameter warning	2023-09-28 10:00:01 +03:00
Antony Polukhin	6b415eaa5c	Merge branch 'master' into develop	2023-09-28 09:44:35 +03:00
denzor200	11133a4f63	Forbid get_name for arrays	2023-09-27 11:36:22 +03:00
denzor200	b1432d5fa9	Fix for printing BOOST_PFR_FUNCTION_SIGNATURE	2023-09-27 11:36:22 +03:00
Denis Mikhailov	8a13352854	Fix typos (#139 )	2023-09-27 11:36:22 +03:00
Antony Polukhin	e48f84dcb1	Harden the filed name checks and improve the diagnostics (#138 )	2023-09-27 11:36:22 +03:00
Antony Polukhin	ba25324b12	Avoid stored_name_of_field duplication in different translation units	2023-09-27 11:36:22 +03:00
Antony Polukhin	df1249f6b8	Suppress non-ASCII warning from boost-inspect	2023-09-27 11:36:22 +03:00
Antony Polukhin	f81c54ced0	Fix compilation on MSVC	2023-09-27 11:36:22 +03:00
Antony Polukhin	f23c003c51	Do not require Python to run tests	2023-09-27 11:36:22 +03:00
Antony Polukhin	95a2044e8b	relax standard library requirements	2023-09-27 11:36:22 +03:00
denzor200	7738b09132	Fix for old MSVC compiler	2023-09-27 11:36:22 +03:00
denzor200	7f5895b3a3	review	2023-09-27 11:36:22 +03:00
denzor200	245ac56645	Rename C++20 features detectors	2023-09-27 11:36:22 +03:00
denzor200	ec0ea4a338	Fix docs	2023-09-27 11:36:22 +03:00
denzor200	d8a10e2abd	Fix strip_boost_namespace.sh	2023-09-27 11:36:22 +03:00
denzor200	2674cf4fd4	Fix CI	2023-09-27 11:36:22 +03:00
denzor200	2876b2e793	Parser might be explicitly tagged as backward	2023-09-27 11:36:22 +03:00
denzor200	48b9be5070	Write docs	2023-09-27 11:36:22 +03:00
denzor200	226352be5e	Parsing ala boost type_index	2023-09-27 11:36:22 +03:00
denzor200	65bf6b579f	review	2023-09-27 11:36:22 +03:00
denzor200	c82490024c	Refactoring for parser	2023-09-27 11:36:22 +03:00
denzor200	552463a4e3	Add test for big structures	2023-09-27 11:36:22 +03:00
denzor200	642d1f7d23	Fix nonascii fields	2023-09-27 11:36:22 +03:00
denzor200	ad7ab1cfc3	Add Clang support	2023-09-27 11:36:22 +03:00
denzor200	3438d5e815	Fix MSVC	2023-09-27 11:36:22 +03:00
denzor200	356e937dd9	Fix strip_boost_namespace.sh	2023-09-27 11:36:22 +03:00
denzor200	282e033e4b	Fix lint issue about nonascii symbol	2023-09-27 11:36:22 +03:00
denzor200	04aef42dcb	review	2023-09-27 11:36:22 +03:00
denzor200	86911e0247	fix lint issues	2023-09-27 11:36:22 +03:00
denzor200	f4ebd9d49d	fix for cxx14 build	2023-09-27 11:36:22 +03:00
denzor200	fc89551a19	Add methods to extract fields names	2023-09-27 11:36:22 +03:00
Antony Polukhin	7e19e45d85	Merge pull request #140 from denzor200/get_name_fixes Couple of fixes for get_name	2023-09-23 09:56:57 +03:00
denzor200	53fcd78d4f	Forbid get_name for arrays	2023-09-23 01:53:00 +03:00
denzor200	833f32960a	Fix for printing BOOST_PFR_FUNCTION_SIGNATURE	2023-09-23 01:52:03 +03:00
Denis Mikhailov	730f40b6b2	Fix typos (#139 )	2023-09-19 11:46:52 +03:00
Antony Polukhin	67f4fc4398	Harden the filed name checks and improve the diagnostics (#138 )	2023-09-18 13:57:58 +03:00
Antony Polukhin	7ba81adbd6	Avoid stored_name_of_field duplication in different translation units	2023-09-17 18:06:35 +03:00
Antony Polukhin	defcf22e4d	Merge pull request #129 from denzor200/feature/get_name Field's names functionality	2023-09-17 17:54:44 +03:00
Antony Polukhin	9cc76bc277	Suppress non-ASCII warning from boost-inspect	2023-09-17 15:15:40 +03:00
Antony Polukhin	27b9706ac5	Fix compilation on MSVC	2023-09-17 14:14:26 +03:00
Antony Polukhin	41e87fbadb	Do not require Python to run tests	2023-09-17 13:55:47 +03:00
Antony Polukhin	3f07e7187e	relax standard library requirements	2023-09-17 13:41:43 +03:00
denzor200	6dcf66cbd5	Fix for old MSVC compiler	2023-09-10 05:19:20 +03:00
denzor200	8794056e20	review	2023-09-10 04:06:58 +03:00
denzor200	dd8a5277fb	Rename C++20 features detectors	2023-09-09 22:41:10 +03:00
denzor200	5a7d6524a7	Fix docs	2023-09-09 22:07:12 +03:00
denzor200	0cb5cf2ae7	Fix strip_boost_namespace.sh	2023-09-08 00:49:52 +03:00
denzor200	2c79ac703b	Fix CI	2023-09-06 01:52:54 +03:00
denzor200	dbbfa6ea7f	Parser might be explicitly tagged as backward	2023-09-03 02:12:25 +03:00
denzor200	fcfca74355	Write docs	2023-09-02 22:42:54 +03:00
denzor200	9b2817a52b	Parsing ala boost type_index	2023-08-31 02:07:39 +03:00
denzor200	efd25e9968	review	2023-08-27 02:23:54 +03:00
denzor200	9b6a0deac6	Refactoring for parser	2023-08-26 23:12:08 +03:00
denzor200	a5b9cd567f	Add test for big structures	2023-08-26 20:23:50 +03:00
denzor200	6e23ed540f	Fix nonascii fields	2023-08-23 01:19:36 +03:00
denzor200	6f544ceaa7	Add Clang support	2023-08-19 19:48:33 +03:00
denzor200	b15196c2e0	Fix MSVC	2023-08-18 02:00:18 +03:00
denzor200	50c9d6f6e7	Fix strip_boost_namespace.sh	2023-08-12 19:28:42 +00:00
denzor200	196aeb6da0	Fix lint issue about nonascii symbol	2023-08-12 17:47:58 +00:00
denzor200	fe5a70bac9	Merge remote-tracking branch 'origin/develop' into feature/get_name	2023-08-12 11:59:31 +00:00
Alexander Karatarakis	b5e523f2b3	Make `for_each_field()` constexpr for c++17 (#134 ) #127	2023-08-12 10:43:20 +03:00
Antony Polukhin	674f3723c5	Run MSVC-14.3 tests in one thread in CI	2023-08-11 16:15:33 +03:00
Antony Polukhin	e61fa139b6	Add CI tests run on msvc-14.3 in C++20 mode (#136 )	2023-08-11 15:05:25 +03:00
denzor200	03e1d768b7	Merge remote-tracking branch 'origin/develop' into feature/get_name	2023-08-11 07:16:16 +00:00
Antony Polukhin	963460a3c1	fix CI (#135 )	2023-08-10 17:22:31 +03:00
Antony Polukhin	275eabb7ed	do not run inspect tool in index.html	2023-08-09 14:05:30 +03:00
Mohammad Nejati	2fa9036d56	Use relative URL for redirect in index.html (#128 )	2023-06-30 17:39:53 +03:00
denzor200	454947de51	review	2023-06-28 12:32:26 +00:00
denzor200	f09357c1bf	fix lint issues	2023-06-27 13:10:57 +00:00
denzor200	e8e077c346	fix for cxx14 build	2023-06-26 20:59:46 +00:00
denzor200	4a1defaaeb	Add methods to extract fields names	2023-06-25 22:40:31 +00:00
René Ferdinand Rivera Morell	b0bf18798c	Fix missing include for unique_ptr. (#125 )	2023-03-07 09:33:06 +03:00
Antony Polukhin	9bc057e2a6	remove trailing whitespaces	2023-03-03 15:46:10 +03:00
Antony Polukhin	e460ce2ddc	Always define is_implicitly_reflectable (#124 ) Always define is_implicitly_reflectable	2023-02-27 10:59:34 +03:00
Antony Polukhin	d66c0a9551	Fix macro definition for Doxygen	2023-02-26 13:07:45 +03:00
Antony Polukhin	95c06fb7c6	Update the docs with more samples and links to online playgrounds	2023-02-26 12:58:08 +03:00
Antony Polukhin	ab509a5b32	implement pfr::get by type (#123 )	2023-02-21 14:28:28 +03:00
Antony Polukhin	ed28602c2c	Merge pull request #121 from caozhanhao/missing-pragma add missing #pragma once	2023-01-31 11:38:58 +03:00
caozhanhao	dbc78d7dd9	add missing #pragma once	2023-01-20 13:00:37 +08:00
Antony Polukhin	551174b58c	Update copyright years	2023-01-19 10:03:04 +03:00
Antony Polukhin	79b0d65d4f	Merge remote-tracking branch 'denzor200/typo_fix' into develop	2023-01-18 19:05:08 +03:00
Antony Polukhin	2116be9285	Merge pull request #117 from markus-oberhumer-forks/fix-Wzero-as-null-pointer-constant Avoid -Wzero-as-null-pointer-constant warnings.	2023-01-17 15:14:44 +03:00
Markus F.X.J. Oberhumer	a9a295e4aa	Avoid -Wzero-as-null-pointer-constant warnings.	2023-01-11 13:11:45 +01:00
Antony Polukhin	2775d19f34	Merge pull request #119 from denzor200/fix/broken_structured_binding2 Workaround for broken C++17 stuctured binding in old compilers	2023-01-10 20:13:44 +03:00
denzor200	633c4bc985	'add_cv_like<T>(arg)' -> 'detail::add_cv_like<T>(arg)'	2023-01-10 00:26:58 +06:00
denzor200	b1af355a49	Workaround for broken C++17 stuctured binding in old compilers	2023-01-09 23:30:41 +06:00
Antony Polukhin	ef505f10c3	Merge pull request #118 from denzor200/fix/config_for_old_stdcpp Fix for using config.hpp in old standards	2023-01-07 18:37:50 +03:00
denzor200	1be5e116f4	add cxx14 check	2023-01-07 17:02:01 +06:00
denzor200	bca51da20f	Add old MSVC CI stage	2023-01-07 16:43:20 +06:00
denzor200	47c6413530	disable cxx14 restriction for config's test	2023-01-07 02:28:03 +06:00
denzor200	52a5a489ba	split tests into two projects	2023-01-07 01:48:39 +06:00
Antony Polukhin	fd584a405d	Merge pull request #114 from denzor200/patch-2 Fix warning missing terminating character	2022-12-30 16:34:10 +03:00
Denis Mikhailov	b6a960757b	Update config.hpp	2022-12-30 11:21:24 +04:00
Antony Polukhin	dac40b2153	Merge pull request #86 from denzor200/feature/85-boost_no_pfr_macro Implemented BOOST_PFR_ENABLED macro	2022-12-18 22:51:01 +03:00
denzor200	58ce59cf38	missed BOOST_PFR_ENABLED in error message	2022-12-18 22:01:57 +04:00
denzor200	5010309967	permissions	2022-12-18 21:54:58 +04:00
denzor200	bf5bd10b36	review discussions	2022-12-18 21:52:40 +04:00
denzor200	3279a7b610	Merge remote-tracking branch 'origin/develop' into feature/85-boost_no_pfr_macro Conflicts: doc/pfr.qbk include/boost/pfr/detail/config.hpp test/print_config.cpp	2022-12-18 20:54:40 +04:00
Antony Polukhin	d7db07e98d	Merge pull request #111 from denzor200/is_implicitly_reflectable Add is_implicitly_reflectable trait	2022-12-18 19:11:27 +03:00
denzor200	6a38a07285	Add test 'boost_no_pfr_macro'	2022-12-17 00:35:56 +04:00
denzor200	69a06b98da	review discussions	2022-12-17 00:33:44 +04:00
denzor200	578b5b2ac2	tests for new traits	2022-12-16 23:37:19 +04:00
denzor200	f12f35ac1a	resolve review discussions	2022-12-16 23:20:37 +04:00
denzor200	2b4e2922ae	fix for sfinae-friendliness issue	2022-12-16 19:57:12 +04:00
denzor200	b2acaacaaf	Ability to disable implicitly reflection using the macro	2022-12-02 18:05:52 +04:00
Denis Mikhaylov	ff6c2b87c0	Remake BOOST_NO_PFR, now it can be overridden by the user	2022-12-01 20:43:36 +06:00
Denis Mikhaylov	2a3ddbfc17	Merge remote-tracking branch 'origin/develop' into feature/85-boost_no_pfr_macro	2022-12-01 19:47:53 +06:00
Denis Mikhaylov	5374f9aebc	Revert "Implemented BOOST_NO_PFR macro" This reverts commit `14185d614f`.	2022-12-01 19:47:29 +06:00
Denis Mikhaylov	968d692c5e	permissions restored	2022-12-01 17:42:09 +06:00
Denis Mikhaylov	5c13668343	Fix strip_boost_namespace's issues	2022-12-01 17:27:13 +06:00
Denis Mikhaylov	6f853dad2c	Fixed inspect issues	2022-12-01 17:13:06 +06:00
Denis Mikhaylov	aa5abd8d76	Fixed C++14 build	2022-12-01 17:05:00 +06:00
Denis Mikhaylov	ba40d86097	Add static test to detect ability to integrate PFR as fallback into the Fusion	2022-12-01 14:09:37 +06:00
denzor200	7a3a419c35	identations in Motivating Example	2022-11-27 19:52:57 +04:00
denzor200	a70d02103a	Add is_implicitly_reflectable trait	2022-11-27 19:48:32 +04:00
denzor200	d59b6f9520	permissions restored	2022-11-27 15:17:00 +04:00
Antony Polukhin	69c5692cd6	Merge pull request #109 from alexiprof/sequence_tuple-nolint feat sequence_tuple: add nolint in functions	2022-09-24 11:25:15 +03:00
Alexander Malkov	8f325567eb	feat sequence_tuple: add nolint in functions add nolint in get_impl functions	2022-09-23 14:36:42 +03:00
Denis Mikhaylov	b10c0c66ed	fix	2022-09-15 10:59:42 +06:00
Denis Mikhaylov	1bb4ced005	Fixed a lot of typos	2022-09-14 20:01:44 +06:00
Antony Polukhin	58dcb40a49	disable MSVC tests for now	2022-09-10 16:28:00 +03:00
Antony Polukhin	b7d839b851	do not test in C++14 mode on modern MSVC	2022-09-09 18:44:02 +03:00
Antony Polukhin	3396cdca9e	Merge branch 'develop' of github.com:boostorg/pfr into develop	2022-09-03 08:17:18 +03:00
Antony Polukhin	fbafd21118	Update Windows version in CI. Remove MacOS run from CI as it almost always hits CI limits	2022-09-03 08:17:07 +03:00
Antony Polukhin	b0aae28eb0	Merge pull request #97 from denzor200/patch-1 Fixed `is_constexpr_aggregate_initializable`	2022-09-01 11:50:08 +03:00
Antony Polukhin	9388c4e4c0	Force CI run	2022-08-31 21:34:59 +03:00
Antony Polukhin	4e84a5b159	Merge pull request #96 from jcelerier/patch-1 for_each_field_impl: use fold expressions if possible	2022-08-31 21:17:01 +03:00
Antony Polukhin	7837449ca7	Force CI run	2022-08-31 18:31:06 +03:00
Antony Polukhin	9bb809d2a5	Merge pull request #104 from alexiprof/patch-1 feat sequence_tuple: add nolint in return value	2022-08-31 18:27:47 +03:00
Alexander Malkov	2a1fd53724	feat sequence_tuple: add nolint in return value add nolint in return value Tests: clang-tidy	2022-08-31 12:28:03 +03:00
Denis Mikhailov	cae0eaad61	Fix compilation error with array	2022-07-28 00:10:16 +04:00
Denis Mikhailov	ba10f9bc94	Update core14_classic.hpp	2022-07-20 15:27:28 +06:00
Antony Polukhin	8a8b5bc8d3	update copyright years	2022-01-30 14:55:36 +03:00
Jean-Michaël Celerier	a73f25d3ff	for_each_field_impl: use fold expressions if possible This makes empty structs work with MSVC in that case.	2021-11-12 21:55:01 +01:00
Antony Polukhin	a24717a4a1	fix samples in the README.md (fixes #94 )	2021-10-09 11:08:12 +03:00
denzor200	14185d614f	Implemented BOOST_NO_PFR macro	2021-06-20 16:32:07 +04:00