Fix unpickler logic and beef up test

Author: odersky

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1163,6 +1163,36 @@ class TreeUnpickler(reader: TastyReader,
           readPathTerm()
       }
 
+      /** Adapt constructor calls where class has only using clauses from old to new scheme.
+       *  or class has mixed using clauses and other clauses.
+       *  Old: leading (), new: nothing, or trailing () if all clauses are using clauses.
+       *  This is neccessary so that we can read pre-3.2 Tasty correctly. There,
+       *  constructor calls use the old scheme, but constructor definitions already
+       *  use the new scheme, since they are reconstituted with normalizeIfConstructor.
+       */
+      def constructorApply(fn: Tree, args: List[Tree]): Tree =
+        if fn.tpe.widen.isContextualMethod && args.isEmpty then
+          fn.withAttachment(SuppressedApplyToNone, ())
+        else
+          val fn1 = fn match
+            case Apply(fn1, Nil) if fn.removeAttachment(InsertedApplyToNone).isDefined =>
+              // We thought we inserted a final `()` but hit a user-written `()` instead.
+              // Remove the inserted `()`.
+              fn1
+            case _ =>
+              fn
+          val res = tpd.Apply(fn1, args)
+          if fn.removeAttachment(SuppressedApplyToNone).isEmpty then
+            res
+          else res.tpe.widen match
+            case mt @ MethodType(params) =>
+              if params.isEmpty then
+                // Assume it's the final synthesized `()` parameter
+                res.appliedToNone.withAttachment(InsertedApplyToNone, ())
+              else if mt.isContextualMethod then
+                res.withAttachment(SuppressedApplyToNone, ())
+              else res
+
       def readLengthTerm(): Tree = {
         val end = readEnd()
         val result =
@@ -1174,22 +1204,8 @@ class TreeUnpickler(reader: TastyReader,
             case APPLY =>
               val fn = readTerm()
               val args = until(end)(readTerm())
-              // Adapt constructor calls where class has only using clauses from old to new scheme.
-              // Old: leading (), new: trailing ().
-              // This is neccessary so that we can read pre-3.2 Tasty correctly. There,
-              // constructor calls use the old scheme, but constructor definitions already
-              // use the new scheme, since they are reconstituted with normalizeIfConstructor.
-              if fn.symbol.isConstructor && fn.tpe.widen.isContextualMethod && args.isEmpty then
-                fn.withAttachment(SuppressedApplyToNone, ())
-              else
-                val res = tpd.Apply(fn, args)
-                if fn.removeAttachment(SuppressedApplyToNone).isEmpty then
-                  res
-                else res.tpe.widen match
-                  case MethodType(Nil) =>
-                    res.appliedToNone
-                  case mt: MethodType if mt.isContextualMethod =>
-                    res.withAttachment(SuppressedApplyToNone, ())
+              if fn.symbol.isConstructor then constructorApply(fn, args)
+              else tpd.Apply(fn, args)
             case TYPEAPPLY =>
               tpd.TypeApply(readTerm(), until(end)(readTpt()))
             case TYPED =>
@@ -1581,4 +1597,9 @@ object TreeUnpickler {
    *  call that has otherwise only using clauses was suppressed.
    */
   val SuppressedApplyToNone: Property.Key[Unit] = Property.Key()
+
+  /** An attachment key indicating that an trailing () in a constructor
+   *  call that has otherwise only using clauses was inserted.
+   */
+  val InsertedApplyToNone: Property.Key[Unit] = Property.Key()
 }

tests/run/backwardsCompat-implicitParens.check

@@ -0,0 +1,20 @@
+Bar
+Bar
+Bar
+Bar
+()
+Bat
+Bat
+Bat
+Bat
+()
+Bax
+Bax
+Bax
+Bax
+()
+Baz
+Baz
+Baz
+Baz
+()

tests/run/backwardsCompat-implicitParens/A_1_c3.0.2.scala

@@ -1,6 +1,32 @@
-class Bar(using x: Int)(y: String)
+class Bar(using x: Int)(y: String):
+  override def toString = "Bar"
 object Bar:
   given Int = 1
   inline def foo =
     println(new Bar()(""))
     println(Bar()(""))
+
+class Bat(using x: Int):
+  override def toString = "Bat"
+object Bat:
+  given Int = 1
+  inline def foo =
+    println(new Bat())
+    println(Bat())
+
+class Bax(using x: Int)():
+  override def toString = "Bax"
+object Bax:
+  given Int = 1
+  inline def foo =
+    println(new Bax())
+    println(Bax())
+
+class Baz(using x: Int)(using y: String):
+  override def toString = "Baz"
+object Baz:
+  given Int = 1
+  given String = "x"
+  inline def foo =
+    println(new Baz())
+    println(Baz())

tests/run/backwardsCompat-implicitParens/Test_2.scala

@@ -1,5 +1,19 @@
 @main def Test =
   given Int = 1
+  given String = "x"
+
   println(new Bar(""))
   println(Bar(""))
   println(Bar.foo)
+
+  println(new Bat())
+  println(Bat())
+  println(Bat.foo)
+
+  println(new Bax())
+  println(Bax())
+  println(Bax.foo)
+
+  println(new Baz())
+  println(Baz())
+  println(Baz.foo)