Fix #3564: Allow annotated singleton types

Previously, singleton types were widened before an annotation was added. Now such
a widening is no longer performed. The change necessitated a systematic generalization
of what it means to be a singleton, where we now use in many places
an extractor instead of a type test. This has the added benefit that we now also
classify as singletons intersections involving a singleton type and aliases to a singleton
type.

Author: odersky

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

@@ -338,7 +338,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     else if (tp.symbol hasAnnotation defn.ScalaStaticAnnot)
       Ident(tp)
     else tp.prefix match {
-      case pre: SingletonType => followOuterLinks(singleton(pre)).select(tp)
+      case SingletonType(pre) => followOuterLinks(singleton(pre)).select(tp)
       case pre => Select(TypeTree(pre), tp)
     } // no checks necessary
 
@@ -777,7 +777,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     /** `tree.isInstanceOf[tp]`, with special treatment of singleton types */
     def isInstance(tp: Type)(implicit ctx: Context): Tree = tp match {
-      case tp: SingletonType =>
+      case SingletonType(tp) =>
         if (tp.widen.derivesFrom(defn.ObjectClass))
           tree.ensureConforms(defn.ObjectType).select(defn.Object_eq).appliedTo(singleton(tp))
         else

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

@@ -247,10 +247,11 @@ trait ConstraintHandling {
    */
   def instanceType(param: TypeParamRef, fromBelow: Boolean): Type = {
     def upperBound = constraint.fullUpperBound(param)
-    def isSingleton(tp: Type): Boolean = tp match {
+    def isMultiSingleton(tp: Type): Boolean = tp match {
       case tp: SingletonType => true
-      case AndType(tp1, tp2) => isSingleton(tp1) | isSingleton(tp2)
-      case OrType(tp1, tp2) => isSingleton(tp1) & isSingleton(tp2)
+      case AndType(tp1, tp2) => isMultiSingleton(tp1) | isMultiSingleton(tp2)
+      case OrType(tp1, tp2) => isMultiSingleton(tp1) & isMultiSingleton(tp2)
+      case AnnotatedType(tp, _) => isMultiSingleton(tp)
       case _ => false
     }
     def isFullyDefined(tp: Type): Boolean = tp match {
@@ -274,7 +275,7 @@ trait ConstraintHandling {
     // 1. If instance is from below and is a singleton type, yet upper bound is
     // not a singleton type or a reference to `scala.Singleton`, widen the
     // instance.
-    if (fromBelow && isSingleton(inst) && !isSingleton(upperBound)
+    if (fromBelow && isMultiSingleton(inst) && !isMultiSingleton(upperBound)
         && !upperBound.isRef(defn.SingletonClass))
       inst = inst.widen
 

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

@@ -114,6 +114,7 @@ object Types {
       case _: SingletonType | NoPrefix => true
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
+      case tp: AnnotatedType => tp.tpe.isStable
       case _ => false
     }
 
@@ -247,6 +248,9 @@ object Types {
       case _ => NoType
     }
 
+    /** Is this type a (possibly aliased or intersected) singleton type? */
+    def isSingleton(implicit ctx: Context) = SingletonType.unapply(this).isDefined
+
     /** Is this type guaranteed not to have `null` as a value? */
     final def isNotNull(implicit ctx: Context): Boolean = this match {
       case tp: ConstantType => tp.value.value != null
@@ -354,7 +358,6 @@ object Types {
     @tailrec final def typeSymbol(implicit ctx: Context): Symbol = this match {
       case tp: TypeRef => tp.symbol
       case tp: ClassInfo => tp.cls
-//    case ThisType(cls) => cls // needed?
       case tp: SingletonType => NoSymbol
       case tp: TypeProxy => tp.underlying.typeSymbol
       case _ => NoSymbol
@@ -918,7 +921,7 @@ object Types {
     /** Widen from singleton type to its underlying non-singleton
      *  base type by applying one or more `underlying` dereferences.
      */
-    final def widenSingleton(implicit ctx: Context): Type = stripTypeVar match {
+    final def widenSingleton(implicit ctx: Context): Type = stripTypeVar.stripAnnots match {
       case tp: SingletonType if !tp.isOverloaded => tp.underlying.widenSingleton
       case _ => this
     }
@@ -1497,6 +1500,17 @@ object Types {
     def isOverloaded(implicit ctx: Context) = false
   }
 
+  /** An extractor that returns the underlying singleton type of a
+   *  (possibly annotated, aliased, or intersected) type
+   */
+  object SingletonType {
+    def unapply(tp: Type)(implicit ctx: Context): Option[SingletonType] = tp.dealias match {
+      case AndType(tp1, tp2) => unapply(tp1).orElse(unapply(tp2))
+      case tp: SingletonType => Some(tp)
+      case _ => None
+    }
+  }
+
   /** A marker trait for types that bind other types that refer to them.
    *  Instances are: LambdaType, RecType.
    */
@@ -3555,16 +3569,18 @@ object Types {
   // ----- Annotated and Import types -----------------------------------------------
 
   /** An annotated type tpe @ annot */
-  case class AnnotatedType(tpe: Type, annot: Annotation)
-      extends UncachedProxyType with ValueType {
+  case class AnnotatedType(tpe: Type, annot: Annotation) extends UncachedProxyType with ValueType {
     // todo: cache them? but this makes only sense if annotations and trees are also cached.
+
     override def underlying(implicit ctx: Context): Type = tpe
+
     def derivedAnnotatedType(tpe: Type, annot: Annotation) =
       if ((tpe eq this.tpe) && (annot eq this.annot)) this
       else AnnotatedType(tpe, annot)
 
     override def stripTypeVar(implicit ctx: Context): Type =
       derivedAnnotatedType(tpe.stripTypeVar, annot)
+
     override def stripAnnots(implicit ctx: Context): Type = tpe.stripAnnots
   }
 
@@ -3974,7 +3990,7 @@ object Types {
             // If H#T = _ >: S <: U, then for any x in L..H, S <: x.T <: U,
             // hence we can replace with S..U under all variances
             range(atVariance(-variance)(reapply(lo)), reapply(hi))
-          case info: SingletonType =>
+          case SingletonType(info) =>
             // if H#x: y.type, then for any x in L..H, x.type =:= y.type,
             // hence we can replace with y.type under all variances
             reapply(info)

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

@@ -244,12 +244,12 @@ object Erasure {
      *  in ExtensionMethods#transform.
      */
     def cast(tree: Tree, pt: Type)(implicit ctx: Context): Tree = trace(i"cast ${tree.tpe.widen} --> $pt", show = true) {
+
       def wrap(tycon: TypeRef) =
         ref(u2evt(tycon.typeSymbol.asClass)).appliedTo(tree)
       def unwrap(tycon: TypeRef) =
         ref(evt2u(tycon.typeSymbol.asClass)).appliedTo(tree)
 
-
       assert(!pt.isInstanceOf[SingletonType], pt)
       if (pt isRef defn.UnitClass) unbox(tree, pt)
       else (tree.tpe.widen, pt) match {

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

@@ -783,7 +783,7 @@ object PatternMatcher {
             // See the test for SI-7214 for motivation for dealias. Later `treeCondStrategy#outerTest`
             // generates an outer test based on `patType.prefix` with automatically dealises.
             expectedTp.dealias match {
-              case tref @ TypeRef(pre: SingletonType, _) =>
+              case tref @ TypeRef(SingletonType(pre), _) =>
                 tref.symbol.isClass &&
                 ExplicitOuter.needsOuterIfReferenced(tref.symbol.asClass)
               case _ =>
@@ -802,7 +802,7 @@ object PatternMatcher {
           }
 
           expectedTp.dealias match {
-            case expectedTp: SingletonType =>
+            case SingletonType(expectedTp) =>
               scrutinee.isInstance(expectedTp)  // will be translated to an equality test
             case _ =>
               val typeTest = scrutinee.select(defn.Any_typeTest).appliedToType(expectedTp)

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

@@ -133,7 +133,7 @@ object TypeTestsCasts {
          *  with `transformIsInstanceOf`, which depends on erased type of `testType`.
          */
         def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias match {
-          case _: SingletonType =>
+          case SingletonType(_) =>
             expr.isInstance(testType).withPos(tree.pos)
           case OrType(tp1, tp2) =>
             evalOnce(expr) { e =>

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -579,9 +579,9 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
    */
   def inhabited(tpe: Type)(implicit ctx: Context): Boolean = {
     val emptySingletonIntersection = new ExistsAccumulator({
-      case AndType(s: SingletonType, t) =>
+      case AndType(SingletonType(s), t) =>
         !(s <:< t)
-      case AndType(t, s: SingletonType) =>
+      case AndType(t, SingletonType(s)) =>
         !(s <:< t)
       case x =>
         false

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

@@ -561,8 +561,7 @@ trait Checking {
    */
   def checkImplicitParamsNotSingletons(vparamss: List[List[ValDef]])(implicit ctx: Context): Unit = vparamss match {
     case (vparam :: Nil) :: _ if !(vparam.symbol is Implicit) =>
-      if (vparam.tpt.tpe.isInstanceOf[SingletonType])
-        ctx.error(s"implicit conversion may not have a parameter of singleton type", vparam.tpt.pos)
+      checkNotSingleton(vparam.tpt, " to be parameter type of an implicit conversion")
     case _ =>
   }
 
@@ -659,11 +658,10 @@ trait Checking {
     else tpt
 
   /** Check that `tpt` does not refer to a singleton type */
-  def checkNotSingleton(tpt: Tree, where: String)(implicit ctx: Context): Tree =
-    if (tpt.tpe.isInstanceOf[SingletonType]) {
-      errorTree(tpt, ex"Singleton type ${tpt.tpe} is not allowed $where")
-    }
-    else tpt
+  def checkNotSingleton(tpt: Tree, where: String)(implicit ctx: Context): Tree = tpt.tpe match {
+    case SingletonType(_) => errorTree(tpt, ex"Singleton type ${tpt.tpe} is not allowed $where")
+    case _ => tpt
+  }
 
   /** Verify classes extending AnyVal meet the requirements */
   def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context) =

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

@@ -352,8 +352,8 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
     case tp: MethodType =>
       (tp.paramNames, tp.paramInfos, argss.head).zipped.foreach { (name, paramtp, arg) =>
         def isByName = paramtp.dealias.isInstanceOf[ExprType]
-        paramBinding(name) = arg.tpe.stripAnnots.stripTypeVar match {
-          case argtpe: SingletonType if isIdempotentExpr(arg) => argtpe
+        paramBinding(name) = arg.tpe match {
+          case SingletonType(_) if isIdempotentExpr(arg) => arg.tpe
           case argtpe =>
             val inlineFlag = if (paramtp.hasAnnotation(defn.InlineParamAnnot)) Inline else EmptyFlags
             val (bindingFlags, bindingType) =
@@ -476,7 +476,7 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
         }
       case _: Ident =>
         paramProxy.get(tree.tpe) match {
-          case Some(t: SingletonType) if tree.isTerm => singleton(t).withPos(tree.pos)
+          case Some(SingletonType(t)) if tree.isTerm => singleton(t).withPos(tree.pos)
           case Some(t) if tree.isType => TypeTree(t).withPos(tree.pos)
           case None => tree
         }

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

@@ -94,7 +94,7 @@ trait TypeAssigner {
         case tp: TermRef
         if toAvoid(tp.symbol) || partsToAvoid(mutable.Set.empty, tp.info).nonEmpty =>
           tp.info.widenExpr match {
-            case info: SingletonType => apply(info)
+            case info @ SingletonType(_) => apply(info)
             case info => range(tp.info.bottomType, apply(info))
           }
         case tp: TypeRef if toAvoid(tp.symbol) =>
@@ -122,7 +122,7 @@ trait TypeAssigner {
        *   1. We first try a widening conversion to the type's info with
        *      the original prefix. Since the original prefix is known to
        *      be a subtype of the returned prefix, this can improve results.
-       *   2. IThen, if the approximation result is a singleton reference C#x.type, we
+       *   2. Then, if the approximation result is a singleton reference C#x.type, we
        *      replace by the widened type, which is usually more natural.
        *   3. Finally, we need to handle the case where the prefix type does not have a member
        *      named `tp.name` anymmore. In that case, we need to fall back to Bot..Top.
@@ -131,7 +131,7 @@ trait TypeAssigner {
         if (pre eq tp.prefix)
           tp
         else tryWiden(tp, tp.prefix).orElse {
-          if (tp.isTerm && variance > 0 && !pre.isInstanceOf[SingletonType])
+          if (tp.isTerm && variance > 0 && !pre.isSingleton)
           	apply(tp.info.widenExpr)
           else if (upper(pre).member(tp.name).exists)
             super.derivedSelect(tp, pre)
@@ -536,7 +536,7 @@ trait TypeAssigner {
     tree.withType(sym.termRef)
 
   def assignType(tree: untpd.Annotated, arg: Tree, annot: Tree)(implicit ctx: Context) =
-    tree.withType(AnnotatedType(arg.tpe.widen, Annotation(annot)))
+    tree.withType(AnnotatedType(arg.tpe, Annotation(annot)))
 
   def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context) =
     tree.withType(pid.symbol.termRef)

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

@@ -1592,7 +1592,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     if (ctx.mode is Mode.Type)
       assignType(cpy.Annotated(tree)(arg1, annot1), arg1, annot1)
     else {
-      val tpt = TypeTree(AnnotatedType(arg1.tpe.widen, Annotation(annot1)))
+      val tpt = TypeTree(AnnotatedType(arg1.tpe, Annotation(annot1)))
       assignType(cpy.Typed(tree)(arg1, tpt), tpt)
     }
   }
@@ -2267,7 +2267,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             // is tried. See strawman-contrib MapDecoratorTest.scala for an example where this happens.
             err.typeMismatch(tree, pt)
           }
-        case wtp: MethodType if !pt.isInstanceOf[SingletonType] =>
+        case wtp: MethodType if !pt.isSingleton =>
           val arity =
             if (functionExpected)
               if (!isFullyDefined(pt, ForceDegree.none) && isFullyDefined(wtp, ForceDegree.none))

tests/pos/i830.scala renamed to tests/neg/i830.scala

@@ -2,5 +2,5 @@ object C {
   trait X[T]
   implicit def u[A, B]: X[A | B] = new X[A | B] {}
   def y[T](implicit x: X[T]): T = ???
-  val x: 1 & 2 | 2 & 3 = y
+  val x: 1 & 2 | 2 & 3 = y // error: singleton is not allowed in a union type
 }

tests/pos/i3564.scala

@@ -0,0 +1,9 @@
+case class Foo(s: "abc")
+
+object Test {
+
+  val x: "abc" @deprecated = "abc"
+
+  val y: "abc" = x
+
+}

tests/pos/i864.scala

@@ -6,5 +6,5 @@ object C {
   trait X[T]
   implicit def u[A, B]: X[A | B] = new X[A | B] {}
   def y[T](implicit x: X[T]): T = ???
-  val x: a.type & b.type | b.type & c.type = y
+  // val x: a.type & b.type | b.type & c.type = y  // no longer allowed, singletons cannot be in union types
 }