Make Matchable an empty marker trait

Author: odersky

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -625,7 +625,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
 
         val sym = fun.symbol
         val cast =
-          if (sym == defn.Matchable_isInstanceOf) false
+          if (sym == defn.Any_isInstanceOf) false
           else if (sym == defn.Any_asInstanceOf) true
           else abort(s"Unexpected type application $fun[sym: ${sym.showFullName}] in: $t")
         val l = tpeTK(obj)

compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala

@@ -149,7 +149,7 @@ class DottyPrimitives(ictx: Context) {
     // scala.Any
     addPrimitive(defn.Any_==, EQ)
     addPrimitive(defn.Any_!=, NE)
-    addPrimitive(defn.Matchable_isInstanceOf, IS)
+    addPrimitive(defn.Any_isInstanceOf, IS)
     addPrimitive(defn.Any_asInstanceOf, AS)
     addPrimitive(defn.Any_##, HASH)
 
@@ -159,7 +159,7 @@ class DottyPrimitives(ictx: Context) {
  /*   addPrimitive(defn.Any_==, EQ)
     addPrimitive(defn.Any_!=, NE)*/
     addPrimitive(defn.Object_synchronized, SYNCHRONIZED)
-    /*addPrimitive(defn.Matchable_isInstanceOf, IS)
+    /*addPrimitive(defn.Any_isInstanceOf, IS)
     addPrimitive(defn.Any_asInstanceOf, AS)*/
 
     // java.lang.String

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -2867,7 +2867,7 @@ class JSCodeGen()(using genCtx: Context) {
 
     if (sym == defn.Any_asInstanceOf) {
       genAsInstanceOf(genReceiver, to)
-    } else if (sym == defn.Matchable_isInstanceOf) {
+    } else if (sym == defn.Any_isInstanceOf) {
       genIsInstanceOf(genReceiver, to)
     } else {
       throw new FatalError(

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -957,7 +957,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           singleton(tp).equal(tree)
       case _ =>
         tree.ensureConforms(defn.MatchableType)
-          .select(defn.Matchable_isInstanceOf)
+          .select(defn.Any_isInstanceOf)
           .appliedToType(tp)
     }
 

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

@@ -287,13 +287,12 @@ class Definitions {
     @tu lazy val Any_hashCode: TermSymbol     = enterMethod(AnyClass, nme.hashCode_, MethodType(Nil, IntType))
     @tu lazy val Any_toString: TermSymbol     = enterMethod(AnyClass, nme.toString_, MethodType(Nil, StringType))
     @tu lazy val Any_## : TermSymbol          = enterMethod(AnyClass, nme.HASHHASH, ExprType(IntType), Final)
+    @tu lazy val Any_isInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
     @tu lazy val Any_asInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, _.paramRefs(0), Final)
     @tu lazy val Any_typeTest: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic | Artifact)
     @tu lazy val Any_typeCast: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOfPM, _.paramRefs(0), Final | Synthetic | Artifact | StableRealizable)
       // generated by pattern matcher and explicit nulls, eliminated by erasure
 
-    @tu lazy val Matchable_isInstanceOf: TermSymbol = enterT1ParameterlessMethod(MatchableClass, nme.isInstanceOf_, _ => BooleanType, Final)
-
     /** def getClass[A >: this.type](): Class[? <: A] */
     @tu lazy val Any_getClass: TermSymbol =
         enterPolyMethod(
@@ -303,11 +302,7 @@ class Definitions {
           bounds = TypeBounds.lower(AnyClass.thisType))
 
     def AnyMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode, Any_getClass,
-      Any_toString, Any_##, Matchable_isInstanceOf, Any_asInstanceOf, Any_typeTest, Any_typeCast)
-
-    def MatchableMethods: List[TermSymbol] = List(Matchable_isInstanceOf)
-
-    @tu lazy val MatchableMethodNames = MatchableMethods.map(_.name)
+      Any_toString, Any_##, Any_isInstanceOf, Any_asInstanceOf, Any_typeTest, Any_typeCast)
 
   @tu lazy val ObjectClass: ClassSymbol = {
     val cls = requiredClass("java.lang.Object")
@@ -443,7 +438,7 @@ class Definitions {
 
   /** Methods in Object, Matchable, and Any that do not have a side effect */
   @tu lazy val pureMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode,
-    Any_toString, Any_##, Any_getClass, Matchable_isInstanceOf, Any_typeTest, Object_eq, Object_ne)
+    Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_typeTest, Object_eq, Object_ne)
 
   @tu lazy val AnyKindClass: ClassSymbol = {
     val cls = newCompleteClassSymbol(ScalaPackageClass, tpnme.AnyKind, AbstractFinal | Permanent, Nil)
@@ -1432,7 +1427,7 @@ class Definitions {
   @tu lazy val NoInitClasses: Set[Symbol] = NotRuntimeClasses + FunctionXXLClass
 
   def isPolymorphicAfterErasure(sym: Symbol): Boolean =
-     (sym eq Matchable_isInstanceOf) || (sym eq Any_asInstanceOf) || (sym eq Object_synchronized)
+     (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf) || (sym eq Object_synchronized)
 
   def isTupleType(tp: Type)(using Context): Boolean = {
     val arity = tp.dealias.argInfos.length
@@ -1748,7 +1743,7 @@ class Definitions {
 
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
   @tu lazy val syntheticCoreMethods: List[TermSymbol] =
-    AnyMethods ++ MatchableMethods ++ ObjectMethods ++ List(String_+, throwMethod)
+    AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
 
   @tu lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
 

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

@@ -207,7 +207,6 @@ object Types {
 
     def isAny(using Context): Boolean     = isRef(defn.AnyClass, skipRefined = false)
     def isAnyRef(using Context): Boolean  = isRef(defn.ObjectClass, skipRefined = false)
-    def isMatchable(using Context): Boolean = isRef(defn.MatchableClass, skipRefined = false)
     def isAnyKind(using Context): Boolean = isRef(defn.AnyKindClass, skipRefined = false)
 
     def isTopType(using Context): Boolean = dealias match
@@ -517,6 +516,20 @@ object Types {
       case _ =>
         false
 
+    /** Same as hasClassSmbol(MatchableClass), except that we also follow the constraint
+     *  bounds of type variables in the constraint.
+     */
+    def isMatchableBound(using Context): Boolean = dealias match
+      case tp: TypeRef => tp.symbol == defn.MatchableClass
+      case tp: TypeParamRef =>
+        ctx.typerState.constraint.entry(tp) match
+          case bounds: TypeBounds => bounds.hi.isMatchableBound
+          case _ => false
+      case tp: TypeProxy => tp.underlying.isMatchableBound
+      case tp: AndType => tp.tp1.isMatchableBound || tp.tp2.isMatchableBound
+      case tp: OrType => tp.tp1.isMatchableBound && tp.tp2.isMatchableBound
+      case _ => false
+
     /** The term symbol associated with the type */
     @tailrec final def termSymbol(using Context): Symbol = this match {
       case tp: TermRef => tp.symbol

compiler/src/dotty/tools/dotc/transform/SymUtils.scala

@@ -49,7 +49,7 @@ object SymUtils:
       else directlyInheritedTraits
 
     def isTypeTest(using Context): Boolean =
-      self == defn.Matchable_isInstanceOf || self == defn.Any_typeTest
+      self == defn.Any_isInstanceOf || self == defn.Any_typeTest
 
     def isTypeCast(using Context): Boolean =
       self == defn.Any_asInstanceOf || self == defn.Any_typeCast

compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala

@@ -274,7 +274,7 @@ object TypeTestsCasts {
                   transformIsInstanceOf(
                     expr, defn.boxedType(testCls.typeRef), testCls.typeRef, flagUnrelated)
             else
-              derivedTree(expr, defn.Matchable_isInstanceOf, testType)
+              derivedTree(expr, defn.Any_isInstanceOf, testType)
           }
         }
 
@@ -339,7 +339,7 @@ object TypeTestsCasts {
               ref(defn.runtimeMethodRef(nme.isArray)).appliedTo(arg, Literal(Constant(ndims)))
             if (ndims == 1) isArrayTest(expr)
             else evalOnce(expr) { e =>
-              derivedTree(e, defn.Matchable_isInstanceOf, e.tpe)
+              derivedTree(e, defn.Any_isInstanceOf, e.tpe)
                 .and(isArrayTest(e))
             }
           case tref: TypeRef if tref.symbol == defn.TupleClass =>

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

@@ -26,7 +26,7 @@ case class Env(ctx: Context) {
   // Methods that should be ignored in the checking
   lazy val ignoredMethods: Set[Symbol] = Set(
     defn.Any_getClass,
-    defn.Matchable_isInstanceOf,
+    defn.Any_isInstanceOf,
     defn.Object_eq,
     defn.Object_ne,
     defn.Object_synchronized

compiler/src/dotty/tools/dotc/transform/sjs/ExplicitJSClasses.scala

@@ -604,7 +604,7 @@ class ExplicitJSClasses extends MiniPhase with InfoTransformer { thisPhase =>
 
         // Translate x.isInstanceOf[T] for inner and local JS classes
         case TypeApply(fun @ Select(obj, _), tpeArg :: Nil)
-            if sym == defn.Matchable_isInstanceOf && isTypeTreeForInnerOrLocalJSClass(tpeArg) =>
+            if sym == defn.Any_isInstanceOf && isTypeTreeForInnerOrLocalJSClass(tpeArg) =>
           val jsCtorOf = genJSConstructorOf(tree, tpeArg.tpe)
           ref(jsdefn.Special_instanceof).appliedTo(obj, jsCtorOf)
 

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

@@ -3524,11 +3524,7 @@ class Typer extends Namer
       }
 
       // try an Any -> Matchable conversion
-      def isMatchableTarget = pt match
-        case SelectionProto(selName, _, _, _) => defn.MatchableMethodNames.contains(selName)
-        case _ => pt.isMatchable
-
-      if isMatchableTarget && !wtp.derivesFrom(defn.MatchableClass) then
+      if pt.isMatchableBound && !wtp.derivesFrom(defn.MatchableClass) then
         checkMatchable(wtp, tree.srcPos, pattern = false)
         val target = AndType(tree.tpe.widenExpr, defn.MatchableType)
         if target <:< pt then

tests/new/test.scala

@@ -1,5 +1,3 @@
+object Test:
 
-type Curried = [X] =>> [Y] =>> String
-type PartialApplication[X] = Curried[String][X]
-val test1 = PartialApplication[String]
-val test2 = Curried[String][String]
+  def test = ???

tests/run/scrutable.scala

@@ -18,7 +18,9 @@ def foo[T](x: T): Matchable =
     case List(y :: Nil) =>
       y :: Nil
     case _ =>
-      x
+      g(x)
+
+def g[T <: Matchable](x: T) = x
 
 @main def Test =
   val x: Matchable = foo(1)