Merge "Remove 100s of CPU time (10%) from build times (1465s -> 1302s)" into main

src/libexpr/eval.cc

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <chrono>
 #include <iostream>
+#include <sstream>
 #include <cstring>
 #include <optional>
 #include <unistd.h>
@@ -29,7 +30,6 @@
 #include <sys/resource.h>
 #include <fstream>
 #include <functional>
-#include <iostream>
 
 #include <sys/resource.h>
 #include <nlohmann/json.hpp>

src/libexpr/lexer.l

@@ -26,10 +26,9 @@
 #pragma clang diagnostic ignored "-Wimplicit-fallthrough"
 #endif
 
-#include <boost/lexical_cast.hpp>
-
 #include "nixexpr.hh"
 #include "parser-tab.hh"
+#include "strings.hh"
 
 using namespace nix;
 
@@ -132,9 +131,10 @@ or          { return OR_KW; }
 
 {ID}        { yylval->id = {yytext, (size_t) yyleng}; return ID; }
 {INT}       { errno = 0;
-              try {
-                  yylval->n = boost::lexical_cast<int64_t>(yytext);
-              } catch (const boost::bad_lexical_cast &) {
+              std::optional<int64_t> numMay = string2Int<int64_t>(yytext);
+              if (numMay.has_value()) {
+                  yylval->n = *numMay;
+              } else {
                   throw ParseError(ErrorInfo{
                       .msg = HintFmt("invalid integer '%1%'", yytext),
                       .pos = state->positions[CUR_POS],

src/libexpr/nixexpr.cc

@@ -6,6 +6,7 @@
 #include "escape-string.hh"
 
 #include <cstdlib>
+#include <sstream>
 
 namespace nix {
 

src/libexpr/primops.cc

@@ -25,6 +25,7 @@
 
 #include <algorithm>
 #include <cstring>
+#include <sstream>
 #include <regex>
 #include <dlfcn.h>
 

src/libexpr/print.cc

@@ -1,6 +1,7 @@
 #include <limits>
 #include <span>
 #include <unordered_set>
+#include <sstream>
 
 #include "escape-string.hh"
 #include "print.hh"

src/libmain/progress-bar.cc

@@ -7,6 +7,7 @@
 #include <atomic>
 #include <map>
 #include <thread>
+#include <sstream>
 #include <iostream>
 #include <chrono>
 

src/libstore/binary-cache-store.cc

@@ -16,6 +16,7 @@
 #include <future>
 #include <regex>
 #include <fstream>
+#include <sstream>
 
 #include <nlohmann/json.hpp>
 

src/libstore/build/local-derivation-goal.cc

@@ -64,10 +64,13 @@ extern "C" int sandbox_init_with_parameters(const char *profile, uint64_t flags,
 
 namespace nix {
 
+namespace {
 /**
  * The system for which Nix is compiled.
  */
-constexpr std::string_view nativeSystem = SYSTEM;
+[[gnu::unused]]
+constexpr const std::string_view nativeSystem = SYSTEM;
+}
 
 void handleDiffHook(
     uid_t uid, uid_t gid,

src/libstore/daemon.cc

@@ -14,6 +14,8 @@
 #include "derivations.hh"
 #include "args.hh"
 
+#include <sstream>
+
 namespace nix::daemon {
 
 Sink & operator << (Sink & sink, const Logger::Fields & fields)

src/libstore/machines.cc

@@ -140,7 +140,7 @@ static Machine parseBuilderLine(const std::string & line)
     };
 
     auto parseFloatField = [&](size_t fieldIndex) {
-        const auto result = string2Int<float>(tokens[fieldIndex]);
+        const auto result = string2Float<float>(tokens[fieldIndex]);
         if (!result) {
             throw FormatError("bad machine specification: failed to convert column #%lu in a row: '%s' to 'float'", fieldIndex, line);
         }

src/libutil/current-process.cc

@@ -5,6 +5,7 @@
 #include "namespaces.hh"
 #include "signals.hh"
 #include "strings.hh"
+#include <math.h>
 
 #ifdef __APPLE__
 # include <mach-o/dyld.h>

src/libutil/file-system.hh

@@ -13,8 +13,6 @@
 #include <dirent.h>
 #include <unistd.h>
 
-#include <boost/lexical_cast.hpp>
-
 #include <functional>
 #include <optional>
 

src/libutil/logging.cc

@@ -6,6 +6,7 @@
 #include "terminal.hh"
 
 #include <atomic>
+#include <sstream>
 #include <nlohmann/json.hpp>
 
 namespace nix {

src/libutil/processes.hh

@@ -10,8 +10,6 @@
 #include <unistd.h>
 #include <signal.h>
 
-#include <boost/lexical_cast.hpp>
-
 #include <functional>
 #include <map>
 #include <optional>

src/libutil/strings.cc

@@ -1,4 +1,6 @@
 #include "strings.hh"
+#include <boost/lexical_cast.hpp>
+#include <stdint.h>
 
 namespace nix {
 
@@ -89,6 +91,43 @@ std::string Rewriter::operator()(std::string s)
     return s;
 }
 
+template<class N>
+std::optional<N> string2Int(const std::string_view s)
+{
+    if (s.substr(0, 1) == "-" && !std::numeric_limits<N>::is_signed)
+        return std::nullopt;
+    try {
+        return boost::lexical_cast<N>(s.data(), s.size());
+    } catch (const boost::bad_lexical_cast &) {
+        return std::nullopt;
+    }
+}
+
+// Explicitly instantiated in one place for faster compilation
+template std::optional<unsigned char>  string2Int<unsigned char>(const std::string_view s);
+template std::optional<unsigned short> string2Int<unsigned short>(const std::string_view s);
+template std::optional<unsigned int> string2Int<unsigned int>(const std::string_view s);
+template std::optional<unsigned long> string2Int<unsigned long>(const std::string_view s);
+template std::optional<unsigned long long> string2Int<unsigned long long>(const std::string_view s);
+template std::optional<signed char> string2Int<signed char>(const std::string_view s);
+template std::optional<signed short> string2Int<signed short>(const std::string_view s);
+template std::optional<signed int> string2Int<signed int>(const std::string_view s);
+template std::optional<signed long> string2Int<signed long>(const std::string_view s);
+template std::optional<signed long long> string2Int<signed long long>(const std::string_view s);
+
+template<class N>
+std::optional<N> string2Float(const std::string_view s)
+{
+    try {
+        return boost::lexical_cast<N>(s.data(), s.size());
+    } catch (const boost::bad_lexical_cast &) {
+        return std::nullopt;
+    }
+}
+
+template std::optional<double> string2Float<double>(const std::string_view s);
+template std::optional<float> string2Float<float>(const std::string_view s);
+
 
 std::string toLower(const std::string & s)
 {

src/libutil/strings.hh

@@ -4,7 +4,6 @@
 #include "error.hh"
 #include "types.hh"
 
-#include <boost/lexical_cast.hpp>
 #include <vector>
 
 namespace nix {
@@ -130,16 +129,7 @@ inline std::string rewriteStrings(std::string s, const StringMap & rewrites)
  * Parse a string into an integer.
  */
 template<class N>
-std::optional<N> string2Int(const std::string_view s)
-{
-    if (s.substr(0, 1) == "-" && !std::numeric_limits<N>::is_signed)
-        return std::nullopt;
-    try {
-        return boost::lexical_cast<N>(s.data(), s.size());
-    } catch (const boost::bad_lexical_cast &) {
-        return std::nullopt;
-    }
-}
+std::optional<N> string2Int(const std::string_view s);
 
 /**
  * Like string2Int(), but support an optional suffix 'K', 'M', 'G' or
@@ -169,14 +159,7 @@ N string2IntWithUnitPrefix(std::string_view s)
  * Parse a string into a float.
  */
 template<class N>
-std::optional<N> string2Float(const std::string_view s)
-{
-    try {
-        return boost::lexical_cast<N>(s.data(), s.size());
-    } catch (const boost::bad_lexical_cast &) {
-        return std::nullopt;
-    }
-}
+std::optional<N> string2Float(const std::string_view s);
 
 
 /**

src/nix-env/user-env.cc

@@ -9,8 +9,9 @@
 #include "eval-inline.hh"
 #include "profiles.hh"
 #include "print-ambiguous.hh"
-#include <limits>
 
+#include <limits>
+#include <sstream>
 
 namespace nix {
 

src/nix/develop.cc

@@ -11,6 +11,7 @@
 
 #include <iterator>
 #include <memory>
+#include <sstream>
 #include <nlohmann/json.hpp>
 #include <algorithm>