Merge GivenClass and Given

Classes can now be Given (if generated from a given def)
or Implicit (if declared as an implicit class)

Author: odersky

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

@@ -810,9 +810,7 @@ object desugar {
         }
       }
       val classMods =
-        if mods.is(Given) then mods &~ Given | Synthetic | GivenClass
-        else if mods.is(Implicit) then mods &~ Implicit | GivenClass
-        else mods
+      	if mods.is(Given) then mods | Synthetic else mods
       cpy.TypeDef(cdef: TypeDef)(
         name = className,
         rhs = cpy.Template(impl)(constr, parents1, clsDerived, self1,

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

@@ -315,7 +315,7 @@ object Flags {
   val (SuperParamAliasOrScala2x @ _, SuperParamAlias @ _, Scala2x @ _) = newFlags(26, "<super-param-alias>", "<scala-2.x>")
 
   /** A parameter with a default value / A structural given class or an implicit class */
-  val (_, HasDefault @ _, GivenClass @ _) = newFlags(27, "<hasdefault/given-class>")
+  val (_, HasDefault @ _, _) = newFlags(27, "<hasdefault>")
 
   /** An extension method, or a collective extension instance */
   val (Extension @ _, ExtensionMethod @ _, _) = newFlags(28, "<extension>")

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

@@ -719,8 +719,8 @@ object SymDenotations {
 	 */
     final def isCoDefinedGiven(cls: Symbol)(using Context): Boolean =
       is(Method) && isOneOf(GivenOrImplicit)
-      && ( is(Synthetic)       // previous scheme used in 3.0
-         || cls.is(GivenClass) // new scheme from 3.1
+      && ( is(Synthetic)                 // previous scheme used in 3.0
+         || cls.isOneOf(GivenOrImplicit) // new scheme from 3.1
          )
       && name == cls.name.toTermName && owner == cls.owner
 

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -732,9 +732,9 @@ class TreePickler(pickler: TastyPickler) {
     if flags.is(Invisible) then writeModTag(INVISIBLE)
     if (flags.is(Erased)) writeModTag(ERASED)
     if (flags.is(Exported)) writeModTag(EXPORTED)
+    if (flags.is(Given)) writeModTag(GIVEN)
     if (isTerm) {
       if (flags.is(Implicit)) writeModTag(IMPLICIT)
-      if (flags.is(Given)) writeModTag(GIVEN)
       if (flags.is(Lazy, butNot = Module)) writeModTag(LAZY)
       if (flags.is(AbsOverride)) { writeModTag(ABSTRACT); writeModTag(OVERRIDE) }
       if (flags.is(Mutable)) writeModTag(MUTABLE)
@@ -755,7 +755,6 @@ class TreePickler(pickler: TastyPickler) {
       if (flags.is(Contravariant)) writeModTag(CONTRAVARIANT)
       if (flags.is(Opaque)) writeModTag(OPAQUE)
       if (flags.is(Open)) writeModTag(OPEN)
-      if (flags.is(GivenClass)) writeModTag(GIVEN)
     }
   }
 

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -667,7 +667,7 @@ class TreeUnpickler(reader: TastyReader,
           case HASDEFAULT => addFlag(HasDefault)
           case STABLE => addFlag(StableRealizable)
           case EXTENSION => addFlag(Extension)
-          case GIVEN => addFlag(if isType then GivenClass else Given)
+          case GIVEN => addFlag(Given)
           case PARAMsetter => addFlag(ParamAccessor)
           case PARAMalias => addFlag(SuperParamAlias)
           case EXPORTED => addFlag(Exported)

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

@@ -473,7 +473,7 @@ object Checking {
     if (sym.is(Implicit)) {
       if (sym.owner.is(Package))
         fail(TopLevelCantBeImplicit(sym))
-      if (sym.isType)
+      if sym.isType && (!sym.isClass || sym.is(Trait)) then
         fail(TypesAndTraitsCantBeImplicit())
     }
     if sym.is(Transparent) then

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 &~ Implicit)
+        val flags = checkFlags(tree.mods.flags)
         val name = checkNoConflict(tree.name, flags.is(Private), tree.span).asTypeName
         val cls =
           createOrRefine[ClassSymbol](tree, name, flags, ctx.owner,
@@ -425,7 +425,7 @@ class Namer { typer: Typer =>
    * is still missing its parents. Parents are set to Nil when completion starts and are
    * set to the actual parents later. If a superclass completes a subclass in one
    * of its parents, the parents of the superclass or some intervening class might
-   * not yet be set. This situation can be detected by asking for the baseType of Any - 
+   * not yet be set. This situation can be detected by asking for the baseType of Any -
    * if that type does not exist, one of the base classes of this class misses its parents.
    * If this situation arises, the computation of the superclass might be imprecise.
    * For instance, in i12722.scala, the superclass of `IPersonalCoinOps` is computed