Docs and tests

The new implementation does not optimize given aliases with pure paths as right hand sides to be
vals anymore. The reason is that even a pure path might be expensive to compute so we might want
the caching. If we want a precomputed val, we can always for this with an explicit value definition:
```
val x = a.b.c
given as T = x
```

Author: odersky

docs/docs/reference/contextual/relationship-implicits.md

@@ -28,32 +28,21 @@ Given instances can be mapped to combinations of implicit objects, classes and i
       class ListOrd[T](implicit ord: Ord[T]) extends Ord[List[T]] { ... }
       final implicit def ListOrd[T](implicit ord: Ord[T]): ListOrd[T] = new ListOrd[T]
     ```
- 3. Alias givens map to implicit methods. If an alias has neither type parameters nor a given clause, its right-hand side is cached in a variable. There are two cases that can be optimized:
-
-  - If the right hand side is a simple reference, we can
-    use a forwarder to that reference without caching it.
-  - If the right hand side is more complex, but still known to be pure, we can
-    create a `val` that computes it ahead of time.
+ 3. Alias givens map to implicit methods or implicit lazy vals. If an alias has neither type parameters nor a given clause,
+    it is treated as a lazy val, unless the right hand side is a simple reference, in which case we can use a forwarder to that
+    reference without caching it.
 
  Examples:
 
     ```scala
       given global as ExecutionContext = new ForkJoinContext()
-      given config as Config = default.config
 
       val ctx: Context
       given as Context = ctx
     ```
     would map to
     ```scala
-      private[this] var global$cache: ExecutionContext | Null = null
-      final implicit def global: ExecutionContext = {
-        if (global$cache == null) global$cache = new ForkJoinContext()
-        global$cache
-      }
-
-      final implicit val config: Config = default.config
-
+      final implicit lazy val global: ExecutionContext = new ForkJoinContext()
       final implicit def Context_given = ctx
     ```
 

tests/pos/i6909.scala

@@ -0,0 +1,7 @@
+import scala.compiletime
+trait Foo[A]
+
+
+trait Qux {
+  given as Foo[Int] = new Foo[Int] {}
+}