Drop support for -Xsource:2.10

Assume 2.11 or higher source level.

Author: adriaanm

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -96,8 +96,6 @@ trait ScalaSettings extends AbsScalaSettings
    * The previous "-source" option is intended to be used mainly
    * though this helper.
    */
-  private[this] val version211 = ScalaVersion("2.11.0")
-  def isScala211: Boolean = source.value >= version211
   private[this] val version212 = ScalaVersion("2.12.0")
   def isScala212: Boolean = source.value >= version212
   private[this] val version213 = ScalaVersion("2.13.0")

src/compiler/scala/tools/nsc/typechecker/Implicits.scala

@@ -1672,9 +1672,9 @@ trait Implicits {
             val outSym = out.typeSymbol
 
             val fail =
-              if (out.annotations.isEmpty && (outSym == ObjectClass || (settings.isScala211 && outSym == AnyValClass)))
+              if (out.annotations.isEmpty && (outSym == ObjectClass || outSym == AnyValClass))
                 maybeInvalidConversionError(s"the result type of an implicit conversion must be more specific than $out")
-              else if (settings.isScala211 && in.annotations.isEmpty && in.typeSymbol == NullClass)
+              else if (in.annotations.isEmpty && in.typeSymbol == NullClass)
                 maybeInvalidConversionError("an expression of type Null is ineligible for implicit conversion")
               else false
 

src/compiler/scala/tools/nsc/typechecker/RefChecks.scala

@@ -140,12 +140,7 @@ abstract class RefChecks extends Transform {
           case MethodType(params, restpe) => (params exists (_.hasDefault)) || hasDefaultParam(restpe)
           case _                          => false
         }
-        val haveDefaults = methods filter (
-          if (settings.isScala211)
-             (sym => mexists(sym.info.paramss)(_.hasDefault) && !nme.isProtectedAccessorName(sym.name))
-          else
-            (sym => hasDefaultParam(sym.info) && !nme.isProtectedAccessorName(sym.name))
-        )
+        val haveDefaults = methods.filter(sym => mexists(sym.info.paramss)(_.hasDefault) && !nme.isProtectedAccessorName(sym.name))
 
         if (haveDefaults.lengthCompare(1) > 0) {
           val owners = haveDefaults map (_.owner)

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -1864,7 +1864,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
         val impl2 = finishMethodSynthesis(impl1, clazz, context)
 
-        if (settings.isScala211 && mdef.symbol == PredefModule)
+        if (mdef.symbol == PredefModule)
           ensurePredefParentsAreInSameSourceFile(impl2)
 
         treeCopy.ModuleDef(mdef, typedMods, mdef.name, impl2) setType NoType

src/reflect/scala/reflect/internal/Definitions.scala

@@ -549,10 +549,9 @@ trait Definitions extends api.StandardDefinitions {
     lazy val TypeCreatorClass      = getClassIfDefined("scala.reflect.api.TypeCreator") // defined in scala-reflect.jar, so we need to be careful
     lazy val TreeCreatorClass      = getClassIfDefined("scala.reflect.api.TreeCreator") // defined in scala-reflect.jar, so we need to be careful
 
-    private def Context_210               = if (settings.isScala211) NoSymbol else getClassIfDefined("scala.reflect.macros.Context") // needed under -Xsource:2.10
-    lazy val BlackboxContextClass         = getClassIfDefined("scala.reflect.macros.blackbox.Context").orElse(Context_210) // defined in scala-reflect.jar, so we need to be careful
+    lazy val BlackboxContextClass         = getClassIfDefined("scala.reflect.macros.blackbox.Context") // defined in scala-reflect.jar, so we need to be careful
 
-    lazy val WhiteboxContextClass         = getClassIfDefined("scala.reflect.macros.whitebox.Context").orElse(Context_210) // defined in scala-reflect.jar, so we need to be careful
+    lazy val WhiteboxContextClass         = getClassIfDefined("scala.reflect.macros.whitebox.Context") // defined in scala-reflect.jar, so we need to be careful
          def MacroContextPrefix           = BlackboxContextClass.map(sym => getMemberMethod(sym, nme.prefix))
          def MacroContextPrefixType       = BlackboxContextClass.map(sym => getTypeMember(sym, tpnme.PrefixType))
          def MacroContextUniverse         = BlackboxContextClass.map(sym => getMemberMethod(sym, nme.universe))

src/reflect/scala/reflect/internal/Variances.scala

@@ -77,19 +77,12 @@ trait Variances {
        *  leading to unsoundness (see scala/bug#6566).
        */
       def relativeVariance(tvar: Symbol): Variance = {
-        def nextVariance(sym: Symbol, v: Variance): Variance = (
+        def nextVariance(sym: Symbol, v: Variance): Variance =
           if (shouldFlip(sym, tvar)) v.flip
           else if (isExemptFromVariance(sym)) Bivariant
-          else if (sym.isAliasType) (
-            // Unsound pre-2.11 behavior preserved under -Xsource:2.10
-            if (settings.isScala211 || sym.isOverridingSymbol) Invariant
-            else {
-              currentRun.reporting.deprecationWarning(sym.pos, "Construct depends on unsound variance analysis and will not compile in scala 2.11 and beyond", "2.11.0")
-              Bivariant
-            }
-          )
+          else if (sym.isAliasType) Invariant
           else v
-        )
+
         def loop(sym: Symbol, v: Variance): Variance = (
           if (sym == tvar.owner || v.isBivariant) v
           else loop(sym.owner, nextVariance(sym, v))

src/reflect/scala/reflect/internal/settings/MutableSettings.scala

@@ -63,7 +63,6 @@ abstract class MutableSettings extends AbsSettings {
 
   def Yrecursion: IntSetting
 
-  def isScala211: Boolean
   def isScala212: Boolean
   private[scala] def isScala213: Boolean
 }

src/reflect/scala/reflect/internal/tpe/TypeComparers.scala

@@ -187,11 +187,11 @@ trait TypeComparers {
   // scala/bug#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)
-    !settings.isScala211 || ignoreVariance(sym1) || ignoreVariance(sym2) || sym1.variance == sym2.variance
+    ignoreVariance(sym1) || ignoreVariance(sym2) || sym1.variance == sym2.variance
   }
 
   private def methodHigherOrderTypeParamsSubVariance(low: Symbol, high: Symbol) =
-    !settings.isScala211 || methodHigherOrderTypeParamsSameVariance(low, high) || low.variance.isInvariant
+    methodHigherOrderTypeParamsSameVariance(low, high) || low.variance.isInvariant
 
   def isSameType2(tp1: Type, tp2: Type): Boolean = {
     def retry() = {

src/reflect/scala/reflect/runtime/Settings.scala

@@ -60,7 +60,6 @@ private[reflect] class Settings extends MutableSettings {
   val YstatisticsEnabled    = new BooleanSetting(false)
 
   val Yrecursion        = new IntSetting(0)
-  def isScala211        = true
   def isScala212        = true
   private[scala] def isScala213 = false
 }

test/files/neg/t8265.check

@@ -1,6 +1,4 @@
-t8265.scala:3: warning: Construct depends on unsound variance analysis and will not compile in scala 2.11 and beyond
+t8265.scala:3: error: covariant type CC occurs in invariant position in type CC[_] of type Coll
 class Foo[+CC[X]] { type Coll = CC[_] }
                          ^
-error: No warnings can be incurred under -Xfatal-warnings.
-one warning found
 one error found

test/files/neg/t8265.scala

@@ -1,3 +1,3 @@
-// scalac: -Xsource:2.10 -deprecation -language:higherKinds -Xfatal-warnings
+// scalac: -deprecation -language:higherKinds
 //
 class Foo[+CC[X]] { type Coll = CC[_] }