Allow multi-variable pattern declarations

Allow multi-variable pattern declarations of the form

    val p1, ..., pn: T

Author: odersky

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

@@ -49,9 +49,6 @@ object desugar {
     case None, Exhaustive, IrrefutablePatDef, IrrefutableGenFrom
   }
 
-  /** Info of a variable in a pattern: The named tree and its type */
-  private type VarInfo = (NameTree, Tree)
-
   /** Is `name` the name of a method that can be invalidated as a compiler-generated
    *  case class method if it clashes with a user-defined method?
    */
@@ -1685,16 +1682,6 @@ object desugar {
     TypeDef(tpnme.REFINE_CLASS, impl).withFlags(Trait)
   }
 
- /** If tree is of the form `id` or `id: T`, return its name and type, otherwise return None.
-   */
-  private object IdPattern {
-    def unapply(tree: Tree)(implicit ctx: Context): Option[VarInfo] = tree match {
-      case id: Ident if id.name != nme.WILDCARD => Some(id, TypeTree())
-      case Typed(id: Ident, tpt) => Some((id, tpt))
-      case _ => None
-    }
-  }
-
   /** Returns list of all pattern variables, possibly with their types,
    *  without duplicates
    */

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

@@ -345,6 +345,18 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
   def bodyKind(body: List[Tree])(implicit ctx: Context): FlagSet =
     body.foldLeft(NoInitsInterface)((fs, stat) => fs & defKind(stat))
 
+  /** Info of a variable in a pattern: The named tree and its type */
+  type VarInfo = (NameTree, Tree)
+
+  /** An extractor for trees of the form `id` or `id: T` */
+  object IdPattern {
+    def unapply(tree: Tree)(implicit ctx: Context): Option[VarInfo] = tree match {
+      case id: Ident if id.name != nme.WILDCARD => Some(id, TypeTree())
+      case Typed(id: Ident, tpt) => Some((id, tpt))
+      case _ => None
+    }
+  }
+
   // todo: fill with other methods from TreeInfo that only apply to untpd.Tree's
 }
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3071,12 +3071,16 @@ object Parsers {
           }
         else EmptyTree
       lhs match {
-        case (id @ Ident(name: TermName)) :: Nil if name != nme.WILDCARD =>
-          val vdef = ValDef(name, tpt, rhs)
+        case IdPattern(id, t) :: Nil if t.isEmpty =>
+          val vdef = ValDef(id.name.asTermName, tpt, rhs)
           if (isBackquoted(id)) vdef.pushAttachment(Backquoted, ())
           finalizeDef(vdef, mods, start)
         case _ =>
-          if rhs.isEmpty then
+          def isAllIds = lhs.forall {
+            case IdPattern(id, t) => t.isEmpty
+            case _ => false
+          }
+          if rhs.isEmpty && !isAllIds then
             syntaxError(ExpectedTokenButFound(EQUALS, in.token), Span(in.lastOffset))
           PatDef(mods, lhs, tpt, rhs)
       }