Follow GADT bounds when computing members

When computing the member denotation of a selection of a TypeRef `T`,
if the normal scheme fails and `T` has GADT bounds, compute the member
in the upper bound instead.

This is needed to make the opaque-probability test work.
Add this test, as well as some others coming from SIP 35.

Author: odersky

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

@@ -263,7 +263,7 @@ object Types {
     }
 
     /** Is some part of this type produced as a repair for an error? */
-    final def isErroneous(implicit ctx: Context): Boolean = existsPart(_.isError, forceLazy = false)
+    def isErroneous(implicit ctx: Context): Boolean = existsPart(_.isError, forceLazy = false)
 
     /** Does the type carry an annotation that is an instance of `cls`? */
     @tailrec final def hasAnnotation(cls: ClassSymbol)(implicit ctx: Context): Boolean = stripTypeVar match {
@@ -1283,6 +1283,23 @@ object Types {
      */
     def deepenProto(implicit ctx: Context): Type = this
 
+    /** If this is a TypeRef or an Application of a GADT-bound type, replace the
+     *  GADT reference by its upper GADT bound. Otherwise NoType.
+     */
+    def followGADT(implicit ctx: Context): Type = widenDealias match {
+      case site: TypeRef if site.symbol.is(Opaque) =>
+        ctx.gadt.bounds(site.symbol) match {
+          case TypeBounds(_, hi) => hi
+          case _ => NoType
+        }
+      case AppliedType(tycon, args) =>
+        val tycon1 = tycon.followGADT
+        if (tycon1.exists) tycon1.appliedTo(args)
+        else NoType
+      case _ =>
+        NoType
+    }
+
 // ----- Substitutions -----------------------------------------------------
 
     /** Substitute all types that refer in their symbol attribute to

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

@@ -6,6 +6,7 @@ import core._
 import ast._
 import Contexts._, Types._, Flags._, Denotations._, Names._, StdNames._, NameOps._, Symbols._
 import NameKinds.DepParamName
+import SymDenotations.NoDenotation
 import Trees._
 import Constants._
 import Scopes._
@@ -104,8 +105,9 @@ object ProtoTypes {
           memberProto.isRef(defn.UnitClass) ||
           compat.normalizedCompatible(NamedType(tp1, name, m), memberProto)
             // Note: can't use `m.info` here because if `m` is a method, `m.info`
-            //       loses knowledge about `m`'s default arguments.
+            //       loses knowledge about `m`'s default arguments. ||
         mbr match { // hasAltWith inlined for performance
+          case NoDenotation => tp1.exists && isMatchedBy(tp1.followGADT)
           case mbr: SingleDenotation => mbr.exists && qualifies(mbr)
           case _ => mbr hasAltWith qualifies
         }
@@ -282,6 +284,9 @@ object ProtoTypes {
 
     def isDropped: Boolean = toDrop
 
+    override def isErroneous(implicit ctx: Context): Boolean =
+      myTypedArgs.tpes.exists(_.widen.isErroneous)
+
     override def toString = s"FunProto(${args mkString ","} => $resultType)"
 
     def map(tm: TypeMap)(implicit ctx: Context): FunProto =

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

@@ -236,8 +236,12 @@ trait TypeAssigner {
     if (reallyExists(mbr)) site.select(name, mbr)
     else if (site.derivesFrom(defn.DynamicClass) && !Dynamic.isDynamicMethod(name)) {
       TryDynamicCallType
-    } else {
-      if (site.isErroneous || name.toTermName == nme.ERROR) UnspecifiedErrorType
+    }
+    else {
+      val site1 = site.followGADT
+      if (site1.exists) selectionType(site1, name, pos)
+      else if (site.isErroneous || name.toTermName == nme.ERROR)
+        UnspecifiedErrorType
       else {
         def kind = if (name.isTypeName) "type" else "value"
         def addendum =

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

@@ -2087,8 +2087,11 @@ class Typer extends Namer
                   noMatches
             }
           case alts =>
-            val remainingDenots = alts map (_.denot.asInstanceOf[SingleDenotation])
-            errorTree(tree, AmbiguousOverload(tree, remainingDenots, pt)(err))
+            if (tree.tpe.isErroneous || pt.isErroneous) tree.withType(UnspecifiedErrorType)
+            else {
+              val remainingDenots = alts map (_.denot.asInstanceOf[SingleDenotation])
+              errorTree(tree, AmbiguousOverload(tree, remainingDenots, pt)(err))
+            }
         }
       }
 

tests/pending/pos/opaque-recursive.scala

@@ -0,0 +1,16 @@
+object opaquetypes {
+
+  opaque type Fix[F[_]] = F[Fix2[F]]
+
+  opaque type Fix2[F[_]] = Fix[F]
+
+  object Fix {
+    def unfold[F[_]](x: Fix[F]): F[Fix]
+  }
+
+  object Fix2 {
+    def unfold[F[_]](x: Fix2[F]: Fix[F] = x
+    def fold[F[_]](x: Fix[F]: Fix2[F] = x
+  }
+
+}

tests/pos/opaque-digits.scala

@@ -0,0 +1,22 @@
+object pkg {
+
+  import Character.{isAlphabetic, isDigit}
+
+  class Alphabetic private[pkg] (val value: String) extends AnyVal
+
+  object Alphabetic {
+    def fromString(s: String): Option[Alphabetic] =
+      if (s.forall(isAlphabetic(_))) Some(new Alphabetic(s))
+      else None
+  }
+
+  opaque type Digits = String
+
+  object Digits {
+    def fromString(s: String): Option[Digits] =
+      if (s.forall(isDigit(_))) Some(s)
+      else None
+
+    def asString(d: Digits): String = d
+  }
+}

tests/pos/opaque-goups.scala

@@ -0,0 +1,95 @@
+package object groups {
+  trait Semigroup[A] {
+    def combine(x: A, y: A): A
+  }
+
+  object Semigroup {
+    def instance[A](f: (A, A) => A): Semigroup[A] =
+      new Semigroup[A] {
+        def combine(x: A, y: A): A = f(x, y)
+      }
+  }
+
+  type Id[A] = A
+
+  trait Wrapping[F[_]] {
+    def wraps[G[_], A](ga: G[A]): G[F[A]]
+    def unwrap[G[_], A](ga: G[F[A]]): G[A]
+  }
+
+  abstract class Wrapper[F[_]] { self =>
+    def wraps[G[_], A](ga: G[A]): G[F[A]]
+    def unwrap[G[_], A](gfa: G[F[A]]): G[A]
+
+    final def apply[A](a: A): F[A] = wraps[Id, A](a)
+
+    implicit object WrapperWrapping extends Wrapping[F] {
+      def wraps[G[_], A](ga: G[A]): G[F[A]] = self.wraps(ga)
+      def unwrap[G[_], A](ga: G[F[A]]): G[A] = self.unwrap(ga)
+    }
+  }
+
+  opaque type First[A] = A
+  object First extends Wrapper[First] {
+    def wraps[G[_], A](ga: G[A]): G[First[A]] = ga
+    def unwrap[G[_], A](gfa: G[First[A]]): G[A] = gfa
+    implicit def firstSemigroup[A]: Semigroup[First[A]] =
+      Semigroup.instance((x, y) => x)
+  }
+
+  opaque type Last[A] = A
+  object Last extends Wrapper[Last] {
+    def wraps[G[_], A](ga: G[A]): G[Last[A]] = ga
+    def unwrap[G[_], A](gfa: G[Last[A]]): G[A] = gfa
+    implicit def lastSemigroup[A]: Semigroup[Last[A]] =
+      Semigroup.instance((x, y) => y)
+  }
+
+  opaque type Min[A] = A
+  object Min extends Wrapper[Min] {
+    def wraps[G[_], A](ga: G[A]): G[Min[A]] = ga
+    def unwrap[G[_], A](gfa: G[Min[A]]): G[A] = gfa
+    implicit def minSemigroup[A](implicit o: Ordering[A]): Semigroup[Min[A]] =
+      Semigroup.instance(o.min)
+  }
+
+  opaque type Max[A] = A
+  object Max extends Wrapper[Max] {
+    def wraps[G[_], A](ga: G[A]): G[Max[A]] = ga
+    def unwrap[G[_], A](gfa: G[Max[A]]): G[A] = gfa
+    implicit def maxSemigroup[A](implicit o: Ordering[A]): Semigroup[Max[A]] =
+      Semigroup.instance(o.max)
+  }
+
+  opaque type Plus[A] = A
+  object Plus extends Wrapper[Plus] {
+    def wraps[G[_], A](ga: G[A]): G[Plus[A]] = ga
+    def unwrap[G[_], A](gfa: G[Plus[A]]): G[A] = gfa
+    implicit def plusSemigroup[A](implicit n: Numeric[A]): Semigroup[Plus[A]] =
+      Semigroup.instance(n.plus)
+  }
+
+  opaque type Times[A] = A
+  object Times extends Wrapper[Times] {
+    def wraps[G[_], A](ga: G[A]): G[Times[A]] = ga
+    def unwrap[G[_], A](gfa: G[Times[A]]): G[A] = gfa
+    implicit def timesSemigroup[A](implicit n: Numeric[A]): Semigroup[Times[A]] =
+      Semigroup.instance(n.times)
+  }
+
+  opaque type Reversed[A] = A
+  object Reversed extends Wrapper[Reversed] {
+    def wraps[G[_], A](ga: G[A]): G[Reversed[A]] = ga
+    def unwrap[G[_], A](gfa: G[Reversed[A]]): G[A] = gfa
+    implicit def reversedOrdering[A](implicit o: Ordering[A]): Ordering[Reversed[A]] =
+      o.reverse
+  }
+
+  opaque type Unordered[A] = A
+  object Unordered extends Wrapper[Unordered] {
+    def wraps[G[_], A](ga: G[A]): G[Unordered[A]] = ga
+    def unwrap[G[_], A](gfa: G[Unordered[A]]): G[A] = gfa
+    implicit def unorderedOrdering[A]: Ordering[Unordered[A]] =
+      Ordering.by(_ => ())
+  }
+}

tests/pos/opaque-nullable.scala

@@ -0,0 +1,26 @@
+object nullable {
+  opaque type Nullable[A >: Null <: AnyRef] = A
+
+  object Nullable {
+    def apply[A >: Null <: AnyRef](a: A): Nullable[A] = a
+
+    implicit class NullableOps[A >: Null <: AnyRef](na: Nullable[A]) {
+      def exists(p: A => Boolean): Boolean =
+        na != null && p(na)
+      def filter(p: A => Boolean): Nullable[A] =
+        if (na != null && p(na)) na else null
+      def flatMap[B >: Null <: AnyRef](f: A => Nullable[B]): Nullable[B] =
+        if (na == null) null else f(na)
+      def forall(p: A => Boolean): Boolean =
+        na == null || p(na)
+      def getOrElse(a: => A): A =
+        if (na == null) a else na
+      def map[B >: Null <: AnyRef](f: A => B): Nullable[B] =
+        if (na == null) null else f(na)
+      def orElse(na2: => Nullable[A]): Nullable[A] =
+        if (na == null) na2 else na
+      def toOption: Option[A] =
+        Option(na)
+    }
+  }
+}

tests/pos/opaque-propability.scala

@@ -0,0 +1,43 @@
+object prob {
+  opaque type Probability = Double
+
+  object Probability {
+    def apply(n: Double): Option[Probability] =
+      if (0.0 <= n && n <= 1.0) Some(n) else None
+
+    def unsafe(p: Double): Probability = {
+      require(0.0 <= p && p <= 1.0, s"probabilities lie in [0, 1] (got $p)")
+      p
+    }
+
+    def asDouble(p: Probability): Double = p
+
+    val Never: Probability = 0.0
+    val CoinToss: Probability = 0.5
+    val Certain: Probability = 1.0
+
+    implicit val ordering: Ordering[Probability] =
+      implicitly[Ordering[Double]]
+
+    implicit class ProbabilityOps(p1: Probability) extends AnyVal {
+      def unary_~ : Probability = Certain - p1
+      def &(p2: Probability): Probability = p1 * p2
+      def |(p2: Probability): Probability = p1 + p2 - (p1 * p2)
+
+      def isImpossible: Boolean = p1 == Never
+      def isCertain: Boolean = p1 == Certain
+
+      import scala.util.Random
+
+      def sample(r: Random = Random): Boolean = r.nextDouble <= p1
+      def toDouble: Double = p1
+    }
+
+    val caughtTrain = Probability.unsafe(0.3)
+    val missedTrain = ~caughtTrain
+    val caughtCab = Probability.CoinToss
+    val arrived = caughtTrain | (missedTrain & caughtCab)
+
+    println((1 to 5).map(_ => arrived.sample()).toList)
+  }
+}