Strip opaque refinement in widening

We only care about the opaque refinement in member selection.
By stripping the opaque alias in widening, the compiler avoids
doing useless work.

Author: liufengyun

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

@@ -769,7 +769,7 @@ object Types {
           tycon.derivedLambdaAbstraction(tycon.paramNames, tycon.paramInfos, info).appliedTo(tp.args))
 
       def goThis(tp: ThisType) =
-        val underlying = tp.underlying
+        val underlying = tp.underlying(withOpaque = true)
         val d = go(underlying)
         if d.exists then
           if underlying.isInstanceOf[AndType] then
@@ -2694,10 +2694,14 @@ object Types {
       case _ if ctx.mode.is(Mode.Interactive) => defn.AnyClass // was observed to happen in IDE mode
     }
 
-    override def underlying(using Context): Type =
+    override def underlying(using Context): Type = underlying(withOpaque = false)
+
+    final def underlying(withOpaque: Boolean)(using Context): Type =
       if (ctx.erasedTypes) tref
       else cls.info match {
-        case cinfo: ClassInfo => cinfo.selfType
+        case cinfo: ClassInfo =>
+          if withOpaque then cinfo.selfType
+          else cinfo.selfTypeWithoutOpaque
         case _: ErrorType | NoType if ctx.mode.is(Mode.Interactive) => cls.info
           // can happen in IDE if `cls` is stale
       }
@@ -4548,6 +4552,7 @@ object Types {
 
     private var selfTypeCache: Type = null
     private var appliedRefCache: Type = null
+    private var selfTypeWithoutOpaqueCache: Type = null
 
     /** The self type of a class is the conjunction of
      *   - the explicit self type if given (or the info of a given self symbol), and
@@ -4566,6 +4571,23 @@ object Types {
       selfTypeCache
     }
 
+    /** The self type without opaque members refinements */
+    def selfTypeWithoutOpaque(using Context): Type = {
+      def dropRefinement(tp: Type): Type = tp match
+        case RefinedType(parent, _, _: TypeAlias) =>
+          // TODO: maybe strengthen the check for Opaque flag
+          parent
+        case AndType(tp1, tp2) =>
+          AndType(dropRefinement(tp1), dropRefinement(tp2))
+        case _ =>
+          tp
+      end dropRefinement
+
+      if selfTypeWithoutOpaqueCache == null then
+        selfTypeWithoutOpaqueCache = dropRefinement(selfType)
+      selfTypeWithoutOpaqueCache
+    }
+
     def appliedRef(using Context): Type = {
       if (appliedRefCache == null)
         appliedRefCache =

tests/run/option-extract.scala

@@ -6,7 +6,7 @@ enum Option[+A]:
   opaque type ExtractResult[B] = (=> B) => B
 
   def extract[B](f: A => B): ExtractResult[B] =
-    def result(default: => B): B = (this: Option[A]) match
+    def result(default: => B): B = this match
       case None => default
       case Some(elem) => f(elem)
     result