Implement deferredSummon

A definition like `given T = deferredSummon` in a trait will be
expanded to an abstract given in the trait that is implemented
automatically in all classes inheriting the trait.

Author: odersky

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

@@ -453,6 +453,7 @@ object StdNames {
     val create: N               = "create"
     val currentMirror: N        = "currentMirror"
     val curried: N              = "curried"
+    val deferredSummon: N       = "deferredSummon"
     val definitions: N          = "definitions"
     val delayedInit: N          = "delayedInit"
     val delayedInitArg: N       = "delayedInit$body"

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

@@ -397,13 +397,12 @@ object Symbols extends SymUtils {
         flags: FlagSet = this.flags,
         info: Type = this.info,
         privateWithin: Symbol = this.privateWithin,
-        coord: Coord = NoCoord, // Can be `= owner.coord` once we bootstrap
-        compUnitInfo: CompilationUnitInfo | Null = null // Can be `= owner.associatedFile` once we bootstrap
+        coord: Coord = NoCoord, // Can be `= owner.coord` once we have new default args
+        compUnitInfo: CompilationUnitInfo | Null = null // Can be `= owner.compilationUnitInfo` once we have new default args
     ): Symbol = {
       val coord1 = if (coord == NoCoord) owner.coord else coord
       val compilationUnitInfo1 = if (compilationUnitInfo == null) owner.compilationUnitInfo else compilationUnitInfo
 
-
       if isClass then
         newClassSymbol(owner, name.asTypeName, flags, _ => info, privateWithin, coord1, compilationUnitInfo1)
       else

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

@@ -1805,6 +1805,18 @@ class Namer { typer: Typer =>
       case _ =>
         WildcardType
     }
+
+    // translate `given T = deferredSummon` to an abstract given with HasDefault flag
+    if sym.is(Given, butNot = Method) then
+      mdef.rhs match
+        case Ident(nme.deferredSummon) if Feature.enabled(modularity) =>
+          if !sym.maybeOwner.is(Trait) then
+            report.error(em"`deferredSummon` can only be used for givens in traits", mdef.rhs.srcPos)
+          else
+            sym.resetFlag(Final | Lazy)
+            sym.setFlag(Deferred | HasDefault)
+        case _ =>
+
     val mbrTpe = paramFn(checkSimpleKinded(typedAheadType(mdef.tpt, tptProto)).tpe)
     if (ctx.explicitNulls && mdef.mods.is(JavaDefined))
       JavaNullInterop.nullifyMember(sym, mbrTpe, mdef.mods.isAllOf(JavaEnumValue))

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

@@ -2572,12 +2572,16 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val ValDef(name, tpt, _) = vdef
     checkNonRootName(vdef.name, vdef.nameSpan)
     completeAnnotations(vdef, sym)
-    if (sym.isOneOf(GivenOrImplicit)) checkImplicitConversionDefOK(sym)
+    if sym.is(Implicit) then checkImplicitConversionDefOK(sym)
     if sym.is(Module) then checkNoModuleClash(sym)
     val tpt1 = checkSimpleKinded(typedType(tpt))
     val rhs1 = vdef.rhs match {
-      case rhs @ Ident(nme.WILDCARD) => rhs withType tpt1.tpe
-      case rhs => typedExpr(rhs, tpt1.tpe.widenExpr)
+      case rhs @ Ident(nme.WILDCARD) =>
+        rhs.withType(tpt1.tpe)
+      case Ident(nme.deferredSummon) if sym.isAllOf(Given | Deferred | HasDefault, butNot = Param) =>
+        EmptyTree
+      case rhs =>
+        typedExpr(rhs, tpt1.tpe.widenExpr)
     }
     val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
     postProcessInfo(vdef1, sym)
@@ -2821,6 +2825,34 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case None =>
           body
 
+    /** Implement givens that were declared with a `deferredSummon` rhs.
+     *  The a given value matching the declared type is searched in a
+     *  context directly enclosing the current class, in which all given
+     *  parameters of the current class are also defined.
+     */
+    def implementDeferredGivens(body: List[Tree]): List[Tree] =
+      if cls.is(Trait) then body
+      else
+        def givenImpl(mbr: TermRef): ValDef =
+          val dcl = mbr.symbol
+          val target = dcl.info.asSeenFrom(cls.thisType, dcl.owner)
+          val constr = cls.primaryConstructor
+          val paramScope = newScopeWith(cls.paramAccessors.filter(_.is(Given))*)
+          val searchCtx = ctx.outer.fresh.setScope(paramScope)
+          val rhs = implicitArgTree(target, cdef.span)(using searchCtx)
+          val impl = dcl.copy(cls,
+            flags = dcl.flags &~ (HasDefault | Deferred) | Final,
+            info = target,
+            coord = rhs.span).entered.asTerm
+          ValDef(impl, rhs)
+
+        val givenImpls =
+          cls.thisType.implicitMembers
+            .filter(_.symbol.isAllOf(Given | Deferred | HasDefault, butNot = Param))
+            .map(givenImpl)
+        body ++ givenImpls
+    end implementDeferredGivens
+
     ensureCorrectSuperClass()
     completeAnnotations(cdef, cls)
     val constr1 = typed(constr).asInstanceOf[DefDef]
@@ -2842,9 +2874,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     else {
       val dummy = localDummy(cls, impl)
       val body1 =
-        addParentRefinements(
-          addAccessorDefs(cls,
-            typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1))
+        implementDeferredGivens(
+          addParentRefinements(
+            addAccessorDefs(cls,
+              typedStats(impl.body, dummy)(using ctx.inClassContext(self1.symbol))._1)))
 
       checkNoDoubleDeclaration(cls)
       val impl1 = cpy.Template(impl)(constr1, parents1, Nil, self1, body1)

tests/neg/deferredSummon.scala

@@ -0,0 +1,12 @@
+//> using options -language:experimental.modularity
+
+object Test:
+  given Int = deferredSummon // error
+
+abstract class C:
+  given Int = deferredSummon // error
+
+trait A:
+  locally:
+    given Int = deferredSummon // error
+

tests/pos/deferredSummon.scala

@@ -0,0 +1,29 @@
+//> using options -language:experimental.modularity -source future
+trait Ord:
+  type Self
+  def less(x: Self, y: Self): Boolean
+
+trait A:
+  type Elem
+  given Elem is Ord = deferredSummon
+  def foo = summon[Elem is Ord]
+
+object Inst:
+  given Int is Ord:
+    def less(x: Int, y: Int) = x < y
+
+object Test:
+  import Inst.given
+  class C extends A:
+    type Elem = Int
+  object E extends A:
+    type Elem = Int
+  given A:
+    type Elem = Int
+
+class D[T: Ord] extends A:
+  type Elem = T
+
+
+
+

tests/pos/hylolib-extract.scala

@@ -0,0 +1,18 @@
+//> using options -language:experimental.modularity -source future
+package hylotest
+
+trait Value[Self]
+
+/** A collection of elements accessible by their position. */
+trait Collection[Self]:
+
+  /** The type of the elements in the collection. */
+  type Element
+  given elementIsValue: Value[Element] = deferredSummon
+
+class BitArray
+
+given Value[Boolean] {}
+
+given Collection[BitArray] with
+  type Element = Boolean

tests/pos/hylolib/AnyCollection.scala

@@ -0,0 +1,69 @@
+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](using b: Collection[Base])(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
+    // `AnyValue` is declared with a context bound rather than an implicit parameter.
+    given Value[b.Position] = b.positionIsValue
+
+    def start(): AnyValue =
+      AnyValue(base.startPosition)
+
+    def end(): AnyValue =
+      AnyValue(base.endPosition)
+
+    def after(p: AnyValue): AnyValue =
+      AnyValue(base.positionAfter(p.unsafelyUnwrappedAs[b.Position]))
+
+    def at(p: AnyValue): b.Element =
+      base.at(p.unsafelyUnwrappedAs[b.Position])
+
+    new AnyCollection[b.Element](
+      _start = start,
+      _end = end,
+      _after = after,
+      _at = at
+    )
+
+}
+
+given anyCollectionIsCollection[T](using tIsValue: Value[T]): Collection[AnyCollection[T]] with {
+
+  type Element = T
+  //given elementIsValue: Value[Element] = tIsValue
+
+  type Position = AnyValue
+  given positionIsValue: Value[Position] = anyValueIsValue
+
+  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,76 @@
+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](using Value[T])(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 anyValueIsValue: Value[AnyValue] with {
+
+  extension (self: AnyValue) {
+
+    def copy(): AnyValue =
+      self.copy()
+
+    def eq(other: AnyValue): Boolean =
+      self `eq` other
+
+    def hashInto(hasher: Hasher): Hasher =
+      self.hashInto(hasher)
+
+  }
+
+}