Skip to content

Commit d257601

Browse files
SporarumSporarum
committed
Uniformize Parsers ParamClause methods
1 parent ebccb1f commit d257601

File tree

1 file changed

+63
-55
lines changed

1 file changed

+63
-55
lines changed

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

Lines changed: 63 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -3083,16 +3083,17 @@ object Parsers {
30833083
* | DefTermParamClause
30843084
* | UsingParamClause
30853085
*/
3086-
def typeOrTermParamClause(nparams: Int, // number of parameters preceding this clause
3087-
ofClass: Boolean = false, // owner is a class
3088-
ofCaseClass: Boolean = false, // owner is a case class
3089-
prefix: Boolean = false, // clause precedes name of an extension method
3090-
givenOnly: Boolean = false, // only given parameters allowed
3091-
firstClause: Boolean = false, // clause is the first in regular list of clauses
3092-
ownerKind: ParamOwner
3086+
def typeOrTermParamClause(
3087+
ownerKind: ParamOwner,
3088+
nparams: Int, // number of parameters preceding this clause
3089+
ofClass: Boolean = false, // owner is a class
3090+
ofCaseClass: Boolean = false, // owner is a case class
3091+
prefix: Boolean = false, // clause precedes name of an extension method
3092+
givenOnly: Boolean = false, // only given parameters allowed
3093+
firstClause: Boolean = false // clause is the first in regular list of clauses
30933094
): List[TypeDef] | List[ValDef] =
30943095
if (in.token == LPAREN)
3095-
paramClause(nparams, ofClass, ofCaseClass, prefix, givenOnly, firstClause)
3096+
termParamClause(nparams, ofClass, ofCaseClass, prefix, givenOnly, firstClause)
30963097
else if (in.token == LBRACKET)
30973098
typeParamClause(ownerKind)
30983099
else
@@ -3103,34 +3104,34 @@ object Parsers {
31033104
/** DefParamClauses ::= DefParamClause { DefParamClause }
31043105
*/
31053106
def typeOrTermParamClauses(
3106-
ownerKind: ParamOwner,
3107-
ofClass: Boolean = false,
3108-
ofCaseClass: Boolean = false,
3109-
givenOnly: Boolean = false,
3110-
numLeadParams: Int = 0
3111-
): List[List[TypeDef] | List[ValDef]] =
3112-
3113-
def recur(firstClause: Boolean, nparams: Int): List[List[TypeDef] | List[ValDef]] =
3107+
ownerKind: ParamOwner,
3108+
ofClass: Boolean = false,
3109+
ofCaseClass: Boolean = false,
3110+
givenOnly: Boolean = false,
3111+
numLeadParams: Int = 0
3112+
): List[List[TypeDef] | List[ValDef]] =
3113+
3114+
def recur(firstClause: Boolean, numLeadParams: Int): List[List[TypeDef] | List[ValDef]] =
31143115
newLineOptWhenFollowedBy(LPAREN)
31153116
newLineOptWhenFollowedBy(LBRACKET)
31163117
if in.token == LPAREN then
31173118
val paramsStart = in.offset
3118-
val params = paramClause(
3119-
nparams,
3119+
val params = termParamClause(
3120+
numLeadParams,
31203121
ofClass = ofClass,
31213122
ofCaseClass = ofCaseClass,
31223123
givenOnly = givenOnly,
31233124
firstClause = firstClause)
31243125
val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
31253126
params :: (
31263127
if lastClause then Nil
3127-
else recur(firstClause = false, nparams + params.length))
3128+
else recur(firstClause = false, numLeadParams + params.length))
31283129
else if in.token == LBRACKET then
3129-
typeParamClause(ownerKind) :: recur(firstClause, nparams)
3130+
typeParamClause(ownerKind) :: recur(firstClause, numLeadParams)
31303131
else Nil
31313132
end recur
31323133

3133-
recur(firstClause = true, nparams = numLeadParams)
3134+
recur(firstClause = true, numLeadParams = numLeadParams)
31343135
end typeOrTermParamClauses
31353136

31363137

@@ -3187,15 +3188,15 @@ object Parsers {
31873188

31883189
/** ContextTypes ::= FunArgType {‘,’ FunArgType}
31893190
*/
3190-
def contextTypes(ofClass: Boolean, nparams: Int, impliedMods: Modifiers): List[ValDef] =
3191+
def contextTypes(ofClass: Boolean, numLeadParams: Int, impliedMods: Modifiers): List[ValDef] =
31913192
val tps = commaSeparated(funArgType)
3192-
var counter = nparams
3193+
var counter = numLeadParams
31933194
def nextIdx = { counter += 1; counter }
31943195
val paramFlags = if ofClass then LocalParamAccessor else Param
31953196
tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | impliedMods.flags))
31963197

3197-
/** ClsParamClause ::= ‘(’ [‘erased’] ClsParams ‘)’ | UsingClsParamClause
3198-
* UsingClsParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
3198+
/** ClsTermParamClause ::= ‘(’ [‘erased’] ClsParams ‘)’ | UsingClsTermParamClause
3199+
* UsingClsTermParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
31993200
* ClsParams ::= ClsParam {‘,’ ClsParam}
32003201
* ClsParam ::= {Annotation}
32013202
*
@@ -3212,13 +3213,14 @@ object Parsers {
32123213
*
32133214
* @return the list of parameter definitions
32143215
*/
3215-
def paramClause(nparams: Int, // number of parameters preceding this clause
3216-
ofClass: Boolean = false, // owner is a class
3217-
ofCaseClass: Boolean = false, // owner is a case class
3218-
prefix: Boolean = false, // clause precedes name of an extension method
3219-
givenOnly: Boolean = false, // only given parameters allowed
3220-
firstClause: Boolean = false // clause is the first in regular list of clauses
3221-
): List[ValDef] = {
3216+
def termParamClause(
3217+
numLeadParams: Int, // number of parameters preceding this clause
3218+
ofClass: Boolean = false, // owner is a class
3219+
ofCaseClass: Boolean = false, // owner is a case class
3220+
prefix: Boolean = false, // clause precedes name of an extension method
3221+
givenOnly: Boolean = false, // only given parameters allowed
3222+
firstClause: Boolean = false // clause is the first in regular list of clauses
3223+
): List[ValDef] = {
32223224
var impliedMods: Modifiers = EmptyModifiers
32233225

32243226
def addParamMod(mod: () => Mod) = impliedMods = addMod(impliedMods, atSpan(in.skipToken()) { mod() })
@@ -3283,7 +3285,7 @@ object Parsers {
32833285
checkVarArgsRules(rest)
32843286
}
32853287

3286-
// begin paramClause
3288+
// begin termParamClause
32873289
inParens {
32883290
if in.token == RPAREN && !prefix && !impliedMods.is(Given) then Nil
32893291
else
@@ -3298,41 +3300,43 @@ object Parsers {
32983300
|| startParamTokens.contains(in.token)
32993301
|| isIdent && (in.name == nme.inline || in.lookahead.isColon)
33003302
if isParams then commaSeparated(() => param())
3301-
else contextTypes(ofClass, nparams, impliedMods)
3303+
else contextTypes(ofClass, numLeadParams, impliedMods)
33023304
checkVarArgsRules(clause)
33033305
clause
33043306
}
33053307
}
33063308

3307-
/** ClsParamClauses ::= {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
3308-
* TypelessClauses ::= TypelessClause {TypelessClause}
3309+
/** ClsTermParamClauses ::= {ClsTermParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
3310+
* TypelessClauses ::= TypelessClause {TypelessClause}
33093311
*
33103312
* @return The parameter definitions
33113313
*/
3312-
def paramClauses(ofClass: Boolean = false,
3313-
ofCaseClass: Boolean = false,
3314-
givenOnly: Boolean = false,
3315-
numLeadParams: Int = 0): List[List[ValDef]] =
3314+
def termParamClauses(
3315+
ofClass: Boolean = false,
3316+
ofCaseClass: Boolean = false,
3317+
givenOnly: Boolean = false,
3318+
numLeadParams: Int = 0
3319+
): List[List[ValDef]] =
33163320

3317-
def recur(firstClause: Boolean, nparams: Int): List[List[ValDef]] =
3321+
def recur(firstClause: Boolean, numLeadParams: Int): List[List[ValDef]] =
33183322
newLineOptWhenFollowedBy(LPAREN)
33193323
if in.token == LPAREN then
33203324
val paramsStart = in.offset
3321-
val params = paramClause(
3322-
nparams,
3325+
val params = termParamClause(
3326+
numLeadParams,
33233327
ofClass = ofClass,
33243328
ofCaseClass = ofCaseClass,
33253329
givenOnly = givenOnly,
33263330
firstClause = firstClause)
33273331
val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
33283332
params :: (
33293333
if lastClause then Nil
3330-
else recur(firstClause = false, nparams + params.length))
3334+
else recur(firstClause = false, numLeadParams + params.length))
33313335
else Nil
33323336
end recur
33333337

33343338
recur(firstClause = true, numLeadParams)
3335-
end paramClauses
3339+
end termParamClauses
33363340

33373341
/* -------- DEFS ------------------------------------------- */
33383342

@@ -3573,11 +3577,15 @@ object Parsers {
35733577
}
35743578
}
35753579

3580+
3581+
35763582
/** DefDef ::= DefSig [‘:’ Type] ‘=’ Expr
35773583
* | this TypelessClauses [DefImplicitClause] `=' ConstrExpr
35783584
* DefDcl ::= DefSig `:' Type
3585+
* DefSig ::= id [DefTypeParamClause] DefTermParamClauses
3586+
*
3587+
* if clauseInterleaving is enabled:
35793588
* DefSig ::= id [DefParamClauses] [DefImplicitClause]
3580-
* | ExtParamClause [nl] [‘.’] id DefParamClauses
35813589
*/
35823590
def defDefOrDcl(start: Offset, mods: Modifiers, numLeadParams: Int = 0): DefDef = atSpan(start, nameStart) {
35833591

@@ -3596,7 +3604,7 @@ object Parsers {
35963604

35973605
if (in.token == THIS) {
35983606
in.nextToken()
3599-
val vparamss = paramClauses(numLeadParams = numLeadParams)
3607+
val vparamss = termParamClauses(numLeadParams = numLeadParams)
36003608
if (vparamss.isEmpty || vparamss.head.take(1).exists(_.mods.isOneOf(GivenOrImplicit)))
36013609
in.token match {
36023610
case LBRACKET => syntaxError(em"no type parameters allowed here")
@@ -3753,12 +3761,12 @@ object Parsers {
37533761
val templ = templateOpt(constr)
37543762
finalizeDef(TypeDef(name, templ), mods, start)
37553763

3756-
/** ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsParamClauses
3764+
/** ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsTermParamClauses
37573765
*/
37583766
def classConstr(isCaseClass: Boolean = false): DefDef = atSpan(in.lastOffset) {
37593767
val tparams = typeParamClauseOpt(ParamOwner.Class)
37603768
val cmods = fromWithinClassConstr(constrModsOpt())
3761-
val vparamss = paramClauses(ofClass = true, ofCaseClass = isCaseClass)
3769+
val vparamss = termParamClauses(ofClass = true, ofCaseClass = isCaseClass)
37623770
makeConstructor(tparams, vparamss).withMods(cmods)
37633771
}
37643772

@@ -3860,7 +3868,7 @@ object Parsers {
38603868
newLineOpt()
38613869
val vparamss =
38623870
if in.token == LPAREN && in.lookahead.isIdent(nme.using)
3863-
then paramClauses(givenOnly = true)
3871+
then termParamClauses(givenOnly = true)
38643872
else Nil
38653873
newLinesOpt()
38663874
val noParams = tparams.isEmpty && vparamss.isEmpty
@@ -3902,25 +3910,25 @@ object Parsers {
39023910
val start = in.skipToken()
39033911
val tparams = typeParamClauseOpt(ParamOwner.Def)
39043912
val leadParamss = ListBuffer[List[ValDef]]()
3905-
def nparams = leadParamss.map(_.length).sum
3913+
def numLeadParams = leadParamss.map(_.length).sum
39063914
while
3907-
val extParams = paramClause(nparams, prefix = true)
3915+
val extParams = termParamClause(numLeadParams, prefix = true)
39083916
leadParamss += extParams
39093917
isUsingClause(extParams)
39103918
do ()
3911-
leadParamss ++= paramClauses(givenOnly = true, numLeadParams = nparams)
3919+
leadParamss ++= termParamClauses(givenOnly = true, numLeadParams = numLeadParams)
39123920
if in.isColon then
39133921
syntaxError(em"no `:` expected here")
39143922
in.nextToken()
39153923
val methods: List[Tree] =
39163924
if in.token == EXPORT then
39173925
exportClause()
39183926
else if isDefIntro(modifierTokens) then
3919-
extMethod(nparams) :: Nil
3927+
extMethod(numLeadParams) :: Nil
39203928
else
39213929
in.observeIndented()
39223930
newLineOptWhenFollowedBy(LBRACE)
3923-
if in.isNestedStart then inDefScopeBraces(extMethods(nparams))
3931+
if in.isNestedStart then inDefScopeBraces(extMethods(numLeadParams))
39243932
else { syntaxErrorOrIncomplete(em"Extension without extension methods") ; Nil }
39253933
val result = atSpan(start)(ExtMethods(joinParams(tparams, leadParamss.toList), methods))
39263934
val comment = in.getDocComment(start)

0 commit comments

Comments
 (0)