Merge pull request #9032 from dotty-staging/fix-#9028

Fix #9028: Introduce super traits

Author: anatoliykmetyuk

community-build/community-projects/stdLib213

@@ -200,6 +200,8 @@ 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

@@ -300,8 +300,12 @@ trait ConstraintHandling[AbstractContext] {
    *      (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. (currently not enabled, see #9028) If `inst` is an intersection with some restricted base types, drop
-   *      the restricted base types from the intersection, provided the result is a subtype of `bound`.
+   *   3. If `inst` 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
+   *      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
+   *      and other types to start with).
    *
    *  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,
@@ -313,21 +317,38 @@ trait ConstraintHandling[AbstractContext] {
    */
   def widenInferred(inst: Type, bound: Type)(implicit actx: AbstractContext): Type =
 
-    def isRestricted(tp: Type) = tp.typeSymbol == defn.EnumValueClass // for now, to be generalized later
+    def dropSuperTraits(tp: Type): 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 =
+        val tpd = tp.dealias
+        if tpd.typeSymbol.isSuperTrait && !tpd.isLambdaSub && !kept.contains(tpd) then
+          dropped = tpd :: dropped
+          defn.AnyType
+        else tpd match
+          case AndType(tp1, tp2) =>
+            val tp1w = dropOneSuperTrait(tp1)
+            if tp1w ne tp1 then tp1w & tp2
+            else
+              val tp2w = dropOneSuperTrait(tp2)
+              if tp2w ne tp2 then tp1 & tp2w
+              else tpd
+          case _ =>
+            tp
 
-    def dropRestricted(tp: Type): Type = tp.dealias match
-      case tpd @ AndType(tp1, tp2) =>
-        if isRestricted(tp1) then tp2
-        else if isRestricted(tp2) then tp1
+      def recur(tp: Type): Type =
+        val tpw = dropOneSuperTrait(tp)
+        if tpw eq tp then tp
+        else if tpw <:< bound then recur(tpw)
         else
-          val tpw = tpd.derivedAndType(dropRestricted(tp1), dropRestricted(tp2))
-          if tpw ne tpd then tpw else tp
-      case _ =>
-        tp
+          kept += dropped.head
+          dropped = dropped.tail
+          recur(tp)
 
-    def widenRestricted(tp: Type) =
-      val tpw = dropRestricted(tp)
-      if (tpw ne tp) && (tpw <:< bound) then tpw else tp
+      val tpw = recur(tp)
+      if (tpw eq tp) || dropped.forall(_ frozen_<:< tpw) then tp else tpw
+    end dropSuperTraits
 
     def widenOr(tp: Type) =
       val tpw = tp.widenUnion
@@ -343,10 +364,7 @@ trait ConstraintHandling[AbstractContext] {
 
     val wideInst =
       if isSingleton(bound) then inst
-      else /*widenRestricted*/(widenOr(widenSingle(inst)))
-        // widenRestricted is currently not called since it's special cased in `dropEnumValue`
-        // in `Namer`. It's left in here in case we want to generalize the scheme to other
-        // "protected inheritance" classes.
+      else dropSuperTraits(widenOr(widenSingle(inst)))
     wideInst match
       case wideInst: TypeRef if wideInst.symbol.is(Module) =>
         TermRef(wideInst.prefix, wideInst.symbol.sourceModule)

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

@@ -640,7 +640,6 @@ class Definitions {
   @tu lazy val EnumClass: ClassSymbol = ctx.requiredClass("scala.Enum")
     @tu lazy val Enum_ordinal: Symbol = EnumClass.requiredMethod(nme.ordinal)
 
-  @tu lazy val EnumValueClass: ClassSymbol = ctx.requiredClass("scala.runtime.EnumValue")
   @tu lazy val EnumValuesClass: ClassSymbol = ctx.requiredClass("scala.runtime.EnumValues")
   @tu lazy val ProductClass: ClassSymbol = ctx.requiredClass("scala.Product")
     @tu lazy val Product_canEqual          : Symbol = ProductClass.requiredMethod(nme.canEqual_)
@@ -809,6 +808,7 @@ class Definitions {
   @tu lazy val ScalaStrictFPAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.strictfp")
   @tu lazy val ScalaStaticAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.static")
   @tu lazy val SerialVersionUIDAnnot: ClassSymbol = ctx.requiredClass("scala.SerialVersionUID")
+  @tu lazy val SuperTraitAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.superTrait")
   @tu lazy val TASTYSignatureAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.TASTYSignature")
   @tu lazy val TASTYLongSignatureAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.internal.TASTYLongSignature")
   @tu lazy val TailrecAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.tailrec")
@@ -1313,6 +1313,21 @@ class Definitions {
   def isInfix(sym: Symbol)(implicit ctx: Context): Boolean =
     (sym eq Object_eq) || (sym eq Object_ne)
 
+  @tu lazy val assumedSuperTraits =
+    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.
+      ctx.requiredClass("scala.collection.SortedOps"),
+      ctx.requiredClass("scala.collection.StrictOptimizedSortedSetOps"),
+      ctx.requiredClass("scala.collection.generic.DefaultSerializable"),
+      ctx.requiredClass("scala.collection.generic.IsIterable"),
+      ctx.requiredClass("scala.collection.generic.IsIterableOnce"),
+      ctx.requiredClass("scala.collection.generic.IsMap"),
+      ctx.requiredClass("scala.collection.generic.IsSeq"),
+      ctx.requiredClass("scala.collection.generic.Subtractable"),
+      ctx.requiredClass("scala.collection.immutable.StrictOptimizedSeqOps")
+    )
+
   // ----- primitive value class machinery ------------------------------------------
 
   /** This class would also be obviated by the implicit function type design */

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

@@ -222,8 +222,8 @@ object Flags {
   /** Labeled with `final` modifier */
   val (Final @ _, _, _) = newFlags(6, "final")
 
-  /** A method symbol */
-  val (_, Method @ _, HigherKinded @ _) = newFlags(7, "<method>", "<higher kinded>") // TODO drop HigherKinded
+  /** A method symbol / a super trait */
+  val (_, Method @ _, SuperTrait @ _) = newFlags(7, "<method>", "super")
 
   /** A (term or type) parameter to a class or method */
   val (Param @ _, TermParam @ _, TypeParam @ _) = newFlags(8, "<param>")
@@ -439,7 +439,7 @@ object Flags {
    */
   val FromStartFlags: FlagSet = commonFlags(
     Module, Package, Deferred, Method, Case, Enum,
-    HigherKinded, Param, ParamAccessor,
+    SuperTrait, Param, ParamAccessor,
     Scala2SpecialFlags, MutableOrOpen, Opaque, Touched, JavaStatic,
     OuterOrCovariant, LabelOrContravariant, CaseAccessor,
     Extension, NonMember, Implicit, Given, Permanent, Synthetic,

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

@@ -1170,6 +1170,12 @@ object SymDenotations {
     final def isEffectivelySealed(using Context): Boolean =
       isOneOf(FinalOrSealed) || isClass && !isOneOf(EffectivelyOpenFlags)
 
+    final def isSuperTrait(using Context): Boolean =
+      isClass
+      && (is(SuperTrait)
+          || defn.assumedSuperTraits.contains(symbol.asClass)
+          || hasAnnotation(defn.SuperTraitAnnot))
+
     /** The class containing this denotation which has the given effective name. */
     final def enclosingClassNamed(name: Name)(implicit ctx: Context): Symbol = {
       val cls = enclosingClass

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

@@ -705,6 +705,7 @@ 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

@@ -639,6 +639,7 @@ 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)

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

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

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -586,7 +586,8 @@ object Scanners {
         currentRegion = r.outer
       case _ =>
 
-    /** - Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT, SEMI + ELSE => ELSE, COLON + <EOL> => COLONEOL
+    /** - Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT, SUPER + TRAIT => SUPERTRAIT
+     *         SEMI + ELSE => ELSE, COLON + <EOL> => COLONEOL
      *  - Insert missing OUTDENTs at EOF
      */
     def postProcessToken(): Unit = {
@@ -602,6 +603,10 @@ object Scanners {
           if (token == CLASS) fuse(CASECLASS)
           else if (token == OBJECT) fuse(CASEOBJECT)
           else reset()
+        case SUPER =>
+          lookAhead()
+          if token == TRAIT then fuse(SUPERTRAIT)
+          else reset()
         case SEMI =>
           lookAhead()
           if (token != ELSE) reset()