Add <format> format specifiers to string interpolation

hsutter · hsutter · commit e38838e678a2 · 2023-09-23T16:27:51.000-07:00
Example: `(x.price(): &lt;10.2f)$` is a space-padded left-aligned 10-width 2-precision value.

When people complain about &lt;iostream&gt;, they're usually complaining about `&lt;&lt;` everywhere to concatenate elements, and the ugliness of the `&lt;iomanip&gt;` manipulators (and locales but that's another topic).

Cpp2 loves streams, but I have to agree that this iomanip code today is pretty horrible:

    std::cout &lt;&lt; std::left &lt;&lt; std::setw(20) &lt;&lt; x.name() &lt;&lt; " color " &lt;&lt; std::left &lt;&lt; std::setw(10) &lt;&lt; x.color() &lt;&lt; " price " &lt;&lt; std::setw(10) &lt;&lt; std::setprecision(3) &lt;&lt; x.price() &lt;&lt; " in stock = " &lt;&lt; std::boolalpha &lt;&lt; (x.count() &gt; 0) &lt;&lt; "\n";

With this commit, you get the same formatted output with string interpolation and a single `&lt;&lt;`:

    std::cout &lt;&lt; "(x.name():20)$ color (x.color():10)$ price (x.price(): &lt;10.2f)$ in stock = (x.count() &gt; 0)$\n";

Both versions print the same thing (see `pure2-interpolation.cpp2`):

    Dog kennel           color mauve      price 3.14       in stock = true
diff --git a/include/cpp2util.h b/include/cpp2util.h
@@ -115,7 +115,7 @@
         #endif
         #include <cwchar>
         #include <cwctype>
-        #ifdef __cpp_lib_format
+        #if defined(__cpp_lib_format) || (defined(_MSC_VER) && _MSC_VER >= 1929)
             #include <format>
         #endif
         #include <string>
@@ -221,6 +221,9 @@
     #include <concepts>
     #include <system_error>
     #include <limits>
+    #if defined(__cpp_lib_format) || (defined(_MSC_VER) && _MSC_VER >= 1929)
+        #include <format>
+    #endif
 
     #ifndef CPP2_NO_EXCEPTIONS
         #include <exception>
@@ -885,6 +888,23 @@ inline auto to_string(std::tuple<Ts...> const& t) -> std::string
     }
 }
 
+//  MSVC supports it but doesn't define __cpp_lib_format until the ABI stablizes, but here
+//  don't care about that, so consider it as supported since VS 2019 16.10 (_MSC_VER 1929)
+#if defined(__cpp_lib_format) || (defined(_MSC_VER) && _MSC_VER >= 1929)
+inline auto to_string(auto&& value, std::string_view fmt) -> std::string
+{
+    return std::vformat(fmt, std::make_format_args(CPP2_FORWARD(value)));
+}
+#else
+inline auto to_string(auto&& value, std::string_view) -> std::string
+{
+    //  This Cpp1 implementation does not support <format>-ted string interpolation
+    //  so the best we can do is ignore the formatting request (degraded operation
+    //  seems better than a dynamic error message string or a hard error)
+    return to_string(CPP2_FORWARD(value));
+}
+#endif
+
 
 //-----------------------------------------------------------------------
 //
diff --git a/regression-tests/pure2-interpolation.cpp2 b/regression-tests/pure2-interpolation.cpp2
@@ -1,14 +1,31 @@
 
+item: @struct type = {
+    name : (this) -> std::string = "Dog kennel";
+    color: (this) -> std::string = "mauve";
+    price: (this) -> double = 3.14;
+    count: (this) -> int = 42;
+}
+
 main: ()->int = {
-    x := 0;
-    std::cout << "g(x)$g(x)$g"  << "\n";
-    std::cout << "(x)$g(x)$g"   << "\n";
-    std::cout << "(x)$g(x)$"    << "\n";
-    std::cout << "(x)$(x)$"     << "\n";
-    std::cout << "\"(x)$\""     << "\n";
-    std::cout << "\"(x)$"       << "\n";
-    std::cout << "\""           << "\n";
-    std::cout << ""             << "\n";
-    std::cout << "pl(ug$h"      << "\n";
-    std::cout << "(x)$pl(ug$h"  << "\n";
+
+    (x := 0) {
+        std::cout << "g(x)$g(x)$g"  << "\n";
+        std::cout << "(x)$g(x)$g"   << "\n";
+        std::cout << "(x)$g(x)$"    << "\n";
+        std::cout << "(x)$(x)$"     << "\n";
+        std::cout << "\"(x)$\""     << "\n";
+        std::cout << "\"(x)$"       << "\n";
+        std::cout << "\""           << "\n";
+        std::cout << ""             << "\n";
+        std::cout << "pl(ug$h"      << "\n";
+        std::cout << "(x)$pl(ug$h"  << "\n";
+
+    }
+
+    (x := item()) {
+        std::cout << std::left << std::setw(20) << x.name() << " color " << std::left << std::setw(10) << x.color() << " price " << std::setw(10) << std::setprecision(3) << x.price() << " in stock = " << std::boolalpha << (x.count() > 0) << "\n";
+
+        std::cout << "(x.name():20)$ color (x.color():10)$ price (x.price(): <10.2f)$ in stock = (x.count() > 0)$\n";
+    }
+
 }
diff --git a/regression-tests/test-results/clang-12/pure2-interpolation.cpp.execution b/regression-tests/test-results/clang-12/pure2-interpolation.cpp.execution
@@ -8,3 +8,5 @@ g0g0g
 
 pl(ug$h
 0pl(ug$h
+Dog kennel           color mauve      price 3.14       in stock = true
+Dog kennel color mauve price 3.140000 in stock = true
diff --git a/regression-tests/test-results/gcc-10/pure2-bugfix-for-requires-clause-in-forward-declaration.cpp.output b/regression-tests/test-results/gcc-10/pure2-bugfix-for-requires-clause-in-forward-declaration.cpp.output
@@ -11,18 +11,18 @@ pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:46: error: expect
 In file included from pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:7:
 ../../../include/cpp2util.h:10005:47: error: static assertion failed: GCC 11 or higher is required to support variables and type-scope functions that have a 'requires' clause. This includes a type-scope 'forward' parameter of non-wildcard type, such as 'func: (this, forward s: std::string)', which relies on being able to add a 'requires' clause - in that case, use 'forward s: _' instead if you need the result to compile with GCC 10.
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:4:1: note: in expansion of macro ‘CPP2_REQUIRES_’
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:3: error: no declaration matches ‘element::element(auto:81&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::__ct ::n)>::type>::type, std::__cxx11::string>’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:3: error: no declaration matches ‘element::element(auto:82&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::__ct ::n)>::type>::type, std::__cxx11::string>’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:5:11: note: candidates are: ‘element::element(const element&)’
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:16:20: note:                 ‘template<class auto:79> element::element(auto:79&&)’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:16:20: note:                 ‘template<class auto:80> element::element(auto:80&&)’
    16 |   public: explicit element(auto&& n)
       |                    ^~~~~~~
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:14:7: note: ‘class element’ defined here
    14 | class element {
       |       ^~~~~~~
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:3: error: expected unqualified-id before ‘{’ token
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:8: error: no declaration matches ‘element& element::operator=(auto:82&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::operator=::n)>::type>::type, std::__cxx11::string>’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:8: error: no declaration matches ‘element& element::operator=(auto:83&&) requires  is_same_v<typename std::remove_cv<typename std::remove_reference<decltype(element::operator=::n)>::type>::type, std::__cxx11::string>’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:6:16: note: candidates are: ‘void element::operator=(const element&)’
-pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:16: note:                 ‘template<class auto:80> element& element::operator=(auto:80&&)’
+pure2-bugfix-for-requires-clause-in-forward-declaration.cpp2:3:16: note:                 ‘template<class auto:81> element& element::operator=(auto:81&&)’
 pure2-bugfix-for-requires-clause-in-forward-declaration.cpp:14:7: note: ‘class element’ defined here
    14 | class element {
       |       ^~~~~~~
diff --git a/regression-tests/test-results/gcc-10/pure2-interpolation.cpp.execution b/regression-tests/test-results/gcc-10/pure2-interpolation.cpp.execution
@@ -8,3 +8,5 @@ g0g0g
 
 pl(ug$h
 0pl(ug$h
+Dog kennel           color mauve      price 3.14       in stock = true
+Dog kennel color mauve price 3.140000 in stock = true
diff --git a/regression-tests/test-results/gcc-13/pure2-interpolation.cpp.execution b/regression-tests/test-results/gcc-13/pure2-interpolation.cpp.execution
@@ -8,3 +8,5 @@ g0g0g
 
 pl(ug$h
 0pl(ug$h
+Dog kennel           color mauve      price 3.14       in stock = true
+Dog kennel           color mauve      price 3.14       in stock = true
diff --git a/regression-tests/test-results/msvc-2022/pure2-interpolation.cpp.execution b/regression-tests/test-results/msvc-2022/pure2-interpolation.cpp.execution
@@ -8,3 +8,5 @@ g0g0g
 
 pl(ug$h
 0pl(ug$h
+Dog kennel           color mauve      price 3.14       in stock = true
+Dog kennel           color mauve      price 3.14       in stock = true
diff --git a/regression-tests/test-results/pure2-interpolation.cpp b/regression-tests/test-results/pure2-interpolation.cpp
@@ -7,29 +7,64 @@
 #include "cpp2util.h"
 
 
+#line 2 "pure2-interpolation.cpp2"
+class item;
+    
 
 //=== Cpp2 type definitions and function declarations ===========================
 
 
 #line 2 "pure2-interpolation.cpp2"
+class item {
+    public: [[nodiscard]] auto name() const& -> std::string;
+    public: [[nodiscard]] auto color() const& -> std::string;
+    public: [[nodiscard]] auto price() const& -> double;
+    public: [[nodiscard]] auto count() const& -> int;
+};
+
 [[nodiscard]] auto main() -> int;
-    
+
 
 //=== Cpp2 function definitions =================================================
 
 
-#line 2 "pure2-interpolation.cpp2"
+#line 3 "pure2-interpolation.cpp2"
+    [[nodiscard]] auto item::name() const& -> std::string { return "Dog kennel";  }
+    [[nodiscard]] auto item::color() const& -> std::string { return "mauve";  }
+    [[nodiscard]] auto item::price() const& -> double { return 3.14;  }
+    [[nodiscard]] auto item::count() const& -> int { return 42;  }
+
+#line 9 "pure2-interpolation.cpp2"
 [[nodiscard]] auto main() -> int{
-    auto x {0}; 
-    std::cout << "g" + cpp2::to_string(x) + "g" + cpp2::to_string(x) + "g"  << "\n";
-    std::cout << cpp2::to_string(x) + "g" + cpp2::to_string(x) + "g"   << "\n";
-    std::cout << cpp2::to_string(x) + "g" + cpp2::to_string(x)    << "\n";
-    std::cout << cpp2::to_string(x) + cpp2::to_string(x)     << "\n";
-    std::cout << "\"" + cpp2::to_string(x) + "\""     << "\n";
-    std::cout << "\"" + cpp2::to_string(x)       << "\n";
-    std::cout << "\""           << "\n";
-    std::cout << ""             << "\n";
-    std::cout << "pl(ug$h"      << "\n";
-    std::cout << cpp2::to_string(std::move(x)) + "pl(ug$h" << "\n";
+{
+auto x = 0;
+
+#line 11 "pure2-interpolation.cpp2"
+    {
+        std::cout << "g" + cpp2::to_string(x) + "g" + cpp2::to_string(x) + "g"  << "\n";
+        std::cout << cpp2::to_string(x) + "g" + cpp2::to_string(x) + "g"   << "\n";
+        std::cout << cpp2::to_string(x) + "g" + cpp2::to_string(x)    << "\n";
+        std::cout << cpp2::to_string(x) + cpp2::to_string(x)     << "\n";
+        std::cout << "\"" + cpp2::to_string(x) + "\""     << "\n";
+        std::cout << "\"" + cpp2::to_string(x)       << "\n";
+        std::cout << "\""           << "\n";
+        std::cout << ""             << "\n";
+        std::cout << "pl(ug$h"      << "\n";
+        std::cout << cpp2::to_string(x) + "pl(ug$h"  << "\n";
+
+    }
+}
+{
+auto x = item();
+
+#line 25 "pure2-interpolation.cpp2"
+    {
+        std::cout << std::left << std::setw(20) << CPP2_UFCS_0(name, x) << " color " << std::left << std::setw(10) << CPP2_UFCS_0(color, x) << " price " << std::setw(10) << std::setprecision(3) << CPP2_UFCS_0(price, x) << " in stock = " << std::boolalpha << (cpp2::cmp_greater(CPP2_UFCS_0(count, x),0)) << "\n";
+
+        std::cout << cpp2::to_string(CPP2_UFCS_0(name, x), "{:20}") + " color " + cpp2::to_string(CPP2_UFCS_0(color, x), "{:10}") + " price " + cpp2::to_string(CPP2_UFCS_0(price, x), "{: <10.2f}") + " in stock = " + cpp2::to_string(cpp2::cmp_greater(CPP2_UFCS_0(count, std::move(x)),0)) + "\n";
+    }
+}
+
+#line 31 "pure2-interpolation.cpp2"
 }
 
diff --git a/regression-tests/test-results/version b/regression-tests/test-results/version
@@ -1,5 +1,5 @@
 
-cppfront compiler v0.2.1   Build 8922:0931
+cppfront compiler v0.2.1   Build 8923:1137
 Copyright(c) Herb Sutter   All rights reserved
 
 SPDX-License-Identifier: CC-BY-NC-ND-4.0
diff --git a/source/build.info b/source/build.info
@@ -1 +1 @@
-"8922:0931"
+"8923:1137"
diff --git a/source/lex.h b/source/lex.h
@@ -434,6 +434,37 @@ auto expand_string_literal(
                 });
                 chunk.erase(last_it, std::end(chunk));
             }
+
+            //  This chunk string is now in the form "(some_capture_text)",
+            //  which might include a :formatter suffix like "(capture_text:formatter)"
+
+            if (std::ssize(chunk) < 1)
+            {
+                errors.emplace_back(
+                    source_position( src_pos.lineno, src_pos.colno + pos ),
+                    "string interpolation must not be empty"
+                );
+                return {};
+            }
+            if (chunk.ends_with(':'))
+            {
+                errors.emplace_back(
+                    source_position( src_pos.lineno, src_pos.colno + pos ),
+                    "string interpolation ':' must be followed by a std::formatter specifier"
+                );
+                return {};
+            }
+
+            //  If there's a :formatter suffix, decorate it as: ,"{:formatter}"
+            if (auto colon = chunk.find_last_of(':');
+                colon != chunk.npos
+                && chunk[colon-1] != ':'    // ignore :: scope resolution
+                )
+            {
+                chunk.insert(colon, ",\"{");
+                chunk.insert(chunk.size()-1, "}\"");
+            }
+
             parts.add_code("cpp2::to_string" + chunk);
 
             current_start = pos+1;
diff --git a/source/parse.h b/source/parse.h
@@ -1883,7 +1883,9 @@ struct statement_node
         std::unique_ptr<jump_statement_node>
     > statement;
 
-    bool emitted = false;   // note field used during lowering
+    bool emitted = false;               // a note field that's used during lowering to Cpp1
+
+    bool marked_for_removal = false;    // for use during metafunctions which may replace members
 
     //  API
     //
@@ -2516,6 +2518,7 @@ struct declaration_node
     std::unique_ptr<statement_node> initializer;
 
     declaration_node*               parent_declaration = {};
+    statement_node*                 my_statement = {};
 
     //  Attributes currently configurable only via metafunction API,
     //  not directly in the base language grammar
@@ -7554,16 +7557,18 @@ class parser
         bool                                 is_template_parameter = false,
         std::unique_ptr<unqualified_id_node> id                    = {},
         accessibility                        access                = {},
-        bool                                 is_variadic           = false
+        bool                                 is_variadic           = false,
+        statement_node const*                my_stmt               = {}
     )
         -> std::unique_ptr<declaration_node>
     {
         auto n = std::make_unique<declaration_node>( current_declarations.back() );
         n->pos = start;
 
-        n->identifier  = std::move(id);
-        n->access      = access;
-        n->is_variadic = is_variadic;
+        n->identifier   = std::move(id);
+        n->access       = access;
+        n->is_variadic  = is_variadic;
+        n->my_statement = my_stmt;
 
         //  If we're in a type scope and the next token is ';', treat this as if
         //  ': _;' without an initializer.
@@ -8217,9 +8222,10 @@ class parser
     //G     private
     //G
     auto declaration(
-        bool semicolon_required    = true,
-        bool is_parameter          = false,
-        bool is_template_parameter = false
+        bool                  semicolon_required    = true,
+        bool                  is_parameter          = false,
+        bool                  is_template_parameter = false,
+        statement_node const* my_stmt               = {}
     )
         -> std::unique_ptr<declaration_node>
     {
@@ -8367,7 +8373,8 @@ class parser
                 is_template_parameter,
                 std::move(id),
                 access,
-                is_variadic
+                is_variadic,
+                my_stmt
             );
             if (!n) {
                 pos = start_pos;    // backtrack
