Restrict auto-tupling more

This was initially an attempt to drop auto-tupling altogether. But it became quickly annoying. The
main problem is that it's unnatural to add another pair of parentheses to infix operations. Compare:

    (x, y) == z
    z == ((x, y))    // !yuck

Same thing for cons:

    ((1, x)) :: ((2, y)) :: xs   // double yuck!

So at the very least we have to allow auto-tupling for arguments of infix operators. I went a little bit
further and also allowed auto-tupling if the expected type is already a (some kind of) product or tuple of the right
arity. The result is this commit.

The language import `noAutoTupling` has been removed. The previous auto-tupling is still reported
under Scala 2 mode, and there is -rewrite support to add the missing (...) automatically.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1216,7 +1216,7 @@ object desugar {
    */
   private object IdPattern {
     def unapply(tree: Tree)(implicit ctx: Context): Option[VarInfo] = tree match {
-      case id: Ident => Some(id, TypeTree())
+      case id: Ident => Some((id, TypeTree()))
       case Typed(id: Ident, tpt) => Some((id, tpt))
       case _ => None
     }

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -537,7 +537,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   object closure {
     def unapply(tree: Tree): Option[(List[Tree], Tree, Tree)] = tree match {
       case Block(_, expr) => unapply(expr)
-      case Closure(env, meth, tpt) => Some(env, meth, tpt)
+      case Closure(env, meth, tpt) => Some((env, meth, tpt))
       case Typed(expr, _)  => unapply(expr)
       case _ => None
     }

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1009,8 +1009,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** An extractor that pulls out type arguments */
   object MaybePoly {
     def unapply(tree: Tree): Option[(Tree, List[Tree])] = tree match {
-      case TypeApply(tree, targs) => Some(tree, targs)
-      case _ => Some(tree, Nil)
+      case TypeApply(tree, targs) => Some((tree, targs))
+      case _ => Some((tree, Nil))
     }
   }
 

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -436,7 +436,6 @@ class Definitions {
   lazy val ArrayModuleType = ctx.requiredModuleRef("scala.Array")
   def ArrayModule(implicit ctx: Context) = ArrayModuleType.symbol.moduleClass.asClass
 
-
   lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", BoxedUnitType, java.lang.Void.TYPE, UnitEnc, nme.specializedTypeNames.Void)
   def UnitClass(implicit ctx: Context) = UnitType.symbol.asClass
   def UnitModuleClass(implicit ctx: Context) = UnitType.symbol.asClass.linkedClass
@@ -776,7 +775,7 @@ class Definitions {
       if (isFunctionClass(tsym)) {
         val targs = ft.dealias.argInfos
         if (targs.isEmpty) None
-        else Some(targs.init, targs.last, tsym.name.isImplicitFunction, tsym.name.isErasedFunction)
+        else Some((targs.init, targs.last, tsym.name.isImplicitFunction, tsym.name.isErasedFunction))
       }
       else None
     }
@@ -821,8 +820,8 @@ class Definitions {
       case ArrayOf(elemtp) =>
         def recur(elemtp: Type): Option[(Type, Int)] = elemtp.dealias match {
           case TypeBounds(lo, hi) => recur(hi)
-          case MultiArrayOf(finalElemTp, n) => Some(finalElemTp, n + 1)
-          case _ => Some(elemtp, 1)
+          case MultiArrayOf(finalElemTp, n) => Some((finalElemTp, n + 1))
+          case _ => Some((elemtp, 1))
         }
         recur(elemtp)
       case _ =>
@@ -879,6 +878,18 @@ class Definitions {
       name.length > prefix.length &&
       name.drop(prefix.length).forall(_.isDigit))
 
+  def arity(cls: Symbol, prefix: String): Int =
+    scalaClassName(cls).applySimple(-1) { name =>
+      if (name.startsWith(prefix)) {
+        val digits = name.drop(prefix.length)
+        if (!digits.isEmpty && digits.forall(_.isDigit))
+          try digits.toString.toInt
+          catch { case ex: NumberFormatException => -1 }
+        else -1
+      }
+      else -1
+    }
+
   def isBottomClass(cls: Symbol) =
     cls == NothingClass || cls == NullClass
   def isBottomType(tp: Type) =

compiler/src/dotty/tools/dotc/core/NameOps.scala

@@ -58,6 +58,12 @@ object NameOps {
       case _ => false
     }
 
+    def applySimple[T](default: T)(f: SimpleName => T): T = name match {
+      case name: SimpleName => f(name)
+      case name: TypeName => name.toTermName.applySimple(default)(f)
+      case _ => default
+    }
+
     def likeSpaced(n: PreName): N =
       (if (name.isTermName) n.toTermName else n.toTypeName).asInstanceOf[N]
 
@@ -81,6 +87,11 @@ object NameOps {
       }
     }
 
+    def isOpName = name match {
+      case name: SimpleName => NameTransformer.encode(name) != name
+      case _ => false
+    }
+
     def isOpAssignmentName: Boolean = name match {
       case raw.NE | raw.LE | raw.GE | EMPTY =>
         false

compiler/src/dotty/tools/dotc/core/TypeOps.scala

@@ -17,7 +17,7 @@ import util.Property
 import collection.mutable
 import ast.tpd._
 import reporting.trace
-import reporting.diagnostic.Message
+import reporting.diagnostic.{Message, NoExplanation}
 
 trait TypeOps { this: Context => // TODO: Make standalone object.
 
@@ -313,10 +313,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     hasImport(ctx.withPhase(ctx.typerPhase)) || hasOption
   }
 
-  /** Is auto-tupling enabled? */
-  def canAutoTuple =
-    !featureEnabled(defn.LanguageModuleClass, nme.noAutoTupling)
-
   def scala2Mode =
     featureEnabled(defn.LanguageModuleClass, nme.Scala2)
 
@@ -325,7 +321,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
 
   def testScala2Mode(msg: => Message, pos: Position, rewrite: => Unit = ()) = {
     if (scala2Mode) {
-      migrationWarning(msg, pos)
+      migrationWarning(
+        new NoExplanation(msg.msg ++ "\nThis can be fixed automatically using -rewrite"), pos)
       rewrite
     }
     scala2Mode

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

@@ -980,10 +980,12 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
                 val (regularArgs, varArgs) = args.splitAt(argTypes.length - 1)
                 regularArgs :+ untpd.SeqLiteral(varArgs, untpd.TypeTree()).withPos(tree.pos)
             }
-          else if (argTypes.lengthCompare(1) == 0 && args.lengthCompare(1) > 0 && ctx.canAutoTuple)
-            untpd.Tuple(args) :: Nil
-          else
-            args
+          else argTypes match {
+            case argType :: Nil if args.lengthCompare(1) > 0 && supportsAutoTupling(argType, args) =>
+              untpd.Tuple(args) :: Nil
+            case _ =>
+              args
+          }
         if (argTypes.length != bunchedArgs.length) {
           ctx.error(UnapplyInvalidNumberOfArguments(qual, argTypes), tree.pos)
           argTypes = argTypes.take(args.length) ++

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

@@ -2032,6 +2032,45 @@ 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 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 _ => false
+      }
+    case tp: TermRef =>
+      tp.denot.alternatives.forall(alt => takesAutoTupledArgs(alt.info, alt.symbol, args))
+    case _ =>
+      false
+  }
+
   /** Perform the following adaptations of expression, pattern or type `tree` wrt to
    *  given prototype `pt`:
    *  (1) Resolve overloading
@@ -2119,21 +2158,9 @@ class Typer extends Namer
         }
       }
 
-      def isUnary(tp: Type): Boolean = tp match {
-        case tp: MethodicType =>
-          tp.firstParamTypes match {
-            case ptype :: Nil => !ptype.isRepeatedParam
-            case _ => false
-          }
-        case tp: TermRef =>
-          tp.denot.alternatives.forall(alt => isUnary(alt.info))
-        case _ =>
-          false
-      }
-
       def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
         case _: MethodOrPoly =>
-          if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
+          if (pt.args.lengthCompare(1) > 0 && takesAutoTupledArgs(wtp, tree.symbol, pt.args))
             adapt(tree, pt.tupled, locked)
           else
             tree
@@ -2499,10 +2526,10 @@ class Typer extends Namer
         case tp: FlexType =>
           ensureReported(tp)
           tree
-        case ref: TermRef =>
+        case ref: TermRef => // this case can happen in case tree.tpe is overloaded
           pt match {
             case pt: FunProto
-            if pt.args.lengthCompare(1) > 0 && isUnary(ref) && ctx.canAutoTuple =>
+            if pt.args.lengthCompare(1) > 0 && takesAutoTupledArgs(ref, ref.symbol, pt.args) =>
               adapt(tree, pt.tupled, locked)
             case _ =>
               adaptOverloaded(ref)

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -180,7 +180,6 @@ class CompilationTests extends ParallelTesting {
     compileFilesInDir("tests/neg-custom-args/allow-double-bindings", allowDoubleBindings) +
     compileFile("tests/neg-custom-args/i3246.scala", scala2Mode) +
     compileFile("tests/neg-custom-args/overrideClass.scala", scala2Mode) +
-    compileFile("tests/neg-custom-args/autoTuplingTest.scala", defaultOptions.and("-language:noAutoTupling")) +
     compileFile("tests/neg-custom-args/i1050.scala", defaultOptions.and("-strict")) +
     compileFile("tests/neg-custom-args/nopredef.scala", defaultOptions.and("-Yno-predef")) +
     compileFile("tests/neg-custom-args/noimports.scala", defaultOptions.and("-Yno-imports")) +

library/src/scalaShadowing/language.scala

@@ -29,7 +29,6 @@ package scalaShadowing
  *  and, for dotty:
  *
  *   - [[Scala2              `Scala2`]               backwards compatibility mode for Scala2
- *   - [[noAtoTupling        `noAutoTupling`]]       disable auto-tupling
  *
  *  @groupname production   Language Features
  *  @groupname experimental Experimental Language Features
@@ -193,9 +192,6 @@ object language {
   /** Where imported, a backwards compatibility mode for Scala2 is enabled */
   object Scala2
 
-  /** Where imported, auto-tupling is disabled */
-  object noAutoTupling
-
   /* Where imported loose equality using eqAny is disabled */
   object strictEquality
 }

tests/neg-custom-args/autoTuplingTest.scala

@@ -1,11 +1,9 @@
-import language.noAutoTupling
-
 object autoTuplingNeg2 {
 
   val x = Some(1, 2) // error: too many arguments for method apply: (x: A)Some[A]
 
   x match {
-    case Some(a, b) => a + b // error: wrong number of argument patterns for Some // error: not found: b
+    case Some(a, b) => a + b // error: wrong number of argument patterns for Some // error: not found: a
     case None =>
   }
 }

tests/neg/autoTuplingTest.scala

@@ -10,7 +10,6 @@ import scala.io.{ Idontexist4 => Foo } // error
 import scala.io.{ Idontexist5 => _ } // error
 
 import scala.language.dynamics
-import scala.language.noAutoTupling
 import scala.language.idontexist // error
 
 object Test

tests/neg/i1286.scala

@@ -6,5 +6,5 @@ class DynTest extends Dynamic {
 
 class CompilerError {
   val test = new DynTest
-  test.crushTheCompiler(a = 1, b = 2) // error
+  test.crushTheCompiler(a = 1, b = 2) // error // error
 }

tests/neg/t6920.scala

@@ -651,7 +651,7 @@ object CollectionStrawMan6 extends LowPriority {
     }
 
     def fromIterator[B](it: Iterator[B]): LazyList[B] =
-      new LazyList(if (it.hasNext) Some(it.next(), fromIterator(it)) else None)
+      new LazyList(if (it.hasNext) Some((it.next(), fromIterator(it))) else None)
   }
 
   // ------------------ Decorators to add collection ops to existing types -----------------------

tests/pos-special/strawman-collections/CollectionStrawMan6.scala

@@ -3,7 +3,7 @@ object Foo {
   case class T(i: Int) extends S(i)
 
   object T {
-    def unapply(s: S): Option[(Int, Int)] = Some(5, 6)
+    def unapply(s: S): Option[(Int, Int)] = Some((5, 6))
     // def unapply(o: Object): Option[(Int, Int, Int)] = Some(5, 6, 7)
   }
 
@@ -22,7 +22,7 @@ object Bar {
   class S(i: Int) extends T(i)
 
   object T {
-    def unapply(s: S): Option[(Int, Int)] = Some(5, 6)
+    def unapply(s: S): Option[(Int, Int)] = Some((5, 6))
     // def unapply(o: Object): Option[(Int, Int, Int)] = Some(5, 6, 7)
   }
 

tests/pos/autoTuplingTest.scala

@@ -17,7 +17,7 @@ object Test {
   }
 
   def test2 = {
-    val f = "".contains("", (_: Int)) // dotc:
+    val f = (x: Int) => "".contains(("", x)) // dotc:
     f.apply(0)
     // sandbox/eta.scala:18: error: apply is not a member of Boolean(f)
     //     f.apply(0)

tests/pos/i1318.scala

@@ -11,21 +11,21 @@ object Match
 
   object Extractor1 {
     def unapply(x: Any) = x match {
-        case x: String => Some(x, x + x, x + x+x, x+x, x)
+        case x: String => Some((x, x + x, x + x+x, x+x, x))
         case _ => None
     }
   }
 
   object Extractor2 {
     def unapply(x: Any) = x match {
-        case x: String => Some(x, x + x, x + x+x)
+        case x: String => Some((x, x + x, x + x+x))
         case _ => None
     }
   }
 
   object Extractor3 {
     def unapply(x: Any) = x match {
-        case x: String => Some(x, x, x)
+        case x: String => Some((x, x, x))
         case _ => None
     }
   }

tests/pos/i903.scala

@@ -10,8 +10,6 @@ class RichA {
 }
 
 object TestNoAutoTupling {
-  import language.noAutoTupling // try with on and off
-
   implicit def AToRichA(a: A): RichA = new RichA
 
   val a = new A
@@ -52,25 +50,3 @@ object Main {
     ()
   }
 }
-
-object TestWithAutoTupling {
-
-  implicit def AToRichA(a: A): RichA = new RichA
-
-  val a = new A
-  a.foo()
-  a.foo(1)
-
-  a.foo("")       // Without implicits, a type error regarding invalid argument types is generated at `""`. This is
-                  // the same position as an argument, so the 'second try' typing with an Implicit View is tried,
-                  // and AToRichA(a).foo("") is found.
-                  //
-                  // My reading of the spec "7.3 Views" is that `a.foo` denotes a member of `a`, so the view should
-                  // not be triggered.
-                  //
-                  // But perhaps the implementation was changed to solve See https://lampsvn.epfl.ch/trac/scala/ticket/1756
-
-  a.foo("a", "b") // Without implicits, a type error regarding invalid arity is generated at `foo(<error>"", "")`.
-                  // Typers#tryTypedApply:3274 only checks if the error is as the same position as `foo`, `"a"`, or `"b"`.
-}
-