Expand tests and fix refined types

Author: HarrisL2

compiler/src/dotty/tools/dotc/core/ImplicitNullInterop.scala

@@ -160,6 +160,7 @@ object ImplicitNullInterop {
       case tp: AnnotatedType => mapOver(tp)
       case tp: OrType => mapOver(tp)
       case tp: MatchType => mapOver(tp)
+      case tp: RefinedType => nullify(mapOver(tp))
       case _ => tp
     }
   }

tests/explicit-nulls/flexible-unpickle/Flexible_2.scala

@@ -1,5 +1,7 @@
 import unsafeNulls.Foo.*
 import unsafeNulls.Unsafe_1
+import unsafeNulls.{A, B, C}
+import scala.reflect.Selectable.reflectiveSelectable
 
 class Inherit_1 extends Unsafe_1 {
   override def foo(s: String): String = s
@@ -37,4 +39,30 @@ def Flexible_2() =
   unsafe.foo("")
   unsafe.foo(null)
 
-  val refinement = new Unsafe_1 {val b: String}
+
+  val a = refinement.b
+  refinement.b = null
+  val refinement2: Unsafe_1 { var b: String } = refinement
+  refinement = null
+
+  val singletonbar: bar.type = singleton
+
+  val extension: String = intersection.reverse
+
+  val stringA: String = intersection.stringA
+  val stringB: String = intersection.stringB
+  intersection.stringA = null
+  intersection.stringB = null
+
+  val intersection2: A & B = intersection
+  intersection = null
+
+  val stringC: String = union.stringC
+  union.stringC = null
+
+  val union2: A | B = union
+  union = null
+
+  val constructorTest = new Unsafe_1(null)
+  val member: String = constructorTest.member
+  constructorTest.member = null

tests/explicit-nulls/flexible-unpickle/Unsafe_1.scala

@@ -1,6 +1,12 @@
 package unsafeNulls
 
 class Unsafe_1 {
+
+  def this(s: String) = {
+    this()
+    ???
+  }
+
   def foo(s: String): String = {
     if (s == null) then "nullString"
     else s
@@ -13,14 +19,30 @@ class Unsafe_1 {
   }
   def bar3[T <: Function1[String,String]](g: T): T = g
   def bar4[HK[_]](i: String): HK[String] = ???
+
+  var member: String = ???
 }
 
-object Foo {
-  def bar = "bar!"
-  def id[T](t: T): T = t
+trait A extends C {
+  var stringA: String
+}
+
+trait B extends C {
+  var stringB: String
+}
 
+trait C {
+  var stringC: String
 }
 
-class Constructors {
+object Foo {
+  extension (c: C)
+    def reverse: String = c.stringC.reverse
 
+  val bar: String = null
+  def id[T](t: T): T = t
+  var refinement: Unsafe_1 { var b: String }  = new Unsafe_1 { var b: String = "???" }
+  var singleton: bar.type = bar
+  var intersection: A & B = ???
+  var union: A | B = ???
 }