Improve cast warnings/errors logic

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

@@ -113,7 +113,8 @@ protected void commonAssignmentCheck(
     }
 
     @Override
-    protected boolean isTypeCastSafe(AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
+    protected TypecastKind isTypeCastSafe(
+            AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
 
         AnnotationMirror exprLTAnno =
                 exprType.getEffectiveAnnotationInHierarchy(atypeFactory.LESS_THAN_UNKNOWN);

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

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

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

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

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

@@ -384,10 +384,11 @@ public Void visitCompoundAssignment(CompoundAssignmentTree tree, Void p) {
     }
 
     @Override
-    protected boolean isTypeCastSafe(AnnotatedTypeMirror castType, AnnotatedTypeMirror exprType) {
+    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 true;
+            return TypecastKind.SAFE;
         }
         return super.isTypeCastSafe(castType, exprType);
     }

checker/tests/lock/ChapterExamples.java

@@ -319,7 +319,7 @@ void someMethod() {
         o2 = o1; // {"lock"} and {} are not identical sets.
     }
 
-    @SuppressWarnings("lock:cast.unsafe")
+    @SuppressWarnings("lock:cast.incomparable")
     void someMethod2() {
         // A cast can be used if the user knows it is safe to do so.
         // However, the @SuppressWarnings must be added.
@@ -567,7 +567,7 @@ public boolean compare(T[] a1, T[] a2) {
     private static final Object NULL_KEY = new Object();
 
     // A guardsatisfied.location.disallowed error is issued for the cast.
-    @SuppressWarnings({"cast.unsafe", "guardsatisfied.location.disallowed"})
+    @SuppressWarnings({"cast.incomparable", "guardsatisfied.location.disallowed"})
     private static @GuardSatisfied(1) Object maskNull(@GuardSatisfied(1) Object key) {
         return (key == null ? (@GuardSatisfied(1) Object) NULL_KEY : key);
     }

checker/tests/lock/Strings.java

@@ -13,7 +13,9 @@ void StringIsGBnothing(
             @GuardSatisfied Object o3,
             @GuardedByBottom Object o4) {
         String s1 = (String) o1;
+        // :: error: (cast.incomparable)
         String s2 = (String) o2;
+        // :: error: (cast.incomparable)
         String s3 = (String) o3;
         String s4 = (String) o4; // OK
     }

checker/tests/signedness/CastFromTtoT.java

@@ -0,0 +1,35 @@
+import org.checkerframework.checker.signedness.qual.*;
+
+import java.util.*;
+
+class CastFromTtoT<T extends @UnknownSignedness Object> {
+    @SuppressWarnings("unchecked")
+    T bar(@UnknownSignedness Object p) {
+        T x = (T) p;
+        return x;
+    }
+
+    // Seems to have no cast, but in the instantiation, it's a downcast.
+    // if we use getEffectiveAnnotations, we'll see it as no cast (qualifier aspect)
+    // But it's fine, as compiler will warn about casting object to 'T' [unchecked warning]
+    void foo(CastFromTtoT<@Signed Integer> s, @UnknownSignedness Object local) {
+        @Signed Integer x = s.bar(local);
+    }
+
+    class Inner<T extends @UnknownSignedness Object> {
+        T bar2(@Signed T p) {
+            // without a warning from the compiler. The T in the casting expression may have
+            // different signedness annotation with the arugment p.
+            // :: warning: (cast.unsafe)
+            T x = (T) p;
+            return x;
+        }
+
+        // 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
+        // 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);
+        }
+    }
+}

checker/tests/signedness/CharCast.java

@@ -8,13 +8,13 @@ void m(@SignedPositive int i) {
 
     void m1(short s) {
         int x = s;
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         char c = (char) x;
     }
 
     void m2(int i) {
         int x = (short) i;
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         char c = (char) x;
     }
 

checker/tests/signedness/CharToFloat.java

@@ -2,7 +2,9 @@
 
 public class CharToFloat {
     void castCharacter(Object o) {
+        // :: error: (cast.incomparable)
         floatParameter((Character) o);
+        // :: error: (cast.incomparable)
         doubleParameter((Character) o);
     }
 

checker/tests/signedness/LiteralCast.java

@@ -24,7 +24,7 @@ void m() {
         requireSigned((@Unsigned int) 2);
         requireSigned((int) 2);
         requireSigned((@m int) 2);
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         requireSigned((@Signed int) u);
         // :: error: (argument.type.incompatible)
         requireSigned((@Unsigned int) u);
@@ -33,7 +33,7 @@ void m() {
         // :: error: (argument.type.incompatible)
         requireSigned((@m int) u);
         requireSigned((@Signed int) s);
-        // :: error: (argument.type.incompatible) :: warning: (cast.unsafe)
+        // :: error: (argument.type.incompatible) :: error: (cast.incomparable)
         requireSigned((@Unsigned int) s);
         requireSigned((int) s);
         requireSigned((@m int) s);
@@ -43,14 +43,14 @@ void m() {
         requireUnsigned((@Unsigned int) 2);
         requireUnsigned((int) 2);
         requireUnsigned((@m int) 2);
-        // :: error: (argument.type.incompatible) :: warning: (cast.unsafe)
+        // :: error: (argument.type.incompatible) :: error: (cast.incomparable)
         requireUnsigned((@Signed int) u);
         requireUnsigned((@Unsigned int) u);
         requireUnsigned((int) u);
         requireUnsigned((@m int) u);
         // :: error: (argument.type.incompatible)
         requireUnsigned((@Signed int) s);
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         requireUnsigned((@Unsigned int) s);
         // :: error: (argument.type.incompatible)
         requireUnsigned((int) s);

checker/tests/signedness/PrimitiveCasts.java

@@ -3,7 +3,7 @@
 public class PrimitiveCasts {
 
     void shortToChar1(short s) {
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         char c = (char) s;
     }
 

checker/tests/signedness/WideningConversion.java

@@ -74,19 +74,19 @@ void plus() {
 
         char c;
         c = (char) (c1 + c2);
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         c = (char) (c1 + i2);
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         c = (char) (i1 + c2);
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         c = (char) (i1 + i2);
 
         c = (char) (c1 + c2);
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         c = (char) (c1 + si2);
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         c = (char) (si1 + c2);
-        // :: warning: (cast.unsafe)
+        // :: error: (cast.incomparable)
         c = (char) (si1 + si2);
 
         c = (char) (c1 + c2);

docs/CHANGELOG.md

@@ -19,6 +19,10 @@ Fixed a bug in the Nullness Checker where an instance receiver is incorrectly ma
 a static method or field access. This could lead to new nullness errors. The static access should be
 changed to be through a class name.
 
+A new error message `cast.incomparable` will be raised if casting an expression to one target type which
+does not share a subtype relationship with the expression type in the lattice. No longer issue errors
+for statically verifiable downcast.
+
 **Implementation details:**
 
 Corrected the arguments to an `ObjectCreationNode` when the node refers to an
@@ -36,9 +40,13 @@ Changed the return types of
 - `AnalysisResult#getFinalLocalValues()` to `Map<VariableElement, V>`, and
 - `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
+is statically verifiable or not.
+
 **Closed issues:**
 
-eisop#297, eisop#376, eisop#400, eisop#519, eisop#532, eisop#533, typetools#1590.
+eisop#155, eisop#297, eisop#376, eisop#400, eisop#519, eisop#532, eisop#533, typetools#1590.
 
 
 Version 3.34.0-eisop1 (May 9, 2023)