remove -Xstrict-inference

"-Xstrict-inference was intended only as a coarse hacky start",
says Paul at scala/bug#6680 (comment)

GitHub search shows very few uses in the wild.  My best is that a few
people just enabled it because the name/description made it sound
good/safer.

Author: SethTisue

project/ScalaOptionParser.scala

@@ -83,7 +83,7 @@ object ScalaOptionParser {
 
   // TODO retrieve this data programmatically, ala https://github.com/scala/scala-tool-support/blob/master/bash-completion/src/main/scala/BashCompletion.scala
   private def booleanSettingNames = List("-X", "-Xcheckinit", "-Xdev", "-Xdisable-assertions", "-Xexperimental", "-Xfatal-warnings", "-Xfull-lubs", "-Xfuture", "-Xlog-free-terms", "-Xlog-free-types", "-Xlog-implicit-conversions", "-Xlog-implicits", "-Xlog-reflective-calls",
-    "-Xno-forwarders", "-Xno-patmat-analysis", "-Xno-uescape", "-Xnojline", "-Xprint-pos", "-Xprint-types", "-Xprompt", "-Xresident", "-Xshow-phases", "-Xstrict-inference", "-Xverify", "-Y",
+    "-Xno-forwarders", "-Xno-patmat-analysis", "-Xno-uescape", "-Xnojline", "-Xprint-pos", "-Xprint-types", "-Xprompt", "-Xresident", "-Xshow-phases", "-Xverify", "-Y",
     "-Ybreak-cycles", "-Ydebug", "-Ycompact-trees", "-YdisableFlatCpCaching", "-Ydoc-debug",
     "-Yide-debug", "-Yinfer-argument-types",
     "-Yissue-debug", "-Ylog-classpath", "-Ymacro-debug-lite", "-Ymacro-debug-verbose", "-Ymacro-no-expand",

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

@@ -141,7 +141,6 @@ trait ScalaSettings extends AbsScalaSettings
   val showPhases         = BooleanSetting      ("-Xshow-phases", "Print a synopsis of compiler phases.")
   val sourceReader       = StringSetting       ("-Xsource-reader", "classname", "Specify a custom method for reading source files.", "")
   val reporter           = StringSetting       ("-Xreporter", "classname", "Specify a custom reporter for compiler messages.", "scala.tools.nsc.reporters.ConsoleReporter")
-  val strictInference    = BooleanSetting      ("-Xstrict-inference", "Don't infer known-unsound types")
   val source             = ScalaVersionSetting ("-Xsource", "version", "Treat compiler input as Scala source for the specified version, see scala/bug#8126.", initial = ScalaVersion("2.13"))
 
   val XnoPatmatAnalysis = BooleanSetting ("-Xno-patmat-analysis", "Don't perform exhaustivity/unreachability analysis. Also, ignore @switch annotation.")

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

@@ -179,7 +179,7 @@ trait PatternTypers {
       def eligible(tparam: Symbol) = (
            tparam.isTypeParameterOrSkolem
         && tparam.owner.isTerm
-        && (settings.strictInference || !variance.isInvariant)
+        && !variance.isInvariant
       )
 
       def skolems = try skolemBuffer.toList finally skolemBuffer.clear()
@@ -225,19 +225,11 @@ trait PatternTypers {
      *
      * see test/files/../t5189*.scala
      */
-    private def convertToCaseConstructor(tree: Tree, caseClass: Symbol, ptIn: Type): Tree = {
-      // TODO scala/bug#7886 / scala/bug#5900 This is well intentioned but doesn't quite hit the nail on the head.
-      //      For now, I've put it completely behind -Xstrict-inference.
-      val untrustworthyPt = settings.strictInference && (
-           ptIn =:= AnyTpe
-        || ptIn =:= NothingTpe
-        || ptIn.typeSymbol != caseClass
-      )
+    private def convertToCaseConstructor(tree: Tree, caseClass: Symbol, pt: Type): Tree = {
       val variantToSkolem     = new VariantToSkolemMap
       val caseClassType       = tree.tpe.prefix memberType caseClass
       val caseConstructorType = caseClassType memberType caseClass.primaryConstructor
       val tree1               = TypeTree(caseConstructorType) setOriginal tree
-      val pt                  = if (untrustworthyPt) caseClassType else ptIn
 
       // have to open up the existential and put the skolems in scope
       // can't simply package up pt in an ExistentialType, because that takes us back to square one (List[_ <: T] == List[T] due to covariance)

src/manual/scala/man1/scalac.scala

@@ -305,9 +305,6 @@ object scalac extends Command {
         Definition(
           CmdOption("Xsource-reader", Argument("classname")),
           "Specify a custom method for reading source files."),
-        Definition(
-          CmdOption("Xstrict-inference"),
-          "Don't infer known-unsound types."),
         Definition(
           CmdOption("Xverify"),
           "Verify generic signatures in generated bytecode (asm backend only)."),

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

@@ -39,7 +39,6 @@ abstract class MutableSettings extends AbsSettings {
   def XfullLubs: BooleanSetting
   def XnoPatmatAnalysis: BooleanSetting
   def Xprintpos: BooleanSetting
-  def strictInference: BooleanSetting
   def Yposdebug: BooleanSetting
   def Yrangepos: BooleanSetting
   def Yshowsymowners: BooleanSetting

src/reflect/scala/reflect/internal/tpe/GlbLubs.scala

@@ -15,7 +15,6 @@ private[internal] trait GlbLubs {
   import statistics._
 
   private final val printLubs = System.getProperty("scalac.debug.lub") != null
-  private final val strictInference = settings.strictInference
 
   /** In case anyone wants to turn off lub verification without reverting anything. */
   private final val verifyLubs = true
@@ -64,26 +63,6 @@ private[internal] trait GlbLubs {
     }
   }
 
-  // only called when strictInference
-  private def willViolateRecursiveBounds(tp: Type, ts: List[Type], tsElimSub: List[Type]) = {
-    val typeSym     = ts.head.typeSymbol // we're uniform, the `.head` is as good as any.
-    def fbounds     = findRecursiveBounds(ts) map (_._2)
-    def isRecursive = typeSym.typeParams exists fbounds.contains
-
-    isRecursive && (transposeSafe(tsElimSub map (_.normalize.typeArgs)) match {
-      case Some(arggsTransposed) =>
-        val mergedTypeArgs = (tp match { case et: ExistentialType => et.underlying; case _ => tp}).typeArgs
-        exists3(typeSym.typeParams, mergedTypeArgs, arggsTransposed) {
-          (param, arg, lubbedArgs) =>
-            val isExistential = arg.typeSymbol.isExistentiallyBound
-            val isInFBound    = fbounds contains param
-            val wasLubbed     = !lubbedArgs.exists(_ =:= arg)
-            (!isExistential && isInFBound && wasLubbed)
-        }
-      case None => false
-    })
-  }
-
   /** Given a matrix `tsBts` whose columns are basetype sequences (and the symbols `tsParams` that should be interpreted as type parameters in this matrix),
     * compute its least sorted upwards closed upper bound relative to the following ordering <= between lists of types:
     *
@@ -136,9 +115,6 @@ private[internal] trait GlbLubs {
           val ts1   = elimSub(ts0, depth) map elimHigherOrderTypeParam
           mergePrefixAndArgs(ts1, Covariant, depth) match {
             case NoType => loop(pretypes, tails)
-            case tp if strictInference && willViolateRecursiveBounds(tp, ts0, ts1) =>
-              log(s"Breaking recursion in lublist, advancing frontier and discarding merged prefix/args from $tp")
-              loop(pretypes, tails)
             case tp =>
               loop(tp :: pretypes, tails)
           }

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

@@ -32,7 +32,6 @@ private[reflect] class Settings extends MutableSettings {
 
   val XfullLubs         = new BooleanSetting(false)
   val XnoPatmatAnalysis = new BooleanSetting(false)
-  val strictInference   = new BooleanSetting(false)
   val Xprintpos         = new BooleanSetting(false)
   val Yposdebug         = new BooleanSetting(false)
   val Yrangepos         = new BooleanSetting(false)