Enum rename; Improve comments

Co-authored-by: Werner Dietl <wdietl@gmail.com>

checker/src/main/java/org/checkerframework/checker/index/inequality/LessThanVisitor.java

@@ -113,7 +113,7 @@ protected void commonAssignmentCheck(
     }
 
     @Override
-    protected TypecastKind isTypeCastSafe(
+    protected TypeCastKind isTypeCastSafe(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
 
         AnnotationMirror exprLTAnno =

checker/src/main/java/org/checkerframework/checker/interning/InterningVisitor.java

@@ -980,10 +980,10 @@ DeclaredType typeToCheck() {
     }
 
     @Override
-    protected TypecastKind isTypeCastSafe(
+    protected TypeCastKind isTypeCastSafe(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
         if (castType.getKind().isPrimitive()) {
-            return TypecastKind.SAFE;
+            return TypeCastKind.SAFE;
         }
         return super.isTypeCastSafe(castType, exprType);
     }

checker/src/main/java/org/checkerframework/checker/mustcall/MustCallVisitor.java

@@ -374,10 +374,10 @@ private boolean noMustCallObligation(AnnotatedTypeMirror atm) {
     }
 
     @Override
-    protected TypecastKind isTypeCastSafe(
+    protected TypeCastKind isTypeCastSafe(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
         if (noMustCallObligation(castType) || noMustCallObligation(exprType)) {
-            return TypecastKind.SAFE;
+            return TypeCastKind.SAFE;
         }
 
         return super.isTypeCastSafe(castType, exprType);

checker/src/main/java/org/checkerframework/checker/signedness/SignednessVisitor.java

@@ -384,11 +384,11 @@ public Void visitCompoundAssignment(CompoundAssignmentTree tree, Void p) {
     }
 
     @Override
-    protected TypecastKind isTypeCastSafe(
+    protected TypeCastKind isTypeCastSafe(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
         if (!atypeFactory.maybeIntegral(castType)) {
             // If the cast is not a number or a char, then it is legal.
-            return TypecastKind.SAFE;
+            return TypeCastKind.SAFE;
         }
         return super.isTypeCastSafe(castType, exprType);
     }

checker/tests/signedness/CastFromTtoT.java

@@ -26,7 +26,7 @@ T bar2(@Signed T p) {
         }
 
         // Looks like an upcast, but it's a downcast.
-        // This time, as arugment p has type T, which is the same as the casting type
+        // This time, as argument p has type T, which is the same as the casting type
         // and the compiler will not issue a warning. So we should give a warning.
         void foo2(Inner<@SignednessGlb Integer> s, @Signed Integer local) {
             @SignednessGlb Integer x = s.bar2(local);

docs/CHANGELOG.md

@@ -41,7 +41,7 @@ Changed the return types of
 - `GenericAnnotatedTypeFactory#getFinalLocalValues()` to `Map<VariableElement, Value>`.
 
 Refactored the implementation of `isTypeCastSafe` to categorize the kinds of a typecast, whether
-it's an upcast, downcast or incomparable cast. Based on that, further determine if the typecast
+it is an upcast, downcast or incomparable cast. Based on that, further determine if the typecast
 is statically verifiable or not.
 
 **Closed issues:**

framework/src/main/java/org/checkerframework/common/basetype/BaseTypeVisitor.java

@@ -2474,7 +2474,7 @@ protected void checkTypecastSafety(TypeCastTree typeCastTree) {
         // We cannot do a simple test of casting, as isSubtypeOf requires
         // the input types to be subtypes according to Java.
         if (!reported) {
-            TypecastKind castResult = isTypeCastSafe(castType, exprType);
+            TypeCastKind castResult = isTypeCastSafe(castType, exprType);
 
             if (castResult == TypecastKind.WARNING) {
                 checker.reportWarning(
@@ -2492,17 +2492,17 @@ protected void checkTypecastSafety(TypeCastTree typeCastTree) {
         }
     }
 
-    /** To represent all possible kinds of typecast */
-    protected enum TypecastKind {
-        /** The cast is safe */
+    /** Represents all possible kinds of typecasts. */
+    protected enum TypeCastKind {
+        /** The cast is safe. */
         SAFE,
-        /** The cast is illegal */
+        /** The cast is illegal. */
         ERROR,
-        /** Cannot statically verify the cast, report a warning */
+        /** Cannot statically verify the cast, report a warning. */
         WARNING,
-        /** It's not an upcast */
+        /** It is not an upcast. */
         NOT_UPCAST,
-        /** It's not a downcast */
+        /** It is not a downcast. */
         NOT_DOWNCAST
     }
 
@@ -2516,7 +2516,7 @@ protected enum TypecastKind {
      * @param exprType annotated type of the casted expression
      * @return return NOT_UPCAST, WARNING or SAFE TypecastKind.
      */
-    protected TypecastKind isUpcast(AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
+    protected TypeCastKind isUpcast(AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
         QualifierHierarchy qualifierHierarchy = atypeFactory.getQualifierHierarchy();
         AnnotationMirrorSet castAnnos;
         TypeKind castTypeKind = castType.getKind();
@@ -2538,13 +2538,13 @@ protected TypecastKind isUpcast(AnnotatedTypeMirror castType, AnnotatedTypeMirro
             }
 
             if (!atypeFactory.getTypeHierarchy().isSubtype(newExprType, newCastType)) {
-                return TypecastKind.WARNING;
+                return TypeCastKind.WARNING;
             }
             if (newCastType.getKind() == TypeKind.ARRAY
                     && newExprType.getKind() != TypeKind.ARRAY) {
                 // Always warn if the cast contains an array, but the expression
                 // doesn't, as in "(Object[]) o" where o is of type Object
-                return TypecastKind.WARNING;
+                return TypeCastKind.WARNING;
             } else if (newCastType.getKind() == TypeKind.DECLARED
                     && newExprType.getKind() == TypeKind.DECLARED) {
                 int castSize = ((AnnotatedDeclaredType) newCastType).getTypeArguments().size();
@@ -2554,7 +2554,7 @@ protected TypecastKind isUpcast(AnnotatedTypeMirror castType, AnnotatedTypeMirro
                     // Always warn if the cast and expression contain a different number of type
                     // arguments, e.g. to catch a cast from "Object" to "List<@NonNull Object>".
                     // TODO: the same number of arguments actually doesn't guarantee anything.
-                    return TypecastKind.WARNING;
+                    return TypeCastKind.WARNING;
                 }
             } else if (castTypeKind == TypeKind.TYPEVAR && exprType.getKind() == TypeKind.TYPEVAR) {
                 // If both the cast type and the casted expression are type variables, then check
@@ -2571,7 +2571,7 @@ protected TypecastKind isUpcast(AnnotatedTypeMirror castType, AnnotatedTypeMirro
                                 && qualifierHierarchy.isSubtype(
                                         exprType.getEffectiveAnnotations(),
                                         castType.getEffectiveAnnotations());
-                return result ? TypecastKind.SAFE : TypecastKind.WARNING;
+                return result ? TypeCastKind.SAFE : TypeCastKind.WARNING;
             }
             if (castTypeKind == TypeKind.TYPEVAR) {
                 // If the cast type is a type var, but the expression is not, then check that the
@@ -2607,9 +2607,9 @@ protected TypecastKind isUpcast(AnnotatedTypeMirror castType, AnnotatedTypeMirro
                 // return SAFE only it satisfies the below condition
                 if (qualifierHierarchy.isSubtype(exprLower, castLower)
                         && qualifierHierarchy.isSubtype(exprUpper, castUpper)) {
-                    return TypecastKind.SAFE;
+                    return TypeCastKind.SAFE;
                 }
-                return TypecastKind.WARNING;
+                return TypeCastKind.WARNING;
             }
         }
 
@@ -2618,12 +2618,12 @@ protected TypecastKind isUpcast(AnnotatedTypeMirror castType, AnnotatedTypeMirro
                 qualifierHierarchy.isSubtype(exprTypeWidened.getEffectiveAnnotations(), castAnnos);
 
         if (result) {
-            return TypecastKind.SAFE;
+            return TypeCastKind.SAFE;
         } else if (checkCastElementType) {
             // when the flag is enabled, and it is not an upcast, return a warning
-            return TypecastKind.WARNING;
+            return TypeCastKind.WARNING;
         } else {
-            return TypecastKind.NOT_UPCAST;
+            return TypeCastKind.NOT_UPCAST;
         }
     }
 
@@ -2635,14 +2635,14 @@ protected TypecastKind isUpcast(AnnotatedTypeMirror castType, AnnotatedTypeMirro
      * @param exprType annotated type of the casted expression
      * @return Can return SAFE, NOT_DOWNCAST or WARNING.
      */
-    protected TypecastKind isSafeDowncast(
+    protected TypeCastKind isSafeDowncast(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
         AnnotationMirrorSet castAnnos = castType.getEffectiveAnnotations();
         AnnotationMirrorSet exprAnnos = exprType.getEffectiveAnnotations();
         QualifierHierarchy qualifierHierarchy = atypeFactory.getQualifierHierarchy();
 
         if (!qualifierHierarchy.isComparable(castAnnos, exprAnnos)) { // exists an incomparable cast
-            return TypecastKind.NOT_DOWNCAST;
+            return TypeCastKind.NOT_DOWNCAST;
         }
 
         // check if the downcast can be statically verified
@@ -2656,14 +2656,14 @@ protected TypecastKind isSafeDowncast(
                     atypeFactory.getTypeDeclarationBounds(castDeclared.getUnderlyingType());
 
             if (AnnotationUtils.areSame(castDeclared.getAnnotations(), bounds)) {
-                return TypecastKind.SAFE;
+                return TypeCastKind.SAFE;
             }
         }
-        return TypecastKind.WARNING;
+        return TypeCastKind.WARNING;
     }
 
     /**
-     * If it's an incomparable cast in terms of qualifiers, return ERROR by default. Subchecker can
+     * If it is an incomparable cast in terms of qualifiers, return ERROR by default. Subchecker can
      * override this method to allow certain incomparable casts.
      *
      * @param castType annotated type of the cast
@@ -2672,26 +2672,26 @@ protected TypecastKind isSafeDowncast(
      */
     protected TypecastKind isSafeIncomparableCast(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
-        return TypecastKind.ERROR;
+        return TypeCastKind.ERROR;
     }
 
     /**
-     * This method returns TypecastKind.SAFE when the typecast is an upcast or a statically
+     * This method returns TypeCastKind.SAFE when the typecast is an upcast or a statically
      * verifiable downcast. Returns TypecastKind.WARNING and ERROR for those downcasts which cannot
      * be statically verified or some incomparable casts.
      *
      * @param castType annotated type of the cast
      * @param exprType annotated type of the casted expression
      * @return TypecastKind.SAFE if the typecast is safe, error or warning otherwise
      */
-    protected TypecastKind isTypeCastSafe(
+    protected TypeCastKind isTypeCastSafe(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
-        TypecastKind castResult = isUpcast(castType, exprType);
+        TypeCastKind castResult = isUpcast(castType, exprType);
 
         // not upcast, do downcast and incomparable cast check
-        if (castResult == TypecastKind.NOT_UPCAST) {
+        if (castResult == TypeCastKind.NOT_UPCAST) {
             castResult = isSafeDowncast(castType, exprType);
-            if (castResult == TypecastKind.NOT_DOWNCAST) { // fall into incomparable cast
+            if (castResult == TypeCastKind.NOT_DOWNCAST) { // fall into incomparable cast
                 return isSafeIncomparableCast(castType, exprType);
             }
         }
@@ -2708,7 +2708,7 @@ protected TypecastKind isTypeCastSafe(
      */
     private boolean isInvariantTypeCastSafe(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType, AnnotationMirror top) {
-        if (isTypeCastSafe(castType, exprType) != TypecastKind.SAFE) {
+        if (isTypeCastSafe(castType, exprType) != TypeCastKind.SAFE) {
             return false;
         }
         AnnotationMirror castTypeAnno = castType.getEffectiveAnnotationInHierarchy(top);
@@ -2759,7 +2759,7 @@ public Void visitInstanceOf(InstanceOfTree tree, Void p) {
             if (variableTree.getModifiers() != null) {
                 AnnotatedTypeMirror variableType = atypeFactory.getAnnotatedType(variableTree);
                 AnnotatedTypeMirror expType = atypeFactory.getAnnotatedType(tree.getExpression());
-                if (isTypeCastSafe(variableType, expType) != TypecastKind.SAFE) {
+                if (isTypeCastSafe(variableType, expType) != TypeCastKind.SAFE) {
                     checker.reportWarning(tree, "instanceof.pattern.unsafe", expType, variableTree);
                 }
             }

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

@@ -345,7 +345,7 @@ public Void visitTypeCast(TypeCastTree tree, Void p) {
     // This method returns true for (@IntVal(-1), @IntVal(255)) if the underlying type is `byte`,
     // but not for any other underlying type.
     @Override
-    protected TypecastKind isTypeCastSafe(
+    protected TypeCastKind isTypeCastSafe(
             AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
         TypeKind castTypeKind =
                 TypeKindUtils.primitiveOrBoxedToTypeKind(castType.getUnderlyingType());
@@ -358,7 +358,7 @@ protected TypecastKind isTypeCastSafe(
             AnnotationMirrorSet castAnnos = castType.getAnnotations();
             AnnotationMirrorSet exprAnnos = exprType.getAnnotations();
             if (castAnnos.equals(exprAnnos)) {
-                return TypecastKind.SAFE;
+                return TypeCastKind.SAFE;
             }
             assert castAnnos.size() == 1;
             assert exprAnnos.size() == 1;
@@ -374,20 +374,20 @@ protected TypecastKind isTypeCastSafe(
                     switch (castTypeKind) {
                         case BYTE:
                             return castValues.get(0).byteValue() == exprValues.get(0).byteValue()
-                                    ? TypecastKind.SAFE
-                                    : TypecastKind.ERROR;
+                                    ? TypeCastKind.SAFE
+                                    : TypeCastKind.ERROR;
                         case INT:
                             return castValues.get(0).intValue() == exprValues.get(0).intValue()
-                                    ? TypecastKind.SAFE
-                                    : TypecastKind.ERROR;
+                                    ? TypeCastKind.SAFE
+                                    : TypeCastKind.ERROR;
                         case SHORT:
                             return castValues.get(0).shortValue() == exprValues.get(0).shortValue()
-                                    ? TypecastKind.SAFE
-                                    : TypecastKind.ERROR;
+                                    ? TypeCastKind.SAFE
+                                    : TypeCastKind.ERROR;
                         default:
                             return castValues.get(0).longValue() == exprValues.get(0).longValue()
-                                    ? TypecastKind.SAFE
-                                    : TypecastKind.ERROR;
+                                    ? TypeCastKind.SAFE
+                                    : TypeCastKind.ERROR;
                     }
                 } else {
                     switch (castTypeKind) {
@@ -402,8 +402,8 @@ protected TypecastKind isTypeCastSafe(
                                                 CollectionsPlume.mapList(
                                                         Number::byteValue, exprValues));
                                 return sortedSetContainsAll(castValuesTree, exprValuesTree)
-                                        ? TypecastKind.SAFE
-                                        : TypecastKind.ERROR;
+                                        ? TypeCastKind.SAFE
+                                        : TypeCastKind.ERROR;
                             }
                         case INT:
                             {
@@ -416,8 +416,8 @@ protected TypecastKind isTypeCastSafe(
                                                 CollectionsPlume.mapList(
                                                         Number::intValue, exprValues));
                                 return sortedSetContainsAll(castValuesTree, exprValuesTree)
-                                        ? TypecastKind.SAFE
-                                        : TypecastKind.ERROR;
+                                        ? TypeCastKind.SAFE
+                                        : TypeCastKind.ERROR;
                             }
                         case SHORT:
                             {
@@ -430,16 +430,16 @@ protected TypecastKind isTypeCastSafe(
                                                 CollectionsPlume.mapList(
                                                         Number::shortValue, exprValues));
                                 return sortedSetContainsAll(castValuesTree, exprValuesTree)
-                                        ? TypecastKind.SAFE
-                                        : TypecastKind.ERROR;
+                                        ? TypeCastKind.SAFE
+                                        : TypeCastKind.ERROR;
                             }
                         default:
                             {
                                 TreeSet<Long> castValuesTree = new TreeSet<>(castValues);
                                 TreeSet<Long> exprValuesTree = new TreeSet<>(exprValues);
                                 return sortedSetContainsAll(castValuesTree, exprValuesTree)
-                                        ? TypecastKind.SAFE
-                                        : TypecastKind.ERROR;
+                                        ? TypeCastKind.SAFE
+                                        : TypeCastKind.ERROR;
                             }
                     }
                 }

javacutil/src/main/java/org/checkerframework/javacutil/TypesUtils.java

@@ -297,7 +297,7 @@ public static boolean areSamePrimitiveTypes(TypeMirror left, TypeMirror right) {
     }
 
     /**
-     * Returns true iff the arguments are both the same type variables.
+     * Returns true iff the arguments are both the same type variable.
      *
      * @param v1 a type variable
      * @param v2 a type variable