Drop infix given for parameters and arguments

Author: odersky

compiler/src/dotty/tools/dotc/core/Annotations.scala

@@ -163,7 +163,7 @@ object Annotations {
       }
 
       /** A regular, non-deferred Child annotation */
-      def apply(sym: Symbol, span: Span)(implicit ctx: Context): Annotation = later(given _ => sym, span)
+      def apply(sym: Symbol, span: Span)(implicit ctx: Context): Annotation = later(sym, span)
 
       def unapply(ann: Annotation)(implicit ctx: Context): Option[Symbol] =
         if (ann.symbol == defn.ChildAnnot) {

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

@@ -943,7 +943,7 @@ object Parsers {
     def applyGiven(t: Tree, operand: () => Tree): Tree =
       atSpan(startOffset(t), in.offset) {
         in.nextToken()
-        val args = if (in.token == LPAREN) parArgumentExprs() else operand() :: Nil
+        val args = if (in.token == LPAREN) parArgumentExprs()._1 else operand() :: Nil
         Apply(t, args)
       }.setGivenApply()
 
@@ -2070,7 +2070,7 @@ object Parsers {
           val tapp = atSpan(startOffset(t), in.offset) { TypeApply(t, typeArgs(namedOK = true, wildOK = false)) }
           simpleExprRest(tapp, canApply = true)
         case LPAREN | LBRACE | INDENT if canApply =>
-          val app = atSpan(startOffset(t), in.offset) { Apply(t, argumentExprs()) }
+          val app = atSpan(startOffset(t), in.offset) { mkApply(t, argumentExprs()) }
           simpleExprRest(app, canApply = true)
         case USCORE =>
           atSpan(startOffset(t), in.skipToken()) { PostfixOp(t, Ident(nme.WILDCARD)) }
@@ -2115,16 +2115,26 @@ object Parsers {
     /** ParArgumentExprs ::= `(' [‘given’] [ExprsInParens] `)'
      *                    |  `(' [ExprsInParens `,'] PostfixExpr `:' `_' `*' ')'
      */
-    def parArgumentExprs(): List[Tree] = inParens {
-      if in.token == RPAREN then Nil
-      else commaSeparated(argumentExpr)
+    def parArgumentExprs(): (List[Tree], Boolean) = inParens {
+      if in.token == RPAREN then
+        (Nil, false)
+      else if in.token == GIVEN then
+        in.nextToken()
+        (commaSeparated(argumentExpr), true)
+      else
+        (commaSeparated(argumentExpr), false)
     }
 
     /** ArgumentExprs ::= ParArgumentExprs
      *                 |  [nl] BlockExpr
      */
-    def argumentExprs(): List[Tree] =
-      if (in.isNestedStart) blockExpr() :: Nil else parArgumentExprs()
+    def argumentExprs(): (List[Tree], Boolean) =
+      if (in.isNestedStart) (blockExpr() :: Nil, false) else parArgumentExprs()
+
+    def mkApply(fn: Tree, args: (List[Tree], Boolean)): Tree =
+      val res = Apply(fn, args._1)
+      if args._2 then res.setGivenApply()
+      res
 
     val argumentExpr: () => Tree = () => exprInParens() match {
       case arg @ Assign(Ident(id), rhs) => cpy.NamedArg(arg)(id, rhs)
@@ -2135,7 +2145,7 @@ object Parsers {
      */
     def argumentExprss(fn: Tree): Tree = {
       possibleBracesStart()
-      if (in.token == LPAREN || in.isNestedStart) argumentExprss(Apply(fn, argumentExprs()))
+      if (in.token == LPAREN || in.isNestedStart) argumentExprss(mkApply(fn, argumentExprs()))
       else fn
     }
 
@@ -2162,7 +2172,7 @@ object Parsers {
       }
       if (in.token == LPAREN && (!inClassConstrAnnots || isLegalAnnotArg))
         parArgumentExprss(
-          atSpan(startOffset(fn)) { Apply(fn, parArgumentExprs()) }
+          atSpan(startOffset(fn)) { mkApply(fn, parArgumentExprs()) }
         )
       else fn
     }
@@ -2696,10 +2706,11 @@ object Parsers {
     def typeParamClauseOpt(ownerKind: ParamOwner.Value): List[TypeDef] =
       if (in.token == LBRACKET) typeParamClause(ownerKind) else Nil
 
-    /** GivenTypes   ::=  AnnotType {‘,’ AnnotType}
+    /** OLD: GivenTypes   ::=  AnnotType {‘,’ AnnotType}
+     *  NEW: GivenTypes   ::=  Type {‘,’ Type}
      */
-    def givenTypes(nparams: Int, ofClass: Boolean): List[ValDef] =
-      val tps = commaSeparated(() => annotType())
+    def givenTypes(newStyle: Boolean, nparams: Int, ofClass: Boolean): List[ValDef] =
+      val tps = commaSeparated(() => if newStyle then typ() else annotType())
       var counter = nparams
       def nextIdx = { counter += 1; counter }
       val paramFlags = if ofClass then Private | Local | ParamAccessor else Param
@@ -2799,7 +2810,7 @@ object Parsers {
                 || startParamTokens.contains(in.token)
                 || isIdent && (in.name == nme.inline || in.lookaheadIn(BitSet(COLON)))
               if isParams then commaSeparated(() => param())
-              else givenTypes(nparams, ofClass)
+              else givenTypes(true, nparams, ofClass)
           checkVarArgsRules(clause)
           clause
       }
@@ -2889,7 +2900,7 @@ object Parsers {
           val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
           params :: (if (lastClause) Nil else recur(firstClause = false, nparams + params.length, isGiven))
         else if isGiven then
-          val params = givenTypes(nparams, ofClass)
+          val params = givenTypes(false, nparams, ofClass)
           params :: recur(firstClause = false, nparams + params.length, isGiven)
         else Nil
       }
@@ -3186,7 +3197,7 @@ object Parsers {
     def selfInvocation(): Tree =
       atSpan(accept(THIS)) {
         possibleBracesStart()
-        argumentExprss(Apply(Ident(nme.CONSTRUCTOR), argumentExprs()))
+        argumentExprss(mkApply(Ident(nme.CONSTRUCTOR), argumentExprs()))
       }
 
     /** TypeDcl ::=  id [TypeParamClause] TypeBounds [‘=’ Type]

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -135,27 +135,27 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     def toTextTuple(args: List[Type]): Text =
       "(" ~ argsText(args) ~ ")"
 
-    def toTextFunction(args: List[Type], isContextual: Boolean, isErased: Boolean): Text =
+    def toTextFunction(args: List[Type], isGiven: Boolean, isErased: Boolean): Text =
       changePrec(GlobalPrec) {
         val argStr: Text =
           if args.length == 2
              && !defn.isTupleType(args.head)
-             && !isContextual && !isErased
+             && !isGiven && !isErased
           then
             atPrec(InfixPrec) { argText(args.head) }
           else
             "("
-            ~ (keywordText("given ") provided isContextual)
-            ~ (keywordText("erased ") provided isErased)
+            ~ keywordText("given ").provided(isGiven)
+            ~ keywordText("erased ").provided(isErased)
             ~ argsText(args.init)
             ~ ")"
         argStr ~ " => " ~ argText(args.last)
       }
 
     def toTextDependentFunction(appType: MethodType): Text =
       "("
-      ~ (keywordText("given ") provided appType.isImplicitMethod)
-      ~ (keywordText("erased ") provided appType.isErasedMethod)
+      ~ keywordText("given ").provided(appType.isImplicitMethod)
+      ~ keywordText("erased ").provided(appType.isErasedMethod)
       ~ paramsText(appType)
       ~ ") => "
       ~ toText(appType.resultType)
@@ -247,8 +247,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case _ => toTextGlobal(args, ", ")
         }
         "[applied to ("
-        ~ (Str("given ") provided tp.isContextualMethod)
-        ~ (Str("erased ") provided tp.isErasedMethod)
+        ~ keywordText("given ").provided(tp.isContextualMethod)
+        ~ keywordText("erased ").provided(tp.isErasedMethod)
         ~ argsText
         ~ ") returning "
         ~ toText(resultType)
@@ -343,8 +343,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         case id :: Nil => toText(id)
         case _ => "{" ~ Text(selectors map selectorText, ", ") ~ "}"
       }
-      (keywordText("given ") provided givenOnly) ~
-      toTextLocal(expr) ~ "." ~ selectorsText
+      keywordText("given ").provided(givenOnly)
+      ~ toTextLocal(expr) ~ "." ~ selectorsText
     }
 
     tree match {
@@ -383,13 +383,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           keywordStr("'{") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
         else if (!printDebug && fun.hasType && fun.symbol == defn.InternalQuoted_exprSplice)
           keywordStr("${") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
-        else if (app.isGivenApply && !homogenizedView)
-          changePrec(InfixPrec) {
-            toTextLocal(fun) ~ " given " ~
-            (if (args.length == 1) toTextLocal(args.head) else "(" ~ toTextGlobal(args, ", ") ~ ")")
-          }
         else
-          toTextLocal(fun) ~ "(" ~ toTextGlobal(args, ", ") ~ ")"
+          toTextLocal(fun)
+          ~ "("
+          ~ keywordText("given ").provided(app.isGivenApply && !homogenizedView)
+          ~ toTextGlobal(args, ", ")
+          ~ ")"
       case tree: TypeApply =>
         typeApplyText(tree)
       case Literal(c) =>
@@ -493,7 +492,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (lo eq hi) optText(lo)(" = " ~ _)
         else optText(lo)(" >: " ~ _) ~ optText(hi)(" <: " ~ _)
       case Bind(name, body) =>
-        ("given ": Text).provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.Type in quote patterns (not pickled)
+        keywordText("given ").provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.Type in quote patterns (not pickled)
         changePrec(InfixPrec) { toText(name) ~ " @ " ~ toText(body) }
       case Alternative(trees) =>
         changePrec(OrPrec) { toText(trees, " | ") }
@@ -560,12 +559,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         toText(id) ~ "\"" ~ Text(segments map segmentText, "") ~ "\""
       case Function(args, body) =>
         var implicitSeen: Boolean = false
-        var contextual: Boolean = false
+        var isGiven: Boolean = false
         var isErased: Boolean = false
         def argToText(arg: Tree) = arg match {
           case arg @ ValDef(name, tpt, _) =>
             val implicitText =
-              if ((arg.mods.is(Given))) { contextual = true; "" }
+              if ((arg.mods.is(Given))) { isGiven = true; "" }
               else if ((arg.mods.is(Erased))) { isErased = true; "" }
               else if ((arg.mods.is(Implicit)) && !implicitSeen) { implicitSeen = true; keywordStr("implicit ") }
               else ""
@@ -575,13 +574,14 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
         val argsText = args match {
           case (arg @ ValDef(_, tpt, _)) :: Nil if tpt.isEmpty => argToText(arg)
-          case _ => "(" ~ Text(args map argToText, ", ") ~ ")"
-        }
-        changePrec(GlobalPrec) {
-          (keywordText("given ") provided contextual) ~
-          (keywordText("erased ") provided isErased) ~
-          argsText ~ " => " ~ toText(body)
+          case _ =>
+            "("
+            ~ keywordText("given ").provided(isGiven)
+            ~ keywordText("erased ").provided(isErased)
+            ~ Text(args.map(argToText), ", ")
+            ~ ")"
         }
+        argsText ~ " => " ~ toText(body)
       case PolyFunction(targs, body) =>
         val targsText = "[" ~ Text(targs.map((arg: Tree) => toText(arg)), ", ") ~ "]"
         changePrec(GlobalPrec) {
@@ -761,6 +761,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       txt ~
       (Str(" given ") provided params.nonEmpty && params.head.mods.is(Given)) ~
       paramsText(params))
+
   protected def valDefToText[T >: Untyped](tree: ValDef[T]): Text = {
     import untpd.{modsDeco => _}
     dclTextOr(tree) {
@@ -770,7 +771,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     }
   }
 
-  private def paramsText[T>: Untyped](params: List[ValDef[T]]) = "(" ~ toText(params, ", ") ~ ")"
+  private def paramsText[T>: Untyped](params: List[ValDef[T]]) =
+    "("
+    ~ keywordText("given ").provided(params.nonEmpty && params.head.mods.is(Given))
+    ~ toText(params, ", ")
+    ~ ")"
 
   protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
     import untpd.{modsDeco => _}

compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala

@@ -36,10 +36,10 @@ class CheckReentrant extends MiniPhase {
   private[this] var seen: Set[ClassSymbol] = Set()
   private[this] var indent: Int = 0
 
-  private val sharableAnnot = new CtxLazy(given ctx =>
-    ctx.requiredClass("scala.annotation.internal.sharable"))
-  private val unsharedAnnot = new CtxLazy(given ctx =>
-    ctx.requiredClass("scala.annotation.internal.unshared"))
+  private val sharableAnnot = new CtxLazy(
+    summon[Context].requiredClass("scala.annotation.internal.sharable"))
+  private val unsharedAnnot = new CtxLazy(
+    summon[Context].requiredClass("scala.annotation.internal.unshared"))
 
   def isIgnored(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.hasAnnotation(sharableAnnot()) ||

compiler/test-resources/repl/3932

@@ -1,2 +1,2 @@
-scala> def fun[T](x: T): given List[T] => Int = ???
-def fun[T](x: T): given List[T] => Int
+scala> def fun[T](x: T): (given List[T]) => Int = ???
+def fun[T](x: T): (given List[T]) => Int

docs/docs/internals/syntax.md

@@ -311,7 +311,7 @@ DefParamClause    ::=  [nl] ‘(’ DefParams ‘)’
 GivenParamClause  ::=  ‘(’ ‘given’ (DefParams | GivenTypes) ‘)’
 DefParams         ::=  DefParam {‘,’ DefParam}
 DefParam          ::=  {Annotation} [‘inline’] Param                            ValDef(mods, id, tpe, expr) -- point of mods at id.
-GivenTypes        ::=  AnnotType {‘,’ AnnotType}
+GivenTypes        ::=  Type {‘,’ Type}
 ClosureMods       ::=  { ‘implicit’ | ‘given’}
 ```
 

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

@@ -4,7 +4,7 @@ import given scala.quoted.autolift._
 object Macros {
 
   inline def foo(i: => Int): Int = ${ fooImpl('i) }
-  def fooImpl(i: Expr[Int]) given QuoteContext: Expr[Int] = {
+  def fooImpl(i: Expr[Int])(given QuoteContext): Expr[Int] = {
     given Toolbox = Toolbox.make(getClass.getClassLoader)
     val y: Int = run(i)
     y

tests/generic-java-signatures/i3653.scala

@@ -5,7 +5,7 @@ class Foo {
      c0: T, c1: T, c2: T, c3: T, c4: T, c5: T, c6: T, c7: T, c8: T, c9: T) => 0
 
   // #6946
-  def baz = (x: (given String) => Unit) => x given ""
+  def baz = (x: (given String) => Unit) => x(given "")
 }
 
 object Test {

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

@@ -1,6 +1,6 @@
 import scala.quoted.QuoteContext
 
-def test given QuoteContext = {
+def test(given QuoteContext) = {
   val x = '{0}
   val y = '{ // error: Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.
     $x

tests/neg-macros/delegate-match-1/Macro_1.scala

@@ -3,7 +3,7 @@ import scala.quoted.matching._
 
 inline def f: Any = ${ fImpl }
 
-private def fImpl given (qctx: QuoteContext): Expr[Unit] = {
+private def fImpl(given qctx: QuoteContext): Expr[Unit] = {
   import qctx.tasty._
   searchImplicit(('[A]).unseal.tpe) match {
     case IsImplicitSearchSuccess(x) =>