Drop UnsafeNonvariant

It's no longer needed.

Author: odersky

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

@@ -657,8 +657,6 @@ class Definitions {
   def UncheckedStableAnnot(implicit ctx: Context) = UncheckedStableAnnotType.symbol.asClass
   lazy val UncheckedVarianceAnnotType = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedVariance")
   def UncheckedVarianceAnnot(implicit ctx: Context) = UncheckedVarianceAnnotType.symbol.asClass
-  lazy val UnsafeNonvariantAnnotType = ctx.requiredClassRef("scala.annotation.internal.UnsafeNonvariant")
-  def UnsafeNonvariantAnnot(implicit ctx: Context) = UnsafeNonvariantAnnotType.symbol.asClass
   lazy val VolatileAnnotType = ctx.requiredClassRef("scala.volatile")
   def VolatileAnnot(implicit ctx: Context) = VolatileAnnotType.symbol.asClass
   lazy val FieldMetaAnnotType = ctx.requiredClassRef("scala.annotation.meta.field")

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

@@ -51,21 +51,14 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
 
       /*>|>*/ ctx.conditionalTraceIndented(TypeOps.track, s"asSeen ${tp.show} from (${pre.show}, ${cls.show})", show = true) /*<|<*/ { // !!! DEBUG
         tp match {
-          case tp: NamedType =>
-            val sym = tp.symbol
-            if (sym.isStatic) tp
+          case tp: NamedType => // inlined for performance; TODO: factor out into inline method
+            if (tp.symbol.isStatic) tp
             else {
-              val pre1 = apply(tp.prefix)
-              if (pre1.isUnsafeNonvariant) {
-                val safeCtx = ctx.withProperty(TypeOps.findMemberLimit, Some(()))
-                pre1.member(tp.name)(safeCtx).info match {
-                  case TypeAlias(alias) =>
-                    // try to follow aliases of this will avoid skolemization.
-                    return alias
-                  case _ =>
-                }
-              }
-              derivedSelect(tp, pre1)
+              val saved = variance
+              variance = variance max 0
+              val prefix1 = this(tp.prefix)
+              variance = saved
+              derivedSelect(tp, prefix1)
             }
           case tp: ThisType =>
             toPrefix(pre, cls, tp.cls)

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

@@ -258,16 +258,6 @@ object Types {
     def isRepeatedParam(implicit ctx: Context): Boolean =
       typeSymbol eq defn.RepeatedParamClass
 
-    /** Does this type carry an UnsafeNonvariant annotation? */
-    final def isUnsafeNonvariant(implicit ctx: Context): Boolean = this match {
-      case AnnotatedType(_, annot) => annot.symbol == defn.UnsafeNonvariantAnnot
-      case _ => false
-    }
-
-    /** Does this type have an UnsafeNonvariant annotation on one of its parts? */
-    final def hasUnsafeNonvariant(implicit ctx: Context): Boolean =
-      new HasUnsafeNonAccumulator().apply(false, this)
-
     /** Is this the type of a method that has a repeated parameter type as
      *  last parameter type?
      */
@@ -4178,10 +4168,6 @@ object Types {
     def apply(x: Unit, tp: Type): Unit = foldOver(p(tp), tp)
   }
 
-  class HasUnsafeNonAccumulator(implicit ctx: Context) extends TypeAccumulator[Boolean] {
-    def apply(x: Boolean, tp: Type) = x || tp.isUnsafeNonvariant || foldOver(x, tp)
-  }
-
   class NamedPartsAccumulator(p: NamedType => Boolean, excludeLowerBounds: Boolean = false)
     (implicit ctx: Context) extends TypeAccumulator[mutable.Set[NamedType]] {
     override def stopAtStatic = false

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

@@ -387,27 +387,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   private def typedSelect(tree: untpd.Select, pt: Type, qual: Tree)(implicit ctx: Context): Select =
-    healNonvariant(
-      checkValue(assignType(cpy.Select(tree)(qual, tree.name), qual), pt),
-      pt)
-
-  /** Let `tree = p.n` where `p: T`. If tree's type is an unsafe instantiation
-   *  (see TypeOps#asSeenFrom for how this can happen), rewrite the prefix `p`
-   *  to `(p: <unknown skolem of type T>)` and try again with the new (stable)
-   *  prefix. If the result has another unsafe instantiation, raise an error.
-   */
-  private def healNonvariant[T <: Tree](tree: T, pt: Type)(implicit ctx: Context): T  =
-    if (ctx.unsafeNonvariant == ctx.runId && tree.tpe.widen.hasUnsafeNonvariant)
-      tree match {
-        case tree @ Select(qual, _) if !qual.tpe.isStable =>
-          val alt = typedSelect(tree, pt, Typed(qual, TypeTree(SkolemType(qual.tpe.widen))))
-          typr.println(i"healed type: ${tree.tpe} --> $alt")
-          alt.asInstanceOf[T]
-        case _ =>
-          ctx.error(ex"unsafe instantiation of type ${tree.tpe}", tree.pos)
-          tree
-      }
-    else tree
+    checkValue(assignType(cpy.Select(tree)(qual, tree.name), qual), pt)
 
   def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = track("typedSelect") {
     def typeSelectOnTerm(implicit ctx: Context): Tree = {
@@ -617,8 +597,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
                 case lhsCore: RefTree if setter.exists =>
                   val setterTypeRaw = pre.select(setterName, setter)
                   val setterType = ensureAccessible(setterTypeRaw, isSuperSelection(lhsCore), tree.pos)
-                  val lhs2 = healNonvariant(
-                    untpd.rename(lhsCore, setterName).withType(setterType), WildcardType)
+                  val lhs2 = untpd.rename(lhsCore, setterName).withType(setterType)
                   typedUnadapted(untpd.Apply(untpd.TypedSplice(lhs2), tree.rhs :: Nil))
                 case _ =>
                   reassignmentToVal