Handle invalid cast in code

The path-insensitive nature of the analysis will necessarily lead to invalid casts. We cannot report
warnings for such invalid casts as that would lead to too many false positives. Instead, we suppress
the warnings on invalid member selections resulted from invalid casts.

Author: liufengyun

compiler/src/dotty/tools/dotc/transform/init/Objects.scala

@@ -133,6 +133,12 @@ object Objects:
 
     def hasOuter(cls: ClassSymbol): Boolean = outers.contains(cls)
 
+    /**
+     * Whether the given symbol is a member of the underlying object?
+     */
+    def hasMember(sym: Symbol)(using Context): Boolean =
+      klass.isSubClass(sym.owner)
+
     def initVal(field: Symbol, value: Value)(using Context) = log("Initialize " + field.show + " = " + value + " for " + this, printer) {
       assert(!field.is(Flags.Mutable), "Field is mutable: " + field.show)
       assert(!vals.contains(field), "Field already set: " + field.show)
@@ -171,7 +177,7 @@ object Objects:
 
     def show(using Context) =
       val valFields = vals.map(_.show +  " -> " +  _.show)
-      "OfClass(" + klass.show + ", outer = " + outer + ", args = " + args.map(_.show) + ", vals = " + valFields + ")"
+      "OfClass(" + klass.show + ", outer = " + outer + ", args = " + args.map(_.show) + ", vals = " + valFields + ", vars = " + vars + ")"
 
   object OfClass:
     def apply(
@@ -612,7 +618,7 @@ object Objects:
    * @param needResolve  Whether the target of the call needs resolution?
    */
   def call(value: Value, meth: Symbol, args: List[ArgInfo], receiver: Type, superType: Type, needResolve: Boolean = true): Contextual[Value] = log("call " + meth.show + ", this = " + value.show + ", args = " + args.map(_.value.show), printer, (_: Value).show) {
-    value match
+    value.match
     case Cold =>
       report.warning("Using cold alias. " + Trace.show, Trace.position)
       Bottom
@@ -786,19 +792,19 @@ object Objects:
             else
               errorReadOtherStaticObject(State.currentObject, addr.owner)
               Bottom
-          else if ref.isObjectRef && ref.klass.hasSource then
+          else if ref.hasMember(target) && !target.isOneOf(Flags.JavaDefined, Flags.Scala2x) then
             report.warning("Access uninitialized field " + field.show + ". " + Trace.show, Trace.position)
             Bottom
           else
-            // initialization error, reported by the initialization checker
+            // Silent for invalid member selection from pattern matching, type cast
             Bottom
         else if ref.hasVal(target) then
           ref.valValue(target)
-        else if ref.isObjectRef && ref.klass.hasSource then
+        else if ref.hasMember(target) && !target.isOneOf(Flags.JavaDefined, Flags.Scala2x) then
           report.warning("Access uninitialized field " + field.show + ". " + Trace.show, Trace.position)
           Bottom
         else
-          // initialization error, reported by the initialization checker
+          // Silent for invalid member selection from pattern matching, type cast
           Bottom
 
       else
@@ -856,7 +862,7 @@ object Objects:
           errorMutateOtherStaticObject(State.currentObject, addr.owner)
         else
           Heap.writeJoin(addr, rhs)
-      else
+      else if ref.hasMember(field) && !field.isOneOf(Flags.JavaDefined, Flags.Scala2x) then
         report.warning("Mutating a field before its initialization: " + field.show + ". " + Trace.show, Trace.position)
     end match
 

tests/init-global/neg/array-buffer2.scala

@@ -0,0 +1,23 @@
+class A:
+  var a = 10
+
+  def foo() = O.n  // error
+
+class B:
+  var b = 20
+  def bar() = O.n  // error
+
+object O:
+  val o1: A | B = new A
+  val o2: A | B = new B
+
+  if o1.isInstanceOf[A] then
+    o1.asInstanceOf[A].foo()
+  else
+    o1.asInstanceOf[B].bar()
+
+  o2 match
+    case o: A => o.foo()
+    case o: B => o.bar()
+
+  val n = 10

tests/init-global/pos/array-buffer2.scala

@@ -0,0 +1,18 @@
+class A:
+  var a = 10
+
+class B:
+  var b = 20
+
+object O:
+  val o: A | B = new A
+
+  if o.isInstanceOf[A] then
+    o.asInstanceOf[A].a += 1
+  else
+    o.asInstanceOf[B].b += 2
+
+  o match
+    case o: A => o.a += 1
+    case o: B => o.b += 2
+