Don't auto-tuple if expected type is a tuple

Author: odersky

compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala

@@ -21,7 +21,7 @@ trait UniqueMessagePositions extends Reporter {
       m.pos.exists && {
         var shouldHide = false
         for (pos <- m.pos.start to m.pos.end) {
-          positions get (ctx.source, pos) match {
+          positions.get((ctx.source, pos)) match {
             case Some(level) if level >= m.level => shouldHide = true
             case _ => positions((ctx.source, pos)) = m.level
           }

compiler/src/dotty/tools/dotc/reporting/trace.scala

@@ -9,40 +9,40 @@ import core.Mode
 
 object trace {
 
-  @inline
+  @`inline`
   def onDebug[TD](question: => String)(op: => TD)(implicit ctx: Context): TD =
     conditionally(ctx.settings.YdebugTrace.value, question, false)(op)
 
-  @inline
+  @`inline`
   def conditionally[TC](cond: Boolean, question: => String, show: Boolean)(op: => TC)(implicit ctx: Context): TC = {
     def op1 = op
     if (Config.tracingEnabled && cond) apply[TC](question, Printers.default, show)(op1)
     else op1
   }
 
-  @inline
+  @`inline`
   def apply[T](question: => String, printer: Printers.Printer, showOp: Any => String)(op: => T)(implicit ctx: Context): T = {
     def op1 = op
     if (!Config.tracingEnabled || printer.eq(config.Printers.noPrinter)) op1
     else doTrace[T](question, printer, showOp)(op1)
   }
 
-  @inline
+  @`inline`
   def apply[T](question: => String, printer: Printers.Printer, show: Boolean)(op: => T)(implicit ctx: Context): T = {
     def op1 = op
     if (!Config.tracingEnabled || printer.eq(config.Printers.noPrinter)) op1
     else doTrace[T](question, printer, if (show) showShowable(_) else alwaysToString)(op1)
   }
 
-  @inline
+  @`inline`
   def apply[T](question: => String, printer: Printers.Printer)(op: => T)(implicit ctx: Context): T =
     apply[T](question, printer, false)(op)
 
-  @inline
+  @`inline`
   def apply[T](question: => String, show: Boolean)(op: => T)(implicit ctx: Context): T =
     apply[T](question, Printers.default, show)(op)
 
-  @inline
+  @`inline`
   def apply[T](question: => String)(op: => T)(implicit ctx: Context): T =
     apply[T](question, Printers.default, false)(op)
 
@@ -59,7 +59,7 @@ object trace {
                         (op: => T)(implicit ctx: Context): T = {
     // Avoid evaluating question multiple time, since each evaluation
     // may cause some extra logging output.
-    lazy val q: String = question
+    @volatile lazy val q: String = question
     apply[T](s"==> $q?", (res: Any) => s"<== $q = ${showOp(res)}")(op)
   }
 

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

@@ -981,7 +981,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
                 regularArgs :+ untpd.SeqLiteral(varArgs, untpd.TypeTree()).withPos(tree.pos)
             }
           else argTypes match {
-            case argType :: Nil if args.lengthCompare(1) > 0 && supportsAutoTupling(argType, args) =>
+            case argType :: Nil if args.lengthCompare(1) > 0 && canAutoTuple(args) =>
               untpd.Tuple(args) :: Nil
             case _ =>
               args

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

@@ -2032,37 +2032,18 @@ class Typer extends Namer
     }
   }
 
-  def supportsAutoTupling(tp: Type, args: List[untpd.Tree])(implicit ctx: Context): Boolean = {
-    def test(tp: Type): Boolean = tp match {
-      case tp: TypeRef =>
-        val sym = tp.symbol
-        defn.isTupleClass(sym) && defn.arity(sym, str.Tuple) == args.length ||
-        defn.isProductClass(sym) && defn.arity(sym, str.Product) == args.length ||
-        !sym.isClass && test(tp.underlying)
-      case tp: TypeParamRef =>
-        val bounds = ctx.typeComparer.bounds(tp)
-        test(bounds.lo) || test(bounds.hi)
-      case tp: TypeProxy =>
-        test(tp.underlying)
-      case _ =>
-        false
-    }
-    test(tp) || {
-      val pos = Position(args.map(_.pos.start).min, args.map(_.pos.end).max)
-      ctx.testScala2Mode(
-          i"""auto-tupling is no longer supported in this case,
-              |arguments now need to be enclosed in parentheses (...).""",
-          pos, { patch(pos.startPos, "("); patch(pos.endPos, ")") })
-    }
+  def canAutoTuple(args: List[untpd.Tree])(implicit ctx: Context): Boolean = {
+    val pos = Position(args.map(_.pos.start).min, args.map(_.pos.end).max)
+    ctx.testScala2Mode(
+        i"""auto-tupling is no longer supported in this case,
+            |arguments now need to be enclosed in parentheses (...).""",
+        pos, { patch(pos.startPos, "("); patch(pos.endPos, ")") })
   }
 
   def takesAutoTupledArgs(tp: Type, sym: Symbol, args: List[untpd.Tree])(implicit ctx: Context): Boolean = tp match {
     case tp: MethodicType =>
       tp.firstParamTypes match {
-        case ptype :: Nil =>
-          !ptype.isRepeatedParam && {
-            sym.name.isOpName || supportsAutoTupling(ptype, args)
-          }
+        case ptype :: Nil => !ptype.isRepeatedParam && (sym.name.isOpName || canAutoTuple(args))
         case _ => false
       }
     case tp: TermRef =>

tests/run/t8610.scala

@@ -3,7 +3,7 @@
 case class X(name: String) {
   def x = "Hi, $name"   // missing interp
   def f(p: (Int, Int)): Int = p._1 * p._2
-  def g = f(3, 4)       // adapted
+  def g = f((3, 4))       // adapted
   def u: Unit = ()      // unitarian universalist
 }