Refactor abstraction over language.feature module

All the deleted code was used to distinguish between scala.language.feature
and dotty.language.feature, but the latter give revomed when we
introduced the scalaShadowing package trick has was dead code since then.

As a side effect, this removes the need for scala2Settings and the new
implementation shouldn't force anything.

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -472,7 +472,7 @@ object desugar {
       New(classTypeRef, vparamss.nestedMap(refOfDef))
     }
 
-    val copiedAccessFlags = if (ctx.scala2Setting) EmptyFlags else AccessFlags
+    val copiedAccessFlags = if (ctx.scala2Mode) EmptyFlags else AccessFlags
 
     // Methods to add to a case class C[..](p1: T1, ..., pN: Tn)(moreParams)
     //     def _1: T1 = this.p1

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

@@ -379,29 +379,21 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
    *  where <prefix> is the full name of the owner followed by a "." minus
    *  the prefix "dotty.language.".
    */
-  def featureEnabled(owner: ClassSymbol, feature: TermName): Boolean = {
-    val hasImport =
+  def featureEnabled(feature: TermName): Boolean = {
+    def hasImport =
       ctx.importInfo != null &&
-      ctx.importInfo.featureImported(owner, feature)(ctx.withPhase(ctx.typerPhase))
-    def hasOption = {
-      def toPrefix(sym: Symbol): String =
-        if (!sym.exists || (sym eq defn.LanguageModuleClass)) ""
-        else toPrefix(sym.owner) + sym.name + "."
-      val featureName = toPrefix(owner) + feature
-      ctx.base.settings.language.value exists (s => s == featureName || s == "_")
-    }
-    hasImport || hasOption
+      ctx.importInfo.featureImported(feature)(ctx.withPhase(ctx.typerPhase))
+    val hasOption =
+      ctx.base.settings.language.value.exists(s => s == feature.toString || s == "_")
+    hasOption || hasImport
   }
 
   /** Is auto-tupling enabled? */
   def canAutoTuple: Boolean =
-    !featureEnabled(defn.LanguageModuleClass, nme.noAutoTupling)
-
-  def scala2Mode: Boolean =
-    featureEnabled(defn.LanguageModuleClass, nme.Scala2)
+    !featureEnabled(nme.noAutoTupling)
 
   def dynamicsEnabled: Boolean =
-    featureEnabled(defn.LanguageModuleClass, nme.dynamics)
+    featureEnabled(nme.dynamics)
 
   def testScala2Mode(msg: => Message, pos: SourcePosition, replace: => Unit = ()): Boolean = {
     if (scala2Mode) {
@@ -411,10 +403,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     scala2Mode
   }
 
-  /** Is option -language:Scala2 set?
-   *  This test is used when we are too early in the pipeline to consider imports.
-   */
-  def scala2Setting = ctx.settings.language.value.contains(nme.Scala2.toString)
+  def scala2Mode: Boolean = featureEnabled(nme.Scala2)
 
   /** Refine child based on parent
    *

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -242,7 +242,7 @@ object Scanners {
 
 // Scala 2 compatibility
 
-    val isScala2Mode: Boolean = ctx.scala2Setting
+    val isScala2Mode: Boolean = ctx.scala2Mode
 
     /** Cannot use ctx.featureEnabled because accessing the context would force too much */
     def testScala2Mode(msg: String, span: Span = Span(offset)): Boolean = {

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -58,19 +58,18 @@ trait Reporting { this: Context =>
     if (this.settings.deprecation.value) reportWarning(new DeprecationWarning(msg, pos))
 
   def migrationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
-    reportWarning(new MigrationWarning(msg, pos))
+    deprecationWarning(msg, pos)
 
   def uncheckedWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
     reportWarning(new UncheckedWarning(msg, pos))
 
   def featureWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
     reportWarning(new FeatureWarning(msg, pos))
 
-  def featureWarning(feature: String, featureDescription: String, isScala2Feature: Boolean,
+  def featureWarning(feature: String, featureDescription: String,
       featureUseSite: Symbol, required: Boolean, pos: SourcePosition): Unit = {
     val req = if (required) "needs to" else "should"
-    val prefix = if (isScala2Feature) "scala." else "dotty."
-    val fqname = prefix + "language." + feature
+    val fqname = s"scala.language.$feature"
 
     val explain = {
       if (reporter.isReportedFeatureUseSite(featureUseSite)) ""

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -617,7 +617,7 @@ trait Checking {
   def checkImplicitConversionDefOK(sym: Symbol)(implicit ctx: Context): Unit = {
     def check(): Unit = {
       checkFeature(
-        defn.LanguageModuleClass, nme.implicitConversions,
+        nme.implicitConversions,
         i"Definition of implicit conversion $sym",
         ctx.owner.topLevelClass,
         sym.sourcePos)
@@ -654,20 +654,17 @@ trait Checking {
         defn.isPredefClass(conv.owner) ||
         conv.name == nme.reflectiveSelectable && conv.maybeOwner.maybeOwner.maybeOwner == defn.ScalaPackageClass
       if (!conversionOK)
-        checkFeature(defn.LanguageModuleClass, nme.implicitConversions,
+        checkFeature(nme.implicitConversions,
           i"Use of implicit conversion ${conv.showLocated}", NoSymbol, posd.sourcePos)
     }
 
   /** Issue a feature warning if feature is not enabled */
-  def checkFeature(base: ClassSymbol,
-                   name: TermName,
+  def checkFeature(name: TermName,
                    description: => String,
                    featureUseSite: Symbol,
                    pos: SourcePosition)(implicit ctx: Context): Unit =
-    if (!ctx.featureEnabled(base, name))
-      ctx.featureWarning(name.toString, description,
-        isScala2Feature = base.isContainedIn(defn.LanguageModuleClass),
-        featureUseSite, required = false, pos)
+    if (!ctx.featureEnabled(name))
+      ctx.featureWarning(name.toString, description, featureUseSite, required = false, pos)
 
   /** Check that `tp` is a class type and that any top-level type arguments in this type
    *  are feasible, i.e. that their lower bound conforms to their upper bound. If a type
@@ -1048,5 +1045,5 @@ trait NoChecking extends ReChecking {
   override def checkNoForwardDependencies(vparams: List[ValDef])(implicit ctx: Context): Unit = ()
   override def checkMembersOK(tp: Type, pos: SourcePosition)(implicit ctx: Context): Type = tp
   override def checkInInlineContext(what: String, posd: Positioned)(implicit ctx: Context): Unit = ()
-  override def checkFeature(base: ClassSymbol, name: TermName, description: => String, featureUseSite: Symbol, pos: SourcePosition)(implicit ctx: Context): Unit = ()
+  override def checkFeature(name: TermName, description: => String, featureUseSite: Symbol, pos: SourcePosition)(implicit ctx: Context): Unit = ()
 }

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -947,7 +947,7 @@ trait Implicits { self: Typer =>
 
   private def strictEquality(implicit ctx: Context): Boolean =
     ctx.mode.is(Mode.StrictEquality) ||
-    ctx.featureEnabled(defn.LanguageModuleClass, nme.strictEquality)
+    ctx.featureEnabled(nme.strictEquality)
 
   /** An Eql[T, U] instance is assumed
    *   - if one of T, U is an error type, or

compiler/src/dotty/tools/dotc/typer/ImportInfo.scala

@@ -146,15 +146,16 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
   private[this] var myUnimported: Symbol = _
 
   /** Does this import clause or a preceding import clause import `owner.feature`? */
-  def featureImported(owner: Symbol, feature: TermName)(implicit ctx: Context): Boolean = {
+  def featureImported(feature: TermName)(implicit ctx: Context): Boolean = {
+    val owner: Symbol = defn.LanguageModuleClass
     def compute = {
       val isImportOwner = site.widen.typeSymbol `eq` owner
       if (isImportOwner && originals.contains(feature)) true
       else if (isImportOwner && excluded.contains(feature)) false
       else {
         var c = ctx.outer
         while (c.importInfo eq ctx.importInfo) c = c.outer
-        (c.importInfo != null) && c.importInfo.featureImported(owner, feature)(c)
+        (c.importInfo != null) && c.importInfo.featureImported(feature)(c)
       }
     }
     if (lastOwner.ne(owner) || !lastResults.contains(feature)) {

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1692,8 +1692,7 @@ class Typer extends Namer
         !ctx.dynamicsEnabled
       if (reportDynamicInheritance) {
         val isRequired = parents1.exists(_.tpe.isRef(defn.DynamicClass))
-        ctx.featureWarning(nme.dynamics.toString, "extension of type scala.Dynamic", isScala2Feature = true,
-          cls, isRequired, cdef.sourcePos)
+        ctx.featureWarning(nme.dynamics.toString, "extension of type scala.Dynamic", cls, isRequired, cdef.sourcePos)
       }
 
       checkNonCyclicInherited(cls.thisType, cls.classParents, cls.info.decls, cdef.posd)

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -31,10 +31,10 @@ class CompilationTests extends ParallelTesting {
 
   // Positive tests ------------------------------------------------------------
 
-  // @Test  // enable to test compileStdLib separately with detailed stats
+  @Test  // enable to test compileStdLib separately with detailed stats
   def compileStdLibOnly: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compileStdLibOnly")
-    compileList("compileStdLib", TestSources.stdLibSources, scala2Mode.and("-migration", "-Yno-inline", "-Ydetailed-stats"))
+    compileList("compileStdLib", TestSources.stdLibSources, scala2Mode.and("-migration", "-Yno-inline"))
   }.checkCompile()
 
   @Test def pos: Unit = {

library/src/scalaShadowing/language.scala

@@ -30,6 +30,7 @@ package scalaShadowing
  *
  *   - [[Scala2              `Scala2`]               backwards compatibility mode for Scala2
  *   - [[noAtoTupling        `noAutoTupling`]]       disable auto-tupling
+ *   - [[strictEquality      `strictEquality`]]      enable strick equality
  *
  *  @groupname production   Language Features
  *  @groupname experimental Experimental Language Features
@@ -211,12 +212,12 @@ object language {
     @volatile implicit lazy val macros: macros = languageFeature.experimental.macros
   }
 
-  /** Where imported, a backwards compatibility mode for Scala2 is enabled */
-  object Scala2
-
   /** Where imported, auto-tupling is disabled */
   object noAutoTupling
 
-  /* Where imported loose equality using eqAny is disabled */
+  /** Where imported, a backwards compatibility mode for Scala2 is enabled */
+  object Scala2
+
+  /** Where imported loose equality using eqAny is disabled */
   object strictEquality
 }