Skip to content

Commit 8c07ebd

Browse files
oderskyodersky
committed
Clean up categorization of type parameters
There are 4 categories, depending on whether (1) context bounds are allowed and (2) variances are allowed ``` Class: yes/yes Type: no/no Hk: no/yes Def: yes/no ``` Furthermore, Type and Hk parameters can be wildcards. The previous grammars confused Type and Hk parameters and contained other errors as well.
1 parent af933c4 commit 8c07ebd

File tree

3 files changed

+52
-47
lines changed

3 files changed

+52
-47
lines changed

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

Lines changed: 28 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -54,9 +54,9 @@ object Parsers {
5454
enum ParamOwner:
5555
case Class // class or trait or enum
5656
case CaseClass // case class or enum case
57-
case Type // type alias or abstract type
58-
case TypeParam // type parameter
5957
case Def // method
58+
case Type // type alias or abstract type or polyfunction type/expr
59+
case Hk // type parameter (i.e. current parameter is higher-kinded)
6060
case Given // given definition
6161
case ExtensionPrefix // extension clause, up to and including extension parameter
6262
case ExtensionFollow // extension clause, following extension parameter
@@ -66,7 +66,11 @@ object Parsers {
6666
def takesOnlyUsingClauses = // only using clauses allowed for this owner
6767
this == Given || this == ExtensionFollow
6868
def acceptsVariance =
69-
this == Class || this == CaseClass || this == Type
69+
this == Class || this == CaseClass || this == Hk
70+
def acceptsCtxBounds =
71+
!(this == Type || this == Hk)
72+
def acceptsWildcard =
73+
this == Type || this == Hk
7074

7175
end ParamOwner
7276

@@ -1569,15 +1573,15 @@ object Parsers {
15691573
else core()
15701574

15711575
/** Type ::= FunType
1572-
* | HkTypeParamClause ‘=>>’ Type
1576+
* | TypTypeParamClause ‘=>>’ Type
15731577
* | FunParamClause ‘=>>’ Type
15741578
* | MatchType
15751579
* | InfixType
15761580
* FunType ::= (MonoFunType | PolyFunType)
15771581
* MonoFunType ::= FunTypeArgs (‘=>’ | ‘?=>’) Type
1578-
* | (‘->’ | ‘?->’ ) [CaptureSet] Type -- under pureFunctions
1579-
* PolyFunType ::= HKTypeParamClause '=>' Type
1580-
* | HKTypeParamClause ‘->’ [CaptureSet] Type -- under pureFunctions
1582+
* | (‘->’ | ‘?->’ ) [CaptureSet] Type -- under pureFunctions
1583+
* PolyFunType ::= TypTypeParamClause '=>' Type
1584+
* | TypTypeParamClause ‘->’ [CaptureSet] Type -- under pureFunctions
15811585
* FunTypeArgs ::= InfixType
15821586
* | `(' [ FunArgType {`,' FunArgType } ] `)'
15831587
* | '(' [ TypedFunParam {',' TypedFunParam } ')'
@@ -1743,7 +1747,7 @@ object Parsers {
17431747
simpleTypeRest(tuple)
17441748
else if in.token == LBRACKET then
17451749
val start = in.offset
1746-
val tparams = typeParamClause(ParamOwner.TypeParam)
1750+
val tparams = typeParamClause(ParamOwner.Type)
17471751
if in.token == TLARROW then
17481752
atSpan(start, in.skipToken()):
17491753
LambdaTypeTree(tparams, toplevelTyp())
@@ -2296,15 +2300,15 @@ object Parsers {
22962300
t
22972301

22982302
/** Expr ::= [`implicit'] FunParams (‘=>’ | ‘?=>’) Expr
2299-
* | HkTypeParamClause ‘=>’ Expr
2303+
* | TypTypeParamClause ‘=>’ Expr
23002304
* | Expr1
23012305
* FunParams ::= Bindings
23022306
* | id
23032307
* | `_'
23042308
* ExprInParens ::= PostfixExpr `:' Type
23052309
* | Expr
23062310
* BlockResult ::= [‘implicit’] FunParams (‘=>’ | ‘?=>’) Block
2307-
* | HkTypeParamClause ‘=>’ Block
2311+
* | TypTypeParamClause ‘=>’ Block
23082312
* | Expr1
23092313
* Expr1 ::= [‘inline’] `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
23102314
* | [‘inline’] `if' Expr `then' Expr [[semi] else Expr]
@@ -2340,7 +2344,7 @@ object Parsers {
23402344
closure(start, location, modifiers(BitSet(IMPLICIT)))
23412345
case LBRACKET =>
23422346
val start = in.offset
2343-
val tparams = typeParamClause(ParamOwner.TypeParam)
2347+
val tparams = typeParamClause(ParamOwner.Type)
23442348
val arrowOffset = accept(ARROW)
23452349
val body = expr(location)
23462350
atSpan(start, arrowOffset) {
@@ -2673,7 +2677,7 @@ object Parsers {
26732677
* ColonArgument ::= colon [LambdaStart]
26742678
* indent (CaseClauses | Block) outdent
26752679
* LambdaStart ::= FunParams (‘=>’ | ‘?=>’)
2676-
* | HkTypeParamClause ‘=>’
2680+
* | TypTypeParamClause ‘=>’
26772681
* ColonArgBody ::= indent (CaseClauses | Block) outdent
26782682
* Quoted ::= ‘'’ ‘{’ Block ‘}’
26792683
* | ‘'’ ‘[’ Type ‘]’
@@ -3390,17 +3394,19 @@ object Parsers {
33903394

33913395
/** ClsTypeParamClause::= ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
33923396
* ClsTypeParam ::= {Annotation} [‘+’ | ‘-’]
3393-
* id [HkTypeParamClause] TypeParamBounds
3397+
* id [HkTypeParamClause] TypeAndCtxBounds
33943398
*
33953399
* DefTypeParamClause::= ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
33963400
* DefTypeParam ::= {Annotation}
3397-
* id [HkTypeParamClause] TypeParamBounds
3401+
* id [HkTypeParamClause] TypeAndCtxBounds
33983402
*
33993403
* TypTypeParamClause::= ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
3400-
* TypTypeParam ::= {Annotation} id [HkTypePamClause] TypeBounds
3404+
* TypTypeParam ::= {Annotation}
3405+
* (id | ‘_’) [HkTypeParamClause] TypeBounds
34013406
*
34023407
* HkTypeParamClause ::= ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
3403-
* HkTypeParam ::= {Annotation} [‘+’ | ‘-’] (id [HkTypePamClause] | ‘_’) TypeBounds
3408+
* HkTypeParam ::= {Annotation} [‘+’ | ‘-’]
3409+
* (id | ‘_’) [HkTypePamClause] TypeBounds
34043410
*/
34053411
def typeParamClause(paramOwner: ParamOwner): List[TypeDef] = inBracketsWithCommas {
34063412

@@ -3411,7 +3417,6 @@ object Parsers {
34113417
ok
34123418

34133419
def typeParam(): TypeDef = {
3414-
val isAbstractOwner = paramOwner == ParamOwner.Type || paramOwner == ParamOwner.TypeParam
34153420
val start = in.offset
34163421
var mods = annotsAsMods() | Param
34173422
if paramOwner.isClass then
@@ -3422,13 +3427,13 @@ object Parsers {
34223427
mods |= Contravariant
34233428
atSpan(start, nameStart) {
34243429
val name =
3425-
if (isAbstractOwner && in.token == USCORE) {
3430+
if paramOwner.acceptsWildcard && in.token == USCORE then
34263431
in.nextToken()
34273432
WildcardParamName.fresh().toTypeName
3428-
}
34293433
else ident().toTypeName
3430-
val hkparams = typeParamClauseOpt(ParamOwner.Type)
3431-
val bounds = if (isAbstractOwner) typeBounds() else typeAndCtxBounds(name)
3434+
val hkparams = typeParamClauseOpt(ParamOwner.Hk)
3435+
val bounds =
3436+
if paramOwner.acceptsCtxBounds then typeAndCtxBounds(name) else typeBounds()
34323437
TypeDef(name, lambdaAbstract(hkparams, bounds)).withMods(mods)
34333438
}
34343439
}
@@ -3938,14 +3943,14 @@ object Parsers {
39383943
argumentExprss(mkApply(Ident(nme.CONSTRUCTOR), argumentExprs()))
39393944
}
39403945

3941-
/** TypeDef ::= id [TypeParamClause] {FunParamClause} TypeAndCtxBounds [‘=’ Type]
3946+
/** TypeDef ::= id [HkTypeParamClause] {FunParamClause} TypeAndCtxBounds [‘=’ Type]
39423947
*/
39433948
def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
39443949
newLinesOpt()
39453950
atSpan(start, nameStart) {
39463951
val nameIdent = typeIdent()
39473952
val tname = nameIdent.name.asTypeName
3948-
val tparams = typeParamClauseOpt(ParamOwner.Type)
3953+
val tparams = typeParamClauseOpt(ParamOwner.Hk)
39493954
val vparamss = funParamClauses()
39503955

39513956
def makeTypeDef(rhs: Tree): Tree = {

‎docs/_docs/internals/syntax.md‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -177,12 +177,12 @@ ClassQualifier ::= ‘[’ id ‘]’
177177
### Types
178178
```ebnf
179179
Type ::= FunType
180-
| HkTypeParamClause ‘=>>’ Type LambdaTypeTree(ps, t)
180+
| TypTypeParamClause ‘=>>’ Type LambdaTypeTree(ps, t)
181181
| FunParamClause ‘=>>’ Type TermLambdaTypeTree(ps, t)
182182
| MatchType
183183
| InfixType
184184
FunType ::= FunTypeArgs (‘=>’ | ‘?=>’) Type Function(ts, t) | FunctionWithMods(ts, t, mods, erasedParams)
185-
| HKTypeParamClause '=>' Type PolyFunction(ps, t)
185+
| TypTypeParamClause '=>' Type PolyFunction(ps, t)
186186
FunTypeArgs ::= InfixType
187187
| ‘(’ [ FunArgTypes ] ‘)’
188188
| FunParamClause
@@ -233,10 +233,10 @@ NameAndType ::= id ':' Type
233233
### Expressions
234234
```ebnf
235235
Expr ::= FunParams (‘=>’ | ‘?=>’) Expr Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr)
236-
| HkTypeParamClause ‘=>’ Expr PolyFunction(ts, expr)
236+
| TypTypeParamClause ‘=>’ Expr PolyFunction(ts, expr)
237237
| Expr1
238238
BlockResult ::= FunParams (‘=>’ | ‘?=>’) Block
239-
| HkTypeParamClause ‘=>’ Block
239+
| TypTypeParamClause ‘=>’ Block
240240
| Expr1
241241
FunParams ::= Bindings
242242
| id
@@ -286,7 +286,7 @@ SimpleExpr ::= SimpleRef
286286
ColonArgument ::= colon [LambdaStart]
287287
indent (CaseClauses | Block) outdent
288288
LambdaStart ::= FunParams (‘=>’ | ‘?=>’)
289-
| HkTypeParamClause ‘=>’
289+
| TypTypeParamClause ‘=>’
290290
Quoted ::= ‘'’ ‘{’ Block ‘}’
291291
| ‘'’ ‘[’ TypeBlock ‘]’
292292
ExprSplice ::= spliceId -- if inside quoted block
@@ -364,11 +364,14 @@ ClsTypeParamClause::= ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
364364
ClsTypeParam ::= {Annotation} [‘+’ | ‘-’] TypeDef(Modifiers, name, tparams, bounds)
365365
id [HkTypeParamClause] TypeAndCtxBounds Bound(below, above, context)
366366
367+
DefTypeParamClause::= [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
368+
DefTypeParam ::= {Annotation} id [HkTypeParamClause] TypeAndCtxBounds
369+
367370
TypTypeParamClause::= ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
368-
TypTypeParam ::= {Annotation} id [HkTypeParamClause] TypeBounds
371+
TypTypeParam ::= {Annotation} (id | ‘_’) [HkTypeParamClause] TypeBounds
369372
370373
HkTypeParamClause ::= ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
371-
HkTypeParam ::= {Annotation} [‘+’ | ‘-’] (id [HkTypeParamClause] | ‘_’)
374+
HkTypeParam ::= {Annotation} [‘+’ | ‘-’] (id | ‘_’) [HkTypeParamClause]
372375
TypeBounds
373376
374377
ClsParamClauses ::= {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
@@ -385,9 +388,6 @@ DefParamClause ::= DefTypeParamClause
385388
TypelessClauses ::= TypelessClause {TypelessClause}
386389
TypelessClause ::= DefTermParamClause
387390
| UsingParamClause
388-
389-
DefTypeParamClause::= [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
390-
DefTypeParam ::= {Annotation} id [HkTypeParamClause] TypeAndCtxBounds
391391
DefTermParamClause::= [nl] ‘(’ [DefTermParams] ‘)’
392392
UsingParamClause ::= [nl] ‘(’ ‘using’ (DefTermParams | FunArgTypes) ‘)’
393393
DefImplicitClause ::= [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
@@ -458,7 +458,7 @@ PatDef ::= ids [‘:’ Type] [‘=’ Expr]
458458
DefDef ::= DefSig [‘:’ Type] [‘=’ Expr] DefDef(_, name, paramss, tpe, expr)
459459
| ‘this’ TypelessClauses [DefImplicitClause] ‘=’ ConstrExpr DefDef(_, <init>, vparamss, EmptyTree, expr | Block)
460460
DefSig ::= id [DefParamClauses] [DefImplicitClause]
461-
TypeDef ::= id [TypeParamClause] {FunParamClause} TypeAndCtxBounds TypeDefTree(_, name, tparams, bound
461+
TypeDef ::= id [HkTypeParamClause] {FunParamClause} TypeAndCtxBounds TypeDefTree(_, name, tparams, bound
462462
[‘=’ Type]
463463
464464
TmplDef ::= ([‘case’] ‘class’ | ‘trait’) ClassDef

‎docs/_docs/reference/syntax.md‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -178,12 +178,11 @@ ClassQualifier ::= ‘[’ id ‘]’
178178
### Types
179179
```
180180
Type ::= FunType
181-
| HkTypeParamClause ‘=>>’ Type
182-
| FunParamClause ‘=>>’ Type
181+
| TypTypeParamClause ‘=>>’ Type
183182
| MatchType
184183
| InfixType
185184
FunType ::= FunTypeArgs (‘=>’ | ‘?=>’) Type
186-
| HKTypeParamClause '=>' Type
185+
| TypTypeParamClause '=>' Type
187186
FunTypeArgs ::= InfixType
188187
| ‘(’ [ FunArgTypes ] ‘)’
189188
| FunParamClause
@@ -215,17 +214,17 @@ ParamValueType ::= Type [‘*’]
215214
TypeArgs ::= ‘[’ Types ‘]’
216215
Refinement ::= :<<< [RefineDcl] {semi [RefineDcl]} >>>
217216
TypeBounds ::= [‘>:’ Type] [‘<:’ Type]
218-
TypeParamBounds ::= TypeBounds {‘:’ Type}
217+
TypeAndCtxBounds ::= TypeBounds {‘:’ Type}
219218
Types ::= Type {‘,’ Type}
220219
```
221220

222221
### Expressions
223222
```
224223
Expr ::= FunParams (‘=>’ | ‘?=>’) Expr
225-
| HkTypeParamClause ‘=>’ Expr
224+
| TypTypeParamClause ‘=>’ Expr
226225
| Expr1
227226
BlockResult ::= FunParams (‘=>’ | ‘?=>’) Block
228-
| HkTypeParamClause ‘=>’ Block
227+
| TypTypeParamClause ‘=>’ Block
229228
| Expr1
230229
FunParams ::= Bindings
231230
| id
@@ -273,7 +272,7 @@ SimpleExpr ::= SimpleRef
273272
ColonArgument ::= colon [LambdaStart]
274273
indent (CaseClauses | Block) outdent
275274
LambdaStart ::= FunParams (‘=>’ | ‘?=>’)
276-
| HkTypeParamClause ‘=>’
275+
| TypTypeParamClause ‘=>’
277276
Quoted ::= ‘'’ ‘{’ Block ‘}’
278277
| ‘'’ ‘[’ TypeBlock ‘]’
279278
ExprSplice ::= spliceId -- if inside quoted block
@@ -339,13 +338,16 @@ ArgumentPatterns ::= ‘(’ [Patterns] ‘)’
339338
### Type and Value Parameters
340339
```
341340
ClsTypeParamClause::= ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
342-
ClsTypeParam ::= {Annotation} [‘+’ | ‘-’] id [HkTypeParamClause] TypeParamBounds
341+
ClsTypeParam ::= {Annotation} [‘+’ | ‘-’] id [HkTypeParamClause] TypeAndCtxBounds
342+
343+
DefTypeParamClause::= [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
344+
DefTypeParam ::= {Annotation} id [HkTypeParamClause] TypeAndCtxBounds
343345
344346
TypTypeParamClause::= ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
345-
TypTypeParam ::= {Annotation} id [HkTypeParamClause] TypeBounds
347+
TypTypeParam ::= {Annotation} (id | ‘_’) [HkTypeParamClause] TypeBounds
346348
347349
HkTypeParamClause ::= ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
348-
HkTypeParam ::= {Annotation} [‘+’ | ‘-’] (id [HkTypeParamClause] | ‘_’) TypeBounds
350+
HkTypeParam ::= {Annotation} [‘+’ | ‘-’] (id | ‘_’) [HkTypeParamClause] TypeBounds
349351
350352
ClsParamClauses ::= {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
351353
ClsParamClause ::= [nl] ‘(’ ClsParams ‘)’
@@ -361,8 +363,6 @@ TypelessClauses ::= TypelessClause {TypelessClause}
361363
TypelessClause ::= DefTermParamClause
362364
| UsingParamClause
363365
364-
DefTypeParamClause::= [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
365-
DefTypeParam ::= {Annotation} id [HkTypeParamClause] TypeParamBounds
366366
DefTermParamClause::= [nl] ‘(’ [DefTermParams] ‘)’
367367
UsingParamClause ::= [nl] ‘(’ ‘using’ (DefTermParams | FunArgTypes) ‘)’
368368
DefImplicitClause ::= [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
@@ -431,7 +431,7 @@ PatDef ::= ids [‘:’ Type] [‘=’ Expr]
431431
DefDef ::= DefSig [‘:’ Type] [‘=’ Expr] DefDef(_, name, paramss, tpe, expr)
432432
| ‘this’ TypelessClauses [DefImplicitClause] ‘=’ ConstrExpr DefDef(_, <init>, vparamss, EmptyTree, expr | Block)
433433
DefSig ::= id [DefParamClauses] [DefImplicitClause]
434-
TypeDef ::= id [TypeParamClause] {FunParamClause} TypeBounds TypeDefTree(_, name, tparams, bound
434+
TypeDef ::= id [HkTypeParamClause] {FunParamClause}TypeBounds TypeDefTree(_, name, tparams, bound
435435
[‘=’ Type]
436436
437437
TmplDef ::= ([‘case’] ‘class’ | ‘trait’) ClassDef

0 commit comments

Comments
 (0)