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 got removed with the
introduction of the scalaShadowing package and has been dead code since then.

Author: OlivierBlanvillain

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

@@ -379,29 +379,24 @@ 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)
+    !featureEnabled(nme.noAutoTupling)
 
   def scala2Mode: Boolean =
-    featureEnabled(defn.LanguageModuleClass, nme.Scala2)
+    featureEnabled(nme.Scala2)
 
   def dynamicsEnabled: Boolean =
-    featureEnabled(defn.LanguageModuleClass, nme.dynamics)
+    featureEnabled(nme.dynamics)
 
   def testScala2Mode(msg: => Message, pos: SourcePosition, replace: => Unit = ()): Boolean = {
     if (scala2Mode) {
@@ -414,7 +409,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
   /** 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 scala2Setting: Boolean =
+    ctx.settings.language.value.contains(nme.Scala2.toString)
 
   /** Refine child based on parent
    *

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

@@ -66,11 +66,10 @@ trait Reporting { this: Context =>
   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
@@ -217,6 +218,6 @@ object language {
   /** Where imported, auto-tupling is disabled */
   object noAutoTupling
 
-  /* Where imported loose equality using eqAny is disabled */
+  /** Where imported loose equality using eqAny is disabled */
   object strictEquality
 }