Rework type-name parser

.clang-format

@@ -48,7 +48,7 @@ KeepEmptyLines:
 # Alignment
 
 AlignAfterOpenBracket: AlwaysBreak
-AlignArrayOfStructures: Right
+AlignArrayOfStructures: Left
 AlignConsecutiveBitFields: None
 AlignConsecutiveDeclarations: None
 AlignConsecutiveAssignments: None

include/mimic++/Utilities.hpp

@@ -1,4 +1,4 @@
-//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
+//          Copyright Dominic (DNKpp) Koepke 2024-2026.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          https://www.boost.org/LICENSE_1_0.txt)
@@ -11,6 +11,7 @@
 #include "mimic++/utilities/C++23Backports.hpp"
 #include "mimic++/utilities/C++26Backports.hpp"
 #include "mimic++/utilities/Concepts.hpp"
+#include "mimic++/utilities/CopyableBox.hpp"
 #include "mimic++/utilities/PassKey.hpp"
 #include "mimic++/utilities/PriorityTag.hpp"
 #include "mimic++/utilities/SourceLocation.hpp"

include/mimic++/config/Config.hpp

@@ -1,4 +1,4 @@
-//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
+//          Copyright Dominic (DNKpp) Koepke 2024-2026.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          https://www.boost.org/LICENSE_1_0.txt)
@@ -69,11 +69,26 @@
     #define MIMICPP_DETAIL_CONSTEXPR_VECTOR inline
 #endif
 
+// Requires constexpr vector and constexpr optional
+// clang-format off
+// Prevent number from getting decorated with '.
+#if 201907L <= __cpp_lib_constexpr_vector \
+    && 202106L <= __cpp_lib_optional
+    // clang-format on
+    #define MIMICPP_DETAIL_CONSTEXPR_PRETTY_TYPES constexpr
+#else
+    #define MIMICPP_DETAIL_CONSTEXPR_PRETTY_TYPES inline
+#endif
+
 // gcc 10 requires a workaround, due to some ambiguities.
 // see: https://github.com/DNKpp/mimicpp/issues/151
 #if MIMICPP_DETAIL_IS_GCC \
     && __GNUC__ <= 10
     #define MIMICPP_DETAIL_STD_GET_WORKAROUND 1
 #endif
 
+#ifdef __cpp_lib_source_location
+    #define MIMICPP_DETAIL_HAS_SOURCE_LOCATION 1
+#endif
+
 #endif

include/mimic++/printing/TypePrinter.hpp

@@ -1,4 +1,4 @@
-//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
+//          Copyright Dominic (DNKpp) Koepke 2024-2026.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          https://www.boost.org/LICENSE_1_0.txt)
@@ -7,10 +7,11 @@
 #define MIMICPP_PRINTING_TYPE_PRINTER_HPP
 
 #include "mimic++/printing/type/CommonTypes.hpp"
-#include "mimic++/printing/type/NameLexer.hpp"
-#include "mimic++/printing/type/NameParser.hpp"
-#include "mimic++/printing/type/NamePrintVisitor.hpp"
+#include "mimic++/printing/type/Lexer.hpp"
+#include "mimic++/printing/type/Parser.hpp"
+#include "mimic++/printing/type/ParserState.hpp"
 #include "mimic++/printing/type/PrintType.hpp"
+#include "mimic++/printing/type/PrintVisitor.hpp"
 #include "mimic++/printing/type/Signature.hpp"
 #include "mimic++/printing/type/Templated.hpp"
 

include/mimic++/printing/state/C++23Backports.hpp

@@ -86,6 +86,7 @@ namespace mimicpp::printing::detail::state
     };
 
     template <tuple_like T>
+        requires(!std::ranges::forward_range<T>)
     struct cxx23_backport_printer<T>
     {
         template <print_iterator OutIter>

include/mimic++/printing/state/CommonTypes.hpp

@@ -1,4 +1,4 @@
-//          Copyright Dominic (DNKpp) Koepke 2024 - 2026.
+//          Copyright Dominic (DNKpp) Koepke 2024-2026.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          https://www.boost.org/LICENSE_1_0.txt)
@@ -19,6 +19,7 @@
 #include "mimic++/printing/type/PrintType.hpp"
 #include "mimic++/utilities/C++20Compatibility.hpp"
 #include "mimic++/utilities/C++23Backports.hpp" // unreachable
+#include "mimic++/utilities/SourceLocation.hpp"
 
 #ifndef MIMICPP_DETAIL_IS_MODULE
     #include <algorithm>
@@ -70,6 +71,20 @@ struct mimicpp::printing::detail::state::common_type_printer<std::source_locatio
 
 namespace mimicpp::printing::detail::state
 {
+    template <>
+    struct common_type_printer<util::SourceLocation>
+    {
+        template <print_iterator OutIter>
+        static constexpr OutIter print(OutIter out, util::SourceLocation const& loc)
+        {
+            return detail::print_source_location(
+                std::move(out),
+                loc.file_name(),
+                loc.line(),
+                loc.function_name());
+        }
+    };
+
     template <>
     struct common_type_printer<std::nullopt_t>
     {

include/mimic++/printing/type/NameLexer.hpp → include/mimic++/printing/type/Lexer.hpp

@@ -1,10 +1,10 @@
-//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
+//          Copyright Dominic (DNKpp) Koepke 2024-2026.
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          https://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef MIMICPP_PRINTING_TYPE_NAME_LEXER_HPP
-#define MIMICPP_PRINTING_TYPE_NAME_LEXER_HPP
+#ifndef MIMICPP_PRINTING_TYPE_LEXER_HPP
+#define MIMICPP_PRINTING_TYPE_LEXER_HPP
 
 #pragma once
 
@@ -24,23 +24,33 @@
 
 namespace mimicpp::printing::type::lexing
 {
+    // This is a constexpr friendly version of `std::isspace`.
     // see: https://en.cppreference.com/w/cpp/string/byte/isspace
     inline auto constexpr is_space = [](char const c) noexcept {
-        return static_cast<bool>(
-            std::isspace(static_cast<unsigned char>(c)));
+        switch (c)
+        {
+        case ' ':  [[fallthrough]];
+        case '\f': [[fallthrough]];
+        case '\n': [[fallthrough]];
+        case '\r': [[fallthrough]];
+        case '\t': [[fallthrough]];
+        case '\v': return true;
+
+        default: return false;
+        }
     };
 
+    // This is a constexpr friendly version of `std::isdigit`.
     // see: https://en.cppreference.com/w/cpp/string/byte/isdigit
     inline auto constexpr is_digit = [](char const c) noexcept {
-        return static_cast<bool>(
-            std::isdigit(static_cast<unsigned char>(c)));
+        return '0' <= c && c <= '9';
     };
 
     namespace texts
     {
         // just list the noteworthy ones here
         inline std::array constexpr visibilityKeywords = std::to_array<StringViewT>({"public", "protected", "private"});
-        inline std::array constexpr specKeywords = std::to_array<StringViewT>({"const", "constexpr", "volatile", "noexcept", "static"});
+        inline std::array constexpr specKeywords = std::to_array<StringViewT>({"const", "constexpr", "volatile", "noexcept", "static", "mutable"});
         inline std::array constexpr contextKeywords = std::to_array<StringViewT>({"operator", "struct", "class", "enum"});
         inline std::array constexpr typeKeywords = std::to_array<StringViewT>(
             // The `__int64` keyword is used by msvc as an alias for `long long`.
@@ -57,8 +67,10 @@ namespace mimicpp::printing::type::lexing
         inline std::array constexpr bitArithmetic = std::to_array<StringViewT>({"~", "&", "|", "^", "<<", ">>"});
         inline std::array constexpr logical = std::to_array<StringViewT>({"!", "&&", "||"});
         inline std::array constexpr access = std::to_array<StringViewT>({".", ".*", "->", "->*"});
-        inline std::array constexpr specialAngles = std::to_array<StringViewT>({"<:", ":>", "<%", "%>"});
         inline std::array constexpr rest = std::to_array<StringViewT>({"::", ";", ",", ":", "...", "?"});
+
+        // These operators exist, but are in fact alternative versions and will probably never encountered.
+        // inline std::array constexpr specialAngles = std::to_array<StringViewT>({"<:", ":>", "<%", "%>"});
     }
 
     [[nodiscard]]
@@ -91,7 +103,6 @@ namespace mimicpp::printing::type::lexing
             texts::bitArithmetic,
             texts::logical,
             texts::access,
-            texts::specialAngles,
             texts::rest);
         std::ranges::sort(collection);
         MIMICPP_ASSERT(collection.cend() == std::ranges::unique(collection).begin(), "Fix your input!");
@@ -132,6 +143,12 @@ namespace mimicpp::printing::type::lexing
             return textCollection[m_KeywordIndex];
         }
 
+        [[nodiscard]]
+        constexpr std::ptrdiff_t index() const noexcept
+        {
+            return m_KeywordIndex;
+        }
+
         [[nodiscard]]
         bool operator==(keyword const&) const = default;
 
@@ -166,6 +183,12 @@ namespace mimicpp::printing::type::lexing
             return textCollection[m_TextIndex];
         }
 
+        [[nodiscard]]
+        constexpr std::ptrdiff_t index() const noexcept
+        {
+            return m_TextIndex;
+        }
+
         [[nodiscard]]
         bool operator==(operator_or_punctuator const&) const = default;
 
@@ -181,6 +204,14 @@ namespace mimicpp::printing::type::lexing
         bool operator==(identifier const&) const = default;
     };
 
+    struct literal
+    {
+        StringViewT content;
+
+        [[nodiscard]]
+        bool operator==(literal const&) const = default;
+    };
+
     struct end
     {
         [[nodiscard]]
@@ -192,7 +223,8 @@ namespace mimicpp::printing::type::lexing
         space,
         keyword,
         operator_or_punctuator,
-        identifier>;
+        identifier,
+        literal>;
 
     struct token
     {
@@ -261,6 +293,13 @@ namespace mimicpp::printing::type::lexing
                 return next_as_op_or_punctuator(options);
             }
 
+            if (std::optional literal = try_next_as_literal())
+            {
+                return token{
+                    .content = literal->content,
+                    .classification = *std::move(literal)};
+            }
+
             StringViewT const content = next_as_identifier();
             // As we do not perform any prefix-checks, we need to check now whether the token actually denotes a keyword.
             if (auto const iter = util::binary_find(keyword::textCollection, content);
@@ -359,6 +398,35 @@ namespace mimicpp::printing::type::lexing
 
             return content;
         }
+
+        // This function currently implements just a very basic integer-literal detection.
+        // see: https://eel.is/c++draft/lex.literal.kinds#nt:literal
+        [[nodiscard]]
+        constexpr std::optional<literal> try_next_as_literal() noexcept
+        {
+            MIMICPP_ASSERT(!m_Text.empty(), "Empty text.");
+
+            if (is_digit(m_Text.front()))
+            {
+                if ('0' == m_Text.front()
+                    && 2u <= m_Text.size())
+                {
+                    // Todo: one of
+                    // https://eel.is/c++draft/lex.icon#nt:binary-literal
+                    // https://eel.is/c++draft/lex.icon#nt:octal-literal
+                    // https://eel.is/c++draft/lex.icon#nt:hexadecimal-prefix
+                }
+
+                // Todo: this is just a very naive approach.
+                auto const last = std::ranges::find_if_not(m_Text.cbegin() + 1, m_Text.cend(), is_digit);
+                StringViewT const content{m_Text.cbegin(), last};
+                m_Text = {last, m_Text.cend()};
+
+                return literal{.content = content};
+            }
+
+            return std::nullopt;
+        }
     };
 }