Get BOUT++ ready for C++20 (master)

include/bout/boutexception.hxx

@@ -19,8 +19,9 @@ public:
   BoutException(std::string msg);
 
   template <class S, class... Args>
-  BoutException(const S& format, const Args&... args)
-      : BoutException(fmt::format(format, args...)) {}
+  BoutException(S&& format, Args&&... args)
+      : BoutException(fmt::format(fmt::runtime(std::forward<S>(format)),
+                                  std::forward<decltype(args)>(args)...)) {}
 
   ~BoutException() override;
 
@@ -46,16 +47,18 @@ class BoutRhsFail : public BoutException {
 public:
   BoutRhsFail(std::string message) : BoutException(std::move(message)) {}
   template <class S, class... Args>
-  BoutRhsFail(const S& format, const Args&... args)
-      : BoutRhsFail(fmt::format(format, args...)) {}
+  BoutRhsFail(S&& format, Args&&... args)
+      : BoutRhsFail(fmt::format(fmt::runtime(std::forward<S>(format)),
+                                std::forward<decltype(args)>(args)...)) {}
 };
 
 class BoutIterationFail : public BoutException {
 public:
   BoutIterationFail(std::string message) : BoutException(std::move(message)) {}
   template <class S, class... Args>
-  BoutIterationFail(const S& format, const Args&... args)
-      : BoutIterationFail(fmt::format(format, args...)) {}
+  BoutIterationFail(S&& format, Args&&... args)
+      : BoutIterationFail(fmt::format(fmt::runtime(std::forward<S>(format)),
+                                      std::forward<decltype(args)>(args)...)) {}
 };
 
 #endif

include/bout/msg_stack.hxx

@@ -76,7 +76,7 @@ public:
 
   template <class S, class... Args>
   int push(const S& format, const Args&... args) {
-    return push(fmt::format(format, args...));
+    return push(fmt::format(fmt::runtime(format), args...));
   }
 
   void pop();       ///< Remove the last message
@@ -145,8 +145,8 @@ public:
 
   template <class S, class... Args>
   MsgStackItem(const std::string& file, int line, const S& msg, const Args&... args)
-      : point(msg_stack.push("{:s} on line {:d} of '{:s}'", fmt::format(msg, args...),
-                             line, file)) {}
+      : point(msg_stack.push("{:s} on line {:d} of '{:s}'",
+                             fmt::format(fmt::runtime(msg), args...), line, file)) {}
   ~MsgStackItem() {
     // If an exception has occurred, don't pop the message
     if (exception_count == std::uncaught_exceptions()) {

include/bout/optionsreader.hxx

@@ -71,7 +71,7 @@ public:
 
   template <class S, class... Args>
   void read(Options* options, const S& format, const Args&... args) {
-    return read(options, fmt::format(format, args...));
+    return read(options, fmt::format(fmt::runtime(format), args...));
   }
 
   /// Write options to file
@@ -82,7 +82,7 @@ public:
 
   template <class S, class... Args>
   void write(Options* options, const S& format, const Args&... args) {
-    return write(options, fmt::format(format, args...));
+    return write(options, fmt::format(fmt::runtime(format), args...));
   }
 
   /// Parse options from the command line

include/bout/output.hxx

@@ -76,7 +76,8 @@ public:
   }
 
   template <class S, class... Args>
-  Output(const S& format, const Args&... args) : Output(fmt::format(format, args...)) {}
+  Output(const S& format, const Args&... args)
+      : Output(fmt::format(fmt::runtime(format), args...)) {}
 
   ~Output() override { close(); }
 
@@ -88,7 +89,7 @@ public:
 
   template <class S, class... Args>
   int open(const S& format, const Args&... args) {
-    return open(fmt::format(format, args...));
+    return open(fmt::format(fmt::runtime(format), args...));
   }
 
   /// Close the log file
@@ -99,14 +100,14 @@ public:
 
   template <class S, class... Args>
   void write(const S& format, const Args&... args) {
-    write(fmt::format(format, args...));
+    write(fmt::format(fmt::runtime(format), args...));
   }
   /// Same as write, but only to screen
   virtual void print(const std::string& message);
 
   template <class S, class... Args>
   void print(const S& format, const Args&... args) {
-    print(fmt::format(format, args...));
+    print(fmt::format(fmt::runtime(format), args...));
   }
 
   /// Add an output stream. All output will be sent to all streams
@@ -173,7 +174,8 @@ public:
   void write(const S& format, const Args&... args) {
     if (enabled) {
       ASSERT1(base != nullptr);
-      base->write(fmt::format(format, args...));
+      base->write(
+          fmt::format(fmt::runtime(format), std::forward<decltype(args)>(args)...));
     }
   }
 
@@ -185,7 +187,8 @@ public:
   void print(const S& format, const Args&... args) {
     if (enabled) {
       ASSERT1(base != nullptr);
-      base->print(fmt::format(format, args...));
+      base->print(
+          fmt::format(fmt::runtime(format), std::forward<decltype(args)>(args)...));
     }
   }
 

include/bout/sys/expressionparser.hxx

@@ -249,7 +249,7 @@ public:
 
   template <class S, class... Args>
   ParseException(const S& format, const Args&... args)
-      : message(fmt::format(format, args...)) {}
+      : message(fmt::format(fmt::runtime(format), args...)) {}
 
   ~ParseException() override = default;
 

include/bout/utils.hxx

@@ -187,6 +187,7 @@ typename std::vector<T, Alloc>::size_type erase_if(std::vector<T, Alloc>& c, Pre
   return r;
 }
 #else
+using std::erase;
 using std::erase_if;
 #endif
 } // namespace utils

src/bout++.cxx

@@ -337,7 +337,7 @@ template <class Factory>
   // type. Note that this does require all the options are used in the
   // constructor, and not in a `init` method or similar
   std::cout << fmt::format("Input options for {} '{}':\n\n", Factory::type_name, type);
-  std::cout << fmt::format("{:id}\n", help_options);
+  std::cout << fmt::format(fmt::runtime("{:id}\n"), help_options);
   std::exit(EXIT_SUCCESS);
 }
 

src/mesh/impls/bout/boutmesh.cxx

@@ -163,14 +163,16 @@ CheckMeshResult checkBoutMeshYDecomposition(int num_y_processors, int ny,
   // Check size of Y mesh if we've got multiple processors in Y
   if (num_local_y_points < num_y_guards and num_y_processors != 1) {
     return {false,
-            fmt::format(_("\t -> ny/NYPE ({:d}/{:d} = {:d}) must be >= MYG ({:d})\n"), ny,
-                        num_y_processors, num_local_y_points, num_y_guards)};
+            fmt::format(fmt::runtime(_(
+                            "\t -> ny/NYPE ({:d}/{:d} = {:d}) must be >= MYG ({:d})\n")),
+                        ny, num_y_processors, num_local_y_points, num_y_guards)};
   }
   // Check branch cuts
   if ((jyseps1_1 + 1) % num_local_y_points != 0) {
-    return {false, fmt::format(_("\t -> Leg region jyseps1_1+1 ({:d}) must be a "
-                                 "multiple of MYSUB ({:d})\n"),
-                               jyseps1_1 + 1, num_local_y_points)};
+    return {false,
+            fmt::format(fmt::runtime(_("\t -> Leg region jyseps1_1+1 ({:d}) must be a "
+                                       "multiple of MYSUB ({:d})\n")),
+                        jyseps1_1 + 1, num_local_y_points)};
   }
 
   if (jyseps2_1 != jyseps1_2) {
@@ -179,50 +181,57 @@ CheckMeshResult checkBoutMeshYDecomposition(int num_y_processors, int ny,
     if ((jyseps2_1 - jyseps1_1) % num_local_y_points != 0) {
       return {
           false,
-          fmt::format(_("\t -> Core region jyseps2_1-jyseps1_1 ({:d}-{:d} = {:d}) must "
-                        "be a multiple of MYSUB ({:d})\n"),
+          fmt::format(fmt::runtime(_(
+                          "\t -> Core region jyseps2_1-jyseps1_1 ({:d}-{:d} = {:d}) must "
+                          "be a multiple of MYSUB ({:d})\n")),
                       jyseps2_1, jyseps1_1, jyseps2_1 - jyseps1_1, num_local_y_points)};
     }
 
     if ((jyseps2_2 - jyseps1_2) % num_local_y_points != 0) {
       return {
           false,
-          fmt::format(_("\t -> Core region jyseps2_2-jyseps1_2 ({:d}-{:d} = {:d}) must "
-                        "be a multiple of MYSUB ({:d})\n"),
+          fmt::format(fmt::runtime(_(
+                          "\t -> Core region jyseps2_2-jyseps1_2 ({:d}-{:d} = {:d}) must "
+                          "be a multiple of MYSUB ({:d})\n")),
                       jyseps2_2, jyseps1_2, jyseps2_2 - jyseps1_2, num_local_y_points)};
     }
 
     // Check upper legs
     if ((ny_inner - jyseps2_1 - 1) % num_local_y_points != 0) {
-      return {
-          false,
-          fmt::format(_("\t -> leg region ny_inner-jyseps2_1-1 ({:d}-{:d}-1 = {:d}) must "
-                        "be a multiple of MYSUB ({:d})\n"),
-                      ny_inner, jyseps2_1, ny_inner - jyseps2_1 - 1, num_local_y_points)};
+      return {false,
+              fmt::format(
+                  fmt::runtime(
+                      _("\t -> leg region ny_inner-jyseps2_1-1 ({:d}-{:d}-1 = {:d}) must "
+                        "be a multiple of MYSUB ({:d})\n")),
+                  ny_inner, jyseps2_1, ny_inner - jyseps2_1 - 1, num_local_y_points)};
     }
     if ((jyseps1_2 - ny_inner + 1) % num_local_y_points != 0) {
-      return {
-          false,
-          fmt::format(_("\t -> leg region jyseps1_2-ny_inner+1 ({:d}-{:d}+1 = {:d}) must "
-                        "be a multiple of MYSUB ({:d})\n"),
-                      jyseps1_2, ny_inner, jyseps1_2 - ny_inner + 1, num_local_y_points)};
+      return {false,
+              fmt::format(
+                  fmt::runtime(
+                      _("\t -> leg region jyseps1_2-ny_inner+1 ({:d}-{:d}+1 = {:d}) must "
+                        "be a multiple of MYSUB ({:d})\n")),
+                  jyseps1_2, ny_inner, jyseps1_2 - ny_inner + 1, num_local_y_points)};
     }
   } else {
     // Single Null
     if ((jyseps2_2 - jyseps1_1) % num_local_y_points != 0) {
       return {
           false,
-          fmt::format(_("\t -> Core region jyseps2_2-jyseps1_1 ({:d}-{:d} = {:d}) must "
-                        "be a multiple of MYSUB ({:d})\n"),
+          fmt::format(fmt::runtime(_(
+                          "\t -> Core region jyseps2_2-jyseps1_1 ({:d}-{:d} = {:d}) must "
+                          "be a multiple of MYSUB ({:d})\n")),
                       jyseps2_2, jyseps1_1, jyseps2_2 - jyseps1_1, num_local_y_points)};
     }
   }
 
   if ((ny - jyseps2_2 - 1) % num_local_y_points != 0) {
-    return {false, fmt::format(
-                       _("\t -> leg region ny-jyseps2_2-1 ({:d}-{:d}-1 = {:d}) must be a "
-                         "multiple of MYSUB ({:d})\n"),
-                       ny, jyseps2_2, ny - jyseps2_2 - 1, num_local_y_points)};
+    return {
+        false,
+        fmt::format(fmt::runtime(_(
+                        "\t -> leg region ny-jyseps2_2-1 ({:d}-{:d}-1 = {:d}) must be a "
+                        "multiple of MYSUB ({:d})\n")),
+                    ny, jyseps2_2, ny - jyseps2_2 - 1, num_local_y_points)};
   }
 
   return {true, ""};

src/sys/boutexception.cxx

@@ -3,7 +3,6 @@
 #include <bout/boutcomm.hxx>
 #include <bout/boutexception.hxx>
 #include <bout/msg_stack.hxx>
-#include <bout/utils.hxx>
 #include <mpi.h>
 
 #if BOUT_USE_BACKTRACE

src/sys/expressionparser.cxx

@@ -333,13 +333,15 @@ may need to change your input file.
 
     // No matches, just point out the error
     if (possible_matches.empty()) {
-      return fmt::format(message_template, name, problem_bit);
+      return fmt::format(fmt::runtime(message_template), name, problem_bit);
     }
 
     // Give the first suggestion as a possible alternative
-    std::string error_message = fmt::format(message_template, name, problem_bit);
-    error_message += fmt::format(_("\n  {1: ^{2}}{0}\n  Did you mean '{0}'?"),
-                                 possible_matches.begin()->name, "", start);
+    std::string error_message =
+        fmt::format(fmt::runtime(message_template), name, problem_bit);
+    error_message +=
+        fmt::format(fmt::runtime(_("\n  {1: ^{2}}{0}\n  Did you mean '{0}'?")),
+                    possible_matches.begin()->name, "", start);
     return error_message;
   };
 

src/sys/options.cxx

@@ -748,7 +748,8 @@ Array<BoutReal> Options::as<Array<BoutReal>>(const Array<BoutReal>& similar_to)
   Array<BoutReal> result = bout::utils::visit(
       ConvertContainer<Array<BoutReal>>{
           fmt::format(
-              _("Value for option {:s} cannot be converted to an Array<BoutReal>"),
+              fmt::runtime(
+                  _("Value for option {:s} cannot be converted to an Array<BoutReal>")),
               full_name),
           similar_to},
       value);
@@ -770,7 +771,8 @@ Matrix<BoutReal> Options::as<Matrix<BoutReal>>(const Matrix<BoutReal>& similar_t
   auto result = bout::utils::visit(
       ConvertContainer<Matrix<BoutReal>>{
           fmt::format(
-              _("Value for option {:s} cannot be converted to an Matrix<BoutReal>"),
+              fmt::runtime(
+                  _("Value for option {:s} cannot be converted to an Matrix<BoutReal>")),
               full_name),
           similar_to},
       value);
@@ -792,7 +794,8 @@ Tensor<BoutReal> Options::as<Tensor<BoutReal>>(const Tensor<BoutReal>& similar_t
   auto result = bout::utils::visit(
       ConvertContainer<Tensor<BoutReal>>{
           fmt::format(
-              _("Value for option {:s} cannot be converted to an Tensor<BoutReal>"),
+              fmt::runtime(
+                  _("Value for option {:s} cannot be converted to an Tensor<BoutReal>")),
               full_name),
           similar_to},
       value);
@@ -1083,20 +1086,22 @@ bout::details::OptionsFormatterBase::format(const Options& options,
   // Get all the child values first
   for (const auto& child : children) {
     if (child.second.isValue()) {
-      fmt::format_to(ctx.out(), format_string, child.second);
+      fmt::format_to(ctx.out(), fmt::runtime(format_string), child.second);
       fmt::format_to(ctx.out(), "\n");
     }
   }
 
   // Now descend the tree, accumulating subsections
   for (const auto& subsection : options.subsections()) {
-    fmt::format_to(ctx.out(), format_string, *subsection.second);
+    fmt::format_to(ctx.out(), fmt::runtime(format_string), *subsection.second);
   }
 
   return ctx.out();
 }
 
-std::string toString(const Options& value) { return fmt::format("{}", value); }
+std::string toString(const Options& value) {
+  return fmt::format(fmt::runtime("{}"), value);
+}
 
 namespace bout {
 void checkForUnusedOptions() {
@@ -1142,7 +1147,7 @@ void checkForUnusedOptions(const Options& options, const std::string& data_dir,
       }
       possible_misspellings += fmt::format("\nUnused option '{}', did you mean:\n", key);
       for (const auto& match : fuzzy_matches) {
-        possible_misspellings += fmt::format("\t{:idk}\n", match.match);
+        possible_misspellings += fmt::format(fmt::runtime("\t{:idk}\n"), match.match);
       }
     }
 

src/sys/options/options_ini.cxx

@@ -161,7 +161,7 @@ void OptionINI::write(Options* options, const std::string& filename) {
   }
 
   // Call recursive function to write to file
-  fout << fmt::format("{:uds}", *options);
+  fout << fmt::format(fmt::runtime("{:uds}"), *options);
 
   fout.close();
 }

tests/unit/fake_mesh.hxx

@@ -212,18 +212,17 @@ public:
                                  "RGN_OUTER_X"};
 
     // Sum up and get unique points in the boundaries defined above
-    addRegion2D("RGN_BNDRY",
-                std::accumulate(begin(boundary_names), end(boundary_names),
-                                Region<Ind2D>{},
-                                [this](Region<Ind2D>& a, const std::string& b) {
-                                  return a + getRegion2D(b);
-                                })
-                    .unique());
+    addRegion2D("RGN_BNDRY", std::accumulate(begin(boundary_names), end(boundary_names),
+                                             Region<Ind2D>{},
+                                             [&](Region<Ind2D> a, const std::string& b) {
+                                               return a + getRegion2D(b);
+                                             })
+                                 .unique());
 
     addRegion3D("RGN_BNDRY",
                 std::accumulate(begin(boundary_names), end(boundary_names),
                                 Region<Ind3D>{},
-                                [this](Region<Ind3D>& a, const std::string& b) {
+                                [this](Region<Ind3D> a, const std::string& b) {
                                   return a + getRegion3D(b);
                                 })
                     .unique());