Replace delegate for by given as in compiler and tests.

Author: odersky

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

@@ -22,7 +22,7 @@ object Flags {
 
   type Flag = opaques.Flag
 
-  delegate FlagOps {
+  given FlagOps {
 
     def (x: FlagSet) bits: Long = opaques.toBits(x)
 

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -121,7 +121,7 @@ object Completion {
     if (buffer.mode != Mode.None) {
       path match {
         case Select(qual, _) :: _                    => buffer.addMemberCompletions(qual)
-        case Import(_, expr, _) :: _                 => buffer.addMemberCompletions(expr) // TODO: distinguish delegate from non-delegate
+        case Import(_, expr, _) :: _                 => buffer.addMemberCompletions(expr) // TODO: distinguish given from plain imports
         case (_: Thicket) :: Import(_, expr, _) :: _ => buffer.addMemberCompletions(expr)
         case _                                       => buffer.addScopeCompletions
       }

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

@@ -1206,7 +1206,7 @@ trait Implicits { self: Typer =>
           case fail: SearchFailureType =>
 
             def hiddenImplicitNote(s: SearchSuccess) =
-              em"\n\nNote: delegate ${s.ref.symbol.showLocated} was not considered because it was not imported with `import delegate`."
+              em"\n\nNote: given instance ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
 
             def FindHiddenImplicitsCtx(ctx: Context): Context =
               if (ctx == NoContext) ctx

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

@@ -28,7 +28,7 @@ object ImportInfo {
  *  @param   selectors     The selector clauses
  *  @param   symNameOpt    Optionally, the name of the import symbol. None for root imports.
  *                         Defined for all explicit imports from ident or select nodes.
- *  @param   importGiven true if this is a delegate import
+ *  @param   importGiven   true if this is a given import
  *  @param   isRootImport  true if this is one of the implicit imports of scala, java.lang,
  *                         scala.Predef or dotty.DottyPredef in the start context, false otherwise.
  */

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

@@ -949,7 +949,7 @@ class Namer { typer: Typer =>
 
         def whyNoForwarder(mbr: SingleDenotation): String = {
           val sym = mbr.symbol
-          if (sym.isOneOf(GivenOrImplicit) != exp.impliedOnly) s"is ${if (exp.impliedOnly) "not " else ""}a delegate"
+          if (sym.isOneOf(GivenOrImplicit) != exp.impliedOnly) s"is ${if (exp.impliedOnly) "not " else ""}a given instance"
           else if (!sym.isAccessibleFrom(path.tpe)) "is not accessible"
           else if (sym.isConstructor || sym.is(ModuleClass) || sym.is(Bridge)) SKIP
           else if (cls.derivesFrom(sym.owner) &&

compiler/test/dotty/tools/repl/ReplCompilerTests.scala

@@ -129,7 +129,7 @@ class ReplCompilerTests extends ReplTest {
   }
 
   @Test def i5897 =
-    fromInitialState { implicit state => run("delegate for Int = 10") }
+    fromInitialState { implicit state => run("given as Int = 10") }
     .andThen         { implicit state =>
       assertEquals(
         "def Int_given: Int",
@@ -151,7 +151,7 @@ class ReplCompilerTests extends ReplTest {
         |  def (x: T) > (y: T) = compare(x, y) > 0
         |}
         |
-        |delegate IntOrd for Ord[Int] {
+        |given IntOrd as Ord[Int] {
         |  def compare(x: Int, y: Int) =
         |  if (x < y) -1 else if (x > y) +1 else 0
         |}

library/src/scala/Eql.scala

@@ -16,7 +16,7 @@ object Eql {
   object derived extends Eql[Any, Any]
 
   /** A fall-back instance to compare values of any types.
-   *  Even though this method is not declared a delegate, the compiler will
+   *  Even though this method is not declared as given, the compiler will
    *  synthesize implicit arguments as solutions to `Eql[T, U]` queries if
    *  the rules of multiversal equality require it.
    */

library/src/scala/quoted/Liftable.scala

@@ -17,15 +17,15 @@ trait Liftable[T] {
  */
 object Liftable {
 
-  delegate Liftable_Boolean_delegate for Liftable[Boolean] = new PrimitiveLiftable
-  delegate Liftable_Byte_delegate for Liftable[Byte] = new PrimitiveLiftable
-  delegate Liftable_Short_delegate for Liftable[Short] = new PrimitiveLiftable
-  delegate Liftable_Int_delegate for Liftable[Int] = new PrimitiveLiftable
-  delegate Liftable_Long_delegate for Liftable[Long] = new PrimitiveLiftable
-  delegate Liftable_Float_delegate for Liftable[Float] = new PrimitiveLiftable
-  delegate Liftable_Double_delegate for Liftable[Double] = new PrimitiveLiftable
-  delegate Liftable_Char_delegate for Liftable[Char] = new PrimitiveLiftable
-  delegate Liftable_String_delegate for Liftable[String] = new PrimitiveLiftable
+  given Liftable_Boolean_delegate as Liftable[Boolean] = new PrimitiveLiftable
+  given Liftable_Byte_delegate as Liftable[Byte] = new PrimitiveLiftable
+  given Liftable_Short_delegate as Liftable[Short] = new PrimitiveLiftable
+  given Liftable_Int_delegate as Liftable[Int] = new PrimitiveLiftable
+  given Liftable_Long_delegate as Liftable[Long] = new PrimitiveLiftable
+  given Liftable_Float_delegate as Liftable[Float] = new PrimitiveLiftable
+  given Liftable_Double_delegate as Liftable[Double] = new PrimitiveLiftable
+  given Liftable_Char_delegate as Liftable[Char] = new PrimitiveLiftable
+  given Liftable_String_delegate as Liftable[String] = new PrimitiveLiftable
 
   private class PrimitiveLiftable[T <: Unit | Null | Int | Boolean | Byte | Short | Int | Long | Float | Double | Char | String] extends Liftable[T] {
     /** Lift a primitive value `n` into `'{ n }` */

library/src/scala/quoted/Type.scala

@@ -17,15 +17,15 @@ package quoted {
 
   /** Some basic type tags, currently incomplete */
   object Type {
-    delegate UnitTag for Type[Unit] = new TaggedType[Unit]
-    delegate BooleanTag for Type[Boolean] = new TaggedType[Boolean]
-    delegate ByteTag for Type[Byte] = new TaggedType[Byte]
-    delegate CharTag for Type[Char] = new TaggedType[Char]
-    delegate ShortTag for Type[Short] = new TaggedType[Short]
-    delegate IntTag for Type[Int] = new TaggedType[Int]
-    delegate LongTag for Type[Long] = new TaggedType[Long]
-    delegate FloatTag for Type[Float] = new TaggedType[Float]
-    delegate DoubleTag for Type[Double] = new TaggedType[Double]
+    given UnitTag as Type[Unit] = new TaggedType[Unit]
+    given BooleanTag as Type[Boolean] = new TaggedType[Boolean]
+    given ByteTag as Type[Byte] = new TaggedType[Byte]
+    given CharTag as Type[Char] = new TaggedType[Char]
+    given ShortTag as Type[Short] = new TaggedType[Short]
+    given IntTag as Type[Int] = new TaggedType[Int]
+    given LongTag as Type[Long] = new TaggedType[Long]
+    given FloatTag as Type[Float] = new TaggedType[Float]
+    given DoubleTag as Type[Double] = new TaggedType[Double]
   }
 
 }

library/src/scala/tasty/reflect/TreeUtils.scala

@@ -286,7 +286,7 @@ trait TreeUtils
   /** Bind the `rhs` to a `val` and use it in `body` */
   def let(rhs: Term)(body: Ident => Term): Term = {
     import scala.quoted.QuoteContext
-    delegate for QuoteContext = new QuoteContext(this)
+    given as QuoteContext = new QuoteContext(this)
     type T // TODO probably it is better to use the Sealed contruct rather than let the user create their own existential type
     implicit val rhsTpe: quoted.Type[T] = rhs.tpe.seal.asInstanceOf[quoted.Type[T]]
     val rhsExpr = rhs.seal.cast[T]

library/src/scalaShadowing/language.scala

@@ -107,7 +107,7 @@ object language {
    *  }}}
    *
    *  Implicit values of other types are not affected, and neither are implicit
-   *  classes. In particular, delegates of the scala.Conversion class can be
+   *  classes. In particular, given instances of the scala.Conversion class can be
    *  defined without having to import the language feature.
    *
    *  The language import is also required to enable _uses_ of implicit conversions
@@ -119,13 +119,13 @@ object language {
    *      class A
    *      class B
    *      object B {
-   *        delegate a2b for Conversion[A, B] { ... }
+   *        given a2b as Conversion[A, B] { ... }
    *      }
    *      object C {
-   *        delegate b2a for Conversion[B, A] { ... }
+   *        given b2a as Conversion[B, A] { ... }
    *      }
-   *      import delegate B._
-   *      import delegate C._
+   *      import given B._
+   *      import given C._
    *      val x: A = new B     // language import required
    *      val x: B = new A     // no import necessary since a2b is co-defined with B
    *  }}}

tests/neg-custom-args/conditionalWarnings.scala

@@ -3,7 +3,7 @@
 object Test {
   @deprecated def foo = ???
 
-  delegate for Conversion[String, Int] = _.length
+  given as Conversion[String, Int] = _.length
 
   foo    // error
 

tests/neg-custom-args/implicit-conversions.scala

@@ -3,25 +3,25 @@ class B
 
 object A {
 
-  delegate for Conversion[A, B] {
+  given as Conversion[A, B] {
     def apply(x: A): B = ???
   }
 
-  delegate for Conversion[B, A] {
+  given as Conversion[B, A] {
     def apply(x: B): A = ???
   }
 }
 
 class C
 
 object D {
-  delegate for Conversion[A, C] {
+  given as Conversion[A, C] {
     def apply(x: A): C = ???
   }
 }
 
 object Test {
-  import delegate D._
+  import given D._
 
   val x1: A = new B
   val x2: B = new A  // error under -Xfatal-warnings -feature

tests/neg/cannot-reduce-delegate-match.scala

@@ -6,7 +6,7 @@ object Test {
     }
 
   {
-    delegate for Int = 9
+    given as Int = 9
     bar()
   }
 

tests/neg/derive-eq.scala

@@ -2,7 +2,7 @@
 case class One() derives Eql
 case class Two() derives Eql
 
-delegate for Eql[One, Two] = Eql.derived
+given as Eql[One, Two] = Eql.derived
 
 enum Lst[T] derives Eql {
   case Cons(x: T, xs: Lst[T])

tests/neg/exports.check

@@ -11,12 +11,12 @@
 25 |    export printUnit.bitmap         // error: no eligible member
    |                     ^^^^^^
    |                     no eligible member bitmap at this.printUnit
-   |                     this.printUnit.bitmap cannot be exported because it is a delegate
--- Error: tests/neg/exports.scala:26:30 --------------------------------------------------------------------------------
-26 |    export delegate printUnit.status // error: no eligible member
-   |                              ^^^^^^
-   |                              no eligible member status at this.printUnit
-   |                              this.printUnit.status cannot be exported because it is not a delegate
+   |                     this.printUnit.bitmap cannot be exported because it is a given instance
+-- Error: tests/neg/exports.scala:26:27 --------------------------------------------------------------------------------
+26 |    export given printUnit.status   // error: no eligible member
+   |                           ^^^^^^
+   |                           no eligible member status at this.printUnit
+   |                           this.printUnit.status cannot be exported because it is not a given instance
 -- [E120] Duplicate Symbol Error: tests/neg/exports.scala:23:33 --------------------------------------------------------
 23 |    export printUnit.{stat => _, _} // error: double definition
    |                                 ^

tests/neg/exports.scala

@@ -5,7 +5,7 @@
     type PrinterType
     def print(bits: BitMap): Unit = ???
     def status: List[String] = ???
-    delegate bitmap for BitMap
+    given bitmap as BitMap
   }
 
   class Scanner {
@@ -23,7 +23,7 @@
     export printUnit.{stat => _, _} // error: double definition
     export scanUnit._               // error: double definition
     export printUnit.bitmap         // error: no eligible member
-    export delegate printUnit.status // error: no eligible member
+    export given printUnit.status   // error: no eligible member
 
     def status: List[String] = printUnit.status ++ scanUnit.status
   }

tests/neg/extmethod-overload.scala

@@ -1,8 +1,8 @@
 object Test {
-  delegate A {
+  given A {
     def (x: Int) |+| (y: Int) = x + y
   }
-  delegate B {
+  given B {
     def (x: Int) |+| (y: String) = x + y.length
   }
   assert((1 |+| 2) == 3)  // error ambiguous

tests/neg/i5455.scala

@@ -11,7 +11,7 @@ object Library {
     def toInt(n: Nat): Int = n
 
   }
-  delegate NatOps {
+  given NatOps {
     def (x: Nat) * (y: Nat): Nat = x * y
     def (x: Nat) toInt: Int = x
   }

tests/neg/implicit-params.scala

@@ -11,8 +11,8 @@ object Test {
 
   def h(x: Int) given () = x // error
 
-  delegate C for C(11)
-  delegate D for D(11)
+  given C as C(11)
+  given D as D(11)
 
   f(1)
   f(1) given C

tests/neg/implied-for.scala

@@ -3,13 +3,13 @@ class B extends T
 class C extends T
 
 object A {
-  delegate b for B
-  delegate c for C
+  given b as B
+  given c as C
 }
 
 object Test extends App {
   import A._
-  import delegate A.{for B}
+  import given A.{for B}
 
   val x: B = b // OK
   println(c) // error: not found

tests/neg/import-implied.scala

@@ -1,6 +1,6 @@
 class TC
 object A {
-  delegate tc for TC
+  given tc as TC
   def foo given TC = ()
 }
 object B {
@@ -11,19 +11,19 @@ object B {
 }
 object C {
   import A._
-  import delegate A.tc
+  import given A.tc
   foo            // ok
   foo given tc   // ok
 }
 object D {
   import A.foo
-  import delegate A._
+  import given A._
   foo            // ok
   foo given tc   // ok
 }
 object E {
   import A._
-  import delegate A._
+  import given A._
   foo            // ok
   foo given tc   // ok
 }

tests/neg/machine-state-encoding-with-implicit-match.scala

@@ -7,13 +7,13 @@ final class Off extends State
 @implicitNotFound("State must be Off")
 class IsOff[S <: State]
 object IsOff {
-  delegate isOff for IsOff[Off] = new IsOff[Off]
+  given isOff as IsOff[Off] = new IsOff[Off]
 }
 
 @implicitNotFound("State must be On")
 class IsOn[S <: State]
 object IsOn {
-  delegate isOn for IsOn[On] = new IsOn[On]
+  given isOn as IsOn[On] = new IsOn[On]
 }
 
 class Machine[S <: State] {

tests/neg/overloading-specifity.scala

@@ -12,7 +12,7 @@ object Generic {
 
 object Test extends App {
   trait Context
-  //delegate ctx for Context
+  //given ctx as Context
 
   object a {
     def foo[T](implicit gen: Generic): Show[T] = new Show[T](1)

tests/new/test.scala

@@ -4,10 +4,10 @@ trait T {
 
 object Test0 {
   trait A[T]
-  delegate a[T] for A[T]
+  given a[T] as A[T]
 
   class B[T]
-  delegate b[T] for B[T]
+  given b[T] as B[T]
 }
 
 class C extends T

tests/pos-macros/i6803b/Macro_1.scala

@@ -8,7 +8,7 @@ object AsObject {
   final class LineNo(val lineNo: Int)
   object LineNo {
     def unsafe(i: Int): LineNo = new LineNo(i)
-    inline delegate x for LineNo = ${impl}
+    inline given x as LineNo = ${impl}
     private def impl given (qctx: QuoteContext): Expr[LineNo] = {
       import qctx.tasty._
       '{unsafe(${rootPosition.startLine})}

tests/pos/combine.scala

@@ -1,8 +1,8 @@
 trait Semigroup[A] {
   def (x: A) combine (y: A): A
 }
-delegate for Semigroup[Int] = ???
-delegate [A, B] for Semigroup[(A, B)] given Semigroup[A], Semigroup[B] = ???
+given as Semigroup[Int] = ???
+given [A, B] as Semigroup[(A, B)] given Semigroup[A], Semigroup[B] = ???
 object Test extends App {
   ((1, 1)) combine ((2, 2)) // doesn't compile
   ((1, 1): (Int, Int)) combine (2, 2) // compiles

tests/pos/derive-eq.scala

@@ -2,7 +2,7 @@
 case class One() derives Eql
 case class Two() derives Eql
 
-delegate for Eql[One, Two] = Eql.derived
+given as Eql[One, Two] = Eql.derived
 
 enum Lst[T] derives Eql {
   case Cons(x: T, xs: Lst[T])