Skip bytecode inference of the actual value for assume.

To do so, I've generalized our existing support for skipping bytecode inference, which I had originally set up for `ExpectFailure` in 3caa0e8 + 24b5a31.

This change improves the performance of failed assumptions. It makes the messages of the resulting `AssumptionViolatedException` somewhat worse, but my sense is that no one really looks at those. As discussed in b/478281659, we could go further by also avoiding cleaning stack traces, which probably also no one looks at.

RELNOTES=n/a
PiperOrigin-RevId: 860538616

Author: cpovirk

core/pom.xml

@@ -145,7 +145,7 @@
                 <include>**/ActualValueInferenceTest.java</include>
               </includes>
               <systemPropertyVariables>
-                <com.google.common.truth.enable_infer_description_for_expect_failure>true</com.google.common.truth.enable_infer_description_for_expect_failure>
+                <com.google.common.truth.force_infer_description>true</com.google.common.truth.force_infer_description>
               </systemPropertyVariables>
             </configuration>
             <goals>

core/src/main/java/com/google/common/truth/Expect.java

@@ -234,7 +234,7 @@ public static Expect create() {
   }
 
   private Expect(ExpectationGatherer gatherer) {
-    super(FailureMetadata.forFailureStrategy(gatherer));
+    super(FailureMetadata.forFailureStrategy(gatherer, /* suppressInferDescription= */ false));
     this.gatherer = checkNotNull(gatherer);
   }
 

core/src/main/java/com/google/common/truth/ExpectFailure.java

@@ -110,15 +110,9 @@ public StandardSubjectBuilder whenTesting() {
     }
     failureExpected = true;
     return StandardSubjectBuilder.forCustomFailureStrategy(
-        (ExpectFailureFailureStrategy) this::captureFailure);
+        this::captureFailure, /* suppressInferDescription= */ true);
   }
 
-  /**
-   * Marker interface that we check for so that we can automatically disable "value of" lines during
-   * {@link ExpectFailure} assertions.
-   */
-  interface ExpectFailureFailureStrategy extends FailureStrategy {}
-
   /**
    * Enters rule context to be ready to capture failures.
    *

core/src/main/java/com/google/common/truth/FailureMetadata.java

@@ -24,15 +24,14 @@
 import static com.google.common.truth.Fact.simpleFact;
 import static com.google.common.truth.LazyMessage.evaluateAll;
 import static com.google.common.truth.Platform.cleanStackTrace;
+import static com.google.common.truth.Platform.forceInferDescription;
 import static com.google.common.truth.Platform.inferDescription;
-import static com.google.common.truth.Platform.isInferDescriptionEnabledForExpectFailure;
 import static com.google.common.truth.Platform.makeComparisonFailure;
 import static com.google.common.truth.SubjectUtils.append;
 import static com.google.common.truth.SubjectUtils.concat;
 
 import com.google.common.base.Function;
 import com.google.common.collect.ImmutableList;
-import com.google.common.truth.ExpectFailure.ExpectFailureFailureStrategy;
 import org.jspecify.annotations.Nullable;
 
 /**
@@ -56,55 +55,18 @@
  * constructor.)
  */
 public final class FailureMetadata {
-  static FailureMetadata forFailureStrategy(FailureStrategy strategy) {
+  static FailureMetadata forFailureStrategy(
+      FailureStrategy strategy, boolean suppressInferDescription) {
     return new FailureMetadata(
-        strategy, /* messages= */ ImmutableList.of(), /* steps= */ ImmutableList.of());
+        strategy,
+        suppressInferDescription,
+        /* messages= */ ImmutableList.of(),
+        /* steps= */ ImmutableList.of());
   }
 
   private final FailureStrategy strategy;
 
-  /**
-   * The data from a call to either (a) a {@link Subject} constructor or (b) {@link Subject#check}.
-   */
-  private static final class Step {
-    static Step subjectCreation(Subject subject) {
-      return new Step(checkNotNull(subject), null, null);
-    }
-
-    static Step checkCall(
-        @Nullable OldAndNewValuesAreSimilar valuesAreSimilar,
-        @Nullable Function<String, String> descriptionUpdate) {
-      return new Step(null, descriptionUpdate, valuesAreSimilar);
-    }
-
-    /*
-     * We store Subject, rather than the actual value itself, so that we can call
-     * actualCustomStringRepresentation(). Why not call actualCustomStringRepresentation()
-     * immediately? First, it might be expensive, and second, the Subject isn't initialized at the
-     * time we receive it. We *might* be able to make it safe to call if it looks only at
-     * actualForPackageMembersToCall(), but it might try to look at facts initialized by a subclass,
-     * which aren't ready yet.
-     */
-    final @Nullable Subject subject;
-
-    final @Nullable Function<String, String> descriptionUpdate;
-
-    // Present only when descriptionUpdate is.
-    final @Nullable OldAndNewValuesAreSimilar valuesAreSimilar;
-
-    private Step(
-        @Nullable Subject subject,
-        @Nullable Function<String, String> descriptionUpdate,
-        @Nullable OldAndNewValuesAreSimilar valuesAreSimilar) {
-      this.subject = subject;
-      this.descriptionUpdate = descriptionUpdate;
-      this.valuesAreSimilar = valuesAreSimilar;
-    }
-
-    boolean isCheckCall() {
-      return subject == null;
-    }
-  }
+  private final boolean suppressInferDescription;
 
   /*
    * TODO(cpovirk): This implementation is wasteful, especially because `steps` is used even by
@@ -119,8 +81,12 @@ boolean isCheckCall() {
   private final ImmutableList<Step> steps;
 
   private FailureMetadata(
-      FailureStrategy strategy, ImmutableList<LazyMessage> messages, ImmutableList<Step> steps) {
+      FailureStrategy strategy,
+      boolean suppressInferDescription,
+      ImmutableList<LazyMessage> messages,
+      ImmutableList<Step> steps) {
     this.strategy = checkNotNull(strategy);
+    this.suppressInferDescription = suppressInferDescription;
     this.messages = checkNotNull(messages);
     this.steps = checkNotNull(steps);
   }
@@ -212,7 +178,7 @@ private void doFail(AssertionError failure) {
   }
 
   private FailureMetadata derive(ImmutableList<LazyMessage> messages, ImmutableList<Step> steps) {
-    return new FailureMetadata(strategy, messages, steps);
+    return new FailureMetadata(strategy, suppressInferDescription, messages, steps);
   }
 
   /**
@@ -246,10 +212,7 @@ private ImmutableList<Fact> description() {
   /** Overload of {@link #description()} that allows passing a custom key for the fact. */
   private ImmutableList<Fact> description(String factKey) {
     String description =
-        strategy instanceof ExpectFailureFailureStrategy
-                && !isInferDescriptionEnabledForExpectFailure()
-            ? null
-            : inferDescription();
+        suppressInferDescription && !forceInferDescription() ? null : inferDescription();
     boolean descriptionIsInteresting = description != null;
     for (Step step : steps) {
       if (step.isCheckCall()) {
@@ -353,4 +316,47 @@ && checkNotNull(step.subject).actualForPackageMembersToCall() instanceof Throwab
     }
     return null;
   }
+
+  /**
+   * The data from a call to either (a) a {@link Subject} constructor or (b) {@link Subject#check}.
+   */
+  private static final class Step {
+    static Step subjectCreation(Subject subject) {
+      return new Step(checkNotNull(subject), null, null);
+    }
+
+    static Step checkCall(
+        @Nullable OldAndNewValuesAreSimilar valuesAreSimilar,
+        @Nullable Function<String, String> descriptionUpdate) {
+      return new Step(null, descriptionUpdate, valuesAreSimilar);
+    }
+
+    /*
+     * We store Subject, rather than the actual value itself, so that we can call
+     * actualCustomStringRepresentation(). Why not call actualCustomStringRepresentation()
+     * immediately? First, it might be expensive, and second, the Subject isn't initialized at the
+     * time we receive it. We *might* be able to make it safe to call if it looks only at
+     * actualForPackageMembersToCall(), but it might try to look at facts initialized by a subclass,
+     * which aren't ready yet.
+     */
+    final @Nullable Subject subject;
+
+    final @Nullable Function<String, String> descriptionUpdate;
+
+    // Present only when descriptionUpdate is.
+    final @Nullable OldAndNewValuesAreSimilar valuesAreSimilar;
+
+    private Step(
+        @Nullable Subject subject,
+        @Nullable Function<String, String> descriptionUpdate,
+        @Nullable OldAndNewValuesAreSimilar valuesAreSimilar) {
+      this.subject = subject;
+      this.descriptionUpdate = descriptionUpdate;
+      this.valuesAreSimilar = valuesAreSimilar;
+    }
+
+    boolean isCheckCall() {
+      return subject == null;
+    }
+  }
 }

core/src/main/java/com/google/common/truth/Platform.java

@@ -242,11 +242,10 @@ private static boolean isInferDescriptionDisabled() {
     }
   }
 
-  static boolean isInferDescriptionEnabledForExpectFailure() {
+  static boolean forceInferDescription() {
     try {
       return Boolean.parseBoolean(
-          System.getProperty(
-              "com.google.common.truth.enable_infer_description_for_expect_failure"));
+          System.getProperty("com.google.common.truth.force_infer_description"));
     } catch (SecurityException e) {
       return false;
     }

core/src/main/java/com/google/common/truth/StandardSubjectBuilder.java

@@ -92,7 +92,13 @@ public class StandardSubjectBuilder {
    * FailureStrategy}.
    */
   public static StandardSubjectBuilder forCustomFailureStrategy(FailureStrategy strategy) {
-    return new StandardSubjectBuilder(FailureMetadata.forFailureStrategy(strategy));
+    return forCustomFailureStrategy(strategy, /* suppressInferDescription= */ false);
+  }
+
+  static StandardSubjectBuilder forCustomFailureStrategy(
+      FailureStrategy strategy, boolean suppressInferDescription) {
+    return new StandardSubjectBuilder(
+        FailureMetadata.forFailureStrategy(strategy, suppressInferDescription));
   }
 
   private final FailureMetadata metadataDoNotReferenceDirectly;

core/src/main/java/com/google/common/truth/TruthJUnit.java

@@ -46,7 +46,8 @@ public final class TruthJUnit {
                 new AssumptionViolatedException(failure.getMessage(), failure.getCause());
             assumptionViolated.setStackTrace(failure.getStackTrace());
             throw assumptionViolated;
-          });
+          },
+          /* suppressInferDescription= */ true);
 
   /**
    * Begins a call chain with the fluent Truth API. If the check made by the chain fails, it will

core/src/main/java/com/google/common/truth/super/com/google/common/truth/Platform.java

@@ -180,7 +180,7 @@ static String expectFailureWarningIfWeb() {
         + " verifying that the expected failure occurred.)";
   }
 
-  static boolean isInferDescriptionEnabledForExpectFailure() {
+  static boolean forceInferDescription() {
     return false; // irrelevant because we can infer descriptions only under the JVM
   }