Skip to content

Commit 04095bc

Browse files
oderskyodersky
committed
Switch to with syntax for context parameters
1 parent 762c644 commit 04095bc

File tree

473 files changed

+1042
-1030
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

473 files changed

+1042
-1030
lines changed

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

Lines changed: 41 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -938,10 +938,13 @@ object Parsers {
938938
lookahead.nextToken()
939939
while lookahead.token == LPAREN || lookahead.token == LBRACKET do
940940
lookahead.skipParens()
941-
if lookahead.token == COLON then
941+
if lookahead.token == COLON then // TODO: remove
942942
lookahead.nextToken()
943943
!lookahead.isAfterLineEnd
944-
else lookahead.token == SUBTYPE || lookahead.isIdent(nme.as)
944+
else
945+
lookahead.token == SUBTYPE // TODO: remove
946+
|| lookahead.isIdent(nme.as)
947+
|| lookahead.token == WITH && lookahead.ch != Chars.LF // TODO: remove LF test
945948

946949
def followingIsExtension() =
947950
val lookahead = in.LookaheadScanner()
@@ -2106,6 +2109,7 @@ object Parsers {
21062109
* | SimpleExpr `.' MatchClause
21072110
* | SimpleExpr (TypeArgs | NamedTypeArgs)
21082111
* | SimpleExpr1 ArgumentExprs
2112+
* | SimpleExpr ContextArguments
21092113
* Quoted ::= ‘'’ ‘{’ Block ‘}’
21102114
* | ‘'’ ‘[’ Type ‘]’
21112115
*/
@@ -2174,6 +2178,8 @@ object Parsers {
21742178
case DOT =>
21752179
in.nextToken()
21762180
simpleExprRest(selector(t), canApply = true)
2181+
case DOTWITH =>
2182+
simpleExprRest(contextArguments(t), canApply = true)
21772183
case LBRACKET =>
21782184
val tapp = atSpan(startOffset(t), in.offset) { TypeApply(t, typeArgs(namedOK = true, wildOK = false)) }
21792185
simpleExprRest(tapp, canApply = true)
@@ -2250,7 +2256,7 @@ object Parsers {
22502256
else fn
22512257
}
22522258

2253-
/** ParArgumentExprss ::= {ParArgumentExprs}
2259+
/** ParArgumentExprss ::= {ParArgumentExprs | ContextArguments}
22542260
*
22552261
* Special treatment for arguments to primary constructor annotations.
22562262
* (...) is considered an argument only if it does not look like a formal
@@ -2275,6 +2281,8 @@ object Parsers {
22752281
parArgumentExprss(
22762282
atSpan(startOffset(fn)) { mkApply(fn, parArgumentExprs()) }
22772283
)
2284+
else if in.token == DOTWITH then
2285+
parArgumentExprss(contextArguments(fn))
22782286
else fn
22792287
}
22802288

@@ -2304,6 +2312,14 @@ object Parsers {
23042312
else Block(stats, EmptyTree)
23052313
}
23062314

2315+
/** ContextArguments ::= ‘.’ ‘with’ ArgumentExprs */
2316+
def contextArguments(t: Tree): Tree =
2317+
if in.token == DOTWITH then
2318+
atSpan(t.span.start, in.skipToken()) {
2319+
Apply(t, argumentExprs()._1).setGivenApply()
2320+
}
2321+
else t
2322+
23072323
/** Guard ::= if PostfixExpr
23082324
*/
23092325
def guard(): Tree =
@@ -2786,23 +2802,23 @@ object Parsers {
27862802
def typeParamClauseOpt(ownerKind: ParamOwner.Value): List[TypeDef] =
27872803
if (in.token == LBRACKET) typeParamClause(ownerKind) else Nil
27882804

2789-
/** OLD: GivenTypes ::= AnnotType {‘,’ AnnotType}
2790-
* NEW: GivenTypes ::= Type {‘,’ Type}
2805+
/** AnnotTypes ::= AnnotType {‘,’ AnnotType}
2806+
* Types ::= Type {‘,’ Type}
27912807
*/
2792-
def givenTypes(nparams: Int, ofClass: Boolean): List[ValDef] =
2793-
val tps = commaSeparated(typ)
2808+
def givenTypes(parseType: () => Tree, nparams: Int, ofClass: Boolean): List[ValDef] =
2809+
val tps = commaSeparated(parseType)
27942810
var counter = nparams
27952811
def nextIdx = { counter += 1; counter }
27962812
val paramFlags = if ofClass then Private | Local | ParamAccessor else Param
27972813
tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | Given))
27982814

27992815
/** ClsParamClause ::= ‘(’ [‘erased’] ClsParams ‘)’
2800-
* GivenClsParamClause::= 'with' ‘(’ (ClsParams | GivenTypes) ‘)’
2816+
* GivenClsParamClause::= 'with' (‘(’ (ClsParams | Types) ‘)’ | AnnotTypes)
28012817
* ClsParams ::= ClsParam {‘,’ ClsParam}
28022818
* ClsParam ::= {Annotation}
28032819
*
28042820
* DefParamClause ::= ‘(’ [‘erased’] DefParams ‘)’
2805-
* GivenParamClause ::= ‘with’ ‘(’ (DefParams | GivenTypes) ‘)’
2821+
* GivenParamClause ::= ‘with’ (‘(’ (DefParams | Types) ‘)’ | AnnotTypes)
28062822
* DefParams ::= DefParam {‘,’ DefParam}
28072823
* DefParam ::= {Annotation} [‘inline’] Param
28082824
*
@@ -2888,34 +2904,33 @@ object Parsers {
28882904
impliedModOpt(GIVEN, () => Mod.Given())
28892905
impliedModOpt(ERASED, () => Mod.Erased())
28902906
if givenOnly && !impliedMods.is(Given) then
2891-
syntaxError(ExpectedTokenButFound(GIVEN, in.token))
2907+
syntaxError("Normal parameter clause cannot follow context parameter clause")
28922908
val isParams =
28932909
!impliedMods.is(Given)
28942910
|| startParamTokens.contains(in.token)
28952911
|| isIdent && (in.name == nme.inline || in.lookaheadIn(BitSet(COLON)))
28962912
if isParams then commaSeparated(() => param())
2897-
else givenTypes(nparams, ofClass)
2913+
else givenTypes(typ, nparams, ofClass)
28982914
checkVarArgsRules(clause)
28992915
clause
29002916
}
29012917
}
29022918

29032919
/** ClsParamClauses ::= {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
2904-
* | {ClsParamClause | GivenClsParamClause} [‘with’ GivenTypes]
2920+
* | {ClsParamClause} {GivenClsParamClause}
29052921
* DefParamClauses ::= {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
2906-
* | {DefParamClause | GivenParamClause} [‘with’ GivenTypes]
2907-
* GivenParamClauses ::= {GivenParamClause} [‘with’ GivenTypes]
2922+
* | {DefParamClause} {GivenParamClause}
29082923
*
29092924
* @return The parameter definitions
29102925
*/
29112926
def paramClauses(ofClass: Boolean = false,
29122927
ofCaseClass: Boolean = false,
29132928
givenOnly: Boolean = false): List[List[ValDef]] =
29142929

2915-
def recur(firstClause: Boolean, nparams: Int): List[List[ValDef]] =
2930+
def recur(firstClause: Boolean, nparams: Int, givenOnly: Boolean): List[List[ValDef]] =
29162931
newLineOptWhenFollowedBy(LPAREN)
29172932
val prefixMods =
2918-
if in.token == WITH then
2933+
if in.token == WITH && in.ch != Chars.LF then // TODO: remove LF test
29192934
in.nextToken()
29202935
Modifiers(Given)
29212936
else
@@ -2930,15 +2945,18 @@ object Parsers {
29302945
firstClause = firstClause,
29312946
prefixMods = prefixMods)
29322947
val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
2948+
val isGivenClause = prefixMods.is(Given)
2949+
|| params.nonEmpty && params.head.mods.flags.is(Given)
29332950
params :: (
29342951
if lastClause then Nil
2935-
else recur(firstClause = false, nparams + params.length))
2952+
else recur(firstClause = false, nparams + params.length, givenOnly | isGivenClause))
29362953
else if prefixMods.is(Given) then
2937-
givenTypes(nparams, ofClass) :: Nil
2954+
val params = givenTypes(annotType, nparams, ofClass)
2955+
params :: recur(firstClause = false, nparams + params.length, true)
29382956
else Nil
29392957
end recur
29402958

2941-
recur(firstClause = true, 0)
2959+
recur(firstClause = true, 0, givenOnly)
29422960
end paramClauses
29432961

29442962
/* -------- DEFS ------------------------------------------- */
@@ -3464,7 +3482,8 @@ object Parsers {
34643482
val tparams = typeParamClauseOpt(ParamOwner.Def)
34653483
val paramsStart = in.offset
34663484
val vparamss =
3467-
if in.token == WITH || in.token == LPAREN && followingIsParamOrGivenType()
3485+
if in.token == WITH && in.ch != Chars.LF // TODO: remove LF test
3486+
|| in.token == LPAREN && followingIsParamOrGivenType()
34683487
then paramClauses()
34693488
else Nil
34703489
def checkAllGivens(vparamss: List[List[ValDef]], what: String) =
@@ -3531,7 +3550,8 @@ object Parsers {
35313550
val constrApp: () => Tree = () => {
35323551
val t = rejectWildcardType(annotType(), fallbackTree = Ident(nme.ERROR))
35333552
// Using Ident(nme.ERROR) to avoid causing cascade errors on non-user-written code
3534-
if in.token == LPAREN then parArgumentExprss(wrapNew(t)) else t
3553+
if in.token == LPAREN || in.token == DOTWITH then parArgumentExprss(wrapNew(t))
3554+
else t
35353555
}
35363556

35373557
/** ConstrApps ::= ConstrApp {(‘,’ | ‘with’) ConstrApp}

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

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -593,7 +593,11 @@ object Scanners {
593593
this.copyFrom(prev)
594594
}
595595

596-
/** - Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT, SEMI + ELSE => ELSE, COLON + <EOL> => COLONEOL
596+
/** - Join CASE + CLASS => CASECLASS,
597+
* CASE + OBJECT => CASEOBJECT,
598+
* SEMI + ELSE => ELSE,
599+
* COLON + <EOL> => COLONEOL
600+
* DOT + WITH => DOTWITH
597601
* - Insert missing OUTDENTs at EOF
598602
*/
599603
def postProcessToken(): Unit = {
@@ -619,6 +623,10 @@ object Scanners {
619623
} else if (token == EOF) { // e.g. when the REPL is parsing "val List(x, y, _*,"
620624
/* skip the trailing comma */
621625
} else reset()
626+
case DOT =>
627+
lookahead()
628+
if token == WITH then fuse(DOTWITH)
629+
else reset()
622630
case COLON =>
623631
if colonSyntax then observeColonEOL()
624632
case EOF | RBRACE =>

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

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -189,7 +189,6 @@ object Tokens extends TokensCommon {
189189
/** special symbols */
190190
final val NEWLINE = 78; enter(NEWLINE, "end of statement", "new line")
191191
final val NEWLINES = 79; enter(NEWLINES, "end of statement", "new lines")
192-
final val COLONEOL = 88; enter(COLONEOL, ":", ": at eol")
193192

194193
/** special keywords */
195194
final val USCORE = 73; enter(USCORE, "_")
@@ -204,6 +203,9 @@ object Tokens extends TokensCommon {
204203

205204
final val QUOTE = 87; enter(QUOTE, "'")
206205

206+
final val COLONEOL = 88; enter(COLONEOL, ":", ": at eol")
207+
final val DOTWITH = 89; enter(DOTWITH, ".with")
208+
207209
/** XML mode */
208210
final val XMLSTART = 98; enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
209211

‎compiler/test-resources/repl/3932‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,2 +1,2 @@
11
scala> def fun[T](x: T): (given List[T]) => Int = ???
2-
def fun[T](x: T): (given List[T]) => Int
2+
def fun[T](x: T): (List[T]) ?=> Int

‎docs/docs/internals/syntax.md‎

Lines changed: 15 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -173,6 +173,8 @@ NamedTypeArgs ::= ‘[’ NamedTypeArg {‘,’ NamedTypeArg} ‘]’
173173
Refinement ::= ‘{’ [RefineDcl] {semi [RefineDcl]} ‘}’ ds
174174
SubtypeBounds ::= [‘>:’ Type] [‘<:’ Type] | INT TypeBoundsTree(lo, hi)
175175
TypeParamBounds ::= SubtypeBounds {‘:’ Type} ContextBounds(typeBounds, tps)
176+
Types ::= Type {‘,’ Type}
177+
AnnotTypes ::= AnnotType {‘,’ AnnotType}
176178
```
177179

178180
### Expressions
@@ -205,7 +207,7 @@ PostfixExpr ::= InfixExpr [id]
205207
InfixExpr ::= PrefixExpr
206208
| InfixExpr id [nl] InfixExpr InfixOp(expr, op, expr)
207209
| InfixExpr MatchClause
208-
MatchClause ::= ‘match’ ‘{’ CaseClauses ‘}’ Match(expr, cases)
210+
MatchClause ::= ‘match’ ‘{’ CaseClauses ‘}’ Match(expr, cases)
209211
PrefixExpr ::= [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr PrefixOp(expr, op)
210212
SimpleExpr ::= Path
211213
| Literal
@@ -219,6 +221,7 @@ SimpleExpr ::= Path
219221
| ‘(’ ExprsInParens ‘)’ Parens(exprs)
220222
| SimpleExpr ‘.’ id Select(expr, id)
221223
| SimpleExpr ‘.’ MatchClause
224+
| SimpleExpr ‘.’ ContextArguments
222225
| SimpleExpr TypeArgs TypeApply(expr, args)
223226
| SimpleExpr ArgumentExprs Apply(expr, args)
224227
| SimpleExpr ‘_’ PostfixOp(expr, _)
@@ -228,10 +231,12 @@ Quoted ::= ‘'’ ‘{’ Block ‘}’
228231
ExprsInParens ::= ExprInParens {‘,’ ExprInParens}
229232
ExprInParens ::= PostfixExpr ‘:’ Type -- normal Expr allows only RefinedType here
230233
| Expr
231-
ParArgumentExprs ::= ‘(’ [‘given’] ExprsInParens ‘)’ exprs
234+
ParArgumentExprs ::= ‘(’ ExprsInParens ‘)’ exprs
232235
| ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘:’ ‘_’ ‘*’ ‘)’ exprs :+ Typed(expr, Ident(wildcardStar))
236+
ParArgumentExprss ::= {ParArgumentExprs | ContextArguments}
233237
ArgumentExprs ::= ParArgumentExprs
234238
| [nl] BlockExpr
239+
ContextArguments ::= ‘.’ ‘with’ ArgumentExprs
235240
BlockExpr ::= ‘{’ (CaseClauses | Block) ‘}’
236241
Block ::= {BlockStat semi} [BlockResult] Block(stats, expr?)
237242
BlockStat ::= Import
@@ -293,23 +298,21 @@ HkTypeParam ::= {Annotation} [‘+’ | ‘-’] (Id[HkTypeParamClause] |
293298
SubtypeBounds
294299
295300
ClsParamClauses ::= {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
296-
| {ClsParamClause | GivenClsParamClause} [‘with’ GivenTypes]
301+
| {ClsParamClause} {GivenClsParamClause}
297302
ClsParamClause ::= [nl] ‘(’ ClsParams ‘)’
298-
GivenClsParamClause::= ‘with’ ‘(’ (ClsParams | GivenTypes) ‘)’
303+
GivenClsParamClause::= ‘with’ (‘(’ (ClsParams | Types) ‘)’ | AnnotTypes)
299304
ClsParams ::= ClsParam {‘,’ ClsParam}
300305
ClsParam ::= {Annotation} ValDef(mods, id, tpe, expr) -- point of mods on val/var
301306
[{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
302307
Param ::= id ‘:’ ParamType [‘=’ Expr]
303308
| INT
304309
305310
DefParamClauses ::= {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
306-
| {DefParamClause | GivenParamClause} [‘with’ GivenTypes]
311+
| {DefParamClause} {GivenParamClause}
307312
DefParamClause ::= [nl] ‘(’ DefParams ‘)’
308-
GivenParamClause ::= ‘with’ ‘(’ (DefParams | GivenTypes) ‘)’
309-
GivenParamClauses ::= {GivenParamClause} [‘with’ GivenTypes]
313+
GivenParamClause ::= ‘with’ (‘(’ (DefParams | Types) ‘)’ | AnnotTypes)
310314
DefParams ::= DefParam {‘,’ DefParam}
311315
DefParam ::= {Annotation} [‘inline’] Param ValDef(mods, id, tpe, expr) -- point of mods at id.
312-
GivenTypes ::= Type {‘,’ Type}
313316
ClosureMods ::= { ‘implicit’ | ‘given’}
314317
```
315318

@@ -332,7 +335,7 @@ LocalModifier ::= ‘abstract’
332335
AccessModifier ::= (‘private’ | ‘protected’) [AccessQualifier]
333336
AccessQualifier ::= ‘[’ id ‘]’
334337
335-
Annotation ::= ‘@’ SimpleType {ParArgumentExprs} Apply(tpe, args)
338+
Annotation ::= ‘@’ SimpleType ParArgumentExprss Apply(tpe, args)
336339
337340
Import ::= ‘import’ ImportExpr {‘,’ ImportExpr}
338341
ImportExpr ::= StableId ‘.’ ImportSpec Import(expr, sels)
@@ -387,14 +390,14 @@ ObjectDef ::= id [Template]
387390
EnumDef ::= id ClassConstr InheritClauses EnumBody EnumDef(mods, name, tparams, template)
388391
GivenDef ::= [GivenSig] [‘_’ ‘<:’] Type ‘=’ Expr
389392
| [GivenSig] ConstrApps [TemplateBody]
390-
GivenSig ::= [id] [DefTypeParamClause] GivenParamClauses ‘as’
391-
ExtensionDef ::= [id] ‘on’ ExtParamClause GivenParamClauses ExtMethods
393+
GivenSig ::= [id] [DefTypeParamClause] {GivenParamClause} ‘as’
394+
ExtensionDef ::= [id] ‘on’ ExtParamClause {GivenParamClause} ExtMethods
392395
ExtMethods ::= [nl] ‘{’ ‘def’ DefDef {semi ‘def’ DefDef} ‘}’
393396
ExtParamClause ::= [DefTypeParamClause] ‘(’ DefParam ‘)’
394397
Template ::= InheritClauses [TemplateBody] Template(constr, parents, self, stats)
395398
InheritClauses ::= [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
396399
ConstrApps ::= ConstrApp {(‘,’ | ‘with’) ConstrApp}
397-
ConstrApp ::= AnnotType {ParArgumentExprs} Apply(tp, args)
400+
ConstrApp ::= AnnotType ParArgumentExprss Apply(tp, args)
398401
ConstrExpr ::= SelfInvocation
399402
| ‘{’ SelfInvocation {semi BlockStat} ‘}’
400403
SelfInvocation ::= ‘this’ ArgumentExprs {ArgumentExprs}

‎tests/disabled/neg-with-compiler/quote-run-in-macro-2/quoted_1.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ import scala.quoted.autolift.given
44
object Macros {
55

66
inline def foo(i: => Int): Int = ${ fooImpl('i) }
7-
def fooImpl(i: Expr[Int])(given QuoteContext): Expr[Int] = {
7+
def fooImpl(i: Expr[Int]) with QuoteContext : Expr[Int] = {
88
given Toolbox = Toolbox.make(getClass.getClassLoader)
99
val y: Int = run(i)
1010
y

‎tests/disabled/reflect/run/t3425b/Base_1.scala‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@ object Gen {
2626
}
2727
case class Pair(tp1: Tp, tp2: Tp) {
2828
def expr = s"((new ABC): $tp)"
29-
def tp = s"($tp1) with ($tp2)"
29+
def tp = s"($tp1) with $tp2"
3030
}
3131
val traits = Vector("Any", "A", "B", "C") map ("%6s" format _)
3232
val types = Vector("P", "Q", "R forSome { type R <: P with Q }")
@@ -39,7 +39,7 @@ object Gen {
3939
import p._
4040
List(
4141
s"type R1_$idx = $tp",
42-
s"type R2_$idx = R1_$idx { val y: (${tp1.elem}) with (${tp2.elem}) }"
42+
s"type R2_$idx = R1_$idx { val y: (${tp1.elem}) with ${tp2.elem} }"
4343
)
4444
}
4545

‎tests/generic-java-signatures/i3653.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ class Foo {
55
c0: T, c1: T, c2: T, c3: T, c4: T, c5: T, c6: T, c7: T, c8: T, c9: T) => 0
66

77
// #6946
8-
def baz = (x: String ?=> Unit) => x(given "")
8+
def baz = (x: String ?=> Unit) => x.with("")
99
}
1010

1111
object Test {

‎tests/neg-custom-args/fatal-warnings/quote-simple-hole.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
import scala.quoted.QuoteContext
22

3-
def test(given QuoteContext) = {
3+
def test with QuoteContext = {
44
val x = '{0}
55
val y = '{ // error: Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.
66
$x

‎tests/neg-macros/GenericNumLits/Even_1.scala‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ object Even {
1111
else throw FromDigits.MalformedNumber(s"$digits is odd")
1212
}
1313

14-
private def evenFromDigitsImpl(digits: Expr[String])(given ctx: QuoteContext): Expr[Even] = digits match {
14+
private def evenFromDigitsImpl(digits: Expr[String]) with (ctx: QuoteContext) : Expr[Even] = digits match {
1515
case Const(ds) =>
1616
val ev =
1717
try evenFromDigits(ds)

0 commit comments

Comments
 (0)