Fix unused/implicit fixed order

Author: nicolasstucki

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

@@ -730,24 +730,23 @@ object Parsers {
       }
     }
 
-    /** Type        ::=  [`implicit'] [`unused'] FunArgTypes `=>' Type
+    /** Type        ::=  [FunArgMods] FunArgTypes `=>' Type
      *                |  HkTypeParamClause `->' Type
      *                |  InfixType
+     *  FunArgMods  ::=  `implicit' FunArgMods
+     *                |  `unused' FunArgMods
      *  FunArgTypes ::=  InfixType
      *                |  `(' [ FunArgType {`,' FunArgType } ] `)'
      */
     def typ(): Tree = {
       val start = in.offset
-      val isImplicit = in.token == IMPLICIT
-      if (isImplicit) in.nextToken()
-      val isUnused = in.token == UNUSED
-      if (isUnused) in.nextToken()
+      val imods = allFunctionMods(EmptyModifiers)
       def functionRest(params: List[Tree]): Tree =
         atPos(start, accept(ARROW)) {
           val t = typ()
-          if (isImplicit && isUnused) new UnusedImplicitFunction(params, t)
-          else if (isImplicit) new ImplicitFunction(params, t)
-          else if (isUnused) new UnusedFunction(params, t)
+          if (imods.is(Implicit) && imods.is(Unused)) new UnusedImplicitFunction(params, t)
+          else if (imods.is(Implicit)) new ImplicitFunction(params, t)
+          else if (imods.is(Unused)) new UnusedFunction(params, t)
           else Function(params, t)
         }
       val t =
@@ -762,7 +761,7 @@ object Parsers {
             val ts = commaSeparated(funArgType)
             openParens.change(LPAREN, -1)
             accept(RPAREN)
-            if (isImplicit || in.token == ARROW) functionRest(ts)
+            if (imods.is(Implicit) || in.token == ARROW) functionRest(ts)
             else {
               for (t <- ts)
                 if (t.isInstanceOf[ByNameTypeTree])
@@ -789,7 +788,7 @@ object Parsers {
         case ARROW => functionRest(t :: Nil)
         case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
         case _ =>
-          if (isImplicit && !t.isInstanceOf[ImplicitFunction])
+          if (imods.is(Implicit) && !t.isInstanceOf[ImplicitFunction])
             syntaxError("Types with implicit keyword can only be function types", Position(start, start + nme.IMPLICITkw.asSimpleName.length))
           t
       }
@@ -1016,14 +1015,16 @@ object Parsers {
       }
     }
 
-    /** Expr              ::=  [`implicit'] FunParams `=>' Expr
+    /** Expr              ::=  [FunArgMods] FunParams =>' Expr
      *                      |  Expr1
+     *  FunArgMods        ::=  `implicit' FunArgMods
+     *                      |  `unused' FunArgMods
      *  FunParams         ::=  Bindings
      *                      |  id
      *                      |  `_'
      *  ExprInParens      ::=  PostfixExpr `:' Type
      *                      |  Expr
-     *  BlockResult       ::=  [`implicit'] FunParams `=>' Block
+     *  BlockResult       ::=  [FunArgMods] FunParams =>' Block
      *                      |  Expr1
      *  Expr1             ::=  `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
      *                      |  `if' Expr `then' Expr [[semi] else Expr]
@@ -1052,9 +1053,7 @@ object Parsers {
     def expr(location: Location.Value): Tree = {
       val start = in.offset
       if (in.token == IMPLICIT || in.token == UNUSED) {
-        var imods = EmptyModifiers
-        if (in.token == IMPLICIT) imods = implicitMods(imods)
-        if (in.token == UNUSED) imods = unusedMods(imods)
+        val imods = allFunctionMods(EmptyModifiers)
         implicitClosure(start, location, imods)
       } else {
         val saved = placeholderParams
@@ -1751,11 +1750,14 @@ object Parsers {
       normalize(loop(start))
     }
 
-    def implicitMods(imods: Modifiers = EmptyModifiers): Modifiers =
-      addMod(imods, atPos(accept(IMPLICIT)) { Mod.Implicit() })
-
-    def unusedMods(imods: Modifiers = EmptyModifiers): Modifiers =
-      addMod(imods, atPos(accept(UNUSED)) { Mod.Unused() })
+    def allFunctionMods(imods: Modifiers, doIfImplicit: () => Unit = () => ()): Modifiers = {
+      if (in.token == IMPLICIT) {
+        doIfImplicit()
+        allFunctionMods(addMod(imods, atPos(accept(IMPLICIT)) { Mod.Implicit() }), doIfImplicit)
+      } else if (in.token == UNUSED)
+        allFunctionMods(addMod(imods, atPos(accept(UNUSED)) { Mod.Unused() }), doIfImplicit)
+      else imods
+    }
 
     /** Wrap annotation or constructor in New(...).<init> */
     def wrapNew(tpt: Tree) = Select(New(tpt), nme.CONSTRUCTOR)
@@ -1843,11 +1845,11 @@ object Parsers {
     def typeParamClauseOpt(ownerKind: ParamOwner.Value): List[TypeDef] =
       if (in.token == LBRACKET) typeParamClause(ownerKind) else Nil
 
-    /** ClsParamClauses   ::=  {ClsParamClause} [[nl] `(' `implicit' [`unused'] ClsParams `)']
+    /** ClsParamClauses   ::=  {ClsParamClause} [[nl] `(' [`unused'] `implicit' [`unused'] ClsParams `)']
      *  ClsParamClause    ::=  [nl] `(' [`unused'] [ClsParams] ')'
      *  ClsParams         ::=  ClsParam {`' ClsParam}
      *  ClsParam          ::=  {Annotation} [{Modifier} (`val' | `var') | `inline'] Param
-     *  DefParamClauses   ::=  {DefParamClause} [[nl] `(' `implicit' [`unused'] DefParams `)']
+     *  DefParamClauses   ::=  {DefParamClause} [[nl] `(' [`unused'] `implicit' DefParams `)']
      *  DefParamClause    ::=  [nl] `(' [`unused'] [DefParams] ')'
      *  DefParams         ::=  DefParam {`,' DefParam}
      *  DefParam          ::=  {Annotation} [`inline'] Param
@@ -1906,14 +1908,9 @@ object Parsers {
       def paramClause(): List[ValDef] = inParens {
         if (in.token == RPAREN) Nil
         else {
-          if (in.token == IMPLICIT || in.token == UNUSED) {
-            if (in.token == IMPLICIT) {
-              implicitOffset = in.offset
-              imods = implicitMods(imods)
-            }
-            if (in.token == UNUSED)
-              imods = unusedMods(imods)
-          }
+          if (in.token == IMPLICIT || in.token == UNUSED)
+            imods = allFunctionMods(imods, () => implicitOffset = in.offset)
+
           commaSeparated(param)
         }
       }
@@ -2505,9 +2502,7 @@ object Parsers {
         else if (isDefIntro(localModifierTokens))
           if (in.token == IMPLICIT || in.token == UNUSED) {
             val start = in.offset
-            var imods = EmptyModifiers
-            if (in.token == IMPLICIT) imods = implicitMods(imods)
-            if (in.token == UNUSED) imods = unusedMods(imods)
+            var imods = allFunctionMods(EmptyModifiers)
             if (isBindingIntro) stats += implicitClosure(start, Location.InBlock, imods)
             else stats +++= localDef(start, imods)
           } else {

tests/run/unused-23.check

@@ -1 +1,2 @@
-lambda
+lambda1
+lambda2

tests/run/unused-23.scala

@@ -2,13 +2,21 @@ object Test {
 
   def main(args: Array[String]): Unit = {
     fun { implicit unused (x: Int) =>
-      println("lambda")
+      println("lambda1")
       "abc"
     }
 
+    fun2 { unused implicit (x: Int) =>
+      println("lambda2")
+      "abc"
+    }
   }
 
   def fun(f: implicit unused Int => String): String = {
     f(35)
   }
+
+  def fun2(f: unused implicit Int => String): String = {
+    f(36)
+  }
 }