Add classSymbolAfterErasure

Author: noti0na1

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

@@ -10,6 +10,7 @@ import core._
 import util.Spans._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
 import Symbols._, StdNames._, Annotations._, Trees._, Symbols._
 import Decorators._, DenotTransformers._
+import NullOpsDecorator._
 import collection.{immutable, mutable}
 import util.{Property, SourceFile, NoSource}
 import NameKinds.{TempResultName, OuterSelectName}
@@ -472,7 +473,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   /** The wrapped array method name for an array of type elemtp */
   def wrapArrayMethodName(elemtp: Type)(using Context): TermName = {
-    val elemCls = elemtp.classSymbol
+    val elemCls = elemtp.classSymbolAfterErasure
     if (elemCls.isPrimitiveValueClass) nme.wrapXArray(elemCls.name)
     else if (elemCls.derivesFrom(defn.ObjectClass) && !elemCls.isNotRuntimeClass) nme.wrapRefArray
     else nme.genericWrapArray

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

@@ -74,6 +74,6 @@ object NullOpsDecorator {
     def isNullableAfterErasure(using Context): Boolean =
       self.isNullType
       || !self.isNothingType
-        && self.derivesFrom(defn.ObjectClass, afterErasure = true)
+        && self.derivesFrom(defn.ObjectClass, isErased = true)
   }
 }

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

@@ -247,15 +247,15 @@ object TypeErasure {
   def isUnboundedGeneric(tp: Type)(using Context): Boolean = tp.dealias match {
     case tp: TypeRef if !tp.symbol.isOpaqueAlias =>
       !tp.symbol.isClass &&
-      !classify(tp).derivesFrom(defn.ObjectClass, afterErasure = true) &&
+      !classify(tp).derivesFrom(defn.ObjectClass, isErased = true) &&
       !tp.symbol.is(JavaDefined)
     case tp: TypeParamRef =>
-      !classify(tp).derivesFrom(defn.ObjectClass, afterErasure = true) &&
+      !classify(tp).derivesFrom(defn.ObjectClass, isErased = true) &&
       !tp.binder.resultType.isJavaMethod
     case tp: TypeAlias => isUnboundedGeneric(tp.alias)
     case tp: TypeBounds =>
       val upper = classify(tp.hi)
-      !upper.derivesFrom(defn.ObjectClass, afterErasure = true) &&
+      !upper.derivesFrom(defn.ObjectClass, isErased = true) &&
       !upper.isPrimitiveValueType
     case tp: TypeProxy => isUnboundedGeneric(tp.translucentSuperType)
     case tp: AndType => isUnboundedGeneric(tp.tp1) && isUnboundedGeneric(tp.tp2)
@@ -292,8 +292,8 @@ object TypeErasure {
     // We need to short-circuit this case here because the regular lub logic below
     // relies on the class hierarchy, which doesn't properly capture `Null`s subtyping
     // behaviour.
-    if (tp1.isBottomTypeAfterErasure && tp2.derivesFrom(defn.ObjectClass, afterErasure = true)) return tp2
-    if (tp2.isBottomTypeAfterErasure && tp1.derivesFrom(defn.ObjectClass, afterErasure = true)) return tp1
+    if (tp1.isBottomTypeAfterErasure && tp2.derivesFrom(defn.ObjectClass, isErased = true)) return tp2
+    if (tp2.isBottomTypeAfterErasure && tp1.derivesFrom(defn.ObjectClass, isErased = true)) return tp1
     tp1 match {
       case JavaArrayType(elem1) =>
         import dotty.tools.dotc.transform.TypeUtils._

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

@@ -259,7 +259,11 @@ object Types {
     /** True if this type is an instance of the given `cls` or an instance of
      *  a non-bottom subclass of `cls`.
      */
-    final def derivesFrom(cls: Symbol, afterErasure: Boolean = false)(using Context): Boolean = {
+    final def derivesFrom(cls: Symbol, isErased: Boolean = false)(using Context): Boolean = {
+      def isLowerBottomType(tp: Type) =
+        (if isErased then tp.isBottomTypeAfterErasure else tp.isBottomType)
+        && (tp.hasClassSymbol(defn.NothingClass)
+            || cls != defn.NothingClass && !cls.isValueClass)
       def loop(tp: Type): Boolean = tp match {
         case tp: TypeRef =>
           val sym = tp.symbol
@@ -276,10 +280,6 @@ object Types {
           // If the type is `T | Null` or `T | Nothing`, the class is != Nothing,
           // and `T` derivesFrom the class, then the OrType derivesFrom the class.
           // Otherwise, we need to check both sides derivesFrom the class.
-          def isLowerBottomType(tp: Type) =
-            (if afterErasure then t.isBottomTypeAfterErasure else t.isBottomType)
-            && (tp.hasClassSymbol(defn.NothingClass)
-                || cls != defn.NothingClass && !cls.isValueClass)
           if isLowerBottomType(tp.tp1) then
             loop(tp.tp2)
           else if isLowerBottomType(tp.tp2) then
@@ -463,28 +463,45 @@ object Types {
      *  instance, or NoSymbol if none exists (either because this type is not a
      *  value type, or because superclasses are ambiguous).
      */
-    final def classSymbol(using Context): Symbol = this match {
-      case tp: TypeRef =>
-        val sym = tp.symbol
-        if (sym.isClass) sym else tp.superType.classSymbol
-      case tp: TypeProxy =>
-        tp.underlying.classSymbol
-      case tp: ClassInfo =>
-        tp.cls
-      case AndType(l, r) =>
-        val lsym = l.classSymbol
-        val rsym = r.classSymbol
-        if (lsym isSubClass rsym) lsym
-        else if (rsym isSubClass lsym) rsym
-        else NoSymbol
-      case tp: OrType =>
-        tp.join.classSymbol
-      case _: JavaArrayType =>
-        defn.ArrayClass
-      case _ =>
-        NoSymbol
-    }
+    final def classSymbol(using Context): Symbol = classSymbolWith(false)
+    final def classSymbolAfterErasure(using Context): Symbol = classSymbolWith(true)
+
+    final private def classSymbolWith(isErased: Boolean)(using Context): Symbol = {
+      def loop(tp:Type): Symbol = tp match {
+        case tp: TypeRef =>
+          val sym = tp.symbol
+          if (sym.isClass) sym else loop(tp.superType)
+        case tp: TypeProxy =>
+          loop(tp.underlying)
+        case tp: ClassInfo =>
+          tp.cls
+        case AndType(l, r) =>
+          val lsym = loop(l)
+          val rsym = loop(r)
+          if (lsym isSubClass rsym) lsym
+          else if (rsym isSubClass lsym) rsym
+          else NoSymbol
+        case tp: OrType =>
+          if tp.tp1.hasClassSymbol(defn.NothingClass) then
+            loop(tp.tp2)
+          else if tp.tp2.hasClassSymbol(defn.NothingClass) then
+            loop(tp.tp1)
+          else
+            val tp1Null = tp.tp1.hasClassSymbol(defn.NullClass)
+            val tp2Null = tp.tp2.hasClassSymbol(defn.NullClass)
+            if isErased && (tp1Null || tp2Null) then
+              val otherSide = if tp1Null then loop(tp.tp2) else loop(tp.tp1)
+              if otherSide.isValueClass then defn.AnyClass else otherSide
+            else
+              loop(tp.join)
+        case _: JavaArrayType =>
+          defn.ArrayClass
+        case _ =>
+          NoSymbol
+      }
 
+      loop(this)
+    }
     /** The least (wrt <:<) set of symbols satisfying the `include` predicate of which this type is a subtype
      */
     final def parentSymbols(include: Symbol => Boolean)(using Context): List[Symbol] = this match {

tests/explicit-nulls/unsafe-common/unsafe-cast.scala

@@ -65,4 +65,9 @@ class S {
     n1(Array("a", null))
     n2(Array("a", null))
   }
+
+  locally {
+    val os: Option[String] = None
+    val s: String = os.orNull // error
+  }
 }