Sniff out the canonical constructor using detective work rather than a flag which isn't there.

PiperOrigin-RevId: 737675769

Author: graememorgan

check_api/src/main/java/com/google/errorprone/util/ASTHelpers.java

@@ -22,13 +22,16 @@
 import static com.google.common.collect.ImmutableList.toImmutableList;
 import static com.google.common.collect.ImmutableSet.toImmutableSet;
 import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.collect.MoreCollectors.onlyElement;
 import static com.google.common.collect.Streams.stream;
+import static com.google.common.collect.Streams.zip;
 import static com.google.errorprone.VisitorState.memoize;
 import static com.google.errorprone.matchers.JUnitMatchers.JUNIT4_RUN_WITH_ANNOTATION;
 import static com.google.errorprone.matchers.Matchers.isSubtypeOf;
 import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;
 import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.toCollection;
+import static javax.lang.model.element.ElementKind.CONSTRUCTOR;
 
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
@@ -833,11 +836,31 @@ private static boolean isFinal(Symbol symbol) {
   /**
    * Returns whether the given {@link Symbol} is a record, a record's canonical constructor or a
    * member that is part of a record's state vector.
+   *
+   * <p>Health warning: some things are flagged within a compilation, but won't be flagged across
+   * compilation boundaries, like canonical constructors.
    */
   public static boolean isRecord(Symbol symbol) {
     return (symbol.flags() & RECORD_FLAG) == RECORD_FLAG;
   }
 
+  /** Finds the canonical constructor on a record. */
+  public static MethodSymbol canonicalConstructor(ClassSymbol record, VisitorState state) {
+    var fieldTypes =
+        record.getRecordComponents().stream().map(rc -> rc.type).collect(toImmutableList());
+    return stream(record.members().getSymbols(s -> s.getKind() == CONSTRUCTOR))
+        .map(c -> (MethodSymbol) c)
+        .filter(
+            c ->
+                c.getParameters().size() == fieldTypes.size()
+                    && zip(
+                            c.getParameters().stream(),
+                            fieldTypes.stream(),
+                            (a, b) -> isSameType(a.type, b, state))
+                        .allMatch(x -> x))
+        .collect(onlyElement());
+  }
+
   /**
    * Determines whether a symbol has an annotation of the given type. This includes annotations
    * inherited from superclasses due to {@code @Inherited}.

check_api/src/test/java/com/google/errorprone/util/ASTHelpersTest.java

@@ -21,7 +21,9 @@
 import static com.google.common.truth.Truth.assertWithMessage;
 import static com.google.errorprone.BugPattern.SeverityLevel.ERROR;
 import static com.google.errorprone.BugPattern.SeverityLevel.WARNING;
+import static com.google.errorprone.util.ASTHelpers.canonicalConstructor;
 import static com.google.errorprone.util.ASTHelpers.getStartPosition;
+import static com.google.errorprone.util.ASTHelpers.getSymbol;
 import static com.google.errorprone.util.ASTHelpers.hasAnnotation;
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
@@ -2104,4 +2106,63 @@ void test(Integer[] i, List<String> s) {
             """)
         .doTest();
   }
+
+  @BugPattern(summary = "", severity = WARNING)
+  public static final class CanonicalConstructorFinder extends BugChecker
+      implements MethodTreeMatcher {
+    @Override
+    public Description matchMethod(MethodTree tree, VisitorState state) {
+      return canonicalConstructor((ClassSymbol) getSymbol(tree).owner, state) == getSymbol(tree)
+          ? describeMatch(tree)
+          : Description.NO_MATCH;
+    }
+  }
+
+  @Test
+  public void canonicalConstructors_found() {
+    CompilationTestHelper.newInstance(CanonicalConstructorFinder.class, getClass())
+        .addSourceLines(
+            "Test.java",
+            """
+            import java.util.List;
+            import java.util.Set;
+
+            class Test {
+              record A(int x) {}
+
+              record B(long y) {
+                // BUG: Diagnostic contains:
+                B {}
+              }
+
+              record C(long y) {
+                // BUG: Diagnostic contains:
+                C {}
+
+                C(int z) {
+                  this((long) (z + 1));
+                }
+              }
+
+              record D(List<Integer> xs) {
+                // BUG: Diagnostic contains:
+                D {}
+
+                D(Set<Integer> s) {
+                  this(List.of(1));
+                }
+              }
+
+              record E() {
+                // BUG: Diagnostic contains:
+                E {}
+
+                E(int x) {
+                  this();
+                }
+              }
+            }
+            """)
+        .doTest();
+  }
 }

core/src/test/java/com/google/errorprone/bugpatterns/argumentselectiondefects/ArgumentSelectionDefectCheckerTest.java

@@ -15,6 +15,8 @@
  */
 package com.google.errorprone.bugpatterns.argumentselectiondefects;
 
+import static com.google.common.truth.TruthJUnit.assume;
+
 import com.google.common.collect.ImmutableSet;
 import com.google.errorprone.BugPattern;
 import com.google.errorprone.BugPattern.SeverityLevel;
@@ -399,4 +401,29 @@ record Foo(String first, String second) {}
 """)
         .doTest();
   }
+
+  public record Foo(String first, String second) {}
+
+  @Test
+  public void recordPattern() {
+    assume().that(Runtime.version().feature()).isAtLeast(21);
+    testHelper
+        .addSourceLines(
+            "Test.java",
+            """
+            import %s;
+            class Test {
+              String test(Object o) {
+                return switch (o) {
+                  case Foo(String first, String second) -> first;
+                  default -> "";
+                };
+              }
+            }
+
+            """
+                .formatted(Foo.class.getCanonicalName()))
+        .setArgs("--enable-preview", "--release", Integer.toString(Runtime.version().feature()))
+        .doTest();
+  }
 }