Fix #5202: Refine argForParam

argForParam was overly naive for the cases where the prefix was an & or | type.

Author: odersky

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

@@ -1988,9 +1988,10 @@ object Types {
     }
 
     /** The argument corresponding to class type parameter `tparam` as seen from
-     *  prefix `pre`.
+     *  prefix `pre`. Can produce a TypeBounds type in case prefix is an & or | type
+     *  and parameter is non-variant.
      */
-    def argForParam(pre: Type)(implicit ctx: Context): Type = {
+    def argForParam(pre: Type, variance: Int)(implicit ctx: Context): Type = {
       val tparam = symbol
       val cls = tparam.owner
       val base = pre.baseType(cls)
@@ -2010,10 +2011,17 @@ object Types {
             idx += 1
           }
           NoType
-        case OrType(base1, base2) => argForParam(base1) | argForParam(base2)
-        case AndType(base1, base2) => argForParam(base1) & argForParam(base2)
+        case base: AndOrType =>
+          var tp1 = argForParam(base.tp1, variance)
+          var tp2 = argForParam(base.tp2, variance)
+          if (tp1.isInstanceOf[TypeBounds] || tp2.isInstanceOf[TypeBounds] || variance == 0) {
+            // compute argument as a type bounds instead of a point type
+            tp1 = tp1.bounds
+            tp2 = tp2.bounds
+          }
+          if (base.isAnd == variance >= 0) tp1 & tp2 else tp1 | tp2
         case _ =>
-          if (pre.termSymbol is Package) argForParam(pre.select(nme.PACKAGE))
+          if (pre.termSymbol is Package) argForParam(pre.select(nme.PACKAGE), variance)
           else if (pre.isBottomType) pre
           else NoType
       }
@@ -2037,7 +2045,7 @@ object Types {
       else {
         if (isType) {
           val res =
-            if (currentSymbol.is(ClassTypeParam)) argForParam(prefix)
+            if (currentSymbol.is(ClassTypeParam)) argForParam(prefix, currentSymbol.paramVariance)
             else prefix.lookupRefined(name)
           if (res.exists) return res
           if (Config.splitProjections)
@@ -4462,14 +4470,17 @@ object Types {
      *  If the expansion is a wildcard parameter reference, convert its
      *  underlying bounds to a range, otherwise return the expansion.
      */
-    def expandParam(tp: NamedType, pre: Type): Type = tp.argForParam(pre) match {
-      case arg @ TypeRef(pre, _) if pre.isArgPrefixOf(arg.symbol) =>
-        arg.info match {
-          case TypeBounds(lo, hi) => range(atVariance(-variance)(reapply(lo)), reapply(hi))
-          case arg => reapply(arg)
-        }
-      case arg => reapply(arg)
-    }
+    def expandParam(tp: NamedType, pre: Type, variance: Int): Type =
+      tp.argForParam(pre, variance) match {
+        case arg @ TypeRef(pre, _) if pre.isArgPrefixOf(arg.symbol) =>
+          arg.info match {
+            case TypeBounds(lo, hi) => range(atVariance(-variance)(reapply(lo)), reapply(hi))
+            case arg => reapply(arg)
+          }
+        case TypeBounds(lo, hi) =>
+          range(lo, hi)
+        case arg => reapply(arg)
+      }
 
     /** Derived selection.
      *  @pre   the (upper bound of) prefix `pre` has a member named `tp.name`.
@@ -4479,12 +4490,15 @@ object Types {
       else pre match {
         case Range(preLo, preHi) =>
           val forwarded =
-            if (tp.symbol.is(ClassTypeParam)) expandParam(tp, preHi)
+            if (tp.symbol.is(ClassTypeParam)) expandParam(tp, preHi, tp.symbol.paramVariance)
             else tryWiden(tp, preHi)
           forwarded.orElse(
             range(super.derivedSelect(tp, preLo), super.derivedSelect(tp, preHi)))
         case _ =>
-          super.derivedSelect(tp, pre)
+          super.derivedSelect(tp, pre) match {
+            case TypeBounds(lo, hi) => range(lo, hi)
+            case tp => tp
+          }
       }
 
     override protected def derivedRefinedType(tp: RefinedType, parent: Type, info: Type): Type =

tests/neg/i5202.scala

@@ -0,0 +1,6 @@
+object Test {
+  val f: (Int => Int) | (String => Int) = (a: Int) => a + 3
+
+  f.apply(5) // error - found: Int expected: Int & String
+  f("c")     // error - found: String expected: Int & String
+}