Drop given parameter syntax

Author: odersky

community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala

@@ -47,7 +47,7 @@ sealed trait CommunityProject:
   /** Is this project running in the test or update mode in the
    *  context of the given suite? @see `run` for more details.
    */
-  final def isUpdateMode(given suite: CommunityBuildTest) =
+  final def isUpdateMode(using suite: CommunityBuildTest) =
     suite.isInstanceOf[CommunityBuildUpdate]
 
   /** Depending on the mode of operation, either
@@ -60,7 +60,7 @@ sealed trait CommunityProject:
    *  and avoid network overhead. See https://github.com/lampepfl/dotty-drone
    *  for more infrastructural details.
    */
-  final def run()(given suite: CommunityBuildTest) =
+  final def run()(using suite: CommunityBuildTest) =
     val runCmd = if isUpdateMode then updateCommand else testCommand
     if !isUpdateMode then dependencies.foreach(_.publish())
     suite.test(project, binaryName, runCommandsArgs :+ runCmd)

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

@@ -917,7 +917,7 @@ object Parsers {
     def followingIsParamOrGivenType() =
       val lookahead = in.LookaheadScanner()
       lookahead.nextToken()
-      if startParamOrGivenTypeTokens.contains(lookahead.token)
+      if startParamTokens.contains(lookahead.token)
          || lookahead.isIdent(nme.using)
       then true
       else if lookahead.token == IDENTIFIER then
@@ -1450,8 +1450,6 @@ object Parsers {
         case MATCH => matchType(t)
         case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
         case _ =>
-          if (imods.isOneOf(GivenOrImplicit) && !t.isInstanceOf[FunctionWithMods])
-            syntaxError(ImplicitTypesCanOnlyBeFunctionTypes(), implicitKwPos(start))
           if (imods.is(Erased) && !t.isInstanceOf[FunctionWithMods])
             syntaxError(ErasedTypesCanOnlyBeFunctionTypes(), implicitKwPos(start))
           t
@@ -2299,7 +2297,7 @@ object Parsers {
     def parArgumentExprs(): (List[Tree], Boolean) = inParens {
       if in.token == RPAREN then
         (Nil, false)
-      else if in.token == GIVEN || isIdent(nme.using) then
+      else if isIdent(nme.using) then
         in.nextToken()
         (commaSeparated(argumentExpr), true)
       else
@@ -2786,7 +2784,7 @@ object Parsers {
       normalize(loop(start))
     }
 
-    val funTypeArgMods: BitSet = BitSet(GIVEN, ERASED)
+    val funTypeArgMods: BitSet = BitSet(ERASED)
 
     /** Wrap annotation or constructor in New(...).<init> */
     def wrapNew(tpt: Tree): Select = Select(New(tpt), nme.CONSTRUCTOR)
@@ -2912,7 +2910,7 @@ object Parsers {
       def paramMods() =
         if in.token == IMPLICIT then addParamMod(() => Mod.Implicit())
         else
-          if in.token == GIVEN || isIdent(nme.using) then addParamMod(() => Mod.Given())
+          if isIdent(nme.using) then addParamMod(() => Mod.Given())
           if in.token == ERASED then addParamMod(() => Mod.Erased())
 
       def param(): ValDef = {

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

@@ -257,7 +257,7 @@ object Tokens extends TokensCommon {
     AT, CASE)
 
   final val canEndStatTokens: TokenSet = atomicExprTokens | BitSet(
-    TYPE, GIVEN, RPAREN, RBRACE, RBRACKET, OUTDENT)
+    TYPE, GIVEN, RPAREN, RBRACE, RBRACKET, OUTDENT) // TODO: remove GIVEN once old import syntax is dropped
 
   /** Tokens that stop a lookahead scan search for a `<-`, `then`, or `do`.
    *  Used for disambiguating between old and new syntax.
@@ -280,12 +280,6 @@ object Tokens extends TokensCommon {
    */
   final val startParamTokens: BitSet = modifierTokens | BitSet(VAL, VAR, AT)
 
-  /** Faced with the choice of a type `(...)` or a parameter or given type list
-   *  in `(...)`, the following tokens after the opening `(` determine it's
-   *  a parameter or given type list.
-   */
-  final val startParamOrGivenTypeTokens: BitSet = startParamTokens | BitSet(GIVEN, ERASED)
-
   final val scala3keywords = BitSet(ENUM, ERASED, GIVEN)
 
   final val softModifierNames = Set(nme.inline, nme.opaque, nme.open)

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.scala

@@ -150,7 +150,7 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     UnknownNamedEnclosingClassOrObjectID,
     IllegalCyclicTypeReferenceID,
     MissingTypeParameterInTypeAppID,
-    ImplicitTypesCanOnlyBeFunctionTypesID,
+    UNUSED_ImplicitTypesCanOnlyBeFunctionTypesID,
     ErasedTypesCanOnlyBeFunctionTypesID,
     CaseClassMissingNonImplicitParamListID,
     EnumerationsShouldNotBeEmptyID,

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -2376,17 +2376,10 @@ object messages {
       """.stripMargin
     }
 
-    case class IllegalCyclicTypeReference(sym: Symbol, where: String, lastChecked: Type)(implicit val ctx: Context)
-      extends Message(IllegalCyclicTypeReferenceID) {
-      val kind: String = "Cyclic"
-      val msg: String = i"illegal cyclic type reference: ${where} ${hl(lastChecked.show)} of $sym refers back to the type itself"
-      val explanation: String = ""
-    }
-
-  case class ImplicitTypesCanOnlyBeFunctionTypes()(implicit val ctx: Context) // TODO remove when (given ...) => is removed
-    extends Message(ImplicitTypesCanOnlyBeFunctionTypesID) {
-    val kind: String = "Syntax"
-    val msg: String = "Types with given keyword can only be function types `(given ...) => ...`"
+  case class IllegalCyclicTypeReference(sym: Symbol, where: String, lastChecked: Type)(implicit val ctx: Context)
+    extends Message(IllegalCyclicTypeReferenceID) {
+    val kind: String = "Cyclic"
+    val msg: String = i"illegal cyclic type reference: ${where} ${hl(lastChecked.show)} of $sym refers back to the type itself"
     val explanation: String = ""
   }
 

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -17,8 +17,8 @@ import java.nio.file.Paths
 
 import PartialFunction.condOpt
 
-import ast.untpd.given
-import NameOps.given
+import ast.untpd.{given _}
+import NameOps.{given _}
 
 import scala.annotation.{ threadUnsafe => tu, tailrec }
 
@@ -28,8 +28,8 @@ import scala.annotation.{ threadUnsafe => tu, tailrec }
  *  TODO: Also extract type information
  */
 class ExtractSemanticDB extends Phase with
-  import Scala3.{_, given}
-  import Symbols.given
+  import Scala3.{_, given _}
+  import Symbols.{given _}
 
   override val phaseName: String = ExtractSemanticDB.name
 

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -863,7 +863,7 @@ trait Applications extends Compatibility {
                 new ApplyToTyped(tree, fun1, funRef, proto.typedArgs(), pt)
               else
                 new ApplyToUntyped(tree, fun1, funRef, proto, pt)(
-                  given fun1.nullableInArgContext(using argCtx(tree)))
+                  using fun1.nullableInArgContext(using argCtx(tree)))
             convertNewGenericArray(
               postProcessByNameArgs(funRef, app.result).computeNullable())
           case _ =>

compiler/src/dotty/tools/dotc/typer/ImportSuggestions.scala

@@ -184,7 +184,7 @@ trait ImportSuggestions with
         try
           timer.schedule(task, testOneImplicitTimeOut)
           typedImplicit(candidate, expectedType, argument, span)(
-            given ctx.fresh.setExploreTyperState()).isSuccess
+            using ctx.fresh.setExploreTyperState()).isSuccess
         finally
           if task.cancel() then // timer task has not run yet
             assert(!ctx.run.isCancelled)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1232,8 +1232,8 @@ class Typer extends Namer
 
     val pat1 = typedPattern(tree.pat, wideSelType)(gadtCtx)
     caseRest(pat1)(
-      given Nullables.caseContext(sel, pat1)(
-        given gadtCtx.fresh.setNewScope))
+      using Nullables.caseContext(sel, pat1)(
+        using gadtCtx.fresh.setNewScope))
   }
 
   def typedLabeled(tree: untpd.Labeled)(implicit ctx: Context): Labeled = {
@@ -2345,7 +2345,7 @@ class Typer extends Namer
             // in preceding statements (unless the DefTree is completed ahead of time,
             // then it is impossible).
             sym.info = Completer(completer.original)(
-              given completer.creationContext.withNotNullInfos(ctx.notNullInfos))
+              using completer.creationContext.withNotNullInfos(ctx.notNullInfos))
           true
         case _ =>
           // If it has been completed, then it must be because there is a forward reference

compiler/test-resources/repl/defs

@@ -10,5 +10,5 @@ scala> def id(x: 4): 4 = x
 def id(x: 4): 4
 scala> id(4)
 val res0: Int = 4
-scala> def f(given Int) = 1
-def f(given x$1: Int): Int
+scala> def f(using Int) = 1
+def f(using x$1: Int): Int

compiler/test-resources/repl/erased-implicit

@@ -1,2 +1,2 @@
-scala> def f(given erased a: Int): Int = ???
-def f(given erased a: Int): Int
+scala> def f(using erased a: Int): Int = ???
+def f(using erased a: Int): Int

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -1685,23 +1685,10 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertEquals("List[X]", lastChecked.show)
     }
 
-  @Test def implicitTypesCanOnlyBeFunctionTypesSuccess() =
-    checkMessagesAfter(RefChecks.name) ("def foo(f: (given Int) => Int): Int = 1")
-    .expectNoErrors
-
   @Test def erasedTypesCanOnlyBeFunctionTypesSuccess() =
     checkMessagesAfter(FrontEnd.name) ("def foo(f: (erased Int) => Int): Int = 1")
       .expectNoErrors
 
-  @Test def implicitTypesCanOnlyBeFunctionTypesFailed() =
-    checkMessagesAfter(FrontEnd.name) ("def foo(f: (given Int)): Int = 1")
-      .expect { (ictx, messages) =>
-        implicit val ctx: Context = ictx
-        assertMessageCount(1, messages)
-        val ImplicitTypesCanOnlyBeFunctionTypes() :: Nil = messages
-        assertEquals("Types with given keyword can only be function types `(given ...) => ...`", messages.head.msg)
-      }
-
   @Test def erasedTypesCanOnlyBeFunctionTypesFailed() =
     checkMessagesAfter(FrontEnd.name) ("def foo(f: (erased Int)): Int = 1")
       .expect { (ictx, messages) =>
@@ -1726,11 +1713,11 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       }
 
   @Test def caseClassMissingNonImplicitParamListSuccessful =
-    checkMessagesAfter(FrontEnd.name) ("case class Test()(given foo: String)")
+    checkMessagesAfter(FrontEnd.name) ("case class Test()(using foo: String)")
       .expectNoErrors
 
   @Test def caseClassMissingNonImplicitParamListFailed =
-    checkMessagesAfter(FrontEnd.name) ("case class Test(given foo: String)")
+    checkMessagesAfter(FrontEnd.name) ("case class Test(using foo: String)")
       .expect {
         (ictx, messages) =>
           implicit val ctx: Context = ictx

docs/docs/reference/changed-features/numeric-literals.md

@@ -201,7 +201,7 @@ no code that can be executed at runtime. That's why we define an intermediary cl
 method in the `FromDigits` given instance. That method is defined in terms of a macro
 implementation method `fromDigitsImpl`. Here is its definition:
 ```scala
-  private def fromDigitsImpl(digits: Expr[String])(given ctx: QuoteContext): Expr[BigFloat] =
+  private def fromDigitsImpl(digits: Expr[String])(using ctx: QuoteContext): Expr[BigFloat] =
     digits match {
       case Const(ds) =>
         try {

docs/docs/reference/contextual/derivation-macro.md

@@ -25,7 +25,7 @@ we need to implement a method `Eq.derived` on the companion object of `Eq` that
 produces a quoted instance for `Eq[T]`. Here is a possible signature,
 
 ```scala
-given derived[T: Type](given qctx: QuoteContext): Expr[Eq[T]]
+given derived[T: Type](using qctx: QuoteContext): Expr[Eq[T]]
 ```
 
 and for comparison reasons we give the same signature we had with `inline`:
@@ -41,10 +41,10 @@ from the signature. The body of the `derived` method is shown below:
 
 
 ```scala
-given derived[T: Type](given qctx: QuoteContext): Expr[Eq[T]] = {
+given derived[T: Type](using qctx: QuoteContext): Expr[Eq[T]] = {
   import qctx.tasty.{_, given}
 
-  val ev: Expr[Mirror.Of[T]] = summonExpr(given '[Mirror.Of[T]]).get
+  val ev: Expr[Mirror.Of[T]] = summonExpr(using '[Mirror.Of[T]]).get
 
   ev match {
     case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = $elementTypes }} =>
@@ -91,10 +91,10 @@ The implementation of `summonAll` as a macro can be show below assuming that we
 have the given instances for our primitive types:
 
 ```scala
-  def summonAll[T](t: Type[T])(given qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
+  def summonAll[T](t: Type[T])(using qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
     case '[String *: $tpes] => '{ summon[Eq[String]] }  :: summonAll(tpes)
     case '[Int *: $tpes]    => '{ summon[Eq[Int]] }     :: summonAll(tpes)
-    case '[$tpe *: $tpes]   => derived(given tpe, qctx) :: summonAll(tpes)
+    case '[$tpe *: $tpes]   => derived(using tpe, qctx) :: summonAll(tpes)
     case '[Unit] => Nil
   }
 ```
@@ -120,7 +120,7 @@ Alternatively and what is shown below is that we can call the `eqv` method
 directly. The `eqGen` can trigger the derivation.
 
 ```scala
-inline def [T](x: =>T) === (y: =>T)(given eq: Eq[T]): Boolean = eq.eqv(x, y)
+inline def [T](x: =>T) === (y: =>T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
 
 implicit inline def eqGen[T]: Eq[T] = ${ Eq.derived[T] }
 ```
@@ -168,17 +168,17 @@ object Eq {
       def eqv(x: T, y: T): Boolean = body(x, y)
     }
 
-  def summonAll[T](t: Type[T])(given qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
+  def summonAll[T](t: Type[T])(using qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
     case '[String *: $tpes] => '{ summon[Eq[String]] }  :: summonAll(tpes)
     case '[Int *: $tpes]    => '{ summon[Eq[Int]] }     :: summonAll(tpes)
-    case '[$tpe *: $tpes]   => derived(given tpe, qctx) :: summonAll(tpes)
+    case '[$tpe *: $tpes]   => derived(using tpe, qctx) :: summonAll(tpes)
     case '[Unit] => Nil
   }
 
-  given derived[T: Type](given qctx: QuoteContext): Expr[Eq[T]] = {
+  given derived[T: Type](using qctx: QuoteContext): Expr[Eq[T]] = {
     import qctx.tasty.{_, given}
 
-    val ev: Expr[Mirror.Of[T]] = summonExpr(given '[Mirror.Of[T]]).get
+    val ev: Expr[Mirror.Of[T]] = summonExpr(using '[Mirror.Of[T]]).get
 
     ev match {
       case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = $elementTypes }} =>
@@ -216,7 +216,7 @@ object Eq {
 }
 
 object Macro3 {
-  inline def [T](x: =>T) === (y: =>T)(given eq: Eq[T]): Boolean = eq.eqv(x, y)
+  inline def [T](x: =>T) === (y: =>T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
 
   implicit inline def eqGen[T]: Eq[T] = ${ Eq.derived[T] }
 }

docs/docs/reference/metaprogramming/macros.md

@@ -713,7 +713,7 @@ private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using
       val argShowedExprs = argExprs.map {
         case '{ $arg: $tp } =>
           val showTp = '[Show[$tp]]
-          summonExpr(given showTp)) match {
+          summonExpr(using showTp)) match {
             case Some(showExpr) => '{ $showExpr.show($arg) }
             case None => qctx.error(s"could not find implicit for ${showTp.show}", arg); '{???}
           }

docs/docs/reference/other-new-features/quoted-pattern-spec.md

@@ -47,14 +47,14 @@ def notMatched = None
 def matched = Some(()) // aka Some(Tuple0())
 def matched[T](x: T) = Some(Tuple1(x))
 def (x: Matching) && (y: Matching) = if (x == None || y == None) None else Some(x.get ++ y.get)
-def fold[T](m: Mattching*)(given Env): Matching = m.fold(matched)(_ && _)
+def fold[T](m: Mattching*)(using Env): Matching = m.fold(matched)(_ && _)
 
 // `a =#= b` stands for `a` matches `b`
-def (scrutinee: Tree) =#= pattern: Tree)(given Env): Matching // described by cases in the tables below
+def (scrutinee: Tree) =#= pattern: Tree)(using Env): Matching // described by cases in the tables below
 
-def envWith(equiv: (Symbol, Symbol)*)(given Env): Env // Adds to the current environment the fact that s1 from the scrutinee is equivalent to s2 in the pattern
+def envWith(equiv: (Symbol, Symbol)*)(using Env): Env // Adds to the current environment the fact that s1 from the scrutinee is equivalent to s2 in the pattern
 
-def equivalent(s1: Symbol, s2: Symbol)(given Env): Env
+def equivalent(s1: Symbol, s2: Symbol)(using Env): Env
 ```
 
 The implementation of `=#=`

language-server/test/dotty/tools/languageserver/util/CodeTester.scala

@@ -237,7 +237,7 @@ class CodeTester(projects: List[Project]) {
 
   private def doAction(action: Action): this.type = {
     try {
-      action.execute()(given testServer, testServer.client, positions)
+      action.execute()(using testServer, testServer.client, positions)
     } catch {
       case ex: AssertionError =>
         val sourcesStr =
@@ -252,7 +252,7 @@ class CodeTester(projects: List[Project]) {
             |
             |$sourcesStr
             |
-            |while executing action: ${action.show(given positions)}
+            |while executing action: ${action.show(using positions)}
             |
           """.stripMargin
         val assertionError = new AssertionError(msg + ex.getMessage)

language-server/test/dotty/tools/languageserver/util/PositionContext.scala

@@ -24,5 +24,5 @@ class PositionContext(positionMap: Map[CodeMarker, (TestFile, Int, Int)]) {
 }
 
 object PositionContext {
-  type PosCtx[T] = (given PositionContext) => T
+  type PosCtx[T] = PositionContext ?=> T
 }

language-server/test/dotty/tools/languageserver/util/actions/Action.scala

@@ -11,7 +11,7 @@ import PositionContext._
  * definition, etc.)
  */
 trait Action {
-  type Exec[T] = (given TestServer, TestClient, PositionContext) => T
+  type Exec[T] = (TestServer, TestClient, PositionContext) ?=> T
 
   /** Execute the action. */
   def execute(): Exec[Unit]

sbt-dotty/sbt-test/sbt-dotty/quoted-example-project/src/main/scala/hello/Hello.scala

@@ -41,7 +41,7 @@ object Main {
     code
   }
 
-  def powerCode(n: Int, x: Expr[Double])(given QuoteContext): Expr[Double] =
+  def powerCode(n: Int, x: Expr[Double])(using QuoteContext): Expr[Double] =
     if (n == 0) '{1.0}
     else if (n == 1) x
     else if (n < 0) throw new Exception("Negative powers not implemented. Left as a small exercise. Dont be shy, try it out.")

sbt-dotty/sbt-test/source-dependencies/macro-expansion-dependencies-1/changes/Macro.scala

@@ -4,7 +4,7 @@ object Macro {
 
    inline def f(): Unit = ${ macroImplementation }
 
-   def macroImplementation(given QuoteContext): Expr[Unit] = {
+   def macroImplementation(using QuoteContext): Expr[Unit] = {
       '{ println("Implementation in Macro") }
    }
 

sbt-dotty/sbt-test/source-dependencies/macro-expansion-dependencies-1/changes/MacroCompileError.scala

@@ -4,7 +4,7 @@ object Macro {
 
    inline def f(): Unit = ${ macroImplementation }
 
-   def macroImplementation(given qctx: QuoteContext): Expr[Unit] = {
+   def macroImplementation(using qctx: QuoteContext): Expr[Unit] = {
       import qctx.tasty._
       error("some error", rootPosition)
       '{ println("Implementation in MacroCompileError") }