Merge pull request #10243 from dotty-staging/fix-#10239

Fix #10239: `@mixin trait` instead of `super trait`

Author: odersky

community-build/community-projects/stdLib213

@@ -213,8 +213,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case class Inline()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Inline)
 
     case class Transparent()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.EmptyFlags)
-
-    case class Super()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.SuperTrait)
   }
 
   /** Modifiers and annotations for definitions

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

@@ -286,35 +286,35 @@ trait ConstraintHandling {
     }
   }
 
-  /** If `tp` is an intersection such that some operands are super trait instances
-   *  and others are not, replace as many super trait instances as possible with Any
+  /** If `tp` is an intersection such that some operands are mixin trait instances
+   *  and others are not, replace as many mixin trait instances as possible with Any
    *  as long as the result is still a subtype of `bound`. But fall back to the
    *  original type if the resulting widened type is a supertype of all dropped
-   *  types (since in this case the type was not a true intersection of super traits
+   *  types (since in this case the type was not a true intersection of mixin traits
    *  and other types to start with).
    */
-  def dropSuperTraits(tp: Type, bound: Type)(using Context): Type =
+  def dropMixinTraits(tp: Type, bound: Type)(using Context): Type =
     var kept: Set[Type] = Set()      // types to keep since otherwise bound would not fit
     var dropped: List[Type] = List() // the types dropped so far, last one on top
 
-    def dropOneSuperTrait(tp: Type): Type =
+    def dropOneMixinTrait(tp: Type): Type =
       val tpd = tp.dealias
-      if tpd.typeSymbol.isSuperTrait && !tpd.isLambdaSub && !kept.contains(tpd) then
+      if tpd.typeSymbol.isMixinTrait && !tpd.isLambdaSub && !kept.contains(tpd) then
         dropped = tpd :: dropped
         defn.AnyType
       else tpd match
         case AndType(tp1, tp2) =>
-          val tp1w = dropOneSuperTrait(tp1)
+          val tp1w = dropOneMixinTrait(tp1)
           if tp1w ne tp1 then tp1w & tp2
           else
-            val tp2w = dropOneSuperTrait(tp2)
+            val tp2w = dropOneMixinTrait(tp2)
             if tp2w ne tp2 then tp1 & tp2w
             else tpd
         case _ =>
           tp
 
     def recur(tp: Type): Type =
-      val tpw = dropOneSuperTrait(tp)
+      val tpw = dropOneMixinTrait(tp)
       if tpw eq tp then tp
       else if tpw <:< bound then recur(tpw)
       else
@@ -324,15 +324,15 @@ trait ConstraintHandling {
 
     val tpw = recur(tp)
     if (tpw eq tp) || dropped.forall(_ frozen_<:< tpw) then tp else tpw
-  end dropSuperTraits
+  end dropMixinTraits
 
   /** Widen inferred type `inst` with upper `bound`, according to the following rules:
    *   1. If `inst` is a singleton type, or a union containing some singleton types,
    *      widen (all) the singleton type(s), provided the result is a subtype of `bound`
    *      (i.e. `inst.widenSingletons <:< bound` succeeds with satisfiable constraint)
    *   2. If `inst` is a union type, approximate the union type from above by an intersection
    *      of all common base types, provided the result is a subtype of `bound`.
-   *   3. drop super traits from intersections (see @dropSuperTraits)
+   *   3. drop mixin traits from intersections (see @dropMixinTraits)
    *
    *  Don't do these widenings if `bound` is a subtype of `scala.Singleton`.
    *  Also, if the result of these widenings is a TypeRef to a module class,
@@ -357,7 +357,7 @@ trait ConstraintHandling {
 
     val wideInst =
       if isSingleton(bound) then inst
-      else dropSuperTraits(widenOr(widenSingle(inst)), bound)
+      else dropMixinTraits(widenOr(widenSingle(inst)), bound)
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>
         TermRef(wideInst.prefix, wideInst.symbol.sourceModule)

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

@@ -909,6 +909,7 @@ class Definitions {
   @tu lazy val InvariantBetweenAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InvariantBetween")
   @tu lazy val MainAnnot: ClassSymbol = requiredClass("scala.main")
   @tu lazy val MigrationAnnot: ClassSymbol = requiredClass("scala.annotation.migration")
+  @tu lazy val MixinAnnot: ClassSymbol = requiredClass("scala.annotation.mixin")
   @tu lazy val NativeAnnot: ClassSymbol = requiredClass("scala.native")
   @tu lazy val RepeatedAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Repeated")
   @tu lazy val SourceFileAnnot: ClassSymbol = requiredClass("scala.annotation.internal.SourceFile")
@@ -917,7 +918,6 @@ class Definitions {
   @tu lazy val ScalaStrictFPAnnot: ClassSymbol = requiredClass("scala.annotation.strictfp")
   @tu lazy val ScalaStaticAnnot: ClassSymbol = requiredClass("scala.annotation.static")
   @tu lazy val SerialVersionUIDAnnot: ClassSymbol = requiredClass("scala.SerialVersionUID")
-  @tu lazy val SuperTraitAnnot: ClassSymbol = requiredClass("scala.annotation.superTrait")
   @tu lazy val TASTYSignatureAnnot: ClassSymbol = requiredClass("scala.annotation.internal.TASTYSignature")
   @tu lazy val TASTYLongSignatureAnnot: ClassSymbol = requiredClass("scala.annotation.internal.TASTYLongSignature")
   @tu lazy val TailrecAnnot: ClassSymbol = requiredClass("scala.annotation.tailrec")
@@ -1506,7 +1506,7 @@ class Definitions {
   def isInfix(sym: Symbol)(using Context): Boolean =
     (sym eq Object_eq) || (sym eq Object_ne)
 
-  @tu lazy val assumedSuperTraits =
+  @tu lazy val assumedMixinTraits =
     Set(ComparableClass, ProductClass, SerializableClass,
       // add these for now, until we had a chance to retrofit 2.13 stdlib
       // we should do a more through sweep through it then.

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

@@ -227,7 +227,7 @@ object Flags {
   val (Final @ _, _, _) = newFlags(6, "final")
 
   /** A method symbol / a super trait */
-  val (_, Method @ _, SuperTrait @ _) = newFlags(7, "<method>", "super")
+  val (_, Method @ _, _) = newFlags(7, "<method>")
 
   /** A (term or type) parameter to a class or method */
   val (Param @ _, TermParam @ _, TypeParam @ _) = newFlags(8, "<param>")
@@ -437,8 +437,7 @@ object Flags {
    *  TODO: Should check that FromStartFlags do not change in completion
    */
   val FromStartFlags: FlagSet = commonFlags(
-    Module, Package, Deferred, Method, Case, Enum,
-    SuperTrait, Param, ParamAccessor,
+    Module, Package, Deferred, Method, Case, Enum, Param, ParamAccessor,
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,
     Extension, NonMember, Implicit, Given, Permanent, Synthetic,

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

@@ -1095,11 +1095,9 @@ object SymDenotations {
     final def isEffectivelySealed(using Context): Boolean =
       isOneOf(FinalOrSealed) || isClass && !isOneOf(EffectivelyOpenFlags)
 
-    final def isSuperTrait(using Context): Boolean =
+    final def isMixinTrait(using Context): Boolean =
       isClass
-      && (is(SuperTrait)
-          || defn.assumedSuperTraits.contains(symbol.asClass)
-          || hasAnnotation(defn.SuperTraitAnnot))
+      && (hasAnnotation(defn.MixinAnnot) || defn.assumedMixinTraits.contains(symbol.asClass))
 
     /** The class containing this denotation which has the given effective name. */
     final def enclosingClassNamed(name: Name)(using Context): Symbol = {

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

@@ -2638,8 +2638,8 @@ object TypeComparer {
   def widenInferred(inst: Type, bound: Type)(using Context): Type =
     comparing(_.widenInferred(inst, bound))
 
-  def dropSuperTraits(tp: Type, bound: Type)(using Context): Type =
-    comparing(_.dropSuperTraits(tp, bound))
+  def dropMixinTraits(tp: Type, bound: Type)(using Context): Type =
+    comparing(_.dropMixinTraits(tp, bound))
 
   def constrainPatternType(pat: Type, scrut: Type)(using Context): Boolean =
     comparing(_.constrainPatternType(pat, scrut))

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

@@ -729,7 +729,6 @@ class TreePickler(pickler: TastyPickler) {
       if (flags.is(Sealed)) writeModTag(SEALED)
       if (flags.is(Abstract)) writeModTag(ABSTRACT)
       if (flags.is(Trait)) writeModTag(TRAIT)
-      if flags.is(SuperTrait) then writeModTag(SUPERTRAIT)
       if (flags.is(Covariant)) writeModTag(COVARIANT)
       if (flags.is(Contravariant)) writeModTag(CONTRAVARIANT)
       if (flags.is(Opaque)) writeModTag(OPAQUE)

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

@@ -648,7 +648,6 @@ class TreeUnpickler(reader: TastyReader,
           case STATIC => addFlag(JavaStatic)
           case OBJECT => addFlag(Module)
           case TRAIT => addFlag(Trait)
-          case SUPERTRAIT => addFlag(SuperTrait)
           case ENUM => addFlag(Enum)
           case LOCAL => addFlag(Local)
           case SYNTHETIC => addFlag(Synthetic)
@@ -672,6 +671,9 @@ class TreeUnpickler(reader: TastyReader,
           case PROTECTEDqualified =>
             addFlag(Protected)
             privateWithin = readWithin
+          case SUPERTRAIT =>
+            readByte()
+            annotFns = (_ => Annotation(defn.MixinAnnot)) :: annotFns
           case ANNOTATION =>
             annotFns = readAnnot :: annotFns
           case tag =>

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

@@ -3378,7 +3378,7 @@ object Parsers {
       }
     }
 
-    /** TmplDef ::=  ([‘case’] ‘class’ | [‘super’] ‘trait’) ClassDef
+    /** TmplDef ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
      *            |  [‘case’] ‘object’ ObjectDef
      *            |  ‘enum’ EnumDef
      *            |  ‘given’ GivenDef
@@ -3388,8 +3388,6 @@ object Parsers {
       in.token match {
         case TRAIT =>
           classDef(start, in.skipToken(addFlag(mods, Trait)))
-        case SUPERTRAIT =>
-          classDef(start, in.skipToken(addFlag(mods, Trait | SuperTrait)))
         case CLASS =>
           classDef(start, in.skipToken(mods))
         case CASECLASS =>