Allow contecxt bounds with abstract Self types

If a context bound type `T` for type parameter `A` does not have
type parameters, demand evidence of type `T { type Self = A }` instead.

Author: odersky

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

@@ -385,6 +385,7 @@ object StdNames {
     val RootPackage: N          = "RootPackage"
     val RootClass: N            = "RootClass"
     val Select: N               = "Select"
+    val Self: N                 = "Self"
     val Shape: N                = "Shape"
     val StringContext: N        = "StringContext"
     val This: N                 = "This"

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

@@ -2280,9 +2280,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val tparam = untpd.Ident(tree.paramName).withSpan(tree.span)
     if tycon.tpe.typeParams.nonEmpty then
       typed(untpd.AppliedTypeTree(tyconSplice, tparam :: Nil))
+    else if Feature.enabled(modularity) && tycon.tpe.member(tpnme.Self).symbol.isAbstractType then
+      val tparamSplice = untpd.TypedSplice(typedExpr(tparam))
+      typed(untpd.RefinedTypeTree(tyconSplice, List(untpd.TypeDef(tpnme.Self, tparamSplice))))
     else
       errorTree(tree,
-        em"""Illegal context bound: ${tycon.tpe} does not take type parameters.""")
+        em"""Illegal context bound: ${tycon.tpe} does not take type parameters and
+            |does not have an abstract type member named `Self` either.""")
 
   def typedSingletonTypeTree(tree: untpd.SingletonTypeTree)(using Context): SingletonTypeTree = {
     val ref1 = typedExpr(tree.ref, SingletonTypeProto)

compiler/test/dotc/pos-test-pickling.blacklist

@@ -121,10 +121,11 @@ i15525.scala
 # alias types at different levels of dereferencing
 parsercombinators-givens.scala
 parsercombinators-givens-2.scala
+parsercombinators-ctx-bounds.scala
+parsercombinators-this.scala
 parsercombinators-arrow.scala
+parsercombinators-new-syntax.scala
 hylolib-deferred-given
 hylolib-cb
-
-
-
+hylolib
 

library/src/scala/runtime/stdLibPatches/Predef.scala

@@ -61,4 +61,16 @@ object Predef:
     inline def ne(inline y: AnyRef | Null): Boolean =
       !(x eq y)
 
+  /** A type supporting Self-based type classes.
+   *
+   *    A is TC
+   *
+   *  expands to
+   *
+   *    TC { type Self = A }
+   *
+   *  which is what is needed for a context bound `[A: TC]`.
+   */
+  infix type is[A <: AnyKind, B <: {type Self <: AnyKind}] = B { type Self = A }
+
 end Predef

tests/pos/FromString.scala

@@ -0,0 +1,15 @@
+//> using options -language:experimental.modularity -source future
+
+trait FromString:
+  type Self
+  def fromString(s: String): Self
+
+given Int is FromString = _.toInt
+
+given Double is FromString = _.toDouble
+
+def add[N: {FromString, Numeric as num}](a: String, b: String): N =
+  N.plus(
+    num.plus(N.fromString(a), N.fromString(b)),
+    N.fromString(a)
+  )

tests/pos/deferred-givens.scala

@@ -1,9 +1,19 @@
 //> using options -language:experimental.modularity -source future
 import compiletime.*
 class Ord[Elem]
-
 given Ord[Double]
 
+trait A:
+  type Elem : Ord
+  def foo = summon[Ord[Elem]]
+
+class AC extends A:
+  type Elem = Double
+  override given Ord[Elem] = ???
+
+class AD extends A:
+  type Elem = Double
+
 trait B:
   type Elem
   given Ord[Elem] = deferred

tests/pos/deferredSummon.scala

@@ -1,20 +1,21 @@
 //> using options -language:experimental.modularity -source future
 import compiletime.deferred
 
-trait Ord[Self]:
+trait Ord:
+  type Self
   def less(x: Self, y: Self): Boolean
 
 trait A:
   type Elem
-  given Ord[Elem] = deferred
-  def foo = summon[Ord[Elem]]
+  given Elem is Ord = deferred
+  def foo = summon[Elem is Ord]
 
 trait B:
   type Elem: Ord
-  def foo = summon[Ord[Elem]]
+  def foo = summon[Elem is Ord]
 
 object Inst:
-  given Ord[Int]:
+  given Int is Ord:
     def less(x: Int, y: Int) = x < y
 
 object Test1:

tests/pos/dep-context-bounds.scala

@@ -1,6 +1,13 @@
 //> using options -language:experimental.modularity -source future
-trait A[X]:
-  type Self = X
+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) = ???

tests/pos/hylolib-extract.scala

@@ -0,0 +1,29 @@
+//> using options -language:experimental.modularity -source future
+package hylotest
+
+trait Value:
+  type Self
+  extension (self: Self) def eq(other: Self): Boolean
+
+/** A collection of elements accessible by their position. */
+trait Collection:
+  type Self
+
+  /** The type of the elements in the collection. */
+  type Element: Value
+
+class BitArray
+
+given Boolean is Value:
+  extension (self: Self) def eq(other: Self): Boolean =
+    self == other
+
+given BitArray is Collection:
+  type Element = Boolean
+
+extension [Self: Value](self: Self)
+  def neq(other: Self): Boolean = !self.eq(other)
+
+extension [Self: Collection](self: Self)
+  def elementsEqual[T: Collection { type Element = Self.Element } ](other: T): Boolean =
+    ???

tests/pos/hylolib/AnyCollection.scala

@@ -0,0 +1,51 @@
+//> using options -language:experimental.modularity -source future
+package hylo
+
+/** A type-erased collection.
+  *
+  * A `AnyCollection` forwards its operations to a wrapped value, hiding its implementation.
+  */
+final class AnyCollection[Element] private (
+    val _start: () => AnyValue,
+    val _end: () => AnyValue,
+    val _after: (AnyValue) => AnyValue,
+    val _at: (AnyValue) => Element
+)
+
+object AnyCollection {
+
+  /** Creates an instance forwarding its operations to `base`. */
+  def apply[Base: Collection](base: Base): AnyCollection[Base.Element] =
+
+    def start(): AnyValue =
+      AnyValue(base.startPosition)
+
+    def end(): AnyValue =
+      AnyValue(base.endPosition)
+
+    def after(p: AnyValue): AnyValue =
+      AnyValue(base.positionAfter(p.unsafelyUnwrappedAs[Base.Position]))
+
+    def at(p: AnyValue): Base.Element =
+      base.at(p.unsafelyUnwrappedAs[Base.Position])
+
+    new AnyCollection[Base.Element](
+      _start = start,
+      _end = end,
+      _after = after,
+      _at = at
+    )
+
+}
+
+given [T: Value] => AnyCollection[T] is Collection:
+
+  type Element = T
+  type Position = AnyValue
+
+  extension (self: AnyCollection[T])
+    def startPosition = self._start()
+    def endPosition = self._end()
+    def positionAfter(p: Position) = self._after(p)
+    def at(p: Position) = self._at(p)
+

tests/pos/hylolib/AnyValue.scala

@@ -0,0 +1,67 @@
+package hylo
+
+/** A wrapper around an object providing a reference API. */
+private final class Ref[T](val value: T) {
+
+  override def toString: String =
+    s"Ref($value)"
+
+}
+
+/** A type-erased value.
+  *
+  * An `AnyValue` forwards its operations to a wrapped value, hiding its implementation.
+  */
+final class AnyValue private (
+    private val wrapped: AnyRef,
+    private val _copy: (AnyRef) => AnyValue,
+    private val _eq: (AnyRef, AnyRef) => Boolean,
+    private val _hashInto: (AnyRef, Hasher) => Hasher
+) {
+
+  /** Returns a copy of `this`. */
+  def copy(): AnyValue =
+    _copy(this.wrapped)
+
+  /** Returns `true` iff `this` and `other` have an equivalent value. */
+  def eq(other: AnyValue): Boolean =
+    _eq(this.wrapped, other.wrapped)
+
+  /** Hashes the salient parts of `this` into `hasher`. */
+  def hashInto(hasher: Hasher): Hasher =
+    _hashInto(this.wrapped, hasher)
+
+  /** Returns the value wrapped in `this` as an instance of `T`. */
+  def unsafelyUnwrappedAs[T]: T =
+    wrapped.asInstanceOf[Ref[T]].value
+
+  /** Returns a textual description of `this`. */
+  override def toString: String =
+    wrapped.toString
+
+}
+
+object AnyValue {
+
+  /** Creates an instance wrapping `wrapped`. */
+  def apply[T: Value](wrapped: T): AnyValue =
+    def copy(a: AnyRef): AnyValue =
+      AnyValue(a.asInstanceOf[Ref[T]].value.copy())
+
+    def eq(a: AnyRef, b: AnyRef): Boolean =
+      a.asInstanceOf[Ref[T]].value `eq` b.asInstanceOf[Ref[T]].value
+
+    def hashInto(a: AnyRef, hasher: Hasher): Hasher =
+      a.asInstanceOf[Ref[T]].value.hashInto(hasher)
+
+    new AnyValue(Ref(wrapped), copy, eq, hashInto)
+
+}
+
+given AnyValue is Value:
+
+  extension (self: AnyValue)
+    def copy(): AnyValue = self.copy()
+    def eq(other: AnyValue): Boolean = self `eq` other
+    def hashInto(hasher: Hasher): Hasher = self.hashInto(hasher)
+

tests/pos/hylolib/AnyValueTests.scala

@@ -0,0 +1,15 @@
+//> using options -language:experimental.modularity -source future
+import hylo.*
+import hylo.given
+
+class AnyValueTests extends munit.FunSuite:
+
+  test("eq"):
+    val a = AnyValue(1)
+    assert(a `eq` a)
+    assert(!(a `neq` a))
+
+    val b = AnyValue(2)
+    assert(!(a `eq` b))
+    assert(a `neq` b)
+