Merge pull request #10670 from dotty-staging/parametric-top

Add Matchable trait

Author: odersky

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

@@ -397,17 +397,14 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case TypeApply(fn, _) =>
       if (fn.symbol.is(Erased) || fn.symbol == defn.QuotedTypeModule_of || fn.symbol == defn.Predef_classOf) Pure else exprPurity(fn)
     case Apply(fn, args) =>
-      def isKnownPureOp(sym: Symbol) =
-        sym.owner.isPrimitiveValueClass
-        || sym.owner == defn.StringClass
-        || defn.pureMethods.contains(sym)
-      if (tree.tpe.isInstanceOf[ConstantType] && isKnownPureOp(tree.symbol) // A constant expression with pure arguments is pure.
-          || (fn.symbol.isStableMember && !fn.symbol.is(Lazy))) // constructors of no-inits classes are stable
+      if isPureApply(tree, fn) then
         minOf(exprPurity(fn), args.map(exprPurity)) `min` Pure
-      else if (fn.symbol.is(Erased)) Pure
-      else if (fn.symbol.isStableMember) /* && fn.symbol.is(Lazy) */
+      else if fn.symbol.is(Erased) then
+        Pure
+      else if fn.symbol.isStableMember /* && fn.symbol.is(Lazy) */ then
         minOf(exprPurity(fn), args.map(exprPurity)) `min` Idempotent
-      else Impure
+      else
+        Impure
     case Typed(expr, _) =>
       exprPurity(expr)
     case Block(stats, expr) =>
@@ -440,6 +437,17 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   def isPureBinding(tree: Tree)(using Context): Boolean = statPurity(tree) >= Pure
 
+  /** Is the application `tree` with function part `fn` known to be pure?
+   *  Function value and arguments can still be impure.
+   */
+  def isPureApply(tree: Tree, fn: Tree)(using Context): Boolean =
+    def isKnownPureOp(sym: Symbol) =
+      sym.owner.isPrimitiveValueClass
+      || sym.owner == defn.StringClass
+      || defn.pureMethods.contains(sym)
+    tree.tpe.isInstanceOf[ConstantType] && isKnownPureOp(tree.symbol) // A constant expression with pure arguments is pure.
+    || fn.symbol.isStableMember && !fn.symbol.is(Lazy)  // constructors of no-inits classes are stable
+
   /** The purity level of this reference.
    *  @return
    *    PurePath        if reference is (nonlazy and stable)

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

@@ -259,10 +259,19 @@ class Definitions {
    */
   @tu lazy val AnyClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.Any, Abstract, Nil), ensureCtor = false)
   def AnyType: TypeRef = AnyClass.typeRef
-  @tu lazy val AnyValClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.AnyVal, Abstract, List(AnyClass.typeRef)))
+  @tu lazy val MatchableClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.Matchable, Trait, AnyType :: Nil), ensureCtor = false)
+  def MatchableType: TypeRef = MatchableClass.typeRef
+  @tu lazy val AnyValClass: ClassSymbol =
+    val res = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.AnyVal, Abstract, List(AnyType, MatchableType)))
+    // Mark companion as absent, so that class does not get re-completed
+    val companion = ScalaPackageVal.info.decl(nme.AnyVal).symbol
+    companion.moduleClass.markAbsent()
+    companion.markAbsent()
+    res
+
   def AnyValType: TypeRef = AnyValClass.typeRef
 
-    @tu lazy val Any_== : TermSymbol           = enterMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
+    @tu lazy val Any_== : TermSymbol          = enterMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
     @tu lazy val Any_!= : TermSymbol          = enterMethod(AnyClass, nme.NE, methOfAny(BooleanType), Final)
     @tu lazy val Any_equals: TermSymbol       = enterMethod(AnyClass, nme.equals_, methOfAny(BooleanType))
     @tu lazy val Any_hashCode: TermSymbol     = enterMethod(AnyClass, nme.hashCode_, MethodType(Nil, IntType))
@@ -288,7 +297,7 @@ class Definitions {
   @tu lazy val ObjectClass: ClassSymbol = {
     val cls = requiredClass("java.lang.Object")
     assert(!cls.isCompleted, "race for completing java.lang.Object")
-    cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope)
+    cls.info = ClassInfo(cls.owner.thisType, cls, List(AnyType, MatchableType), newScope)
     cls.setFlag(NoInits | JavaDefined)
 
     // The companion object doesn't really exist, so it needs to be marked as
@@ -444,7 +453,7 @@ class Definitions {
       MethodType(List(ThrowableType), NothingType))
 
   @tu lazy val NothingClass: ClassSymbol = enterCompleteClassSymbol(
-    ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
+    ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyType))
   def NothingType: TypeRef = NothingClass.typeRef
   @tu lazy val NullClass: ClassSymbol = {
     val parent = if (ctx.explicitNulls) AnyType else ObjectType
@@ -520,7 +529,7 @@ class Definitions {
     // but does not define it as an explicit class.
     enterCompleteClassSymbol(
       ScalaPackageClass, tpnme.Singleton, PureInterfaceCreationFlags | Final,
-      List(AnyClass.typeRef), EmptyScope)
+      List(AnyType), EmptyScope)
   @tu lazy val SingletonType: TypeRef = SingletonClass.typeRef
 
   @tu lazy val CollectionSeqType: TypeRef = requiredClassRef("scala.collection.Seq")
@@ -1144,6 +1153,8 @@ class Definitions {
 
   // ----- Symbol sets ---------------------------------------------------
 
+  @tu lazy val topClasses: Set[Symbol] = Set(AnyClass, MatchableClass, ObjectClass, AnyValClass)
+
   @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0)
   val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))
   def AbstractFunctionClass(n: Int)(using Context): Symbol = AbstractFunctionClassPerRun()(using ctx)(n)
@@ -1372,7 +1383,7 @@ class Definitions {
   @tu lazy val ShadowableImportNames: Set[TermName] = Set("Predef".toTermName)
 
   /** Class symbols for which no class exist at runtime */
-  @tu lazy val NotRuntimeClasses: Set[Symbol] = Set(AnyClass, AnyValClass, NullClass, NothingClass)
+  @tu lazy val NotRuntimeClasses: Set[Symbol] = Set(AnyClass, MatchableClass, AnyValClass, NullClass, NothingClass)
 
   @tu lazy val SpecialClassTagClasses: Set[Symbol] = Set(UnitClass, AnyClass, AnyValClass)
 
@@ -1672,6 +1683,7 @@ class Definitions {
   @tu lazy val specialErasure: SimpleIdentityMap[Symbol, ClassSymbol] =
     SimpleIdentityMap.empty[Symbol]
       .updated(AnyClass, ObjectClass)
+      .updated(MatchableClass, ObjectClass)
       .updated(AnyValClass, ObjectClass)
       .updated(SingletonClass, ObjectClass)
       .updated(TupleClass, ProductClass)
@@ -1683,6 +1695,7 @@ class Definitions {
   @tu lazy val syntheticScalaClasses: List[TypeSymbol] = {
     val synth = List(
       AnyClass,
+      MatchableClass,
       AnyRefAlias,
       AnyKindClass,
       andType,

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

@@ -116,4 +116,7 @@ object Mode {
 
   /** Are we typechecking the rhs of an extension method? */
   val InExtensionMethod: Mode = newMode(26, "InExtensionMethod")
+
+  /** Are we resolving a TypeTest node? */
+  val InTypeTest: Mode = newMode(27, "InTypeTest")
 }

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

@@ -297,7 +297,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
   /** If `inst` is a TypeBounds, make sure it does not contain toplevel
    *  references to `param` (see `Constraint#occursAtToplevel` for a definition
    *  of "toplevel").
-   *  Any such references are replace by `Nothing` in the lower bound and `Any`
+   *  Any such references are replaced by `Nothing` in the lower bound and `Any`
    *  in the upper bound.
    *  References can be direct or indirect through instantiations of other
    *  parameters in the constraint.

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

@@ -371,6 +371,7 @@ object StdNames {
     val Import: N               = "Import"
     val Literal: N              = "Literal"
     val LiteralAnnotArg: N      = "LiteralAnnotArg"
+    val Matchable: N            = "Matchable"
     val MatchCase: N            = "MatchCase"
     val MirroredElemTypes: N    = "MirroredElemTypes"
     val MirroredElemLabels: N   = "MirroredElemLabels"

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

@@ -2246,9 +2246,7 @@ object SymDenotations {
           if (pcls.isCompleting) recur(pobjs1, acc)
           else
             val pobjMembers = pcls.nonPrivateMembersNamed(name).filterWithPredicate { d =>
-              // Drop members of `Any` and `Object`
-              val owner = d.symbol.maybeOwner
-              (owner ne defn.AnyClass) && (owner ne defn.ObjectClass)
+              !defn.topClasses.contains(d.symbol.maybeOwner) // Drop members of top classes
             }
             recur(pobjs1, acc.union(pobjMembers))
         case nil =>

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

@@ -209,6 +209,10 @@ object Types {
     def isAnyRef(using Context): Boolean  = isRef(defn.ObjectClass, skipRefined = false)
     def isAnyKind(using Context): Boolean = isRef(defn.AnyKindClass, skipRefined = false)
 
+    def isTopType(using Context): Boolean = dealias match
+      case tp: TypeRef => defn.topClasses.contains(tp.symbol)
+      case _ => false
+
     /** Is this type exactly Nothing (no vars, aliases, refinements etc allowed)? */
     def isExactlyNothing(using Context): Boolean = this match {
       case tp: TypeRef =>
@@ -512,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
@@ -3812,10 +3830,6 @@ object Types {
 
     def unapply(tl: PolyType): Some[(List[LambdaParam], Type)] =
       Some((tl.typeParams, tl.resType))
-
-    def any(n: Int)(using Context): PolyType =
-      apply(syntheticParamNames(n))(
-        pt => List.fill(n)(TypeBounds.empty), pt => defn.AnyType)
   }
 
   private object DepStatus {

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -266,10 +266,7 @@ import transform.SymUtils._
       val postScript = addenda.find(!_.isEmpty) match
         case Some(p) => p
         case None =>
-          if expected.isAny
-             || expected.isAnyRef
-             || expected.isRef(defn.AnyValClass)
-             || found.isBottomType
+          if expected.isTopType || found.isBottomType
           then ""
           else ctx.typer.importSuggestionAddendum(ViewProto(found.widen, expected))
       val (where, printCtx) = Formatting.disambiguateTypes(found2, expected2)

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

@@ -61,8 +61,8 @@ class Erasure extends Phase with DenotTransformer {
         // After erasure, all former Any members are now Object members
         val ClassInfo(pre, _, ps, decls, selfInfo) = ref.info
         val extendedScope = decls.cloneScope
-        for (decl <- defn.AnyClass.classInfo.decls)
-          if (!decl.isConstructor) extendedScope.enter(decl)
+        for decl <- defn.AnyClass.classInfo.decls do
+          if !decl.isConstructor then extendedScope.enter(decl)
         ref.copySymDenotation(
           info = transformInfo(ref.symbol,
               ClassInfo(pre, defn.ObjectClass, ps, extendedScope, selfInfo))
@@ -71,11 +71,12 @@ class Erasure extends Phase with DenotTransformer {
       else {
         val oldSymbol = ref.symbol
         val newSymbol =
-          if ((oldSymbol.owner eq defn.AnyClass) && oldSymbol.isConstructor)
+          if ((oldSymbol.owner eq defn.AnyClass) && oldSymbol.isConstructor) then
+            //assert(false)
             defn.ObjectClass.primaryConstructor
           else oldSymbol
         val oldOwner = ref.owner
-        val newOwner = if (oldOwner eq defn.AnyClass) defn.ObjectClass else oldOwner
+        val newOwner = if oldOwner == defn.AnyClass then defn.ObjectClass else oldOwner
         val oldName = ref.name
         val newName = ref.targetName
         val oldInfo = ref.info

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

@@ -1158,6 +1158,8 @@ trait Applications extends Compatibility {
   def typedUnApply(tree: untpd.Apply, selType: Type)(using Context): Tree = {
     record("typedUnApply")
     val Apply(qual, args) = tree
+    if !ctx.mode.is(Mode.InTypeTest) then
+      checkMatchable(selType, tree.srcPos, pattern = true)
 
     def notAnExtractor(tree: Tree): Tree =
       // prefer inner errors