Merge pull request scala#10815 from som-snytt/unused/parser

Reduce unused parameters in parser

Author: som-snytt

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

@@ -218,7 +218,7 @@ self =>
 
     override def blockExpr(): Tree = skipBraces(EmptyTree)
 
-    override def templateBody(isPre: Boolean) = skipBraces((noSelfType, EmptyTree.asList))
+    override def templateBody() = skipBraces((noSelfType, EmptyTree.asList))
   }
 
   class UnitParser(override val unit: global.CompilationUnit, patches: List[BracePatch]) extends SourceFileParser(unit.source) { uself =>
@@ -617,22 +617,18 @@ self =>
       and
     }
 
-    // warn under -Xsource:3
-    def migrationWarning(offset: Offset, msg: String, since: String, actions: List[CodeAction] = Nil): Unit =
-      if (currentRun.isScala3)
-        warning(offset, msg, WarningCategory.Scala3Migration, actions)
-
-    // warn under -Xsource:3, otherwise deprecation
-    def hardMigrationWarning(offset: Offset, msg: String, since: String, actions: List[CodeAction] = Nil): Unit =
+    // warn under -Xsource:3; otherwise if since is nonEmpty, issue a deprecation
+    def migrationWarning(offset: Offset, msg: String, since: String = "", actions: List[CodeAction] = Nil): Unit =
       if (currentRun.isScala3) warning(offset, msg, WarningCategory.Scala3Migration, actions)
-      else deprecationWarning(offset, msg, since, actions)
+      else if (!since.isEmpty) deprecationWarning(offset, msg, since, actions)
 
     // deprecation or migration under -Xsource:3, with different messages
-    def hardMigrationWarning(offset: Offset, depr: => String, migr: => String, since: String, actions: String => List[CodeAction]): Unit =
-      if (currentRun.isScala3) warning(offset, migr, WarningCategory.Scala3Migration, actions(migr))
-      else deprecationWarning(offset, depr, since, actions(depr))
-    def hardMigrationWarning(offset: Offset, depr: => String, migr: => String, since: String): Unit =
-      hardMigrationWarning(offset, depr, migr, since, _ => Nil)
+    def migrationWarning(offset: Offset, depr: => String, migr: => String, since: String, actions: String => List[CodeAction]): Unit = {
+      val msg = if (currentRun.isScala3) migr else depr
+      migrationWarning(offset, msg, since, actions(msg))
+    }
+    def migrationWarning(offset: Offset, depr: => String, migr: => String, since: String): Unit =
+      migrationWarning(offset, depr, migr, since, (_: String) => Nil)
 
     def expectedMsgTemplate(exp: String, fnd: String) = s"$exp expected but $fnd found."
     def expectedMsg(token: Token): String =
@@ -819,7 +815,7 @@ self =>
         def actions =
           if (tree.pos.isRange) runReporting.codeAction("add parentheses", tree.pos, s"(${unit.source.sourceAt(tree.pos)})", msg)
           else Nil
-        migrationWarning(tree.pos.point, wrn, "2.13.11", actions)
+        migrationWarning(tree.pos.point, wrn, /*since="2.13.11",*/ actions = actions)
         List(convertToParam(tree))
       case _ => List(convertToParam(tree))
     }
@@ -1037,8 +1033,7 @@ self =>
         val fun = s"${CodeAction.maybeWrapInParens(qual)}.${unit.source.sourceAt(operatorPos.withEnd(rhs.pos.start))}".trim
         val fix = s"$fun${CodeAction.wrapInParens(unit.source.sourceAt(rhs.pos))}"
         val msg = "type application is not allowed for infix operators"
-        migrationWarning(offset, msg, "2.13.11",
-          runReporting.codeAction("use selection", pos, fix, msg))
+        migrationWarning(offset, msg, /*since="2.13.11",*/ actions = runReporting.codeAction("use selection", pos, fix, msg))
       }
       atPos(pos)(makeBinop(isExpr, lhs, operator, rhs, operatorPos, targs))
     }
@@ -2114,7 +2109,7 @@ self =>
         def msg(what: String, instead: String): String = s"`val` keyword in for comprehension is $what: $instead"
         if (hasEq) {
           val without = "instead, bind the value without `val`"
-          hardMigrationWarning(in.offset, msg("deprecated", without), msg("unsupported", without), "2.10.0", actions)
+          migrationWarning(in.offset, msg("deprecated", without), msg("unsupported", without), since="2.10.0", actions=actions(_))
         } else {
           val m = msg("unsupported", "just remove `val`")
           syntaxError(in.offset, m, actions(m))
@@ -2669,7 +2664,7 @@ self =>
         val pname: TypeName =
           if (in.token == USCORE) {
             if (!isAbstractOwner)
-              hardMigrationWarning(in.offset, "Top-level wildcard is not allowed", "2.13.7")
+              migrationWarning(in.offset, "Top-level wildcard is not allowed", since = "2.13.7")
             in.nextToken()
             freshTypeName("_$$")
           }
@@ -2682,7 +2677,7 @@ self =>
           def msg(what: String) = s"""view bounds are $what; use an implicit parameter instead.
                                      |  example: instead of `def f[A <% Int](a: A)` use `def f[A](a: A)(implicit ev: A => Int)`""".stripMargin
           while (in.token == VIEWBOUND) {
-            hardMigrationWarning(in.offset, msg("deprecated"), msg("unsupported"), "2.12.0")
+            migrationWarning(in.offset, msg("deprecated"), msg("unsupported"), since = "2.12.0")
             contextBoundBuf += atPos(in.skipToken())(makeFunctionTypeTree(List(Ident(pname)), typ()))
           }
           while (in.token == COLON) {
@@ -3021,18 +3016,17 @@ self =>
       if (in.token == THIS) {
         def missingEquals() = {
           val msg = "procedure syntax is deprecated for constructors: add `=`, as in method definition"
-          hardMigrationWarning(in.lastOffset, msg, "2.13.2",
-            runReporting.codeAction("replace procedure syntax", o2p(in.lastOffset), " =", msg))
+          migrationWarning(in.lastOffset, msg, since = "2.13.2", actions = runReporting.codeAction("replace procedure syntax", o2p(in.lastOffset), " =", msg))
         }
         atPos(start, in.skipToken()) {
-          val vparamss = paramClauses(nme.CONSTRUCTOR, classContextBounds map (_.duplicate), ofCaseClass = false)
+          val vparamss = paramClauses(nme.CONSTRUCTOR, classContextBounds.map(_.duplicate), ofCaseClass = false)
           newLineOptWhenFollowedBy(LBRACE)
           val rhs =
             if (in.token == LBRACE) {
-              missingEquals(); atPos(in.offset) { constrBlock(vparamss) }
+              missingEquals(); atPos(in.offset) { constrBlock() }
             }
             else {
-              accept(EQUALS) ; atPos(in.offset) { constrExpr(vparamss) }
+              accept(EQUALS) ; atPos(in.offset) { constrExpr() }
             }
           DefDef(mods, nme.CONSTRUCTOR, List(), vparamss, TypeTree(), rhs)
         }
@@ -3065,13 +3059,13 @@ self =>
         val rhs =
           if (isStatSep || in.token == RBRACE) {
             if (restype.isEmpty) {
-              hardMigrationWarning(in.lastOffset, msg("deprecated", ": Unit"), msg("unsupported", ": Unit"), "2.13.0", declActions)
+              migrationWarning(in.lastOffset, msg("deprecated", ": Unit"), msg("unsupported", ": Unit"), since = "2.13.0", actions = declActions)
               restype = scalaUnitConstr
             }
             newmods |= Flags.DEFERRED
             EmptyTree
           } else if (restype.isEmpty && in.token == LBRACE) {
-            hardMigrationWarning(in.offset, msg("deprecated", ": Unit ="), msg("unsupported", ": Unit ="), "2.13.0", defnActions)
+            migrationWarning(in.offset, msg("deprecated", ": Unit ="), msg("unsupported", ": Unit ="), since = "2.13.0", actions = defnActions)
             restype = scalaUnitConstr
             blockExpr()
           } else {
@@ -3093,7 +3087,7 @@ self =>
             val o = nameOffset + name.decode.length
             runReporting.codeAction("remove ()", r2p(o, o, o + 2), "", msg, expected = Some(("()", unit)))
           }
-          def warnNilary() = hardMigrationWarning(nameOffset, unaryMsg("deprecated"), unaryMsg("unsupported"), "2.13.4", action)
+          def warnNilary() = migrationWarning(nameOffset, unaryMsg("deprecated"), unaryMsg("unsupported"), since = "2.13.4", actions = action)
           vparamss match {
             case List(List())                               => warnNilary()
             case List(List(), x :: xs) if x.mods.isImplicit => warnNilary()
@@ -3111,15 +3105,15 @@ self =>
      *                    |  ConstrBlock
      *  }}}
      */
-    def constrExpr(vparamss: List[List[ValDef]]): Tree =
-      if (in.token == LBRACE) constrBlock(vparamss)
-      else Block(selfInvocation(vparamss) :: Nil, literalUnit)
+    def constrExpr(): Tree =
+      if (in.token == LBRACE) constrBlock()
+      else Block(selfInvocation() :: Nil, literalUnit)
 
     /** {{{
      *  SelfInvocation  ::= this ArgumentExprs {ArgumentExprs}
      *  }}}
      */
-    def selfInvocation(vparamss: List[List[ValDef]]): Tree =
+    def selfInvocation(): Tree =
       atPos(accept(THIS)) {
         newLineOptWhenFollowedBy(LBRACE)
         var t = Apply(Ident(nme.CONSTRUCTOR), argumentExprs())
@@ -3135,9 +3129,9 @@ self =>
      *  ConstrBlock    ::=  `{` SelfInvocation {semi BlockStat} `}`
      *  }}}
      */
-    def constrBlock(vparamss: List[List[ValDef]]): Tree =
+    def constrBlock(): Tree =
       atPos(in.skipToken()) {
-        val stats = selfInvocation(vparamss) :: {
+        val stats = selfInvocation() :: {
           if (isStatSep) { in.nextToken(); blockStatSeq() }
           else Nil
         }
@@ -3224,7 +3218,7 @@ self =>
       val nameOffset = in.offset
       val name = identForType()
       if (currentRun.isScala3 && in.token == LBRACKET && isAfterLineEnd)
-        hardMigrationWarning(in.offset, "type parameters should not follow newline", "2.13.7")
+        migrationWarning(in.offset, "type parameters should not follow newline", since = "2.13.7")
       def orStart(p: Offset) = if (name == tpnme.ERROR) start else p
       val namePos = NamePos(r2p(orStart(nameOffset), orStart(nameOffset)))
       atPos(start, orStart(nameOffset)) {
@@ -3328,12 +3322,12 @@ self =>
       if (in.token == LBRACE) {
         val braceOffset = in.offset
         // @S: pre template body cannot stub like post body can!
-        val (self, body) = templateBody(isPre = true)
+        val (self, body) = templateBody()
         if (in.token == WITH && (self eq noSelfType)) {
           val advice =
             if (currentRun.isScala3) "use trait parameters instead."
             else "they will be replaced by trait parameters in 3.0, see the migration guide on avoiding var/val in traits."
-          hardMigrationWarning(braceOffset, s"early initializers are deprecated; $advice", "2.13.0")
+          migrationWarning(braceOffset, s"early initializers are deprecated; $advice", since = "2.13.0")
           val earlyDefs: List[Tree] = body.map(ensureEarlyDef).filter(_.nonEmpty)
           in.nextToken()
           val parents = templateParents()
@@ -3354,7 +3348,7 @@ self =>
         copyValDef(vdef)(mods = mods | Flags.PRESUPER)
       case tdef @ TypeDef(mods, name, tparams, rhs) =>
         def msg(what: String): String = s"early type members are $what: move them to the regular body; the semantics are the same"
-        hardMigrationWarning(tdef.pos.point, msg("deprecated"), msg("unsupported"), "2.11.0")
+        migrationWarning(tdef.pos.point, msg("deprecated"), msg("unsupported"), since = "2.11.0")
         treeCopy.TypeDef(tdef, mods | Flags.PRESUPER, name, tparams, rhs)
       case docdef @ DocDef(comm, rhs) =>
         treeCopy.DocDef(docdef, comm, rhs)
@@ -3410,16 +3404,15 @@ self =>
     /** {{{
      *  TemplateBody ::= [nl] `{` TemplateStatSeq `}`
      *  }}}
-     * @param isPre specifies whether in early initializer (true) or not (false)
      */
-    def templateBody(isPre: Boolean) = inBraces(templateStatSeq(isPre)) match {
+    def templateBody() = inBraces(templateStatSeq()) match {
       case (selfTypeVal, Nil) => (selfTypeVal, EmptyTree.asList)
       case result             => result
     }
     def templateBodyOpt(parenMeansSyntaxError: Boolean): (ValDef, List[Tree]) = {
       newLineOptWhenFollowedBy(LBRACE)
       if (in.token == LBRACE) {
-        templateBody(isPre = false)
+        templateBody()
       } else {
         if (in.token == LPAREN) {
           if (parenMeansSyntaxError) syntaxError(s"traits or objects may not have parameters", skipIt = true)
@@ -3482,9 +3475,8 @@ self =>
     /** {{{
      *  TemplateStatSeq  ::= [id [`:` Type] `=>`] TemplateStats
      *  }}}
-     * @param isPre specifies whether in early initializer (true) or not (false)
      */
-    def templateStatSeq(isPre : Boolean): (ValDef, List[Tree]) = {
+    def templateStatSeq(): (ValDef, List[Tree]) = {
       var self: ValDef = noSelfType
       var firstOpt: Option[Tree] = None
       if (isExprIntro) checkNoEscapingPlaceholders {