Better type inference for new

For an expression of the form `new { ... }`,
infer the parent type if possible from the expected
type. Fallback to `Object` if the expected type is undefined
or is illegal for a class parent.

Author: odersky

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

@@ -443,13 +443,18 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     tree.tpt match {
       case templ: untpd.Template =>
         import untpd._
-        templ.parents foreach {
+        var templ1 = templ
+        if (templ1.parents.isEmpty &&
+            isFullyDefined(pt, ForceDegree.noBottom) &&
+            pt.underlyingClassRef(refinementOK = false).exists)
+          templ1 = cpy.Template(templ)(parents = untpd.TypeTree(pt) :: Nil)
+        templ1.parents foreach {
           case parent: RefTree =>
             typedAheadImpl(parent, tree => inferTypeParams(typedType(tree), pt))
           case _ =>
         }
         val x = tpnme.ANON_CLASS
-        val clsDef = TypeDef(x, templ).withFlags(Final)
+        val clsDef = TypeDef(x, templ1).withFlags(Final)
         typed(cpy.Block(tree)(clsDef :: Nil, New(Ident(x), Nil)), pt)
       case _ =>
         var tpt1 = typedType(tree.tpt)

docs/docs/reference/implicit-by-name-parameters.md

@@ -3,21 +3,22 @@
 Call-by-name implicit parameters can be used to avoid a divergent implicit expansion.
 
 ```scala
-trait Serializable[T] {
+trait Codec[T] {
   def write(x: T): Unit
 }
 
-implicit def serializeInt: Serializable[Int] = ???
+implicit def intCodec: Codec[Int] = ???
 
-implicit def serializeOption[T](implicit ev: => Serializable[T]): Serializable[Option[T]] =
-  new Serializable[Option[T]] {
+implicit def optionCodec[T]
+    (implicit ev: => Codec[T]): Codec[Option[T]] =
+  new {
     def write(xo: Option[T]) = xo match {
       case Some(x) => ev.write(x)
       case None =>
     }
   }
 
-val s = implicitly[Serializable[Option[Int]]]
+val s = implicitly[Codec[Option[Int]]]
 
 s.write(Some(33))
 s.write(None)
@@ -53,8 +54,8 @@ The precise steps for constructing an implicit argument for a by-name parameter
 In the example above, the definition of `s` would be expanded as follows.
 
 ```scala
-val s = implicitly[Test.Serializable[Option[Int]]](
-  serializeOption[Int](serializeInt))
+val s = implicitly[Test.Codec[Option[Int]]](
+  optionCodec[Int](intCodec))
 ```
 
 No lazy val was generated because the synthesized argument is not recursive.

tests/pos/news.scala

@@ -0,0 +1,10 @@
+object Test {
+
+  abstract class C[T] { def f: T }
+
+  val x: C[Int] = new { def f = 2 }
+
+  val y = new { val name = "Bob" }
+
+
+}