fixed bug875

2 files changed, 25 insertions, 24 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 9d3180f0f2..352dc3b75c 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -277,30 +277,19 @@ abstract class UnCurry extends InfoTransform with TypingTransformers {
         val args1 =
           formals.last match {
             case TypeRef(pre, sym, List(elempt)) if (sym == RepeatedParamClass) =>
-              def mkArrayValue(ts: List[Tree]): Tree =
+              def mkArrayValue(ts: List[Tree]) =
                 atPos(pos)(ArrayValue(TypeTree(elempt), ts) setType formals.last);
-              def mkConcat(left: Tree, right: Tree): Tree =
-                atPos(pos) {
-                  localTyper.typed {
-                    Apply(
-                      TypeApply(
-                        Select(left, nme.PLUSPLUS),
-                        List(TypeTree(elempt))),
-                      List(right))
-                  } setType formals.last
-                }
+
               if (args.isEmpty)
                 List(mkArrayValue(args))
               else {
-                val {fixedArgs, varArgs} = args.splitAt(formals.length - 1)
-                val suffix = args.last match {
+                val suffix: Tree = args.last match {
                   case Typed(arg, Ident(name)) if name == nme.WILDCARD_STAR.toTypeName =>
-                    if (varArgs.length > 1) mkConcat(ArrayValue(TypeTree(elempt), varArgs.init), arg)
-                    else arg setType seqType(arg.tpe)
+                    arg setType seqType(arg.tpe)
                   case _ =>
-                    mkArrayValue(varArgs)
+                    mkArrayValue(args.drop(formals.length - 1))
                 }
-                fixedArgs ::: List(suffix)
+                args.take(formals.length - 1) ::: List(suffix)
               }
             case _ => args
           }
@@ -487,8 +476,7 @@ abstract class UnCurry extends InfoTransform with TypingTransformers {
         case Apply(Apply(fn, args), args1) =>
           copy.Apply(tree, fn, args ::: args1)
         case Ident(name) =>
-          if (name == nme.WILDCARD_STAR.toTypeName)
-            unit.error(tree.pos, " argument does not correspond to `*'-parameter");
+          assert(name != nme.WILDCARD_STAR.toTypeName)
           applyUnary(tree);
         case Select(qual, name) =>
           /* Function1.apply to ByNameFunction.apply if qualifier is a ByNameFunction */
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index be33fb215d..2e98c001c7 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -990,9 +990,11 @@ trait Typers requires Analyzer {
                     var ownAcc = clazz.info.decl(name).suchThat(.hasFlag(PARAMACCESSOR))
                     if ((ownAcc hasFlag ACCESSOR) && !(ownAcc hasFlag DEFERRED))
                       ownAcc = ownAcc.accessed
-                    if (settings.debug.value)
-                      log("" + ownAcc + " has alias "+alias + alias.locationString);//debug
-                    ownAcc.asInstanceOf[TermSymbol].setAlias(alias)
+                    if (!ownAcc.isVariable && !alias.accessed.isVariable) {
+                      if (settings.debug.value)
+                        log("" + ownAcc + " has alias "+alias + alias.locationString);//debug
+                      ownAcc.asInstanceOf[TermSymbol].setAlias(alias)
+                    }
                   }
                 }
               case _ =>
@@ -1302,8 +1304,18 @@ trait Typers requires Analyzer {
     def typedArgs(args: List[Tree], mode: int) =
       List.mapConserve(args)(arg => typedArg(arg, mode, 0, WildcardType))
 
-    def typedArgs(args: List[Tree], mode: int, originalFormals: List[Type], adaptedFormals: List[Type]) =
-      if ((mode & PATTERNmode) != 0 && isVarArgs(originalFormals)) {
+    def typedArgs(args: List[Tree], mode: int, originalFormals: List[Type], adaptedFormals: List[Type]) = {
+      val varargs = isVarArgs(originalFormals)
+      if (!args.isEmpty)
+        args.last match {
+          case Typed(expr, Ident(name)) if (name == nme.WILDCARD_STAR.toTypeName) =>
+            if (!varargs)
+              error(args.last.pos, "_*-argument does not correspond to *-parameter")
+            else if (originalFormals.length != adaptedFormals.length)
+              error(args.last.pos, "_*-argument may not appear after other arguments matching a *-parameter")
+          case _ =>
+        }
+      if (varargs && (mode & PATTERNmode) != 0) {
         val nonVarCount = originalFormals.length - 1
         val prefix =
           List.map2(args take nonVarCount, adaptedFormals take nonVarCount) ((arg, formal) =>
@@ -1315,6 +1327,7 @@ trait Typers requires Analyzer {
       } else {
         List.map2(args, adaptedFormals)((arg, formal) => typedArg(arg, mode, 0, formal))
       }
+    }
 
     /**
      *  @param tree ...