Rename TransparentTrait -> TransparentClass

Author: odersky

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

@@ -449,7 +449,7 @@ trait ConstraintHandling {
 
   private def isTransparent(tp: Type)(using Context): Boolean = tp match
     case AndType(tp1, tp2) => isTransparent(tp1) && isTransparent(tp2)
-    case _ => tp.typeSymbol.isTransparentTrait && !tp.isLambdaSub
+    case _ => tp.typeSymbol.isTransparentClass && !tp.isLambdaSub
 
   /** 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
@@ -458,28 +458,28 @@ trait ConstraintHandling {
    *  types (since in this case the type was not a true intersection of transparent traits
    *  and other types to start with).
    */
-  def dropTransparentTraits(tp: Type, bound: Type)(using Context): Type =
+  def dropTransparentClasses(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 dropOneTransparentTrait(tp: Type): Type =
+    def dropOneTransparentClass(tp: Type): Type =
       val tpd = tp.dealias
       if isTransparent(tpd) && !kept.contains(tpd) then
         dropped = tpd :: dropped
         defn.AnyType
       else tpd match
         case AndType(tp1, tp2) =>
-          val tp1w = dropOneTransparentTrait(tp1)
+          val tp1w = dropOneTransparentClass(tp1)
           if tp1w ne tp1 then tp1w & tp2
           else
-            val tp2w = dropOneTransparentTrait(tp2)
+            val tp2w = dropOneTransparentClass(tp2)
             if tp2w ne tp2 then tp1 & tp2w
             else tpd
         case _ =>
           tp
 
     def recur(tp: Type): Type =
-      val tpw = dropOneTransparentTrait(tp)
+      val tpw = dropOneTransparentClass(tp)
       if tpw eq tp then tp
       else if tpw <:< bound then recur(tpw)
       else
@@ -496,7 +496,7 @@ trait ConstraintHandling {
       tp
     else
       tpw
-  end dropTransparentTraits
+  end dropTransparentClasses
 
   /** If `tp` is an applied match type alias which is also an unreducible application
    *  of a higher-kinded type to a wildcard argument, widen to the match type's bound,
@@ -519,7 +519,7 @@ trait ConstraintHandling {
    *      of all common base types, provided the result is a subtype of `bound`.
    *   3. Widen some irreducible applications of higher-kinded types to wildcard arguments
    *      (see @widenIrreducible).
-   *   4. Drop transparent traits from intersections (see @dropTransparentTraits).
+   *   4. Drop transparent traits from intersections (see @dropTransparentClasses).
    *
    *  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,
@@ -551,7 +551,7 @@ trait ConstraintHandling {
           if (widenedFromUnion ne widenedFromSingle) && isTransparent(widenedFromUnion) then
             widenedFromSingle
           else
-            dropTransparentTraits(widenedFromUnion, bound)
+            dropTransparentClasses(widenedFromUnion, bound)
         widenIrreducible(widened)
 
     wideInst match

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

@@ -1761,7 +1761,7 @@ class Definitions {
   def isInfix(sym: Symbol)(using Context): Boolean =
     (sym eq Object_eq) || (sym eq Object_ne)
 
-  @tu lazy val assumedTransparentTraits =
+  @tu lazy val assumedTransparentClasses =
     Set[Symbol](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/SymDenotations.scala

@@ -1144,9 +1144,9 @@ object SymDenotations {
     final def isEffectivelySealed(using Context): Boolean =
       isOneOf(FinalOrSealed) || isClass && !isOneOf(EffectivelyOpenFlags)
 
-    final def isTransparentTrait(using Context): Boolean =
+    final def isTransparentClass(using Context): Boolean =
       is(TransparentType)
-      || defn.assumedTransparentTraits.contains(symbol)
+      || defn.assumedTransparentClasses.contains(symbol)
       || isClass && hasAnnotation(defn.TransparentTraitAnnot)
 
     /** The class containing this denotation which has the given effective name. */

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

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

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

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