Handle abstract givens

Add tests for them. Also, improve error message if a given instance still has abstract members.

Author: odersky

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

@@ -800,10 +800,12 @@ object desugar {
             Nil
         }
       }
+      val classMods = if mods.is(Given) then mods &~ Given | Synthetic else mods
       cpy.TypeDef(cdef: TypeDef)(
         name = className,
         rhs = cpy.Template(impl)(constr, parents1, clsDerived, self1,
-          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths)): TypeDef
+          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths)
+      ).withMods(classMods)
     }
 
     // install the watch on classTycon

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

@@ -443,7 +443,7 @@ object Checking {
       fail(ParamsNoInline(sym.owner))
     if sym.isInlineMethod && !sym.is(Deferred) && sym.allOverriddenSymbols.nonEmpty then
       checkInlineOverrideParameters(sym)
-    if (sym.isOneOf(GivenOrImplicit)) {
+    if (sym.is(Implicit)) {
       if (sym.owner.is(Package))
         fail(TopLevelCantBeImplicit(sym))
       if (sym.isType)

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

@@ -241,7 +241,7 @@ class Namer { typer: Typer =>
 
     tree match {
       case tree: TypeDef if tree.isClassDef =>
-        val flags = checkFlags(tree.mods.flags &~ GivenOrImplicit)
+        val flags = checkFlags(tree.mods.flags &~ Implicit)
         val name = checkNoConflict(tree.name, flags.is(Private), tree.span).asTypeName
         val cls =
           createOrRefine[ClassSymbol](tree, name, flags, ctx.owner,

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

@@ -503,7 +503,9 @@ object RefChecks {
         def prelude = (
           if (clazz.isAnonymousClass || clazz.is(Module)) "object creation impossible"
           else if (mustBeMixin) s"$clazz needs to be a mixin"
-          else s"$clazz needs to be abstract") + ", since"
+          else if clazz.is(Synthetic) then "instance cannot be created"
+          else s"$clazz needs to be abstract"
+          ) + ", since"
 
         if (abstractErrors.isEmpty) abstractErrors ++= List(prelude, msg)
         else abstractErrors += msg

tests/neg/abstract-givens.check

@@ -0,0 +1,14 @@
+-- Error: tests/neg/abstract-givens.scala:11:8 -------------------------------------------------------------------------
+11 |  given s[T](using T): Seq[T] with // error
+   |        ^
+   |        instance cannot be created, since def iterator: => Iterator[A] is not defined 
+-- Error: tests/neg/abstract-givens.scala:8:8 --------------------------------------------------------------------------
+8 |  given y(using Int): String = summon[Int].toString * 22 // error
+  |        ^
+  |        error overriding method y in trait T of type (using x$1: Int): String;
+  |          method y of type (using x$1: Int): String cannot override final member method y in trait T
+-- Error: tests/neg/abstract-givens.scala:9:8 --------------------------------------------------------------------------
+9 |  given z[T](using T): Seq[T] = List(summon[T]) // error
+  |        ^
+  |        error overriding method z in trait T of type [T](using x$1: T): List[T];
+  |          method z of type [T](using x$1: T): Seq[T] has incompatible type

tests/neg/abstract-givens.scala

@@ -0,0 +1,16 @@
+trait T:
+  given x: Int
+  given y(using Int): String = summon[Int].toString
+  given z[T](using T): List[T]
+
+object Test extends T:
+  given x: Int = 22
+  given y(using Int): String = summon[Int].toString * 22 // error
+  given z[T](using T): Seq[T] = List(summon[T]) // error
+
+  given s[T](using T): Seq[T] with // error
+    def apply(x: Int) = ???
+    override def length = ???
+
+end Test
+

tests/neg/struct-given.scala

@@ -1,8 +1,8 @@
 class C
-given c as C with
+given c[T]: C with
   def foo = 1
 
-given d as C = new C { def foo = 1 }
+given d[T]: C = new C { def foo = 1 }
 
 def test =
   c.foo  // OK

tests/run/abstract-givens.scala

@@ -0,0 +1,19 @@
+trait T:
+  given x: Int
+  given y(using Int): String
+  given z[T](using T): Seq[T]
+
+object Test extends T, App:
+  given x: Int = 22
+  override given y(using Int): String = summon[Int].toString
+  given z[T](using T): Seq[T] with
+    override def apply(x: Int) = ???
+    override def length = ???
+    override def iterator = ???
+    override def toString = s"seq $x"
+
+  assert(summon[Int] == 22)
+  assert(summon[String] == "22")
+  assert(summon[Seq[Int]].toString == "seq 22")
+
+