Interpret transparent for traits

Author: odersky

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

@@ -286,35 +286,35 @@ trait ConstraintHandling {
     }
   }
 
-  /** 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
+  /** If `tp` is an intersection such that some operands are transparent trait instances
+   *  and others are not, replace as many transparent 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 mixin traits
+   *  types (since in this case the type was not a true intersection of transparent traits
    *  and other types to start with).
    */
-  def dropMixinTraits(tp: Type, bound: Type)(using Context): Type =
+  def dropTransparentTraits(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 dropOneMixinTrait(tp: Type): Type =
+    def dropOneTransparentTrait(tp: Type): Type =
       val tpd = tp.dealias
-      if tpd.typeSymbol.isMixinTrait && !tpd.isLambdaSub && !kept.contains(tpd) then
+      if tpd.typeSymbol.isTransparentTrait && !tpd.isLambdaSub && !kept.contains(tpd) then
         dropped = tpd :: dropped
         defn.AnyType
       else tpd match
         case AndType(tp1, tp2) =>
-          val tp1w = dropOneMixinTrait(tp1)
+          val tp1w = dropOneTransparentTrait(tp1)
           if tp1w ne tp1 then tp1w & tp2
           else
-            val tp2w = dropOneMixinTrait(tp2)
+            val tp2w = dropOneTransparentTrait(tp2)
             if tp2w ne tp2 then tp1 & tp2w
             else tpd
         case _ =>
           tp
 
     def recur(tp: Type): Type =
-      val tpw = dropOneMixinTrait(tp)
+      val tpw = dropOneTransparentTrait(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 dropMixinTraits
+  end dropTransparentTraits
 
   /** 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 mixin traits from intersections (see @dropMixinTraits)
+   *   3. drop transparent traits from intersections (see @dropTransparentTraits)
    *
    *  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 dropMixinTraits(widenOr(widenSingle(inst)), bound)
+      else dropTransparentTraits(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/Flags.scala

@@ -579,4 +579,5 @@ object Flags {
   val SyntheticParam: FlagSet                = Synthetic | Param
   val SyntheticTermParam: FlagSet            = Synthetic | TermParam
   val SyntheticTypeParam: FlagSet            = Synthetic | TypeParam
+  val TransparentTrait: FlagSet              = Trait | Transparent
 }

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

@@ -1109,9 +1109,10 @@ object SymDenotations {
     final def isEffectivelySealed(using Context): Boolean =
       isOneOf(FinalOrSealed) || isClass && !isOneOf(EffectivelyOpenFlags)
 
-    final def isMixinTrait(using Context): Boolean =
-      isClass
-      && (hasAnnotation(defn.MixinAnnot) || defn.assumedMixinTraits.contains(symbol.asClass))
+    final def isTransparentTrait(using Context): Boolean =
+      isAllOf(TransparentTrait)
+      || isClass
+          && (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/TypeComparer.scala

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

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

@@ -1135,7 +1135,7 @@ trait Applications extends Compatibility {
        && tree.tpe.classSymbol.isEnumCase
        && tree.tpe.widen.isValueType
     then
-      val widened = TypeComparer.dropMixinTraits(
+      val widened = TypeComparer.dropTransparentTraits(
         tree.tpe.parents.reduceLeft(TypeComparer.andType(_, _)),
         pt)
       if widened <:< pt then Typed(tree, TypeTree(widened))

tests/neg-custom-args/fatal-warnings/supertraits.scala

@@ -1,6 +1,6 @@
 import annotation.mixin
-@mixin sealed trait TA
-@mixin sealed trait TB
+transparent sealed trait TA
+transparent sealed trait TB
 trait S
 case object a extends S, TA, TB
 case object b extends S, TA, TB

tests/neg/supertraits.scala

@@ -1,5 +1,5 @@
 import annotation.mixin
-@mixin trait S
+transparent trait S
 trait A
 class B extends A, S
 class C extends A, S