Keep symbolic floating defaults in GetFunctionArgDefault

The printed default of a floating-typed parameter need not be a numeric
literal (double ratio = kDefaultRatio, arrow's pool = default_memory_pool()
style); std::stod then throws std::invalid_argument into exception-free
LLVM code and the process terminates. Parse with strtod non-throwingly
(full consumption + ERANGE checked) and keep the printed spelling when the
default is not a plain literal; literals keep the precision normalization
the code exists for.

Co-developed-with-the-help-of: Claude Code (Fable 5, human in the loop)

Author: Emery Conrad

lib/CppInterOp/CppInterOp.cpp

@@ -103,6 +103,7 @@
 #include <algorithm>
 #include <array>
 #include <cassert>
+#include <cerrno>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
@@ -5502,10 +5503,21 @@ std::string GetFunctionArgDefault(ConstFuncRef func, size_t param_index) {
     if (PI->getType()->isFloatingType()) {
       if (!Result.empty() && Result.back() == '.')
         return INTEROP_RETURN(Result);
-      auto DefaultArgValue = std::stod(Result);
-      std::ostringstream oss;
-      oss << DefaultArgValue;
-      Result = oss.str();
+      // The printed default need not be a numeric literal (an identifier
+      // such as `kDefaultRatio`, or a call such as `quiet_NaN()`); std::stod
+      // would throw std::invalid_argument, and this library is built
+      // without exception support, so the throw terminates the process.
+      // Parse non-throwingly and keep the printed spelling when the default
+      // is not a plain literal.
+      errno = 0;
+      char* ParseEnd = nullptr;
+      double DefaultArgValue = std::strtod(Result.c_str(), &ParseEnd);
+      if (ParseEnd != Result.c_str() && ParseEnd != nullptr &&
+          *ParseEnd == '\0' && errno != ERANGE) {
+        std::ostringstream oss;
+        oss << DefaultArgValue;
+        Result = oss.str();
+      }
     }
     return INTEROP_RETURN(Result);
   }

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -2903,6 +2903,31 @@ TYPED_TEST(CPPINTEROP_TEST_MODE, FunctionReflection_GetFunctionArgDefault) {
   EXPECT_EQ(Cpp::GetFunctionArgDefault(fn, 1), "S()");
 }
 
+TYPED_TEST(CPPINTEROP_TEST_MODE,
+           FunctionReflection_GetFunctionArgDefaultSymbolic) {
+  std::vector<Decl*> Decls;
+  std::string code = R"(
+    constexpr double kDefaultRatio = 0.5;
+    double default_ratio();
+    double scaled(double ratio = kDefaultRatio);
+    double rescaled(double ratio = default_ratio());
+    double inverted(double ratio = 2.0 / kDefaultRatio);
+    double pi_ish(double p = 3.14);
+    )";
+
+  GetAllTopLevelDecls(code, Decls);
+
+  // A floating-typed default need not be a numeric literal. Formatting a
+  // symbolic default must not throw (std::stod would terminate the
+  // exception-free build) and must preserve the printed spelling.
+  EXPECT_EQ(Cpp::GetFunctionArgDefault(Decls[2], 0), "kDefaultRatio");
+  EXPECT_EQ(Cpp::GetFunctionArgDefault(Decls[3], 0), "default_ratio()");
+  // Starts with a valid literal but has trailing text: spelling preserved.
+  EXPECT_EQ(Cpp::GetFunctionArgDefault(Decls[4], 0), "2. / kDefaultRatio");
+  // Plain literals keep the precision normalization.
+  EXPECT_EQ(Cpp::GetFunctionArgDefault(Decls[5], 0), "3.14");
+}
+
 TYPED_TEST(CPPINTEROP_TEST_MODE, FunctionReflection_Construct) {
 #ifdef _WIN32
   GTEST_SKIP() << "Disabled on Windows. Needs fixing.";