Rename deferredSummon to deferred and allow it for defs

The idea is that `given ... = deferred` should be the new syntax for abstract givens. These
can only be defined in traits and need to be implemented in the first subclass extending the
trait. If the definition of a given vals is missing, one is synthesized by an implicit search
at the site of the extending class.

This will free the syntax

    given A is TC

for the more common case where we just want to implement a marker type class TC.

Also allow

# Conflicts:
#	compiler/src/dotty/tools/dotc/typer/Namer.scala

Author: odersky

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

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

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

@@ -922,10 +922,10 @@ trait Implicits:
 
 
   /** Search an implicit argument and report error if not found */
-  def implicitArgTree(formal: Type, span: Span)(using Context): Tree = {
+  def implicitArgTree(formal: Type, span: Span, where: => String = "")(using Context): Tree = {
     val arg = inferImplicitArg(formal, span)
     if (arg.tpe.isInstanceOf[SearchFailureType])
-      report.error(missingArgMsg(arg, formal, ""), ctx.source.atSpan(span))
+      report.error(missingArgMsg(arg, formal, where), ctx.source.atSpan(span))
     arg
   }
 

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

@@ -1806,12 +1806,12 @@ class Namer { typer: Typer =>
         WildcardType
     }
 
-    // translate `given T = deferredSummon` to an abstract given with HasDefault flag
-    if sym.is(Given, butNot = Method) then
+    // translate `given T = deferred` to an abstract given with HasDefault flag
+    if sym.is(Given) then
       mdef.rhs match
-        case Ident(nme.deferredSummon) if Feature.enabled(modularity) =>
+        case Ident(nme.deferred) 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)
+            report.error(em"`deferred` can only be used for givens in traits", mdef.rhs.srcPos)
           else
             sym.resetFlag(Final | Lazy)
             sym.setFlag(Deferred | HasDefault)

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

@@ -2579,7 +2579,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val rhs1 = vdef.rhs match {
       case rhs @ Ident(nme.WILDCARD) =>
         rhs.withType(tpt1.tpe)
-      case Ident(nme.deferredSummon) if sym.isAllOf(DeferredGivenFlags, butNot = Param) =>
+      case Ident(nme.deferred) if sym.isAllOf(DeferredGivenFlags, butNot = Param) =>
         EmptyTree
       case rhs =>
         typedExpr(rhs, tpt1.tpe.widenExpr)
@@ -2643,9 +2643,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     if sym.isInlineMethod then rhsCtx.addMode(Mode.InlineableBody)
     if sym.is(ExtensionMethod) then rhsCtx.addMode(Mode.InExtensionMethod)
-    val rhs1 = PrepareInlineable.dropInlineIfError(sym,
-      if sym.isScala2Macro then typedScala2MacroBody(ddef.rhs)(using rhsCtx)
-      else typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(using rhsCtx))
+    val rhs1 = ddef.rhs match
+      case Ident(nme.deferred) if sym.isAllOf(DeferredGivenFlags) =>
+        EmptyTree
+      case rhs =>
+        PrepareInlineable.dropInlineIfError(sym,
+          if sym.isScala2Macro then typedScala2MacroBody(ddef.rhs)(using rhsCtx)
+          else typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(using rhsCtx))
 
     if sym.isInlineMethod then
       if StagingLevel.level > 0 then
@@ -2826,21 +2830,33 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         case None =>
           body
 
-    /** Implement givens that were declared with a `deferredSummon` rhs.
+    /** Implement givens that were declared with a `deferred` 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 isGivenValue(mbr: TermRef) =
+          val dcl = mbr.symbol
+          if dcl.is(Method) then
+            report.error(
+              em"""Cannnot infer the implementation of the deferred ${dcl.showLocated}
+                  |since that given is parameterized. An implementing given needs to be written explicitly.""",
+              cdef.srcPos)
+            false
+          else true
+
         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 rhs = implicitArgTree(target, cdef.span,
+              where = i"inferring the implementation of the deferred ${dcl.showLocated}"
+            )(using searchCtx)
           val impl = dcl.copy(cls,
             flags = dcl.flags &~ (HasDefault | Deferred) | Final,
             info = target,
@@ -2850,6 +2866,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         val givenImpls =
           cls.thisType.implicitMembers
             .filter(_.symbol.isAllOf(DeferredGivenFlags, butNot = Param))
+            .filter(isGivenValue)
             .map(givenImpl)
         body ++ givenImpls
     end implementDeferredGivens

tests/neg/deferred-givens.check

@@ -0,0 +1,13 @@
+-- [E172] Type Error: tests/neg/deferred-givens.scala:9:6 --------------------------------------------------------------
+9 |class B extends A // error
+  |^^^^^^^^^^^^^^^^^
+  |No given instance of type Ctx was found for inferring the implementation of the deferred given instance ctx in trait A
+-- [E172] Type Error: tests/neg/deferred-givens.scala:11:15 ------------------------------------------------------------
+11 |abstract class C extends A // error
+   |^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |No given instance of type Ctx was found for inferring the implementation of the deferred given instance ctx in trait A
+-- Error: tests/neg/deferred-givens.scala:24:8 -------------------------------------------------------------------------
+24 |  class E extends A2  // error, can't summon polymorphic given
+   |  ^^^^^^^^^^^^^^^^^^
+   |  Cannnot infer the implementation of the deferred given instance given_Ctx3_T in trait A2
+   |  since that given is parameterized. An implementing given needs to be written explicitly.

tests/neg/deferred-givens.scala

@@ -0,0 +1,28 @@
+//> using options -YXtypeclass -source future
+class Ctx
+class Ctx2
+
+trait A:
+  given Ctx as ctx = deferred
+  given Ctx2 = deferred
+
+class B extends A // error
+
+abstract class C extends A // error
+
+class D extends A:
+  given Ctx as ctx = Ctx() // ok, was implemented
+  given Ctx2 = Ctx2()      // ok
+
+class Ctx3[T]
+
+trait A2:
+  given [T] => Ctx3[T] = deferred
+
+object O:
+  given [T] => Ctx3[T] = Ctx3[T]()
+  class E extends A2  // error, can't summon polymorphic given
+
+class E extends A2:
+  given [T] => Ctx3[T] = Ctx3[T]() // ok
+

tests/neg/deferredSummon.scala

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

tests/pos/deferredSummon.scala

@@ -5,7 +5,7 @@ trait Ord:
 
 trait A:
   type Elem
-  given Elem is Ord = deferredSummon
+  given Elem is Ord = deferred
   def foo = summon[Elem is Ord]
 
 trait B: