Update code

Author: noti0na1

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

@@ -464,7 +464,7 @@ object Contexts {
     def explicitNulls: Boolean = base.settings.YexplicitNulls.value
 
     /** Is the flexible types option set? */
-    def flexibleTypes: Boolean = base.settings.YflexibleTypes.value
+    def flexibleTypes: Boolean = base.settings.YexplicitNulls.value && base.settings.YflexibleTypes.value
 
     /** A fresh clone of this context embedded in this context. */
     def fresh: FreshContext = freshOver(this)

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

@@ -122,7 +122,7 @@ object JavaNullInterop {
         // We don't make the outmost levels of type arguments nullable if tycon is Java-defined.
         // This is because Java classes are _all_ nullified, so both `java.util.List[String]` and
         // `java.util.List[String|Null]` contain nullable elements.
-        outermostLevelAlreadyNullable = tp.classSymbol.is(JavaDefined) && !ctx.flexibleTypes
+        outermostLevelAlreadyNullable = tp.classSymbol.is(JavaDefined)
         val targs2 = targs map this
         outermostLevelAlreadyNullable = oldOutermostNullable
         val appTp2 = derivedAppliedType(appTp, tycon, targs2)

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

@@ -39,7 +39,7 @@ object NullOpsDecorator:
             if (tp1s ne tp1) && (tp2s ne tp2) then
               tp.derivedAndType(tp1s, tp2s)
             else tp
-          case tp @ FlexibleType(tp1) => strip(tp1)
+          case tp: FlexibleType => tp.hi
           case tp @ TypeBounds(lo, hi) =>
             tp.derivedTypeBounds(strip(lo), strip(hi))
           case tp => tp

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

@@ -545,7 +545,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       // invariant: tp2 is NOT a FlexibleType
       // is Flex(T) <: tp2?
       case tp1: FlexibleType =>
-        recur(tp1.underlying, tp2)
+        recur(tp1.hi, tp2)
       case CapturingType(parent1, refs1) =>
         if tp2.isAny then true
         else if subCaptures(refs1, tp2.captureSet, frozenConstraint).isOK && sameBoxed(tp1, tp2, refs1)

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

@@ -3408,19 +3408,28 @@ object Types {
    * in Kotlin. A FlexibleType(T) generally behaves like an abstract type with bad bounds
    * T|Null .. T, so that T|Null <: FlexibleType(T) <: T.
    */
+  case class FlexibleType(underlying: Type, lo: Type, hi: Type) extends CachedGroundType with ValueType {
+    def derivedFlexibleType(underlying: Type)(using Context): Type =
+      if this.underlying eq underlying then this else FlexibleType(underlying)
+
+    override def computeHash(bs: Binders): Int = doHash(bs, underlying)
+
+    override final def baseClasses(using Context): List[ClassSymbol] = underlying.baseClasses
+  }
 
   object FlexibleType {
-    def apply(underlying: Type) = underlying match {
+    def apply(underlying: Type)(using Context): FlexibleType = underlying match {
       case ft: FlexibleType => ft
-      case _ => new FlexibleType(underlying)
+      case _ =>
+        val hi = underlying.stripNull
+        val lo = if hi eq underlying then OrNull(hi) else underlying
+        new FlexibleType(underlying, lo, hi)
+    }
+
+    def unapply(tp: Type)(using Context): Option[Type] = tp match {
+      case ft: FlexibleType => Some(ft.underlying)
+      case _ => None
     }
-  }
-  case class FlexibleType(underlying: Type) extends CachedGroundType with ValueType {
-    def lo(using Context): Type = OrNull(underlying)
-    def derivedFlexibleType(under: Type)(using Context): Type =
-      if this.underlying eq under then this else FlexibleType(under)
-    override def computeHash(bs: Binders): Int = doHash(bs, underlying)
-    override final def baseClasses(using Context): List[ClassSymbol] = underlying.baseClasses
   }
 
   // --- AndType/OrType ---------------------------------------------------------------
@@ -5662,8 +5671,8 @@ object Types {
             val args1 = args.zipWithConserve(tparams):
               case (arg @ TypeBounds(lo, hi), tparam) =>
                 boundFollowingVariance(lo, hi, tparam)
-              case (arg @ FlexibleType(lo, hi), tparam) =>
-                boundFollowingVariance(arg.lo, hi, tparam)
+              case (arg: FlexibleType, tparam) =>
+                boundFollowingVariance(arg.lo, arg.hi, tparam)
               case (arg, _) => arg
             tp.derivedAppliedType(tycon, args1)
           case tp: RefinedType =>

compiler/src/dotty/tools/dotc/typer/Nullables.scala

@@ -35,7 +35,7 @@ object Nullables:
 
   private def nullifiedHi(lo: Type, hi: Type)(using Context): Type =
     if needNullifyHi(lo, hi) then
-      if ctx.flexibleTypes then FlexibleType(hi) else OrType(hi, defn.NullType, soft = false)
+      if ctx.flexibleTypes then FlexibleType(hi) else OrNull(hi)
     else hi
 
   /** Create a nullable type bound

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -205,16 +205,24 @@ class CompilationTests {
   }.checkRuns()
 
   // Flexible types tests
-  @Test def flexibleTypesRun: Unit = {
-    implicit val testGroup: TestGroup = TestGroup("flexibleTypesRun")
-    compileFilesInDir("tests/flexible-types/run", flexibleTypesOptions)
-  }.checkRuns()
+  // @Test def flexibleTypesRun: Unit = {
+  //   implicit val testGroup: TestGroup = TestGroup("flexibleTypesRun")
+  //   compileFilesInDir("tests/flexible-types/run", flexibleTypesOptions)
+  // }.checkRuns()
+
+  @Test def flexibleTypesNeg: Unit = {
+    implicit val testGroup: TestGroup = TestGroup("flexibleTypesNeg")
+    aggregateTests(
+      compileFilesInDir("tests/explicit-nulls/flexible-types/neg", defaultOptions and "-Yexplicit-nulls"),
+      compileFilesInDir("tests/explicit-nulls/flexible-types/common", defaultOptions and "-Yexplicit-nulls"),
+    )
+  }.checkExpectedErrors()
 
   @Test def flexibleTypesPos: Unit = {
     implicit val testGroup: TestGroup = TestGroup("flexibleTypesPos")
     aggregateTests(
-      compileFilesInDir("tests/flexible-types/pos", flexibleTypesOptions),
-      compileFilesInDir("tests/flexible-types/pos-separate", flexibleTypesOptions)
+      compileFilesInDir("tests/explicit-nulls/flexible-types/pos", flexibleTypesOptions),
+      compileFilesInDir("tests/explicit-nulls/flexible-types/common", flexibleTypesOptions),
     )
   }.checkCompile()
 

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -85,6 +85,8 @@ object TestConfiguration {
   val picklingWithCompilerOptions =
     picklingOptions.withClasspath(withCompilerClasspath).withRunClasspath(withCompilerClasspath)
 
+  val explicitNullsOptions = defaultOptions and "-Yexplicit-nulls"
+
   val flexibleTypesOptions = explicitNullsOptions and "-Yflexible-types"
 
   /** Default target of the generated class files */

tests/explicit-nulls/flexible-types/common/equal/J.java

@@ -0,0 +1,9 @@
+public class J {
+  public String f() {
+    return "";
+  }
+
+  public <T> T g() {
+    return null;
+  }
+}

tests/explicit-nulls/flexible-types/common/equal/S.scala

@@ -0,0 +1,17 @@
+// Check Java calls have been cast to non-nullable.
+
+def test[T <: AnyRef] =
+  val j: J = new J
+
+  val s = j.f()
+  val sn = s == null
+  val sn2 = s != null
+  val seqn = s eq null
+  val seqn2 = null eq s
+
+
+  val t = j.g[T]()
+  val tn = t == null
+  val tn2 = t != null
+  val teqn = t eq null
+  val teqn2 = null eq t

tests/flexible-types/pos/i7883.scala renamed to tests/explicit-nulls/flexible-types/common/i7883.scala

@@ -6,11 +6,4 @@ object Test extends App {
       case r(hd, tl) => Some((hd, tl))  // error // error // error
       case _ => None
     }
-
-  def headUnsafe(s: String, r: Regex): Option[(String, String)] =
-    import scala.language.unsafeNulls
-    s.trim match {
-      case r(hd, tl) => Some((hd, tl))
-      case _ => None
-    }
 }

tests/flexible-types/pos/interop-propagate.scala renamed to tests/explicit-nulls/flexible-types/common/interop-propagate.scala

@@ -0,0 +1,28 @@
+public class J {
+
+  public class K {}
+
+  public J self() {
+    return this;
+  }
+
+  public String f1() {
+    return "";
+  }
+
+  public int f2() {
+    return 0;
+  }
+
+  public K f3() {
+    return null;
+  }
+
+  public <T> T g1() {
+    return null;
+  }
+}
+
+class J2<T> {
+  public T x = null;
+}

tests/explicit-nulls/flexible-types/common/java-call/J.java

@@ -0,0 +1,37 @@
+// Check Java calls have been cast to non-nullable.
+
+val j: J = new J
+
+val jj = j.self()
+
+val s1: String = j.f1() // error
+
+val s1n: String | Null = j.f1()
+
+val i1: Int = j.f2()
+
+val k: jj.K = jj.f3()
+
+val s2: String = j.g1[String]()  // error
+
+val s2n: String | Null = j.g1[String]()
+
+val s3: String = j.g1[String | Null]()  // error
+
+val s3n: String | Null = j.g1[String | Null]()
+
+val i2: Int = j.g1[Int]()  // error
+
+val a1: Any = j.g1[Any]()
+
+val ar1: AnyRef = j.g1[AnyRef]()  // error
+
+val n1: Null = j.g1[Null]()
+
+def clo1[T]: T = j.g1[T]()  // error
+
+def clo3[T >: Null <: AnyRef | Null]: T = j.g1[T]()
+
+def testJ2[T]: T =
+  val j2: J2[T] = new J2
+  j2.x // error

tests/explicit-nulls/flexible-types/common/java-call/S.scala

@@ -0,0 +1,7 @@
+class J1 {
+  J2 getJ2() { return new J2(); }
+}
+
+class J2 {
+  J1 getJ1() { return new J1(); }
+}

tests/explicit-nulls/flexible-types/common/java-chain/J.java

@@ -0,0 +1,4 @@
+class S {
+  val j: J2 = new J2()
+  j.getJ1().getJ2().getJ1().getJ2().getJ1().getJ2() // error
+}

tests/explicit-nulls/flexible-types/common/java-chain/S.scala

@@ -1,4 +1,3 @@
 abstract class J {
   abstract void foo(String... x);
-  abstract void bar(String x, String... y);
 }

tests/flexible-types/pos/override-java-varargs/J.java renamed to tests/explicit-nulls/flexible-types/common/java-varargs-src/J.java

@@ -0,0 +1,20 @@
+class S {
+  val j: J = ???
+
+  j.foo()
+  j.foo("")
+  j.foo(null)
+  j.foo("", "")
+  j.foo("", null, "")
+
+  val arg1: Array[String] = ???
+  val arg2: Array[String | Null] = ???
+  val arg3: Array[String] | Null = ???
+  val arg4: Array[String | Null] | Null = ???
+
+  j.foo(arg1: _*)
+  j.foo(arg2: _*)
+  // TODO: fix for flexible types
+  j.foo(arg3: _*) // error
+  j.foo(arg4: _*) // error
+}

tests/explicit-nulls/flexible-types/common/java-varargs-src/S.scala

@@ -0,0 +1,9 @@
+// Test that we can select through "| Null" is unsafeNulls is enabled (unsoundly).
+
+class Foo {
+  import java.util.ArrayList
+  import java.util.Iterator
+
+  val x3 = new ArrayList[ArrayList[ArrayList[String]]]()
+  val x4: Int = x3.get(0).get(0).get(0).length() // error
+}

tests/explicit-nulls/flexible-types/common/unsafe-chain.scala

@@ -0,0 +1,10 @@
+class S {
+  locally {
+    // OfType Implicits
+
+    import java.nio.charset.StandardCharsets
+    import scala.io.Codec
+
+    val c: Codec = StandardCharsets.UTF_8 // error
+  }
+}

tests/explicit-nulls/flexible-types/common/unsafe-implicit.scala

@@ -0,0 +1,38 @@
+import java.nio.file.Paths
+
+def test1 = {
+  Paths.get("")
+  Paths.get("", null)
+  Paths.get("", "")
+  Paths.get("", "", null)
+
+  val x1: String = ???
+  val x2: String | Null = ???
+
+  Paths.get("", x1)
+  Paths.get("", x2)
+}
+
+def test2 = {
+  val xs1: Seq[String] = ???
+  val xs2: Seq[String | Null] = ???
+  val xs3: Seq[String | Null] | Null = ???
+  val xs4: Seq[String] | Null = ???
+
+  val ys1: Array[String] = ???
+  val ys2: Array[String | Null] = ???
+  val ys3: Array[String | Null] | Null = ???
+  val ys4: Array[String] | Null = ???
+
+  Paths.get("", xs1: _*)
+  Paths.get("", xs2: _*)
+  Paths.get("", xs3: _*) // error
+  Paths.get("", xs4: _*) // error
+
+  Paths.get("", ys1: _*)
+  Paths.get("", ys2: _*)
+  Paths.get("", ys3: _*) // error
+  Paths.get("", ys4: _*) // error
+
+  Paths.get("", null: _*) // error
+}

tests/explicit-nulls/flexible-types/common/unsafe-java-varargs.scala

@@ -0,0 +1,5 @@
+def test1 =
+  val s: String = ???
+  s.trim() match
+    case _: String =>
+    case null => // error: Values of types Null and String cannot be compared

tests/explicit-nulls/flexible-types/common/unsafe-match-null.scala

@@ -0,0 +1,22 @@
+class S {
+  class O {
+    type I = Int
+    val a: I = 1
+
+    type S = String | Null
+    val s: S = ""
+  }
+
+  def f = {
+    val o: O = new O
+    val m: O | Null = o
+    val n0: o.I = o.a
+    val n1: m.I = 0 // error
+    val n2: Int = m.a // error
+
+    val s1: m.S = ??? // error
+    val s2: m.S | Null = ??? // error
+    val s3: String = m.s // error
+    val ss: String = o.s // error
+  }
+}

tests/explicit-nulls/flexible-types/common/unsafe-path.scala

@@ -0,0 +1,7 @@
+import java.util.ArrayList
+
+def f[T]: ArrayList[T] = {
+  val cz = Class.forName("java.util.ArrayList")
+  val o = cz.newInstance() // error: T of Class[?] | Null
+  o.asInstanceOf[ArrayList[T]]
+}

tests/explicit-nulls/flexible-types/common/unsafe-select-type-member.scala

@@ -0,0 +1,3 @@
+public class J<T> {
+  public J<T> j = this;
+}