Fix problem preserving & and | types in WithBounds annotations

Author: odersky

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

@@ -181,7 +181,12 @@ object Annotations {
     object WithBounds {
       def unapply(ann: Annotation)(implicit ctx: Context): Option[TypeBounds] =
         if (ann.symbol == defn.WithBoundsAnnot) {
-          val AppliedType(_, lo :: hi :: Nil) = ann.tree.tpe
+          // We need to extract the type of the type tree in the New itself.
+          // The annotation's type has been simplified as the type of an expression,
+          // which means that `&` or `|` might have been lost.
+          // Test in pos/reference/opaque.scala
+          val Apply(TypeApply(Select(New(tpt), nme.CONSTRUCTOR), _), Nil) = ann.tree
+          val AppliedType(_, lo :: hi :: Nil) = tpt.tpe
           Some(TypeBounds(lo, hi))
         }
         else None

tests/neg/opaque-bounds.scala

@@ -11,4 +11,38 @@ class Test { // error: class Test cannot be instantiated
   val f: Flag = Flag.make("hello")
   val g: FlagSet = f
 
+}
+
+object Access {
+
+  opaque type Permissions = Int
+  opaque type PermissionChoice = Int
+  opaque type Permission <: Permissions & PermissionChoice = Int
+
+  def (x: Permissions) & (y: Permissions): Permissions = x & y
+  def (x: PermissionChoice) | (y: PermissionChoice): PermissionChoice = x | y
+  def (x: Permissions) is (y: Permissions) = (x & y) == y
+  def (x: Permissions) isOneOf (y: PermissionChoice) = (x & y) != 0
+
+  val NoPermission: Permission = 0
+  val ReadOnly: Permission = 1
+  val WriteOnly: Permission = 2
+  val ReadWrite: Permissions = ReadOnly & WriteOnly
+  val ReadOrWrite: PermissionChoice = ReadOnly | WriteOnly
+}
+
+object User {
+  import Access._
+
+  case class Item(rights: Permissions)
+
+  val p1: Permissions = ReadOrWrite  // error
+  val p2: PermissionChoice = ReadWrite // error
+
+  val x = Item(ReadOnly)
+
+  assert( x.rights.is(ReadWrite) == false )
+  assert( x.rights.isOneOf(ReadOrWrite) == true )
+
+  assert( x.rights.isOneOf(ReadWrite) == true ) // error: found Permissions, required: PermissionChoice
 }

tests/pos/opaque-bounds.scala

@@ -0,0 +1,71 @@
+object Logarithms {
+
+  opaque type Logarithm = Double
+
+  object Logarithm {
+
+    // These are the ways to lift to the logarithm type
+    def apply(d: Double): Logarithm = math.log(d)
+
+    def safe(d: Double): Option[Logarithm] =
+      if (d > 0.0) Some(math.log(d)) else None
+  }
+
+  // Extension methods define opaque types' public APIs
+  implied LogarithmOps {
+    def (x: Logarithm) toDouble: Double = math.exp(x)
+    def (x: Logarithm) + (y: Logarithm): Logarithm = Logarithm(math.exp(x) + math.exp(y))
+    def (x: Logarithm) * (y: Logarithm): Logarithm = Logarithm(x + y)
+  }
+}
+
+object Test {
+  import Logarithms._
+  import Predef.{any2stringadd => _, _}
+
+  val l = Logarithm(1.0)
+  val l2 = Logarithm(2.0)
+  val l3 = l * l2
+  val l4 = l + l2
+}
+
+
+object Access {
+
+  opaque type Permissions = Int
+  opaque type PermissionChoice = Int
+  opaque type Permission <: Permissions & PermissionChoice = Int
+
+  def (x: Permissions) & (y: Permissions): Permissions = x & y
+  def (x: PermissionChoice) | (y: PermissionChoice): PermissionChoice = x | y
+  def (x: Permissions) is (y: Permissions) = (x & y) == y
+  def (x: Permissions) isOneOf (y: PermissionChoice) = (x & y) != 0
+
+  val NoPermission: Permission = 0
+  val ReadOnly: Permission = 1
+  val WriteOnly: Permission = 2
+  val ReadWrite: Permissions = ReadOnly & WriteOnly
+  val ReadOrWrite: PermissionChoice = ReadOnly | WriteOnly
+}
+
+object User {
+  import Access._
+
+  case class Item(rights: Permissions)
+
+  val x = Item(ReadOnly)  // OK, since Permission <: Permissions
+
+  assert( x.rights.is(ReadWrite) == false )
+  assert( x.rights.isOneOf(ReadOrWrite) == true )
+
+  // Would be a type error:
+  //   assert( x.rights.isOneOf(ReadWrite) == true )
+
+}
+
+object o {
+  opaque type T = Int
+  val x: Int = id(1)
+  val y: Int = identity(1)
+}
+def id(x: o.T): o.T = x