Redo infoMeet so that it returns one of its operands where possible

Author: odersky

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

@@ -385,7 +385,7 @@ object Denotations {
      *
      *  If there is no preferred accessible denotation, return a JointRefDenotation
      *  with one of the operand symbols (unspecified which one), and an info which
-     *  is the intersection (using `&` or `safe_&` if `safeIntersection` is true)
+     *  is the intersection using `&` or `safe_&` if `safeIntersection` is true)
      *  of the infos of the operand denotations.
      */
     def & (that: Denotation, pre: Type, safeIntersection: Boolean = false)(implicit ctx: Context): Denotation = {
@@ -542,82 +542,70 @@ object Denotations {
     (for ((name1, name2, idx) <- tp1.paramNames.lazyZip(tp2.paramNames).lazyZip(tp1.paramNames.indices))
       yield if (name1 == name2) name1 else tp1.companion.syntheticParamName(idx)).toList
 
-  /** Normally, `tp1 & tp2`
-    *  Special cases for matching methods and classes, with
-    *  the possibility of returning NoType.
-    *  Special handling of ExprTypes, where mixed intersections widen the ExprType away.
-    */
+  /** Normally, `tp1 & tp2`, with extra care taken to return `tp1` or `tp2` directly if that's
+   *  a valid answer. Special cases for matching methods and classes, with
+   *  the possibility of returning NoType. Special handling of ExprTypes, where mixed
+   *  intersections widen the ExprType away.
+   */
   def infoMeet(tp1: Type, tp2: Type, safeIntersection: Boolean)(implicit ctx: Context): Type =
-    if (tp1 eq tp2) tp1
-    else tp1 match {
+    if tp1 eq tp2 then tp1
+    else tp1 match
       case tp1: TypeBounds =>
-        tp2 match {
-          case tp2: TypeBounds => if (safeIntersection) tp1 safe_& tp2 else tp1 & tp2
+        tp2 match
+          case tp2: TypeBounds => if safeIntersection then tp1 safe_& tp2 else tp1 & tp2
           case tp2: ClassInfo => tp2
           case _ => NoType
-        }
       case tp1: ClassInfo =>
-        tp2 match {
+        tp2 match
           case tp2: ClassInfo if tp1.cls eq tp2.cls => tp1.derivedClassInfo(tp1.prefix & tp2.prefix)
           case tp2: TypeBounds => tp1
           case _ => NoType
-        }
-
-      // Two remedial strategies:
-      //
-      //  1. Prefer method types over poly types. This is necessary to handle
-      //     overloaded definitions like the following
-      //
-      //        def ++ [B >: A](xs: C[B]): D[B]
-      //        def ++ (xs: C[A]): D[A]
-      //
-      //     (Code like this is found in the collection strawman)
-      //
-      // 2. In the case of two method types or two polytypes with matching
-      //    parameters and implicit status, merge corresponding parameter
-      //    and result types.
       case tp1: MethodType =>
-        tp2 match {
+        tp2 match
           case tp2: MethodType
           if ctx.typeComparer.matchingMethodParams(tp1, tp2) && (tp1.companion eq tp2.companion) =>
-            val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
-            if resType.exists then
-              tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)
-            else
-              NoType
+            val resType1 = tp1.resType
+            val resType2 = tp2.resType.subst(tp2, tp1)
+            val resType = infoMeet(resType1, resType2, safeIntersection)
+            if resType eq resType1 then tp1
+            else if resType eq resType2 then tp2
+            else if !resType.exists then NoType
+            else tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)
           case _ =>
             NoType
-        }
       case tp1: PolyType =>
-        tp2 match {
-          case tp2: PolyType if ctx.typeComparer.matchingPolyParams(tp1, tp2) =>
-            val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
-            if resType.exists then
+        tp2 match
+          case tp2: PolyType if sameLength(tp1.paramNames, tp2.paramNames) =>
+            val resType1 = tp1.resType
+            val resType2 = tp2.resType.subst(tp2, tp1)
+            val resType = infoMeet(resType1, resType2, safeIntersection)
+            if (resType eq resType1) && ctx.typeComparer.matchingPolyParams(tp1, tp2) then
+              tp1
+            else if (resType eq resType2) && ctx.typeComparer.matchingPolyParams(tp2, tp1) then
+              tp2
+            else if !resType.exists then
+              NoType
+            else
               tp1.derivedLambdaType(
                 mergeParamNames(tp1, tp2),
                 tp1.paramInfos.zipWithConserve(tp2.paramInfos)( _ & _ ),
                 resType)
-            else
-              NoType
           case _ =>
             NoType
-        }
       case ExprType(rtp1) =>
-        tp2 match {
-          case ExprType(rtp2) => ExprType(rtp1 & rtp2)
-          case _ => infoMeet(rtp1, tp2, safeIntersection)
-        }
-      case _ =>
         tp2 match
-          case _: MethodType | _: PolyType =>
-            NoType
+          case ExprType(rtp2) =>
+            val resType = rtp1 & rtp2
+            if resType eq rtp1 then tp1
+            else if resType eq rtp2 then tp2
+            else ExprType(resType)
           case _ =>
-            try tp1 & tp2.widenExpr
-            catch
-              case ex: Throwable =>
-                println(i"error for meet: $tp1 &&& $tp2, ${tp1.getClass}, ${tp2.getClass}")
-                throw ex
-    }
+            infoMeet(rtp1, tp2, safeIntersection)
+      case _ =>
+        tp2 match
+          case _: MethodType | _: PolyType => NoType
+          case _ => tp1 & tp2.widenExpr
+  end infoMeet
 
   /** A non-overloaded denotation */
   abstract class SingleDenotation(symbol: Symbol, initInfo: Type) extends Denotation(symbol, initInfo) {