Fix #3005: Treat singleton ExprTypes as stable values

Two main changes:

 - values with type => T are stable if T is stable
 - types deriving from scala.Singleton are considered stable

The two changes together allow to declare by-name-parameters to be stable
by declaring them to have a Singleton type.

Author: odersky

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

@@ -595,8 +595,11 @@ object SymDenotations {
       )
 
     /** Is this a denotation of a stable term (or an arbitrary type)? */
-    final def isStable(implicit ctx: Context) =
-      isType || is(Stable) || !(is(UnstableValue) || info.isInstanceOf[ExprType])
+    final def isStable(implicit ctx: Context) = {
+      def isUnstable =
+      	is(UnstableValue) || info.isInstanceOf[ExprType] && !info.isStable
+      isType || is(Stable) || !isUnstable
+    }
 
     /** Is this a "real" method? A real method is a method which is:
      *  - not an accessor

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

@@ -115,7 +115,7 @@ object Types {
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
       case tp: AnnotatedType => tp.tpe.isStable
-      case _ => false
+      case tp => tp.derivesFrom(defn.SingletonClass)
     }
 
     /** Is this type a (possibly refined or applied or aliased) type reference

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

@@ -417,7 +417,7 @@ object ProtoTypes {
 
   /** Create a new TypeVar that represents a dependent method parameter singleton */
   def newDepTypeVar(tp: Type)(implicit ctx: Context): TypeVar =
-    newTypeVar(TypeBounds.upper(AndType(tp, defn.SingletonClass.typeRef)))
+    newTypeVar(TypeBounds.upper(AndType(tp.widenExpr, defn.SingletonClass.typeRef)))
 
   /** The result type of `mt`, where all references to parameters of `mt` are
    *  replaced by either wildcards (if typevarsMissContext) or TypeParamRefs.

tests/pos-special/i3005.scala

@@ -0,0 +1,16 @@
+trait Foo {
+  type Out
+  def out: Out
+}
+
+object Test extends App {
+
+  implicit def bar(implicit foo: => Foo & Singleton): foo.Out = foo.out
+
+  var x = new Foo { type Out = String; def out = "hello" }
+
+  implicit val y: Foo = x
+
+  assert(bar(y) == "hello")
+  assert(bar == "hello")
+}