Tweak position where synthetic evidence parameters are added

Make sure that any references to a synthetic evidence parameter come
after that parameter is introduced.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -407,21 +407,38 @@ object desugar {
         (Nil, tree)
 
   /**  Add all evidence parameters in `params` as implicit parameters to `meth`.
-   *   If the parameters of `meth` end in an implicit parameter list or using clause,
-   *   evidence parameters are added in front of that list. Otherwise they are added
-   *   as a separate parameter clause.
+   *   The position of the added parameters is determined as follows:
+   *
+   *     - If there is an existing parameter list that refers to one of the added
+   *       parameters in one of its parameter types, add the new parameters
+   *       in front of the first such parameter list.
+   *     - Otherwise, if the last parameter list consists implicit or using parameters,
+   *       join the new parameters in front of this parameter list, creating one
+   *       parameter list (this is equilavent to Scala 2's scheme).
+   *     - Otherwise, add the new parameter list at the end as a separate parameter clause.
    */
   private def addEvidenceParams(meth: DefDef, params: List[ValDef])(using Context): DefDef =
-    params match
+    if params.isEmpty then return meth
+
+    val boundNames = params.map(_.name).toSet
+
+    def references(vdef: ValDef): Boolean =
+      vdef.tpt.existsSubTree:
+        case Ident(name: TermName) => boundNames.contains(name)
+        case _ => false
+
+    def recur(mparamss: List[ParamClause]): List[ParamClause] = mparamss match
+      case ValDefs(mparams) :: _ if mparams.exists(references) =>
+        params :: mparamss
+      case ValDefs(mparams @ (mparam :: _)) :: Nil if mparam.mods.isOneOf(GivenOrImplicit) =>
+        (params ++ mparams) :: Nil
+      case mparams :: mparamss1 =>
+        mparams :: recur(mparamss1)
       case Nil =>
-        meth
-      case evidenceParams =>
-        val paramss1 = meth.paramss.reverse match
-          case ValDefs(vparams @ (vparam :: _)) :: rparamss if vparam.mods.isOneOf(GivenOrImplicit) =>
-            ((evidenceParams ++ vparams) :: rparamss).reverse
-          case _ =>
-            meth.paramss :+ evidenceParams
-        cpy.DefDef(meth)(paramss = paramss1)
+        params :: Nil
+
+    cpy.DefDef(meth)(paramss = recur(meth.paramss))
+  end addEvidenceParams
 
   /** The parameters generated from the contextual bounds of `meth`, as generated by `desugar.defDef` */
   private def evidenceParams(meth: DefDef)(using Context): List[ValDef] =

tests/pos/dep-context-bounds.scala

@@ -0,0 +1,17 @@
+//> using options -language:experimental.modularity -source future
+trait A:
+  type Self
+
+object Test1:
+  def foo[X: A](x: X.Self) = ???
+
+  def bar[X: A](a: Int) = ???
+
+  def baz[X: A](a: Int)(using String) = ???
+
+object Test2:
+  def foo[X: A as x](a: x.Self) = ???
+
+  def bar[X: A as x](a: Int) = ???
+
+  def baz[X: A as x](a: Int)(using String) = ???

tests/pos/hylolib/AnyCollection.scala

@@ -14,7 +14,7 @@ final class AnyCollection[Element] private (
 object AnyCollection {
 
   /** Creates an instance forwarding its operations to `base`. */
-  def apply[Base](using b: Collection[Base])(base: Base): AnyCollection[b.Element] =
+  def apply[Base: Collection as b](base: Base): AnyCollection[b.Element] =
     // NOTE: This evidence is redefined so the compiler won't report ambiguity between `intIsValue`
     // and `anyValueIsValue` when the method is called on a collection of `Int`s. None of these
     // choices is even correct! Note also that the ambiguity is suppressed if the constructor of
@@ -42,7 +42,7 @@ object AnyCollection {
 
 }
 
-given anyCollectionIsCollection[T](using tIsValue: Value[T]): Collection[AnyCollection[T]] with {
+given anyCollectionIsCollection[T: Value]: Collection[AnyCollection[T]] with {
 
   type Element = T
   type Position = AnyValue

tests/pos/hylolib/AnyValue.scala

@@ -44,7 +44,7 @@ final class AnyValue private (
 object AnyValue {
 
   /** Creates an instance wrapping `wrapped`. */
-  def apply[T](using Value[T])(wrapped: T): AnyValue =
+  def apply[T: Value](wrapped: T): AnyValue =
     def copy(a: AnyRef): AnyValue =
       AnyValue(a.asInstanceOf[Ref[T]].value.copy())
 

tests/pos/hylolib/Collection.scala

@@ -89,7 +89,7 @@ trait Collection[Self] {
 
 }
 
-extension [Self](self: Self)(using s: Collection[Self]) {
+extension [Self: Collection as s](self: Self) {
 
   /** Returns the first element of `self` along with a slice containing the suffix after this
     * element, or `None` if `self` is empty.
@@ -148,7 +148,7 @@ extension [Self](self: Self)(using s: Collection[Self]) {
     * @complexity
     *   O(n) where n is the number of elements in `self`.
     */
-  def map[T](using Value[T])(transform: (s.Element) => T): HyArray[T] =
+  def map[T: Value](transform: (s.Element) => T): HyArray[T] =
     self.reduce(
       HyArray[T](),
       (r, e) => r.append(transform(e), assumeUniqueness = true)
@@ -257,9 +257,8 @@ extension [Self](self: Self)(using s: Collection[Self]) {
 
 }
 
-extension [Self](self: Self)(using
-    s: Collection[Self],
-    e: Value[s.Element]
+extension [Self: Collection as s](self: Self)(using
+    Value[s.Element]
 ) {
 
   /** Returns `true` if `self` contains the same elements as `other`, in the same order. */

tests/pos/hylolib/HyArray.scala

@@ -1,12 +1,11 @@
+//> using options -language:experimental.modularity -source future
 package hylo
 
 import java.util.Arrays
 import scala.collection.mutable
 
 /** An ordered, random-access collection. */
-final class HyArray[Element] private (using
-    elementIsValue: Value[Element]
-)(
+final class HyArray[Element: Value as elementIsCValue](
     private var _storage: scala.Array[AnyRef | Null] | Null,
     private var _count: Int // NOTE: where do I document private fields
 ) {
@@ -155,14 +154,14 @@ final class HyArray[Element] private (using
 object HyArray {
 
   /** Creates an array with the given `elements`. */
-  def apply[T](using t: Value[T])(elements: T*): HyArray[T] =
+  def apply[T: Value](elements: T*): HyArray[T] =
     var a = new HyArray[T](null, 0)
     for (e <- elements) a = a.append(e, assumeUniqueness = true)
     a
 
 }
 
-given hyArrayIsValue[T](using tIsValue: Value[T]): Value[HyArray[T]] with {
+given [T: Value] => Value[HyArray[T]] with {
 
   extension (self: HyArray[T]) {
 
@@ -179,7 +178,7 @@ given hyArrayIsValue[T](using tIsValue: Value[T]): Value[HyArray[T]] with {
 
 }
 
-given hyArrayIsCollection[T](using tIsValue: Value[T]): Collection[HyArray[T]] with {
+given [T: Value] => Collection[HyArray[T]] with {
 
   type Element = T
   type Position = Int

tests/pos/hylolib/Range.scala

@@ -30,7 +30,7 @@ object Range {
     * @requires
     *   `lowerBound` is lesser than or equal to `upperBound`.
     */
-  def apply[Bound](lowerBound: Bound, upperBound: Bound)(using Comparable[Bound]) =
+  def apply[Bound: Comparable](lowerBound: Bound, upperBound: Bound) =
     require(lowerBound `le` upperBound)
     new Range(lowerBound, upperBound)
 

tests/pos/hylolib/Slice.scala

@@ -1,9 +1,7 @@
 package hylo
 
 /** A view into a collection. */
-final class Slice[Base](using
-    val b: Collection[Base]
-)(
+final class Slice[Base: Collection as b](
     val base: Base,
     val bounds: Range[b.Position]
 ) {
@@ -26,7 +24,7 @@ final class Slice[Base](using
 
 }
 
-given sliceIsCollection[T](using c: Collection[T]): Collection[Slice[T]] with {
+given sliceIsCollection[T: Collection as c]: Collection[Slice[T]] with {
 
   type Element = c.Element
   type Position = c.Position