From 5c5e8d4dcd151a6e2bf9e7c259c618b9b4eff00f Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Fri, 20 Jul 2012 19:12:30 +0200
Subject: SI-4881 infer variance from formals, then result

Changed behavior so that when determining the target variance of a method parameter,
the variance in formals comes first. If variance is still undecided by that,
the variance in the result type is used as a secondary criterion.

(This is also done when determining prototype type params.)
---
 .../scala/tools/nsc/typechecker/Infer.scala        | 15 +++++++++--
 test/files/neg/t5845.check                         |  5 +---
 test/files/pos/t4881.scala                         | 31 ++++++++++++++++++++++
 3 files changed, 45 insertions(+), 6 deletions(-)
 create mode 100644 test/files/pos/t4881.scala

diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
index 960c210649..47cf80807a 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala
@@ -445,7 +445,7 @@ trait Infer {
       val tvars = tparams map freshVar
       if (isConservativelyCompatible(restpe.instantiateTypeParams(tparams, tvars), pt))
         map2(tparams, tvars)((tparam, tvar) =>
-          instantiateToBound(tvar, varianceInTypes(formals)(tparam)))
+          instantiateToBound(tvar, inferVariance(formals, restpe)(tparam)))
       else
         tvars map (tvar => WildcardType)
     }
@@ -575,13 +575,24 @@ trait Infer {
             "argument expression's type is not compatible with formal parameter type" + foundReqMsg(tp1, pt1))
         }
       }
+
       val targs = solvedTypes(
-        tvars, tparams, tparams map varianceInTypes(formals),
+        tvars, tparams, tparams map inferVariance(formals, restpe),
         false, lubDepth(formals) max lubDepth(argtpes)
       )
       adjustTypeArgs(tparams, tvars, targs, restpe)
     }
 
+    /** Determine which variance to assume for the type paraneter. We first chose the variance
+     *  that minimizes any formal parameters. If that is still undetermined, because the type parameter
+     *  does not appear as a formal parameter type, then we pick the variance so that it minimizes the
+     *  method's result type instead.
+     */
+    private def inferVariance(formals: List[Type], restpe: Type)(tparam: Symbol): Int = {
+      val v = varianceInTypes(formals)(tparam)
+      if (v != VarianceFlags) v else varianceInType(restpe)(tparam)
+    }
+
     private[typechecker] def followApply(tp: Type): Type = tp match {
       case NullaryMethodType(restp) =>
         val restp1 = followApply(restp)
diff --git a/test/files/neg/t5845.check b/test/files/neg/t5845.check
index 8c6100d6de..c0b402fccb 100644
--- a/test/files/neg/t5845.check
+++ b/test/files/neg/t5845.check
@@ -1,7 +1,4 @@
-t5845.scala:9: error: value +++ is not a member of Int
-  println(5 +++ 5)
-            ^
 t5845.scala:15: error: value +++ is not a member of Int
   println(5 +++ 5)
             ^
-two errors found
+one error found
diff --git a/test/files/pos/t4881.scala b/test/files/pos/t4881.scala
new file mode 100644
index 0000000000..46cfad9793
--- /dev/null
+++ b/test/files/pos/t4881.scala
@@ -0,0 +1,31 @@
+class Contra[-T]
+trait A
+trait B extends A
+trait C extends B
+
+// test improved variance inference: first try formals to see in which variance positions the type param appears;
+// only when that fails to determine variance, look at result type
+object Test {
+  def contraLBUB[a >: C <: A](): Contra[a] = null
+  def contraLB[a >: C](): Contra[a] = null
+
+{
+  val x = contraLBUB() //inferred Contra[C] instead of Contra[A]
+  val x1: Contra[A] = x
+}
+
+{
+  val x = contraLB() //inferred Contra[C] instead of Contra[Any]
+  val x1: Contra[Any] = x
+}
+
+{
+  val x = contraLBUB // make sure it does the same thing as its ()-less counterpart
+  val x1: Contra[A] = x
+}
+
+{
+  val x = contraLB
+  val x1: Contra[Any] = x
+}
+}
-- 
cgit v1.2.3