Don't pass docstring as a parameter.

It's completely redundant, docstring is just the comment found
at the `start` offset, which is passed anyway.

1 files changed, 33 insertions, 39 deletions

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index d3c100406..1084b5784 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1888,17 +1888,17 @@ object Parsers {
       case VAL =>
         val mod = atPos(in.skipToken()) { Mod.Val() }
         val mods1 = mods.withAddedMod(mod)
-        patDefOrDcl(start, mods1, in.getDocComment(start))
+        patDefOrDcl(start, mods1)
       case VAR =>
         val mod = atPos(in.skipToken()) { Mod.Var() }
         val mod1 = addMod(mods, mod)
-        patDefOrDcl(start, mod1, in.getDocComment(start))
+        patDefOrDcl(start, mod1)
       case DEF =>
-        defDefOrDcl(start, posMods(start, mods), in.getDocComment(start))
+        defDefOrDcl(start, posMods(start, mods))
       case TYPE =>
-        typeDefOrDcl(start, posMods(start, mods), in.getDocComment(start))
+        typeDefOrDcl(start, posMods(start, mods))
       case CASE =>
-        enumCase(start, mods, in.getDocComment(start))
+        enumCase(start, mods)
       case _ =>
         tmplDef(start, mods)
     }
@@ -1908,7 +1908,7 @@ object Parsers {
      *  ValDcl ::= id {`,' id} `:' Type
      *  VarDcl ::= id {`,' id} `:' Type
      */
-    def patDefOrDcl(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): Tree = atPos(start, nameStart) {
+    def patDefOrDcl(start: Offset, mods: Modifiers): Tree = atPos(start, nameStart) {
       val lhs = commaSeparated(pattern2)
       val tpt = typedOpt()
       val rhs =
@@ -1923,7 +1923,7 @@ object Parsers {
         } else EmptyTree
       lhs match {
         case (id @ Ident(name: TermName)) :: Nil => {
-          ValDef(name, tpt, rhs).withMods(mods).setComment(docstring)
+          ValDef(name, tpt, rhs).withMods(mods).setComment(in.getDocComment(start))
         } case _ =>
           PatDef(mods, lhs, tpt, rhs)
       }
@@ -1949,7 +1949,7 @@ object Parsers {
      *  DefDcl ::= DefSig `:' Type
      *  DefSig ::= id [DefTypeParamClause] ParamClauses
      */
-    def defDefOrDcl(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): Tree = atPos(start, nameStart) {
+    def defDefOrDcl(start: Offset, mods: Modifiers): Tree = atPos(start, nameStart) {
       def scala2ProcedureSyntax(resultTypeStr: String) = {
         val toInsert =
           if (in.token == LBRACE) s"$resultTypeStr ="
@@ -1992,7 +1992,7 @@ object Parsers {
             accept(EQUALS)
             expr()
           }
-        DefDef(name, tparams, vparamss, tpt, rhs).withMods(mods1).setComment(docstring)
+        DefDef(name, tparams, vparamss, tpt, rhs).withMods(mods1).setComment(in.getDocComment(start))
       }
     }
 
@@ -2026,7 +2026,7 @@ object Parsers {
     /** TypeDef ::= type id [TypeParamClause] `=' Type
      *  TypeDcl ::= type id [TypeParamClause] TypeBounds
      */
-    def typeDefOrDcl(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): Tree = {
+    def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
       newLinesOpt()
       atPos(start, nameStart) {
         val name = ident().toTypeName
@@ -2034,9 +2034,9 @@ object Parsers {
         in.token match {
           case EQUALS =>
             in.nextToken()
-            TypeDef(name, lambdaAbstract(tparams, typ())).withMods(mods).setComment(docstring)
+            TypeDef(name, lambdaAbstract(tparams, typ())).withMods(mods).setComment(in.getDocComment(start))
           case SUPERTYPE | SUBTYPE | SEMI | NEWLINE | NEWLINES | COMMA | RBRACE | EOF =>
-            TypeDef(name, lambdaAbstract(tparams, typeBounds())).withMods(mods).setComment(docstring)
+            TypeDef(name, lambdaAbstract(tparams, typeBounds())).withMods(mods).setComment(in.getDocComment(start))
           case _ =>
             syntaxErrorOrIncomplete("`=', `>:', or `<:' expected")
             EmptyTree
@@ -2049,23 +2049,22 @@ object Parsers {
      *            |  `enum' EnumDef
      */
     def tmplDef(start: Int, mods: Modifiers): Tree = {
-      val docstring = in.getDocComment(start)
       in.token match {
         case TRAIT =>
-          classDef(start, posMods(start, addFlag(mods, Trait)), docstring)
+          classDef(start, posMods(start, addFlag(mods, Trait)))
         case CLASS =>
-          classDef(start, posMods(start, mods), docstring)
+          classDef(start, posMods(start, mods))
         case CASECLASS =>
-          classDef(start, posMods(start, mods | Case), docstring)
+          classDef(start, posMods(start, mods | Case))
         case OBJECT =>
-          objectDef(start, posMods(start, mods | Module), docstring)
+          objectDef(start, posMods(start, mods | Module))
         case CASEOBJECT =>
-          objectDef(start, posMods(start, mods | Case | Module), docstring)
+          objectDef(start, posMods(start, mods | Case | Module))
         case ENUM =>
           val mods1 = addMod(mods, atPos(in.skipToken()) { Mod.Enum() })
           in.token match {
             case CLASS | TRAIT | OBJECT => tmplDef(start, mods1)
-            case _ => enumDef(start, mods, docstring)
+            case _ => enumDef(start, mods)
           }
         case _ =>
           syntaxErrorOrIncomplete("expected start of definition")
@@ -2075,14 +2074,14 @@ object Parsers {
 
     /** ClassDef ::= id ClassConstr TemplateOpt
      */
-    def classDef(start: Offset, mods: Modifiers, docstring: Option[Comment]): TypeDef = atPos(start, nameStart) {
-      classDefRest(start, mods, docstring, ident().toTypeName)
+    def classDef(start: Offset, mods: Modifiers): TypeDef = atPos(start, nameStart) {
+      classDefRest(start, mods, ident().toTypeName)
     }
 
-    def classDefRest(start: Offset, mods: Modifiers, docstring: Option[Comment], name: TypeName): TypeDef = {
+    def classDefRest(start: Offset, mods: Modifiers, name: TypeName): TypeDef = {
       val constr = classConstr(name, isCaseClass = mods is Case)
       val templ = templateOpt(constr)
-      TypeDef(name, templ).withMods(mods).setComment(docstring)
+      TypeDef(name, templ).withMods(mods).setComment(in.getDocComment(start))
     }
 
     /** ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsParamClauses
@@ -2107,19 +2106,19 @@ object Parsers {
 
     /** ObjectDef       ::= id TemplateOpt
      */
-    def objectDef(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): ModuleDef = atPos(start, nameStart) {
-      objectDefRest(start, mods, docstring, ident())
+    def objectDef(start: Offset, mods: Modifiers): ModuleDef = atPos(start, nameStart) {
+      objectDefRest(start, mods, ident())
     }
 
-    def objectDefRest(start: Offset, mods: Modifiers, docstring: Option[Comment] = None, name: TermName): ModuleDef = {
+    def objectDefRest(start: Offset, mods: Modifiers, name: TermName): ModuleDef = {
       val template = templateOpt(emptyConstructor)
-      ModuleDef(name, template).withMods(mods).setComment(docstring)
+      ModuleDef(name, template).withMods(mods).setComment(in.getDocComment(start))
     }
 
     /**  id ClassConstr [`extends' [ConstrApps]]
      *   [nl] ‘{’ EnumCaseStats ‘}’
      */
-    def enumDef(start: Offset, mods: Modifiers, docstring: Option[Comment] = None): EnumDef = atPos(start, nameStart) {
+    def enumDef(start: Offset, mods: Modifiers): EnumDef = atPos(start, nameStart) {
       val name = ident().toTypeName
       val constr = classConstr(name)
       val parents =
@@ -2146,23 +2145,19 @@ object Parsers {
     }
 
     /** EnumCaseStat = {Annotation [nl]} {Modifier} EnumCase */
-    def enumCaseStat(): MemberDef = {
-      val start = in.offset
-      val docstring = in.getDocComment(start)
-      val mods = defAnnotsMods(modifierTokens)
-      enumCase(start, mods, docstring)
-    }
+    def enumCaseStat(): MemberDef =
+      enumCase(in.offset, defAnnotsMods(modifierTokens))
 
     /** EnumCase = `case' (EnumClassDef | ObjectDef) */
-    def enumCase(start: Offset, mods: Modifiers, docstring: Option[Comment]): MemberDef = {
+    def enumCase(start: Offset, mods: Modifiers): MemberDef = {
       val mods1 = mods.withAddedMod(atPos(in.offset)(Mod.EnumCase())) | Case
       accept(CASE)
       atPos(start, nameStart) {
         val name = ident()
         if (in.token == LBRACKET || in.token == LPAREN)
-          classDefRest(start, mods1, docstring, name.toTypeName)
+          classDefRest(start, mods1, name.toTypeName)
         else
-          objectDefRest(start, mods1, docstring, name)
+          objectDefRest(start, mods1, name)
       }
     }
 
@@ -2389,8 +2384,7 @@ object Parsers {
         if (in.token == PACKAGE) {
           in.nextToken()
           if (in.token == OBJECT) {
-            val docstring = in.getDocComment(start)
-            ts += objectDef(start, atPos(start, in.skipToken()) { Modifiers(Package) }, docstring)
+            ts += objectDef(start, atPos(start, in.skipToken()) { Modifiers(Package) })
             if (in.token != EOF) {
               acceptStatSep()
               ts ++= topStatSeq()