Code review

Co-authored-by: Michael Ernst <mernst@cs.washington.edu>

Author: mernstcheckerframework

framework/src/main/java/org/checkerframework/common/value/ValueCheckerUtils.java

@@ -371,7 +371,7 @@ public static List<Integer> getLengthsForStringValues(List<String> values) {
 
   /**
    * Finds the maximum value in a Value Checker type. If there is no information (such as when the
-   * list of possible values is empty or null), returns null. Otherwise, returns the smallest value
+   * list of possible values is empty or null), returns null. Otherwise, returns the largest value
    * in the list of possible values.
    */
   public static @Nullable Long getMaxValue(Tree tree, ValueAnnotatedTypeFactory factory) {

framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java

@@ -726,7 +726,7 @@ public AnnotatedTypeFactory(BaseTypeChecker checker) {
    * That is, no element has a {@code @Target} meta-annotation that contains something besides
    * TYPE_USE or TYPE_PARAMETER. ({@code @Target({})} is allowed.)
    *
-   * @throws BugInCF If supportedQuals is empty or contaions a non-type qualifier
+   * @throws TypeSystemError if supportedQuals is empty or contains a non-type qualifier
    */
   private void checkSupportedQualsAreTypeQuals() {
     if (supportedQuals == null || supportedQuals.isEmpty()) {
@@ -1893,7 +1893,7 @@ public void postAsMemberOf(AnnotatedTypeMirror type, AnnotatedTypeMirror owner,
    *
    * @param type annotated type to which the annotation is added
    * @param accessedVia the annotated type of the receiver of the accessing tree. (Only used to get
-   *     the type element of the underling type.)
+   *     the type element of the underlying type.)
    * @param field element representing the field
    */
   protected void addAnnotationFromFieldInvariant(
@@ -2652,11 +2652,11 @@ protected void adaptGetClassReturnTypeToReceiver(
 
   /**
    * Returns the element type of {@code expression}. This is usually the type of {@code
-   * expression.itertor().next()}. If {@code expression} is an array, it is the component type of
+   * expression.iterator().next()}. If {@code expression} is an array, it is the component type of
    * the array.
    *
    * @param expression an expression whose type is an array or implements {@link Iterable}
-   * @return the type of {@code expression.itertor().next()} or if {@code expression} is an array,
+   * @return the type of {@code expression.iterator().next()} or if {@code expression} is an array,
    *     the component type of the array
    */
   public AnnotatedTypeMirror getIterableElementType(ExpressionTree expression) {
@@ -2665,12 +2665,12 @@ public AnnotatedTypeMirror getIterableElementType(ExpressionTree expression) {
 
   /**
    * Returns the element type of {@code iterableType}. This is usually the type of {@code
-   * expression.itertor().next()}. If {@code expression} is an array, it is the component type of
+   * expression.iterator().next()}. If {@code expression} is an array, it is the component type of
    * the array.
    *
    * @param expression an expression whose type is an array or implements {@link Iterable}
    * @param iterableType the type of the expression
-   * @return the type of {@code expression.itertor().next()} or if {@code expression} is an array,
+   * @return the type of {@code expression.iterator().next()} or if {@code expression} is an array,
    *     the component type of the array
    */
   protected AnnotatedTypeMirror getIterableElementType(
@@ -4007,7 +4007,7 @@ public boolean shouldWarnIfStubRedundantWithBytecode() {
    *
    * @param elt the element to retrieve the annotation from
    * @param annoClass the class of the annotation to retrieve
-   * @param checkAliases if true, the metnhod may return an annotation mirror for an alias of the
+   * @param checkAliases if true, the method may return an annotation mirror for an alias of the
    *     requested annotation class name
    * @return the annotation mirror for the requested annotation, or null if not found
    */
@@ -4767,7 +4767,7 @@ private AnnotatedTypeMirror getFunctionalInterfaceType(Tree tree) {
    *
    * @param typeMirror a type that must be a functional interface
    * @param contextTree the tree that has the given type; used only for diagnostic messages
-   * @param tree a labmba tree that encloses {@code contextTree}; used only for diagnostic messages
+   * @param tree a lambda tree that encloses {@code contextTree}; used only for diagnostic messages
    */
   private void assertIsFunctionalInterface(TypeMirror typeMirror, Tree contextTree, Tree tree) {
     if (typeMirror.getKind() == TypeKind.WILDCARD) {
@@ -5787,7 +5787,7 @@ public boolean doesAnnotatedForApplyToThisChecker(AnnotationMirror annotatedForA
    * Returns the {@code expression} field/element of the given contract annotation.
    *
    * @param contractAnno a {@link RequiresQualifier}, {@link EnsuresQualifier}, or {@link
-   *     EnsuresQualifier}
+   *     EnsuresQualifierIf}
    * @return the {@code expression} field/element of the given annotation
    */
   public List<String> getContractExpressions(AnnotationMirror contractAnno) {

framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeMirror.java

@@ -252,7 +252,7 @@ public boolean hasPrimaryAnnotationInHierarchy(AnnotationMirror annotation) {
    * #getAnnotationInHierarchy(AnnotationMirror)} should be called instead.
    *
    * @param annotation an annotation in the qualifier hierarchy to check for
-   * @return the annotation mirror whose class is named {@code annoNAme} or null
+   * @return the annotation in the same hierarchy as {@code annotation}, or null
    */
   public @Nullable AnnotationMirror getPrimaryAnnotationInHierarchy(AnnotationMirror annotation) {
     if (primaryAnnotations.isEmpty()) {
@@ -377,7 +377,7 @@ public AnnotationMirrorSet getAnnotations() {
    * <p>This method requires that there is only a single hierarchy. Therefore, it is equivalent to
    * {@link #getAnnotationInHierarchy(AnnotationMirror)}.
    *
-   * @return a set of the annotations on this
+   * @return the annotation on this type, or null if there is none
    */
   public final AnnotationMirror getAnnotation() {
     AnnotationMirrorSet effectiveAnnotations = getAnnotations();
@@ -386,7 +386,7 @@ public final AnnotationMirror getAnnotation() {
       return null;
     }
     if (effectiveAnnotations.size() != 1) {
-      throw new BugInCF("Bad annotation size for getPrimaryAnnotation(): " + this);
+      throw new BugInCF("Bad annotation size for getAnnotation(): " + this);
     }
     return effectiveAnnotations.iterator().next();
   }
@@ -669,7 +669,7 @@ public void addAnnotations(Iterable<? extends AnnotationMirror> annotations) {
    * {@link AnnotatedIntersectionType}s, adds them to all bounds. (The canonical version is found
    * via {@link AnnotatedTypeFactory#canonicalAnnotation(AnnotationMirror)} or {@link
    * AnnotatedTypeFactory#canonicalAnnotation(AnnotationMirror,TypeMirror)}.) If the canonical
-   * version of an annotation is not a supported qualifier, then that annotation is not add added.
+   * version of an annotation is not a supported qualifier, then that annotation is not added.
    *
    * @param annotations the annotations to add
    */
@@ -688,7 +688,7 @@ public void addMissingAnnotations(Iterable<? extends AnnotationMirror> annotatio
    * {@link AnnotatedIntersectionType}s) added to all bounds. (The canonical version is found via
    * {@link AnnotatedTypeFactory#canonicalAnnotation(AnnotationMirror)} or {@link
    * AnnotatedTypeFactory#canonicalAnnotation(AnnotationMirror,TypeMirror)}.) If the canonical
-   * version of an {@code annotation} is not a supported qualifier, then that annotation is not add
+   * version of an {@code annotation} is not a supported qualifier, then that annotation is not
    * added.
    *
    * @param annotation the annotations to add
@@ -1741,9 +1741,9 @@ public TypeVariable getUnderlyingType() {
     /**
      * Set the lower bound of this variable type.
      *
-     * <p>Returns the lower bound of this type variable. While a type parameter cannot include an
-     * explicit lower bound declaration, capture conversion can produce a type variable with a
-     * non-trivial lower bound. Type variables otherwise have a lower bound of NullType.
+     * <p>While a type parameter cannot include an explicit lower bound declaration, capture
+     * conversion can produce a type variable with a non-trivial lower bound. Type variables
+     * otherwise have a lower bound of NullType.
      *
      * @param type the lower bound type
      */

framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeParameterBounds.java

@@ -46,10 +46,6 @@ public boolean equals(@Nullable Object obj) {
     if (!(obj instanceof AnnotatedTypeParameterBounds other)) {
       return false;
     }
-    return this.upper == null
-        ? other.upper == null
-        : (this.upper.equals(other.upper) && this.lower == null)
-            ? other.lower == null
-            : this.lower.equals(other.lower);
+    return Objects.equals(this.upper, other.upper) && Objects.equals(this.lower, other.lower);
   }
 }

framework/src/main/java/org/checkerframework/framework/type/AsSuperVisitor.java

@@ -172,7 +172,7 @@ private AnnotatedTypeMirror copyPrimaryAnnos(AnnotatedTypeMirror from, Annotated
    * A helper method for asSuper(AMT, Wildcard) methods to use to annotate the wildcard's lower
    * bound.
    *
-   * <p>If the lower bound of superType is Null, then return copyPrimarayAnnos(type, superType)
+   * <p>If the lower bound of superType is Null, then return copyPrimaryAnnos(type, superType)
    *
    * <p>otherwise, return asSuper(type, superType.getLowerBound()
    *

framework/src/main/java/org/checkerframework/framework/type/BoundsInitializer.java

@@ -162,8 +162,8 @@ private void initializeTypeVariable(AnnotatedTypeVariable annotatedTypeVariable)
     /**
      * Sets the extends and super bounds of {@code annotatedWildcardType} to {@code
      * AnnotatedTypeMirror} that match the upper and lower bounds of the underlying type of {@code
-     * annotatedWildcardType} by calling visiting each bound. This method should only be called once
-     * per {@link WildcardType}.
+     * annotatedWildcardType} by visiting each bound. This method should only be called once per
+     * {@link WildcardType}.
      *
      * @param annotatedWildcardType an annotated wildcard type
      */

framework/src/main/java/org/checkerframework/framework/type/DeclarationsIntoElements.java

@@ -32,6 +32,7 @@ private DeclarationsIntoElements() {
   /**
    * The entry point.
    *
+   * @param env the processing environment
    * @param atypeFactory the type factory
    * @param tree the ClassTree to process
    */

framework/src/main/java/org/checkerframework/framework/type/DefaultAnnotatedTypeFormatter.java

@@ -139,7 +139,7 @@ protected static class FormattingVisitor
     /**
      * For a given call to format, this setting specifies whether or not to printInvisibles. If a
      * user did not specify a printInvisible parameter in the call to format then this value will
-     * equal DefaultAnnotatedTypeFormatter.defaultInvisibleSettings for this object
+     * equal DefaultAnnotatedTypeFormatter.defaultInvisiblesSetting for this object
      */
     protected boolean currentPrintInvisibleSetting;
 
@@ -148,7 +148,7 @@ protected static class FormattingVisitor
 
     /**
      * Prints type variables in a less ambiguous manner using [] to delimit them. Always prints both
-     * bounds even if they lower bound is an AnnotatedNull type.
+     * bounds even if the lower bound is an AnnotatedNull type.
      */
     protected boolean currentPrintVerboseGenerics;
 

framework/src/main/java/org/checkerframework/framework/type/DefaultTypeHierarchy.java

@@ -1129,7 +1129,7 @@ public Boolean visitWildcard_Wildcard(
    *
    * @param subtype the possible subtype
    * @param supertype the possible supertype
-   * @return true {@code subtype} is a subtype of {@code supertype}
+   * @return true if {@code subtype} is a subtype of {@code supertype}
    */
   protected boolean visitType_Intersection(
       AnnotatedTypeMirror subtype, AnnotatedIntersectionType supertype) {

framework/src/main/java/org/checkerframework/framework/type/ElementAnnotationApplier.java

@@ -92,7 +92,12 @@ public static void apply(
     }
   }
 
-  /** Issues an "invalid.annotation.location.bytecode warning. */
+  /**
+   * Issues an "invalid.annotation.location.bytecode" warning.
+   *
+   * @param element the location at which to report the warning
+   * @param typeFactory the factory that reports the warning
+   */
   private static void reportInvalidLocation(Element element, AnnotatedTypeFactory typeFactory) {
     Element report = element;
     if (element.getEnclosingElement().getKind() == ElementKind.METHOD) {
@@ -183,6 +188,7 @@ public static void annotateSupers(
    * has been placed here.
    *
    * @param varEle the element that may represent a lambda's parameter
+   * @param typeFactory the type factory
    * @return a LambdaExpressionTree if the varEle represents a parameter in a lambda expression,
    *     otherwise null
    */