Annotate repeated params with case flag to indicate that they are legal

One drawback with this approach is that the type seems to propagate.
I.e. if the return type of an expression is `repeated` then the
enclosing variable will get the `repeated` type instead of getting the
expected `Seq` type

Author: felixmulder

src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -119,7 +119,12 @@ class TreeChecker extends Phase with SymTransformer {
     val prevPhase = ctx.phase.prev // can be a mini-phase
     val squahsedPhase = ctx.squashed(prevPhase)
     ctx.echo(s"checking ${ctx.compilationUnit} after phase ${squahsedPhase}")
-    val checkingCtx = ctx.fresh.setReporter(new ThrowingReporter(ctx.reporter))
+
+    val checkingCtx = ctx
+        .fresh
+        .setMode(Mode.ImplicitsEnabled)
+        .setReporter(new ThrowingReporter(ctx.reporter))
+
     val checker = new Checker(previousPhases(phasesToRun.toList)(ctx))
     try checker.typedExpr(ctx.compilationUnit.tpdTree)(checkingCtx)
     catch {
@@ -307,7 +312,9 @@ class TreeChecker extends Phase with SymTransformer {
     }.apply(tp)
 
     def checkNotRepeated(tree: Tree)(implicit ctx: Context): tree.type = {
-      assert(!tree.tpe.widen.isRepeatedParam, i"repeated parameter type not allowed here: $tree")
+      def allowedRepeated = (tree.symbol.flags is Case) && tree.tpe.widen.isRepeatedParam
+
+      assert(!tree.tpe.widen.isRepeatedParam || allowedRepeated, i"repeated parameter type not allowed here: $tree")
       tree
     }
 
@@ -322,6 +329,7 @@ class TreeChecker extends Phase with SymTransformer {
       assert(tree.isTerm || !ctx.isAfterTyper, tree.show + " at " + ctx.phase)
       assert(tree.isType || !needsSelect(tree.tpe), i"bad type ${tree.tpe} for $tree # ${tree.uniqueId}")
       assertDefined(tree)
+
       checkNotRepeated(super.typedIdent(tree, pt))
     }
 

src/dotty/tools/dotc/typer/ReTyper.scala

@@ -23,6 +23,7 @@ import config.Printers
 class ReTyper extends Typer {
   import tpd._
 
+  /** Checks that the given tree has been typed */
   protected def promote(tree: untpd.Tree)(implicit ctx: Context): tree.ThisTree[Type] = {
     assert(tree.hasType, i"$tree ${tree.getClass} ${tree.uniqueId}")
     tree.withType(tree.typeOpt)

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

@@ -427,7 +427,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
     if (untpd.isWildcardStarArg(tree))
       cases(
-        //ifPat = ascription(TypeTree(defn.SeqType.appliedTo(pt :: Nil)), isWildcard = true),
         ifPat = ascription(TypeTree(defn.RepeatedParamType.appliedTo(pt)), isWildcard = true),
         ifExpr = seqToRepeated(typedExpr(tree.expr, defn.SeqType)),
         wildName = nme.WILDCARD_STAR)
@@ -976,7 +975,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             typed(untpd.Bind(tree.name, arg).withPos(tree.pos), arg.tpe) :: Nil)
       case _ =>
         val flags = if (tree.isType) BindDefinedType else EmptyFlags
-        val sym = ctx.newSymbol(ctx.owner, tree.name, flags, body1.tpe, coord = tree.pos)
+        val sym = ctx.newSymbol(ctx.owner, tree.name, flags | Case, body1.tpe, coord = tree.pos)
         assignType(cpy.Bind(tree)(tree.name, body1), sym)
     }
   }

tests/disabled/pos/t3480.scala

@@ -1,4 +1,4 @@
 object Test {
   val List(_: _*) = List(1)
-    val Array( who, what : _* ) = "Eclipse plugin cannot not handle this" split (" ")
+  val Array(who, what: _*) = "Eclipse plugin cannot not handle this" split (" ")
 }

tests/pos/vararg-pattern.scala

@@ -1,12 +1,9 @@
 object Test {
-
   List(1, 2, 3, 4) match {
     case List(1, 2, xs: _*) =>
       val ys: Seq[Int] = xs
       println(ys)
   }
-  val List(1, 2, x: _*) = List(1, 2, 3, 4)
 
+  val List(1, 2, x: _*) = List(1, 2, 3, 4)
 }
-
-