Prioritize custom printers over default aggregate printing.

This change makes `AbslStringify` and `FuzzTestPrintSourceCode` take precedence over the default field-level printing for aggregate types. If a custom printer is defined for a type, it will be used for both human-readable and source-code modes, with fallback between `AbslStringify` and `FuzzTestPrintSourceCode`. The documentation is updated to reflect this behavior.

This reduces the amount of boilerplate that the user has to write to override the default field-level printing: with the change, it suffices to define `AbslStringify`. This is important for aggregate types that have a nested C-style array, for which the aggregate detection yields a compile-time error.

PiperOrigin-RevId: 868817106

Author: fniksic

doc/domains-reference.md

@@ -894,10 +894,11 @@ support seeds.
 ## Customizing Value Printers
 
 FuzzTest provides a mechanism to display the values that cause a test to fail.
-By default, it knows how to print standard C++ types, but you can extend this
-system to support your own custom types. This is especially useful for making
-test failure reports clear and actionable. There are two ways FuzzTest prints
-values, and you can customize the output for each:
+By default, it knows how to print standard C++ types, including aggregate types
+like tuples and simple structs, but you can extend this system to support your
+own custom types. This is especially useful for making test failure reports
+clear and actionable. There are two ways FuzzTest prints values, and you can
+customize the output for each:
 
 -   Human-readable mode: This mode is designed to be easily read and understood
     by a developer. The goal is clarity, not necessarily compilable code.
@@ -907,9 +908,22 @@ values, and you can customize the output for each:
 
 ### Customizing the human-readable printer
 
-The simplest and most recommended way to implement custom printing for your
-types is to implement `AbslStringify`. This hooks into Abseil's string
-formatting library, which FuzzTest uses internally. For example:
+For aggregate types (like simple structs), FuzzTest already provides a default
+printer that performs field-level printing, but without field names. For
+example, if you have:
+
+```c++
+struct MyObject {
+  int id;
+  std::string name;
+};
+```
+
+The default output for `MyObject{1, "Alice"}` will be `MyObject{1, "Alice"}`.
+
+To customize the output, the simplest and most recommended way is to implement
+`AbslStringify`. This hooks into Abseil's string formatting library, which
+FuzzTest uses internally. For example:
 
 ```c++
 struct MyObject {
@@ -918,11 +932,18 @@ struct MyObject {
 
   template <typename Sink>
   friend void AbslStringify(Sink& sink, const MyObject& obj) {
-    absl::Format(&sink, "MyObject[%d](name=\"%s\")", obj.id, obj.name);
+    absl::Format(&sink, "MyObject{.id = %d, .name = \"%s\"}", obj.id, obj.name);
   }
 };
 ```
 
+Now the output for `MyObject{1, "Alice"}` will be
+`MyObject{.id = 1, .name = "Alice"}`.
+
+WARNING: If your aggregate type contains a nested C-style array, the default
+field-type printing may yield a compile-time error. In this case, you should
+define a custom printer as a workaround.
+
 ### Customizing the source code printer
 
 To provide a custom source code representation (which is used in regression
@@ -953,9 +974,6 @@ If you define only one of `AbslStringify` and `FuzzTestPrintSourceCode`,
 FuzzTest will use the defined function for both the human-readable and the
 source-code mode. If you define both, FuzzTest will use `AbslStringify` for the
 human-readable mode, and `FuzzTestPrintSourceCode` for the source-code mode.
-Note that this fallback behavior primarily applies to non-aggregate types. For
-aggregate types (like simple structs), FuzzTest prefers field-level printing for
-the mode that doesn't have a custom extension point.
 
 NOTE: FuzzTest does not validate the output. You are responsible for ensuring
 that in the source-code mode, the function prints a valid C++ expression that

fuzztest/internal/type_support.h

@@ -221,6 +221,60 @@ struct StringPrinter {
   }
 };
 
+// A wrapper around `RawSink` that can be passed to the user's
+// `FuzzTestPrintSourceCode` function, a FTADLE extension point for custom
+// printers. This is so that the function can look more like `AbslStringify`,
+// which is parameterized by the sink type and passes a pointer to the sink to
+// `absl::Format()`.
+struct RawSinkWrapper {
+  domain_implementor::RawSink& raw_sink;
+
+  friend void AbslFormatFlush(RawSinkWrapper* absl_nonnull sink,
+                              absl::string_view part) {
+    absl::Format(sink->raw_sink, "%s", part);
+  }
+};
+
+template <typename T, typename = void>
+struct HasCustomSourceCodePrinter : std::false_type {};
+
+template <typename T>
+struct HasCustomSourceCodePrinter<
+    T, std::enable_if_t<std::is_void<decltype(FuzzTestPrintSourceCode(
+           std::declval<RawSinkWrapper&>(), std::declval<const T&>()))>::value>>
+    : std::true_type {};
+
+template <typename T>
+inline constexpr bool has_custom_source_code_printer_v =
+    HasCustomSourceCodePrinter<T>::value;
+
+template <typename T>
+inline constexpr bool has_custom_printer_v =
+    has_absl_stringify_v<T> || has_custom_source_code_printer_v<T>;
+
+template <typename T, typename = std::enable_if_t<has_custom_printer_v<T>>>
+struct CustomPrinter {
+  void PrintUserValue(const T& v, domain_implementor::RawSink out,
+                      domain_implementor::PrintMode mode) {
+    RawSinkWrapper sink{out};
+    if (mode == domain_implementor::PrintMode::kHumanReadable) {
+      // Prefer AbslStringify, fall back on source code printer.
+      if constexpr (has_absl_stringify_v<T>) {
+        absl::Format(out, "%v", v);
+      } else {
+        FuzzTestPrintSourceCode(sink, v);
+      }
+    } else {
+      // Prefer source code printer, fall back on AbslStringify.
+      if constexpr (has_custom_source_code_printer_v<T>) {
+        FuzzTestPrintSourceCode(sink, v);
+      } else {
+        absl::Format(out, "%v", v);
+      }
+    }
+  }
+};
+
 template <typename DomainT, typename... Inner>
 struct AggregatePrinter {
   const DomainT& domain;
@@ -230,12 +284,11 @@ struct AggregatePrinter {
   void PrintCorpusValue(const corpus_type_t<DomainT>& v,
                         domain_implementor::RawSink out,
                         domain_implementor::PrintMode mode) const {
-    if (mode == domain_implementor::PrintMode::kHumanReadable) {
-      // In human-readable mode, prefer formatting with Abseil if possible.
-      if constexpr (has_absl_stringify_v<value_type_t<DomainT>>) {
-        absl::Format(out, "%v", domain.GetValue(v));
-        return;
-      }
+    if constexpr (has_custom_printer_v<value_type_t<DomainT>>) {
+      // Prefer the custom printer if there is one.
+      CustomPrinter<value_type_t<DomainT>>{}.PrintUserValue(domain.GetValue(v),
+                                                            out, mode);
+      return;
     }
 
     absl::Format(out, "%s", type_name);
@@ -543,55 +596,10 @@ struct TimePrinter {
   }
 };
 
-// A wrapper around `RawSink` that can be passed to the user's
-// `FuzzTestPrintSourceCode` function, a FTADLE extension point for custom
-// printers. This is so that the function can look more like `AbslStringify`,
-// which is parameterized by the sink type and passes a pointer to the sink to
-// `absl::Format()`.
-struct RawSinkWrapper {
-  domain_implementor::RawSink& raw_sink;
-
-  friend void AbslFormatFlush(RawSinkWrapper* absl_nonnull sink,
-                              absl::string_view part) {
-    absl::Format(sink->raw_sink, "%s", part);
-  }
-};
-
-template <typename T, typename = void>
-struct HasCustomSourceCodePrinter : std::false_type {};
-
-template <typename T>
-struct HasCustomSourceCodePrinter<
-    T, std::enable_if_t<std::is_void<decltype(FuzzTestPrintSourceCode(
-           std::declval<RawSinkWrapper&>(), std::declval<const T&>()))>::value>>
-    : std::true_type {};
-
-template <typename T>
-inline constexpr bool has_custom_source_code_printer_v =
-    HasCustomSourceCodePrinter<T>::value;
-
-template <typename T>
-inline constexpr bool has_custom_printer_v =
-    has_absl_stringify_v<T> || has_custom_source_code_printer_v<T>;
-
 struct AutodetectAggregatePrinter {
   template <typename T>
   void PrintUserValue(const T& v, domain_implementor::RawSink out,
                       domain_implementor::PrintMode mode) {
-    if (mode == domain_implementor::PrintMode::kHumanReadable) {
-      // In human-readable mode, prefer formatting with Abseil if possible.
-      if constexpr (has_absl_stringify_v<T>) {
-        absl::Format(out, "%v", v);
-        return;
-      }
-    } else {
-      // In source-code mode, prefer custom source-code printer if possible.
-      if constexpr (has_custom_source_code_printer_v<T>) {
-        RawSinkWrapper sink{out};
-        FuzzTestPrintSourceCode(sink, v);
-        return;
-      }
-    }
     std::tuple bound = DetectBindAggregate(v);
     const auto print_one = [&](auto I) {
       if (I > 0) absl::Format(out, ", ");
@@ -606,40 +614,11 @@ struct AutodetectAggregatePrinter {
   }
 };
 
-template <typename T, typename = std::enable_if_t<has_custom_printer_v<T>>>
-struct CustomPrinter {
-  void PrintUserValue(const T& v, domain_implementor::RawSink out,
-                      domain_implementor::PrintMode mode) {
-    RawSinkWrapper sink{out};
-    if (mode == domain_implementor::PrintMode::kHumanReadable) {
-      // Prefer AbslStringify, fall back on source code printer.
-      if constexpr (has_absl_stringify_v<T>) {
-        absl::Format(out, "%v", v);
-      } else {
-        FuzzTestPrintSourceCode(sink, v);
-      }
-    } else {
-      // Prefer source code printer, fall back on AbslStringify.
-      if constexpr (has_custom_source_code_printer_v<T>) {
-        FuzzTestPrintSourceCode(sink, v);
-      } else {
-        absl::Format(out, "%v", v);
-      }
-    }
-  }
-};
-
 struct UnknownPrinter {
   template <typename T>
   void PrintUserValue(const T& v, domain_implementor::RawSink out,
                       domain_implementor::PrintMode mode) {
     if (mode == domain_implementor::PrintMode::kHumanReadable) {
-      // Try formatting with Abseil. We can't guarantee a good source code
-      // result, but it should be ok for human readable.
-      if constexpr (has_absl_stringify_v<T>) {
-        absl::Format(out, "%v", v);
-        return;
-      }
       // Some standard types have operator<<.
       if constexpr (std::is_scalar_v<T> || is_std_complex_v<T>) {
         absl::Format(out, "%s", absl::FormatStreamed(v));
@@ -654,8 +633,8 @@ template <typename T>
 decltype(auto) AutodetectTypePrinter() {
   // The order of these checks somewhat matters. Most of the concrete types have
   // AbslStringify, so they should come first not to be captured by the custom
-  // printer case. The aggregate case is also more specific than the custom
-  // printer case, so it needs to come before.
+  // printer case. The aggregate case comes after the custom case so that the
+  // user can override the default aggregate printer.
   if constexpr (is_protocol_buffer_enum_v<T>) {
     return ProtobufEnumPrinter<const google::protobuf::EnumDescriptor*>{
         google::protobuf::GetEnumDescriptor<T>()};
@@ -676,10 +655,10 @@ decltype(auto) AutodetectTypePrinter() {
     return DurationPrinter{};
   } else if constexpr (std::is_same_v<T, absl::Time>) {
     return TimePrinter{};
-  } else if constexpr (is_bindable_aggregate_v<T>) {
-    return AutodetectAggregatePrinter{};
   } else if constexpr (has_custom_printer_v<T>) {
     return CustomPrinter<T>{};
+  } else if constexpr (is_bindable_aggregate_v<T>) {
+    return AutodetectAggregatePrinter{};
   } else {
     return UnknownPrinter{};
   }