SI-8325 Accept infix star type outside patterns

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -654,9 +654,10 @@ self =>
     def isIdentExcept(except: Name) = isIdent && in.name != except
     def isIdentOf(name: Name)       = isIdent && in.name == name
 
-    def isUnaryOp = isIdent && raw.isUnary(in.name)
-    def isRawStar = isIdent && in.name == raw.STAR
-    def isRawBar  = isIdent && in.name == raw.BAR
+    def isUnaryOp  = isIdent && raw.isUnary(in.name)
+    def isRawStar  = isRawIdent && in.name == raw.STAR
+    def isRawBar   = isRawIdent && in.name == raw.BAR
+    def isRawIdent = in.token == IDENTIFIER
 
     def isIdent = in.token == IDENTIFIER || in.token == BACKQUOTED_IDENT
     def isMacro = in.token == IDENTIFIER && in.name == nme.MACROkw
@@ -1001,19 +1002,30 @@ self =>
       }
 
       def infixTypeRest(t: Tree, mode: InfixMode.Value): Tree = {
-        if (isIdent && in.name != nme.STAR) {
-          val opOffset = in.offset
+        // Detect postfix star for repeated args.
+        // Only RPAREN can follow, but accept COMMA and EQUALS for error's sake.
+        // Take RBRACE as a paren typo.
+        def checkRepeatedParam = if (isRawStar) {
+          lookingAhead (in.token match {
+            case RPAREN | COMMA | EQUALS | RBRACE => t
+            case _                                => EmptyTree
+          })
+        } else EmptyTree
+        def asInfix = {
+          val opOffset  = in.offset
           val leftAssoc = treeInfo.isLeftAssoc(in.name)
-          if (mode != InfixMode.FirstOp) checkAssoc(opOffset, in.name, leftAssoc = mode == InfixMode.LeftOp)
-          val op = identForType()
-          val tycon = atPos(opOffset) { Ident(op) }
+          if (mode != InfixMode.FirstOp)
+            checkAssoc(opOffset, in.name, leftAssoc = mode == InfixMode.LeftOp)
+          val tycon = atPos(opOffset) { Ident(identForType()) }
           newLineOptWhenFollowing(isTypeIntroToken)
           def mkOp(t1: Tree) = atPos(t.pos.start, opOffset) { AppliedTypeTree(tycon, List(t, t1)) }
           if (leftAssoc)
             infixTypeRest(mkOp(compoundType()), InfixMode.LeftOp)
           else
             mkOp(infixType(InfixMode.RightOp))
-        } else t
+        }
+        if (isIdent) checkRepeatedParam orElse asInfix
+        else t
       }
 
       /** {{{

test/files/neg/t8325-b.check

@@ -0,0 +1,10 @@
+t8325-b.scala:3: error: Unmatched closing brace '}' ignored here
+  def k(is: Int*} = ???
+                ^
+t8325-b.scala:3: error: ';' expected but '=' found.
+  def k(is: Int*} = ???
+                  ^
+t8325-b.scala:4: error: eof expected but '}' found.
+}
+^
+three errors found

test/files/neg/t8325-b.scala

@@ -0,0 +1,4 @@
+
+trait Test {
+  def k(is: Int*} = ???
+}

test/files/neg/t8325-c.check

@@ -0,0 +1,7 @@
+t8325-c.scala:3: error: identifier expected but ')' found.
+  def k(xx: Int`*`) = ???
+                  ^
+t8325-c.scala:4: error: ')' expected but '}' found.
+}
+^
+two errors found

test/files/neg/t8325-c.scala

@@ -0,0 +1,4 @@
+
+trait Test {
+  def k(xx: Int`*`) = ???
+}

test/files/neg/t8325.check

@@ -0,0 +1,15 @@
+t8325.scala:5: error: *-parameter must come last
+  def f(is: Int*, s: String) = ???
+        ^
+t8325.scala:7: error: *-parameter must come last
+  def h(is: Int * String *, s: String) = ???
+        ^
+t8325.scala:10: error: type mismatch;
+ found   : Int(5)
+ required: Int*
+  def j(is: Int* = 5) = ???
+                   ^
+t8325.scala:10: error: a parameter section with a `*'-parameter is not allowed to have default arguments
+  def j(is: Int* = 5) = ???
+      ^
+four errors found

test/files/neg/t8325.scala

@@ -0,0 +1,11 @@
+
+trait Test {
+  type OK[A,B] = A Tuple2 B
+  type *[A,B]  = A Tuple2 B
+  def f(is: Int*, s: String) = ???
+  def g(is: Int * String, s: String) = ???     // OK
+  def h(is: Int * String *, s: String) = ???
+  // won't recover from following
+  //def i(is: Int OK) = ???  //error: identifier expected but ')' found.
+  def j(is: Int* = 5) = ???
+}

test/files/pos/t8325.scala

@@ -0,0 +1,9 @@
+
+trait Test {
+  type +[A, B] = (A, B)
+  type *[A, B] = (A, B)
+
+  type X[A, B] = A + B
+  type Y[A, B] = A * B
+  type Z[A, B] = A `*` B
+}