Fallback from A to new A

Author: odersky

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

@@ -2272,8 +2272,37 @@ class Typer extends Namer
       else try adapt(simplify(sel, pt1, locked), pt1, locked) finally sel.removeAttachment(InsertedApply)
     }
 
+    def tryNew(fallBack: => Tree): Tree = {
+
+      def tryNewWithType(tpt: untpd.Tree): Tree =
+        tryEither { implicit ctx =>
+          val tycon = typed(tpt.withSpan(tree.span))
+          if (ctx.reporter.hasErrors)
+            EmptyTree // signal that we should return the error in fallBack
+          else
+            typed(untpd.Select(untpd.New(untpd.TypedSplice(tycon)), nme.CONSTRUCTOR), pt)
+        } { (nu, nuState) =>
+          if (nu.isEmpty) fallBack
+          else {
+            // we found a type constructor, signal the error in its application instead of the original one
+            nuState.commit()
+            nu
+          }
+        }
+
+      tree match {
+        case Ident(name) =>
+          tryNewWithType(untpd.Ident(name.toTypeName))
+        case Select(qual, name) =>
+          tryNewWithType(untpd.Select(untpd.TypedSplice(qual), name.toTypeName))
+        case _ =>
+          fallBack
+      }
+    }
+
     def tryImplicit(fallBack: => Tree) =
-      tryInsertImplicitOnQualifier(tree, pt.withContext(ctx), locked).getOrElse(fallBack)
+      tryInsertImplicitOnQualifier(tree, pt.withContext(ctx), locked)
+        .getOrElse(tryNew(fallBack))
 
     if (ctx.mode.is(Mode.SynthesizeExtMethodReceiver))
       // Suppress insertion of apply or implicit conversion on extension method receiver

tests/run/creator-applys.scala

@@ -0,0 +1,69 @@
+object Test extends App {
+  class A {
+    def run = "A"
+  }
+  object A
+  class B[T] {
+    def run = "B"
+  }
+  object B
+  class C[S, T](x: S, y: T) {
+    def run = s"C $x $y"
+  }
+  object C
+
+  val x1 = Test.A()
+  assert(x1.run == "A")
+
+  val x2 = B[String]()
+  assert(x2.run == "B")
+
+  val x3: B[String] = B()
+  assert(x3.run == "B")
+
+  val x4: C[String, Int] = C("a", 1)
+  assert(x4.run == "C a 1")
+
+  val x5 = C[String, Int]("a", 1)
+  assert(x5.run == "C a 1")
+
+  val x6 = C("a", 1)
+  assert((x6: C[String, Int]).run == "C a 1")
+/*
+  val x7 = C[S = String]("a", 1)
+  assert((x7: C[String, Int]).run == "C a 1")
+
+  val x8 = C[T = Int]("a", 1)
+  assert((x8: C[String, Int]).run == "C a 1")
+*/
+}
+/*
+object Test2 {
+  class A {
+    def run = "A"
+  }
+  class B[T] {
+    def run = "B"
+  }
+  class C[S, T](x: S, y: T) {
+    def run = s"C $x $y"
+  }
+
+  val x1 = Test.A()
+  assert(x1.run == "A")
+
+  val x2 = B[String]()
+  assert(x2.run == "B")
+
+  val x3: B[String] = B()
+  assert(x3.run == "B")
+
+  val x4: C[String, Int] = C("a", 1)
+  assert(x4.run == "C a 1")
+
+  val x5 = C[String, Int]("a", 1)
+  assert(x5.run == "C a 1")
+
+  val x6 = C("a", 1)
+  assert((x6: C[String, Int]).run == "C a 1")
+}*/