Skip to content

Commit 320b638

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 a212ff0 commit 320b638

File tree

4 files changed

+58
-55
lines changed

4 files changed

+58
-55
lines changed

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

Lines changed: 28 additions & 24 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

@@ -1565,15 +1569,15 @@ object Parsers {
15651569
else core()
15661570

15671571
/** Type ::= FunType
1568-
* | HkTypeParamClause ‘=>>’ Type
1572+
* | TypTypeParamClause ‘=>>’ Type
15691573
* | FunParamClause ‘=>>’ Type
15701574
* | MatchType
15711575
* | InfixType
15721576
* FunType ::= (MonoFunType | PolyFunType)
15731577
* MonoFunType ::= FunTypeArgs (‘=>’ | ‘?=>’) Type
1574-
* | (‘->’ | ‘?->’ ) [CaptureSet] Type -- under pureFunctions
1575-
* PolyFunType ::= HKTypeParamClause '=>' Type
1576-
* | HKTypeParamClause ‘->’ [CaptureSet] Type -- under pureFunctions
1578+
* | (‘->’ | ‘?->’ ) [CaptureSet] Type -- under pureFunctions
1579+
* PolyFunType ::= TypTypeParamClause '=>' Type
1580+
* | TypTypeParamClause ‘->’ [CaptureSet] Type -- under pureFunctions
15771581
* FunTypeArgs ::= InfixType
15781582
* | `(' [ FunArgType {`,' FunArgType } ] `)'
15791583
* | '(' [ TypedFunParam {',' TypedFunParam } ')'
@@ -1739,7 +1743,7 @@ object Parsers {
17391743
simpleTypeRest(tuple)
17401744
else if in.token == LBRACKET then
17411745
val start = in.offset
1742-
val tparams = typeParamClause(ParamOwner.TypeParam)
1746+
val tparams = typeParamClause(ParamOwner.Type)
17431747
if in.token == TLARROW then
17441748
atSpan(start, in.skipToken()):
17451749
LambdaTypeTree(tparams, toplevelTyp())
@@ -2286,15 +2290,15 @@ object Parsers {
22862290
t
22872291

22882292
/** Expr ::= [`implicit'] FunParams (‘=>’ | ‘?=>’) Expr
2289-
* | HkTypeParamClause ‘=>’ Expr
2293+
* | TypTypeParamClause ‘=>’ Expr
22902294
* | Expr1
22912295
* FunParams ::= Bindings
22922296
* | id
22932297
* | `_'
22942298
* ExprInParens ::= PostfixExpr `:' Type
22952299
* | Expr
22962300
* BlockResult ::= [‘implicit’] FunParams (‘=>’ | ‘?=>’) Block
2297-
* | HkTypeParamClause ‘=>’ Block
2301+
* | TypTypeParamClause ‘=>’ Block
22982302
* | Expr1
22992303
* Expr1 ::= [‘inline’] `if' `(' Expr `)' {nl} Expr [[semi] else Expr]
23002304
* | [‘inline’] `if' Expr `then' Expr [[semi] else Expr]
@@ -2330,7 +2334,7 @@ object Parsers {
23302334
closure(start, location, modifiers(BitSet(IMPLICIT)))
23312335
case LBRACKET =>
23322336
val start = in.offset
2333-
val tparams = typeParamClause(ParamOwner.TypeParam)
2337+
val tparams = typeParamClause(ParamOwner.Type)
23342338
val arrowOffset = accept(ARROW)
23352339
val body = expr(location)
23362340
atSpan(start, arrowOffset) {
@@ -2663,7 +2667,7 @@ object Parsers {
26632667
* ColonArgument ::= colon [LambdaStart]
26642668
* indent (CaseClauses | Block) outdent
26652669
* LambdaStart ::= FunParams (‘=>’ | ‘?=>’)
2666-
* | HkTypeParamClause ‘=>’
2670+
* | TypTypeParamClause ‘=>’
26672671
* ColonArgBody ::= indent (CaseClauses | Block) outdent
26682672
* Quoted ::= ‘'’ ‘{’ Block ‘}’
26692673
* | ‘'’ ‘[’ Type ‘]’
@@ -3380,18 +3384,19 @@ object Parsers {
33803384

33813385
/** ClsTypeParamClause::= ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
33823386
* ClsTypeParam ::= {Annotation} [‘+’ | ‘-’]
3383-
* id [HkTypeParamClause] TypeParamBounds
3387+
* id [HkTypeParamClause] TypeAndCtxBounds
33843388
*
33853389
* DefTypeParamClause::= ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
33863390
* DefTypeParam ::= {Annotation}
3387-
* [`sealed`] -- under captureChecking
3388-
* id [HkTypeParamClause] TypeParamBounds
3391+
* id [HkTypeParamClause] TypeAndCtxBounds
33893392
*
33903393
* TypTypeParamClause::= ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
3391-
* TypTypeParam ::= {Annotation} id [HkTypePamClause] TypeBounds
3394+
* TypTypeParam ::= {Annotation}
3395+
* (id | ‘_’) [HkTypeParamClause] TypeBounds
33923396
*
33933397
* HkTypeParamClause ::= ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
3394-
* HkTypeParam ::= {Annotation} [‘+’ | ‘-’] (id [HkTypePamClause] | ‘_’) TypeBounds
3398+
* HkTypeParam ::= {Annotation} [‘+’ | ‘-’]
3399+
* (id | ‘_’) [HkTypePamClause] TypeBounds
33953400
*/
33963401
def typeParamClause(paramOwner: ParamOwner): List[TypeDef] = inBracketsWithCommas {
33973402

@@ -3402,7 +3407,6 @@ object Parsers {
34023407
ok
34033408

34043409
def typeParam(): TypeDef = {
3405-
val isAbstractOwner = paramOwner == ParamOwner.Type || paramOwner == ParamOwner.TypeParam
34063410
val start = in.offset
34073411
var mods = annotsAsMods() | Param
34083412
if paramOwner.isClass then
@@ -3413,13 +3417,13 @@ object Parsers {
34133417
mods |= Contravariant
34143418
atSpan(start, nameStart) {
34153419
val name =
3416-
if (isAbstractOwner && in.token == USCORE) {
3420+
if paramOwner.acceptsWildcard && in.token == USCORE then
34173421
in.nextToken()
34183422
WildcardParamName.fresh().toTypeName
3419-
}
34203423
else ident().toTypeName
3421-
val hkparams = typeParamClauseOpt(ParamOwner.Type)
3422-
val bounds = if (isAbstractOwner) typeBounds() else typeAndCtxBounds(name)
3424+
val hkparams = typeParamClauseOpt(ParamOwner.Hk)
3425+
val bounds =
3426+
if paramOwner.acceptsCtxBounds then typeAndCtxBounds(name) else typeBounds()
34233427
TypeDef(name, lambdaAbstract(hkparams, bounds)).withMods(mods)
34243428
}
34253429
}
@@ -3929,14 +3933,14 @@ object Parsers {
39293933
argumentExprss(mkApply(Ident(nme.CONSTRUCTOR), argumentExprs()))
39303934
}
39313935

3932-
/** TypeDef ::= id [TypeParamClause] {FunParamClause} TypeAndCtxBounds [‘=’ Type]
3936+
/** TypeDef ::= id [HkTypeParamClause] {FunParamClause} TypeAndCtxBounds [‘=’ Type]
39333937
*/
39343938
def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
39353939
newLinesOpt()
39363940
atSpan(start, nameStart) {
39373941
val nameIdent = typeIdent()
39383942
val tname = nameIdent.name.asTypeName
3939-
val tparams = typeParamClauseOpt(ParamOwner.Type)
3943+
val tparams = typeParamClauseOpt(ParamOwner.Hk)
39403944
val vparamss = funParamClauses()
39413945

39423946
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

‎tests/new/test.scala

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,8 @@
1-
import language.experimental.namedTuples
2-
3-
type Person = (name: String, age: Int)
1+
def foo(x: [A] => (x: A) => A) = x[Int](22)
42

53
def test =
6-
val bob = (name = "Bob", age = 33): (name: String, age: Int)
7-
8-
val silly = bob match
9-
case (name = n, age = a) => n.length + a
4+
foo((x: Int) => x)
5+
foo: x =>
6+
x
7+
foo: [Int] =>
8+
(x: Int) => x

0 commit comments

Comments
 (0)