Fix handling of creator applications with type arguments

Author: odersky

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -15,7 +15,7 @@ import Denotations._
 import SymDenotations._
 import StdNames.{nme, tpnme}
 import ast.{Trees, untpd}
-import typer.{Implicits, Namer}
+import typer.{Implicits, Namer, Applications}
 import typer.ProtoTypes._
 import Trees._
 import TypeApplications._
@@ -578,6 +578,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         else keywordStr("'{") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case Splice(tree) =>
         keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
+      case tree: Applications.IntegratedTypeArgs =>
+        toText(tree.app) ~ "(with integrated type args)"
       case Thicket(trees) =>
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case _ =>

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

@@ -2243,8 +2243,16 @@ class Typer extends Namer
         val tycon = typed(tpt)
         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)
+        else {
+          def recur(tpt: Tree, pt: Type): Tree = pt.revealIgnored match {
+            case PolyProto(targs, pt1) if !targs.exists(_.isInstanceOf[NamedArg]) =>
+              IntegratedTypeArgs(recur(AppliedTypeTree(tpt, targs), pt1))
+            case _ =>
+              typed(untpd.Select(untpd.New(untpd.TypedSplice(tpt)), nme.CONSTRUCTOR), pt)
+          }
+          recur(tycon, pt)
+            .reporting(res => i"try new $tree -> $res", typr)
+        }
       } { (nu, nuState) =>
         if (nu.isEmpty) fallBack
         else {
@@ -2969,7 +2977,7 @@ class Typer extends Namer
               adaptToArgs(wtp, pt)
             case pt: PolyProto =>
               tree match {
-                case _: ExtMethodApply => tree
+                case _: IntegratedTypeArgs => tree
                 case _ =>  tryInsertApplyOrImplicit(tree, pt, locked)(tree) // error will be reported in typedTypeApply
               }
             case _ =>

tests/neg/creator-applys.scala

@@ -0,0 +1,35 @@
+class Test {
+  class A {
+    def run = "A"
+  }
+  object A
+  class B[T] {
+    def run = "B"
+  }
+  class C[S, T](x: S, y: T) {
+    def run = s"C $x $y"
+  }
+
+  val x1 = new Test().A()      // error: object A does not take parameters
+  val x2 = new Test().B()      // error: value B is not a member of Test
+  val x3 = new Test().B[Int]() // error: value B is not a member of Test
+}
+
+
+object Test2 {
+  class A(s: String = "A") {
+    def run = s
+  }
+  object A {
+    def apply() = A("X")  // error: recursive method needs return type
+  }
+}
+
+object Test3 {
+  class A(s: String = "A") {
+    def run = s
+  }
+  object A {
+    def apply(): A = A("X")  // error too many arguments
+  }
+}

tests/run/creator-applys.scala

@@ -18,7 +18,7 @@ object Test extends App {
   val x2 = B[String]()
   assert(x2.run == "B")
 
-  val x3: B[String] = B()
+  val x3: B[String] = Test.B()
   assert(x3.run == "B")
 
   val x4: C[String, Int] = C("a", 1)
@@ -27,19 +27,18 @@ object Test extends App {
   val x5 = C[String, Int]("a", 1)
   assert(x5.run == "C a 1")
 
+  val x5a = C[S = String, T = Int]("a", 1)
+  assert(x5a.run == "C a 1")
+
+  val x5b = C[T = Int]("a", 1)
+  assert(x5b.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")
-*/
-  Test2
+  Test1
 }
 
-object Test2 {
+object Test1 {
   class A {
     def run = "A"
   }
@@ -50,21 +49,116 @@ object Test2 {
     def run = s"C $x $y"
   }
 
+  val x1 = 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")
+  Test2
+}
+
+object Test2 {
   val x1 = Test.A()
   assert(x1.run == "A")
 
   val x2 = Test.B[String]()
   assert(x2.run == "B")
 
-  val x3: B[String] = Test.B()
+  val x3: Test.B[String] = Test.B()
   assert(x3.run == "B")
 
-  val x4: C[String, Int] = Test.C("a", 1)
+  val x4: Test.C[String, Int] = Test.C("a", 1)
   assert(x4.run == "C a 1")
 
   val x5 = Test.C[String, Int]("a", 1)
   assert(x5.run == "C a 1")
 
   val x6 = Test.C("a", 1)
-  assert((x6: C[String, Int]).run == "C a 1")
+  assert((x6: Test.C[String, Int]).run == "C a 1")
+  Test3
+}
+
+object Test3 {
+  val x1 = Test1.A()
+  assert(x1.run == "A")
+
+  val x2 = Test1.B[String]()
+  assert(x2.run == "B")
+
+  val x3: Test1.B[String] = Test1.B()
+  assert(x3.run == "B")
+
+  val x4: Test1.C[String, Int] = Test1.C("a", 1)
+  assert(x4.run == "C a 1")
+
+  val x5 = Test1.C[String, Int]("a", 1)
+  assert(x5.run == "C a 1")
+
+  val x6 = Test1.C("a", 1)
+  assert((x6: Test1.C[String, Int]).run == "C a 1")
+  Test4
+}
+
+object Test4 {
+  type A = Test.A
+  type AA[T] = A
+  type B[T] = Test.B[T]
+  type C[T] = Test.C[T, Int]
+
+  val x1 = A()
+  assert(x1.run == "A")
+
+  val x1a = AA[Int]()
+  assert(x1a.run == "A")
+
+  val x2 = B[String]()
+  assert(x2.run == "B")
+
+  val x3: B[String] = B()
+  assert(x3.run == "B")
+
+  val x5 = C[String]("a", 1)
+  assert(x5.run == "C a 1")
+  Test5
+}
+
+object Test5 {
+  val x1 = Test4.A()
+  assert(x1.run == "A")
+
+  val x1a = Test4.AA[Int]()
+  assert(x1a.run == "A")
+
+  val x2 = Test4.B[String]()
+  assert(x2.run == "B")
+
+  val x3: Test4.B[String] = Test4.B()
+  assert(x3.run == "B")
+
+  val x5 = Test4.C[String]("a", 1)
+  assert(x5.run == "C a 1")
+  Test6
+}
+
+object Test6 {
+  class A(s: String = "A") {
+    def run = s
+  }
+  object A {
+    def apply(): A = new A("X")
+  }
+  val x1 = A()
+  assert(x1.run == "X")
 }