Merge branch 'typetools:master' into patch-1

Author: Shivam7-1

checker/build.gradle

@@ -65,7 +65,7 @@ dependencies {
   // For the Resource Leak Checker's support for JavaEE.
   testImplementation 'javax.servlet:javax.servlet-api:4.0.1'
   // For the Resource Leak Checker's support for IOUtils.
-  testImplementation 'commons-io:commons-io:2.18.0'
+  testImplementation 'commons-io:commons-io:2.19.0'
   // To test for an obscure crash in CFG construction for try-with-resources;
   // see https://github.com/typetools/checker-framework/issues/6396
   testImplementation 'org.apache.spark:spark-sql_2.12:3.3.2'

checker/src/main/java/org/checkerframework/checker/calledmethods/CalledMethodsAnnotatedTypeFactory.java

@@ -293,7 +293,7 @@ filterTree, collectionsSingletonList, getProcessingEnv())) {
    * At a fluent method call (which returns {@code this}), add the method to the type of the return
    * value.
    */
-  private class CalledMethodsTreeAnnotator extends AccumulationTreeAnnotator {
+  private class CalledMethodsTreeAnnotator extends TreeAnnotator {
     /**
      * Creates an instance of this tree annotator for the given type factory.
      *

checker/tests/nullness/java17/Issue7029Nullness.java

@@ -0,0 +1,24 @@
+package open.crash;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.checkerframework.checker.initialization.qual.Initialized;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+// @below-java17-jdk-skip-test
+public class Issue7029Nullness {
+
+  private record Item(@Nullable String id) {}
+
+  Map<String, Item> test(Collection<Item> source) {
+    return source.stream()
+        .flatMap(
+            item -> {
+              @Initialized String id = item.id();
+              return id == null ? Stream.empty() : Stream.of(Map.entry(id, item));
+            })
+        .collect(Collectors.toUnmodifiableMap(entry -> entry.getKey(), entry -> entry.getValue()));
+  }
+}

checker/tests/resourceleak-returns-receiver/ReturnsReceiverPerformance.java

@@ -0,0 +1,163 @@
+// Earlier versions of the Checker Framework exhibited exponentially-long run time on this code due
+// to the long chain of `@This` methods.
+
+import org.checkerframework.common.returnsreceiver.qual.*;
+
+class ReturnsReceiverPerformance {
+
+  static class Builder {
+    @This Builder m01() {
+      return this;
+    }
+
+    @This Builder m02() {
+      return this;
+    }
+
+    @This Builder m03() {
+      return this;
+    }
+
+    @This Builder m04() {
+      return this;
+    }
+
+    @This Builder m05() {
+      return this;
+    }
+
+    @This Builder m06() {
+      return this;
+    }
+
+    @This Builder m07() {
+      return this;
+    }
+
+    @This Builder m08() {
+      return this;
+    }
+
+    @This Builder m09() {
+      return this;
+    }
+
+    @This Builder m10() {
+      return this;
+    }
+
+    @This Builder m11() {
+      return this;
+    }
+
+    @This Builder m12() {
+      return this;
+    }
+
+    @This Builder m13() {
+      return this;
+    }
+
+    @This Builder m14() {
+      return this;
+    }
+
+    @This Builder m15() {
+      return this;
+    }
+
+    @This Builder m16() {
+      return this;
+    }
+
+    @This Builder m17() {
+      return this;
+    }
+
+    @This Builder m18() {
+      return this;
+    }
+
+    @This Builder m19() {
+      return this;
+    }
+
+    @This Builder m20() {
+      return this;
+    }
+
+    @This Builder m21() {
+      return this;
+    }
+
+    @This Builder m22() {
+      return this;
+    }
+
+    @This Builder m23() {
+      return this;
+    }
+
+    @This Builder m24() {
+      return this;
+    }
+
+    @This Builder m25() {
+      return this;
+    }
+
+    @This Builder m26() {
+      return this;
+    }
+
+    @This Builder m27() {
+      return this;
+    }
+
+    @This Builder m28() {
+      return this;
+    }
+
+    @This Builder m29() {
+      return this;
+    }
+
+    Object build() {
+      return new Object();
+    }
+  }
+
+  Object go() {
+    return new Builder()
+        .m01()
+        .m02()
+        .m03()
+        .m04()
+        .m05()
+        .m06()
+        .m07()
+        .m08()
+        .m09()
+        .m10()
+        .m11()
+        .m12()
+        .m13()
+        .m14()
+        .m15()
+        .m16()
+        .m17()
+        .m18()
+        .m19()
+        .m20()
+        .m21()
+        .m22()
+        .m23()
+        .m24()
+        .m25()
+        .m26()
+        .m27()
+        .m28()
+        .m29()
+        .build();
+  }
+}

docs/manual/signature-checker.tex

@@ -176,6 +176,25 @@
 \end{description}
 
 
+\subsectionAndLabel{How to choose which annotation to use}{signature-choosing-annotation}
+
+Sometimes, there are multiple valid annotations for a value.  As an
+example, a non-primitive non-array type is represented identically by
+\<@BinaryName>, \<@ClassGetName>, and \<@FqBinaryName>.  Using the lowest
+type in the type hierarchy (in this case, \<@BinaryName>) has two
+advantages.  First, it acts as documentation that the value is never a
+primitive or array.  Second, it permits the value to be used in any of the
+three contexts:  as a \<@BinaryName>, a \<@ClassGetName>, or a
+\<@FqBinaryName>.
+
+Casting to \<@BinaryName> from one of the other types adds clutter if it is not
+necessary.  Suppose that a method returns a \<@ClassGetName> and the value will
+only be used in contexts that require a \<@ClassGetName> (say, it is passed to a
+method that requires an argument of that type).  Then there is no point in
+casting to \<@BinaryName> in between, even if you know the type being
+represented is not a primitive or an array.
+
+
 \sectionAndLabel{What the Signature Checker checks}{signature-checks}
 
 Certain methods in the JDK, such as \<Class.forName>, are annotated
@@ -196,4 +215,5 @@
 % LocalWords:  jls getName ClassGetName ClassLoader LMyClass Ljava jvms
 % LocalWords:  DotSeparatedIdentifiers CharSequence Lmypackage mypackage
 % LocalWords:  FieldDescriptorWithoutPackage InternalForm getSimpleName
-% LocalWords:  ClassGetSimpleName FqBinaryName CanonicalName
+% LocalWords:  ClassGetSimpleName FqBinaryName CanonicalName checkers''
+% LocalWords:  Lpkg

framework/src/main/java/org/checkerframework/framework/util/typeinference8/util/CheckedExceptionsUtil.java

@@ -8,10 +8,12 @@
 import com.sun.source.tree.TryTree;
 import com.sun.source.util.TreeScanner;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.type.UnionType;
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.framework.type.AnnotatedTypeMirror;
 import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedExecutableType;
 import org.checkerframework.javacutil.TreeUtils;
@@ -31,14 +33,16 @@ private CheckedExceptionsUtil() {}
    */
   public static List<TypeMirror> thrownCheckedExceptions(
       LambdaExpressionTree lambda, Java8InferenceContext context) {
-    return new CheckedExceptionVisitor(context).scan(lambda, null);
+    @Nullable List<TypeMirror> result = new CheckedExceptionVisitor(context).scan(lambda, null);
+    return result != null ? result : Collections.emptyList();
   }
 
   /**
    * Helper class for gathering the types of checked exceptions in a lambda. See
    * https://docs.oracle.com/javase/specs/jls/se9/html/jls-11.html#jls-11.2.2
    */
-  private static class CheckedExceptionVisitor extends TreeScanner<List<TypeMirror>, Void> {
+  private static class CheckedExceptionVisitor
+      extends TreeScanner<@Nullable List<TypeMirror>, Void> {
 
     /** the context. */
     private final Java8InferenceContext context;
@@ -70,7 +74,7 @@ public List<TypeMirror> visitThrow(ThrowTree node, Void aVoid) {
       if (result == null) {
         result = new ArrayList<>();
       }
-      TypeMirror type = TreeUtils.typeOf(node);
+      TypeMirror type = TreeUtils.typeOf(node.getExpression());
       if (isCheckedException(type, context)) {
         result.add(type);
       }
@@ -171,15 +175,17 @@ private static boolean isCheckedException(TypeMirror type, Java8InferenceContext
    */
   public static List<AnnotatedTypeMirror> thrownCheckedExceptionsATM(
       LambdaExpressionTree lambda, Java8InferenceContext context) {
-    return new CheckedExceptionATMVisitor(context).scan(lambda, null);
+    @Nullable List<AnnotatedTypeMirror> result =
+        new CheckedExceptionATMVisitor(context).scan(lambda, null);
+    return result != null ? result : Collections.emptyList();
   }
 
   /**
    * Helper class for gathering the types of checked exceptions in a lambda. See
    * https://docs.oracle.com/javase/specs/jls/se9/html/jls-11.html#jls-11.2.2
    */
   private static class CheckedExceptionATMVisitor
-      extends TreeScanner<List<AnnotatedTypeMirror>, Void> {
+      extends TreeScanner<@Nullable List<AnnotatedTypeMirror>, Void> {
 
     /** The context. */
     private final Java8InferenceContext context;
@@ -212,7 +218,7 @@ public List<AnnotatedTypeMirror> visitThrow(ThrowTree node, Void aVoid) {
       if (result == null) {
         result = new ArrayList<>();
       }
-      AnnotatedTypeMirror type = context.typeFactory.getAnnotatedType(node);
+      AnnotatedTypeMirror type = context.typeFactory.getAnnotatedType(node.getExpression());
       if (isCheckedException(type, context)) {
         result.add(type);
       }