Add experimental flexible types feature on top of explicit nulls

Enabled by -Yflexible-types with -Yexplicit-nulls.
A flexible type T! is a non-denotable type such that T <: T! <: T|Null and T|Null <: T! <: T. Here we patch return types and parameter types of Java methods and fields to use flexible types.
This is unsound and kills subtyping transitivity but makes interop with Java play more nicely with the explicit nulls experimental feature (i.e. fewer nullability casts).
Also adds a few tests for flexible types, mostly lifted from the explicit nulls tests.

Author: evangirardin

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

@@ -2577,53 +2577,73 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   /** Try to distribute `&` inside type, detect and handle conflicts
    *  @pre !(tp1 <: tp2) && !(tp2 <:< tp1) -- these cases were handled before
    */
-  private def distributeAnd(tp1: Type, tp2: Type): Type = tp1 match {
-    case tp1 @ AppliedType(tycon1, args1) =>
-      tp2 match {
-        case AppliedType(tycon2, args2)
-        if tycon1.typeSymbol == tycon2.typeSymbol && tycon1 =:= tycon2 =>
-          val jointArgs = glbArgs(args1, args2, tycon1.typeParams)
-          if (jointArgs.forall(_.exists)) (tycon1 & tycon2).appliedTo(jointArgs)
-          else NoType
-        case _ =>
-          NoType
-      }
-    case tp1: RefinedType =>
-      // opportunistically merge same-named refinements
-      // this does not change anything semantically (i.e. merging or not merging
-      // gives =:= types), but it keeps the type smaller.
-      tp2 match {
-        case tp2: RefinedType if tp1.refinedName == tp2.refinedName =>
-          val jointInfo = Denotations.infoMeet(tp1.refinedInfo, tp2.refinedInfo, safeIntersection = false)
-          if jointInfo.exists then
-            tp1.derivedRefinedType(tp1.parent & tp2.parent, tp1.refinedName, jointInfo)
-          else
+  private def distributeAnd(tp1: Type, tp2: Type): Type = {
+    var ft1 = false
+    var ft2 = false
+    def recur(tp1: Type, tp2: Type): Type = tp1 match {
+      case tp1 @ FlexibleType(tp) =>
+        // Hack -- doesn't generalise to other intersection/union types
+        // but covers a common special case for pattern matching
+        ft1 = true
+        recur(tp, tp2)
+      case tp1 @ AppliedType(tycon1, args1) =>
+        tp2 match {
+          case AppliedType(tycon2, args2)
+          if tycon1.typeSymbol == tycon2.typeSymbol && tycon1 =:= tycon2 =>
+            val jointArgs = glbArgs(args1, args2, tycon1.typeParams)
+            if (jointArgs.forall(_.exists)) (tycon1 & tycon2).appliedTo(jointArgs)
+            else {
+              NoType
+            }
+          case FlexibleType(tp) =>
+            // Hack from above
+            ft2 = true
+            recur(tp1, tp)
+          case _ =>
             NoType
-        case _ =>
-          NoType
-      }
-    case tp1: RecType =>
-      tp1.rebind(distributeAnd(tp1.parent, tp2))
-    case ExprType(rt1) =>
-      tp2 match {
-        case ExprType(rt2) =>
-          ExprType(rt1 & rt2)
-        case _ =>
-          NoType
-      }
-    case tp1: TypeVar if tp1.isInstantiated =>
-      tp1.underlying & tp2
-    case CapturingType(parent1, refs1) =>
-      if subCaptures(tp2.captureSet, refs1, frozen = true).isOK
-        && tp1.isBoxedCapturing == tp2.isBoxedCapturing
-      then
-        parent1 & tp2
-      else
-        tp1.derivedCapturingType(parent1 & tp2, refs1)
-    case tp1: AnnotatedType if !tp1.isRefining =>
-      tp1.underlying & tp2
-    case _ =>
-      NoType
+        }
+
+      // if result exists and is not notype, maybe wrap result in flex based on whether seen flex on both sides
+      case tp1: RefinedType =>
+        // opportunistically merge same-named refinements
+        // this does not change anything semantically (i.e. merging or not merging
+        // gives =:= types), but it keeps the type smaller.
+        tp2 match {
+          case tp2: RefinedType if tp1.refinedName == tp2.refinedName =>
+            val jointInfo = Denotations.infoMeet(tp1.refinedInfo, tp2.refinedInfo, safeIntersection = false)
+            if jointInfo.exists then
+              tp1.derivedRefinedType(tp1.parent & tp2.parent, tp1.refinedName, jointInfo)
+            else
+              NoType
+          case _ =>
+            NoType
+        }
+      case tp1: RecType =>
+        tp1.rebind(recur(tp1.parent, tp2))
+      case ExprType(rt1) =>
+        tp2 match {
+          case ExprType(rt2) =>
+            ExprType(rt1 & rt2)
+          case _ =>
+            NoType
+        }
+      case tp1: TypeVar if tp1.isInstantiated =>
+        tp1.underlying & tp2
+      case CapturingType(parent1, refs1) =>
+        if subCaptures(tp2.captureSet, refs1, frozen = true).isOK
+          && tp1.isBoxedCapturing == tp2.isBoxedCapturing
+        then
+          parent1 & tp2
+        else
+          tp1.derivedCapturingType(parent1 & tp2, refs1)
+      case tp1: AnnotatedType if !tp1.isRefining =>
+        tp1.underlying & tp2
+      case _ =>
+        NoType
+    }
+    // if flex on both sides, return flex type
+    val ret = recur(tp1, tp2)
+    if (ft1 && ft2) then FlexibleType(ret) else ret
   }
 
   /** Try to distribute `|` inside type, detect and handle conflicts

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

@@ -561,6 +561,7 @@ object TypeErasure {
     case tp: TypeProxy => hasStableErasure(tp.translucentSuperType)
     case tp: AndType => hasStableErasure(tp.tp1) && hasStableErasure(tp.tp2)
     case tp: OrType  => hasStableErasure(tp.tp1) && hasStableErasure(tp.tp2)
+    case _: FlexibleType => false
     case _ => false
   }
 

tests/flexible-types/flexible-types.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/neg" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

tests/flexible-types/run/array/S.scala

@@ -0,0 +1,30 @@
+/*
+class Foo {
+  def err(msg: String): Nothing = {
+    throw new RuntimeException("Hello")
+  }
+  def retTypeNothing(): String = {
+    val y: String|Null = ???
+    if (y == null) err("y is null!")
+    y
+  }
+}
+*/
+
+
+
+@main def main() = {
+  val i : Integer = new Integer(3) // Constructor with non-ref arg
+  val s1 : String | Null = new String("abc") // Constructor with ref arg
+  val s2 : String = new String("abc") // Constructor with ref arg, not null
+  val s3 = s1.nn.substring(0,1).substring(0,1)
+  val s4 = s2.substring(0,1).substring(0,1)
+  val s5 = s4.startsWith(s4)
+  // s1.substring(0,1) // error
+  val j : J = new J("")
+  println(s4)
+  //val f : Foo = new Foo("x")
+  //f.err("Hello")
+  //val l : List[String] = Java.returnsNull();
+  //val j : J = new J
+}