Merge pull request #3412 from retronym/ticket/2066-2.10-compat

 -Xsource:2.10: lenient treatment of variance in <:<, =:=

5 files changed, 77 insertions, 2 deletions

diff --git a/src/reflect/scala/reflect/internal/settings/MutableSettings.scala b/src/reflect/scala/reflect/internal/settings/MutableSettings.scala
index 28afd18fe0..816916787e 100644
--- a/src/reflect/scala/reflect/internal/settings/MutableSettings.scala
+++ b/src/reflect/scala/reflect/internal/settings/MutableSettings.scala
@@ -51,6 +51,8 @@ abstract class MutableSettings extends AbsSettings {
 
   def Yrecursion: IntSetting
   def maxClassfileName: IntSetting
+
+  def isScala211: Boolean
 }
 
 object MutableSettings {
diff --git a/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala b/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala
index 3c4e93f11d..f9b10c90be 100644
--- a/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala
+++ b/src/reflect/scala/reflect/internal/tpe/TypeComparers.scala
@@ -173,11 +173,11 @@ trait TypeComparers {
   // SI-2066 This prevents overrides with incompatible variance in higher order type parameters.
   private def methodHigherOrderTypeParamsSameVariance(sym1: Symbol, sym2: Symbol) = {
     def ignoreVariance(sym: Symbol) = !(sym.isHigherOrderTypeParameter && sym.logicallyEnclosingMember.isMethod)
-    ignoreVariance(sym1) || ignoreVariance(sym2) || sym1.variance == sym2.variance
+    !settings.isScala211 || ignoreVariance(sym1) || ignoreVariance(sym2) || sym1.variance == sym2.variance
   }
 
   private def methodHigherOrderTypeParamsSubVariance(low: Symbol, high: Symbol) =
-    methodHigherOrderTypeParamsSameVariance(low, high) || low.variance.isInvariant
+    !settings.isScala211 || methodHigherOrderTypeParamsSameVariance(low, high) || low.variance.isInvariant
 
   def isSameType2(tp1: Type, tp2: Type): Boolean = {
     def retry(lhs: Type, rhs: Type) = ((lhs ne tp1) || (rhs ne tp2)) && isSameType(lhs, rhs)
diff --git a/src/reflect/scala/reflect/runtime/Settings.scala b/src/reflect/scala/reflect/runtime/Settings.scala
index 11db83d7d5..de5ba99900 100644
--- a/src/reflect/scala/reflect/runtime/Settings.scala
+++ b/src/reflect/scala/reflect/runtime/Settings.scala
@@ -48,4 +48,5 @@ private[reflect] class Settings extends MutableSettings {
 
   val Yrecursion        = new IntSetting(0)
   val maxClassfileName  = new IntSetting(255)
+  def isScala211        = true
 }
diff --git a/test/files/pos/t2066-2.10-compat.flags b/test/files/pos/t2066-2.10-compat.flags
new file mode 100644
index 0000000000..94c8056747
--- /dev/null
+++ b/test/files/pos/t2066-2.10-compat.flags
@@ -0,0 +1 @@
+-Xsource:2.10
diff --git a/test/files/pos/t2066-2.10-compat.scala b/test/files/pos/t2066-2.10-compat.scala
new file mode 100644
index 0000000000..fb8103e4ad
--- /dev/null
+++ b/test/files/pos/t2066-2.10-compat.scala
@@ -0,0 +1,71 @@
+import language._
+trait A1 {
+  def f[T[_]] = ()
+}
+
+trait B1 extends A1 {
+  override def f[T[+_]] = ()
+}
+
+trait C1 extends A1 {
+  override def f[T[-_]] = ()
+}
+
+
+trait A2 {
+  def f[T[+_]] = ()
+}
+
+trait B2 extends A2 {
+  override def f[T[_]] = () // okay
+}
+
+trait C2 extends A2 {
+  override def f[T[-_]] = ()
+}
+
+
+trait A3 {
+  def f[T[-_]] = ()
+}
+
+trait B3 extends A3 {
+  override def f[T[_]] = () // okay
+}
+
+trait C3 extends A3 {
+  override def f[T[-_]] = ()
+}
+
+
+trait A4 {
+  def f[T[X[+_]]] = ()
+}
+
+trait B4 extends A4 {
+  override def f[T[X[_]]] = ()
+}
+
+trait A5 {
+  def f[T[X[-_]]] = ()
+}
+
+trait B5 extends A5 {
+  override def f[T[X[_]]] = ()
+}
+
+
+
+trait A6 {
+  def f[T[X[_]]] = ()
+}
+
+trait B6 extends A6 {
+  override def f[T[X[+_]]] = () // okay
+}
+trait C6 extends A6 {
+  override def f[T[X[_]]] = () // okay
+}
+trait D6 extends A6 {
+  override def f[T[X[-_]]] = ()
+}