Simplifications

Avoid a notation of "owner" when checking for a language feature. Instead,
allow qualified names for language features, e.g. `experimental.dependent".

Author: odersky

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

@@ -251,21 +251,27 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case TypeDefs(_) => true
     case _ => isUsingClause(params)
 
-  private val languageImportParts = List(nme.language, nme.scala, nme.ROOTPKG)
-  private val languageImportNested = Set[Name](nme.experimental)
-
-  /** Strip the name of any local object in `scala.language` from `path` */
-  def stripLanguageNested(path: Tree): Tree = path match
-    case Select(qual, name) if languageImportNested.contains(name) => qual
-    case _ => path
-
-  /** Does this `path` look like a language import? */
-  def isLanguageImport(path: Tree): Boolean =
-    def parts(tree: Tree): List[Name] = tree match
-      case tree: RefTree => tree.name :: parts(tree.qualifier)
-      case EmptyTree => Nil
-      case _ => EmptyTermName :: Nil
-    !path.isEmpty && languageImportParts.startsWith(parts(stripLanguageNested(path)))
+  /** If `path` looks like a language import, `Some(name)` where name
+   *  is `experimental` if that sub-module is imported, and the empty
+   *  term name otherwise.
+   */
+  def languageImport(path: Tree): Option[TermName] = path match
+    case Select(p1, nme.experimental) =>
+      languageImport(p1) match
+        case Some(EmptyTermName) => Some(nme.experimental)
+        case _ => None
+    case p1: RefTree if p1.name == nme.language =>
+      p1.qualifier match
+        case EmptyTree => Some(EmptyTermName)
+        case p2: RefTree if p2.name == nme.scala =>
+          p2.qualifier match
+            case EmptyTree => Some(EmptyTermName)
+            case Ident(nme.ROOTPKG) => Some(EmptyTermName)
+            case _ => None
+        case _ => None
+    case _ => None
+
+  def isLanguageImport(path: Tree): Boolean = languageImport(path).isDefined
 
   /** The underlying pattern ignoring any bindings */
   def unbind(x: Tree): Tree = unsplice(x) match {

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -9,12 +9,17 @@ import Decorators.{_, given}
 import util.SrcPos
 import SourceVersion._
 import reporting.Message
+import NameKinds.QualifiedName
 
 object Feature:
 
-  private val dependent = "dependent".toTermName
-  private val namedTypeArguments = "namedTypeArguments".toTermName
-  private val genericNumberLiterals = "genericNumberLiterals".toTermName
+  private def experimental(str: String): TermName =
+    QualifiedName(nme.experimental, str.toTermName)
+
+  private val Xdependent = experimental("dependent")
+  private val XnamedTypeArguments = experimental("namedTypeArguments")
+  private val XgenericNumberLiterals = experimental("genericNumberLiterals")
+  private val Xmacros = experimental("macros")
 
 /** Is `feature` enabled by by a command-line setting? The enabling setting is
    *
@@ -23,12 +28,8 @@ object Feature:
    *  where <prefix> is the fully qualified name of `owner`, followed by a ".",
    *  but subtracting the prefix `scala.language.` at the front.
    */
-  def enabledBySetting(feature: TermName, owner: Symbol = NoSymbol)(using Context): Boolean =
-    def toPrefix(sym: Symbol): String =
-      if !sym.exists || sym == defn.LanguageModule.moduleClass then ""
-      else toPrefix(sym.owner) + sym.name.stripModuleClassSuffix + "."
-    val prefix = if owner ne NoSymbol then toPrefix(owner) else ""
-    ctx.base.settings.language.value.contains(prefix + feature)
+  def enabledBySetting(feature: TermName)(using Context): Boolean =
+    ctx.base.settings.language.value.contains(feature.toString)
 
   /** Is `feature` enabled by by an import? This is the case if the feature
    *  is imported by a named import
@@ -39,39 +40,31 @@ object Feature:
    *
    *       import owner.{ feature => _ }
    */
-  def enabledByImport(feature: TermName, owner: Symbol = NoSymbol)(using Context): Boolean =
-    atPhase(typerPhase) {
-      ctx.importInfo != null
-      && ctx.importInfo.featureImported(feature,
-          if owner.exists then owner else defn.LanguageModule.moduleClass)
-    }
+  def enabledByImport(feature: TermName)(using Context): Boolean =
+    //atPhase(typerPhase) {
+      ctx.importInfo != null && ctx.importInfo.featureImported(feature)
+    //}
 
   /** Is `feature` enabled by either a command line setting or an import?
    *  @param  feature   The name of the feature
    *  @param  owner     The prefix symbol (nested in `scala.language`) where the
    *                    feature is defined.
    */
-  def enabled(feature: TermName, owner: Symbol = NoSymbol)(using Context): Boolean =
-    enabledBySetting(feature, owner) || enabledByImport(feature, owner)
+  def enabled(feature: TermName)(using Context): Boolean =
+    enabledBySetting(feature) || enabledByImport(feature)
 
   /** Is auto-tupling enabled? */
-  def autoTuplingEnabled(using Context): Boolean =
-    !enabled(nme.noAutoTupling)
+  def autoTuplingEnabled(using Context): Boolean = !enabled(nme.noAutoTupling)
 
-  def dynamicsEnabled(using Context): Boolean =
-    enabled(nme.dynamics)
+  def dynamicsEnabled(using Context): Boolean = enabled(nme.dynamics)
 
-  def dependentEnabled(using Context) =
-    enabled(dependent, defn.LanguageExperimentalModule.moduleClass)
+  def dependentEnabled(using Context) = enabled(Xdependent)
 
-  def namedTypeArgsEnabled(using Context) =
-    enabled(namedTypeArguments, defn.LanguageExperimentalModule.moduleClass)
+  def namedTypeArgsEnabled(using Context) = enabled(XnamedTypeArguments)
 
-  def genericNumberLiteralsEnabled(using Context) =
-    enabled(genericNumberLiterals, defn.LanguageExperimentalModule.moduleClass)
+  def genericNumberLiteralsEnabled(using Context) = enabled(XgenericNumberLiterals)
 
-  def scala2ExperimentalMacroEnabled(using Context) =
-    enabled("macros".toTermName, defn.LanguageExperimentalModule.moduleClass)
+  def scala2ExperimentalMacroEnabled(using Context) = enabled(Xmacros)
 
   def sourceVersionSetting(using Context): SourceVersion =
     SourceVersion.valueOf(ctx.settings.source.value)

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

@@ -736,13 +736,19 @@ trait Checking {
   /** Check that `path` is a legal prefix for an import clause */
   def checkLegalImportPath(path: Tree)(using Context): Unit =
     checkLegalImportOrExportPath(path, "import prefix")
-    val normPath = stripLanguageNested(path)
-    if isLanguageImport(normPath) then
-      if normPath.symbol != defn.LanguageModule then
-        report.error(em"import looks like a language import, but refers to something else: ${normPath.symbol.showLocated}", path.srcPos)
-    else
-      if normPath.tpe.classSymbols.contains(defn.LanguageModule.moduleClass) then
-        report.error(em"no aliases can be used to refer to a language import", path.srcPos)
+    languageImport(path) match
+      case Some(prefix) =>
+        val required =
+          if prefix == nme.experimental then defn.LanguageExperimentalModule
+          else defn.LanguageModule
+        if path.symbol != required then
+          report.error(em"import looks like a language import, but refers to something else: ${path.symbol.showLocated}", path.srcPos)
+      case None =>
+        val foundClasses = path.tpe.classSymbols
+        if foundClasses.contains(defn.LanguageModule.moduleClass)
+           || foundClasses.contains(defn.LanguageExperimentalModule.moduleClass)
+        then
+          report.error(em"no aliases can be used to refer to a language import", path.srcPos)
 
   /** Check that `path` is a legal prefix for an export clause */
   def checkLegalExportPath(path: Tree, selectors: List[untpd.ImportSelector])(using Context): Unit =

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

@@ -13,6 +13,7 @@ import config.SourceVersion
 import StdNames.nme
 import printing.Texts.Text
 import ProtoTypes.NoViewsAllowed.normalizedCompatible
+import NameKinds.QualifiedName
 import Decorators._
 
 object ImportInfo {
@@ -45,7 +46,7 @@ object ImportInfo {
 }
 
 /** Info relating to an import clause
- *  @param   sym           The import symbol defined by the clause
+ *  @param   symf          A function that computes the import symbol defined by the clause
  *  @param   selectors     The selector clauses
  *  @param   qualifier     The import qualifier, or EmptyTree for root imports.
  *                         Defined for all explicit imports from ident or select nodes.
@@ -62,7 +63,7 @@ class ImportInfo(symf: Context ?=> Symbol,
     case _                  => None
   }
 
-  def sym(using Context): Symbol = {
+  def importSym(using Context): Symbol = {
     if (mySym == null) {
       mySym = symf
       assert(mySym != null)
@@ -72,7 +73,7 @@ class ImportInfo(symf: Context ?=> Symbol,
   private var mySym: Symbol = _
 
   /** The (TermRef) type of the qualifier of the import clause */
-  def site(using Context): Type = sym.info match {
+  def site(using Context): Type = importSym.info match {
     case ImportType(expr) => expr.tpe
     case _ => NoType
   }
@@ -185,27 +186,46 @@ class ImportInfo(symf: Context ?=> Symbol,
 
   private var myUnimported: Symbol = _
 
-  private var myOwner: Symbol = null
-  private var myResults: SimpleIdentityMap[TermName, java.lang.Boolean] = SimpleIdentityMap.empty
-
-  /** Does this import clause or a preceding import clause import `owner.feature`? */
-  def featureImported(feature: TermName, owner: Symbol)(using Context): Boolean =
-
-    def compute: Boolean =
-      if isLanguageImport then
-        val isImportOwner = site.typeSymbol.eq(owner)
-        if isImportOwner then
-          if forwardMapping.contains(feature) then return true
-          if excluded.contains(feature) then return false
-      var c = ctx.outer
-      while c.importInfo eq ctx.importInfo do c = c.outer
-      (c.importInfo != null) && c.importInfo.featureImported(feature, owner)(using c)
-
-    if myOwner.ne(owner) || !myResults.contains(feature) then
-      myOwner = owner
-      myResults = myResults.updated(feature, compute)
-    myResults(feature)
-  end featureImported
+  private var featureCache: SimpleIdentityMap[TermName, java.lang.Boolean] = SimpleIdentityMap.empty
+
+  /** Does this import clause or a preceding import clause enable or disable `feature`?
+   *  @param  feature   See featureImported for a description
+   *  @return Some(true)  if `feature` is imported
+   *          Some(false) if `feature` is excluded
+   *          None        if `feature` is not mentioned, or this is not a language import
+   */
+  def mentionsFeature(feature: TermName)(using Context): Option[Boolean] =
+    def test(prefix: TermName, feature: TermName): Option[Boolean] =
+      untpd.languageImport(qualifier) match
+        case Some(`prefix`) =>
+          if forwardMapping.contains(feature) then Some(true)
+          else if excluded.contains(feature) then Some(false)
+          else None
+        case _ => None
+    feature match
+      case QualifiedName(prefix, name) => test(prefix, name)
+      case _ => test(EmptyTermName, feature)
+
+  /** Does this import clause or a preceding import clause enable `feature`?
+   *
+   *  @param  feature  a possibly quailified name, e.g.
+   *                      strictEquality
+   *                      experimental.genericNumberLiterals
+   *
+   *  An excluded feature such as `strictEquality => _` in a language import
+   *  means that preceding imports are not considered and the feature is not imported.
+   */
+  def featureImported(feature: TermName)(using Context): Boolean =
+    if !featureCache.contains(feature) then
+      featureCache = featureCache.updated(feature,
+        mentionsFeature(feature) match
+          case Some(bv) => bv
+          case None =>
+            var c = ctx.outer
+            while c.importInfo eq ctx.importInfo do c = c.outer
+            (c.importInfo != null) && c.importInfo.featureImported(feature)(using c)
+      )
+    featureCache(feature)
 
   def toText(printer: Printer): Text = printer.toText(this)
 }

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

@@ -122,7 +122,7 @@ trait ImportSuggestions:
               .flatMap(sym => rootsIn(sym.termRef))
         val imported =
           if ctx.importInfo eq ctx.outer.importInfo then Nil
-          else ctx.importInfo.sym.info match
+          else ctx.importInfo.importSym.info match
             case ImportType(expr) => rootsOnPath(expr.tpe)
             case _ => Nil
         defined ++ imported ++ recur(using ctx.outer)

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

@@ -206,7 +206,7 @@ class Typer extends Namer
         else found
 
       def selection(imp: ImportInfo, name: Name, checkBounds: Boolean): Type =
-        imp.sym.info match
+        imp.importSym.info match
           case ImportType(expr) =>
             val pre = expr.tpe
             var denot = pre.memberBasedOnFlags(name, required, excluded)
@@ -222,8 +222,8 @@ class Typer extends Namer
                 if unimported.isEmpty || !unimported.contains(pre.termSymbol) then
                   return pre.select(name, denot)
           case _ =>
-            if imp.sym.isCompleting then
-              report.warning(i"cyclic ${imp.sym}, ignored", pos)
+            if imp.importSym.isCompleting then
+              report.warning(i"cyclic ${imp.importSym}, ignored", pos)
         NoType
 
       /** The type representing a named import with enclosing name when imported
@@ -393,7 +393,7 @@ class Typer extends Namer
               val namedImp = namedImportRef(curImport)
               if (namedImp.exists)
                 recurAndCheckNewOrShadowed(namedImp, NamedImport, ctx)(using outer)
-              else if (isPossibleImport(WildImport) && !curImport.sym.isCompleting) {
+              else if (isPossibleImport(WildImport) && !curImport.importSym.isCompleting) {
                 val wildImp = wildImportRef(curImport)
                 if (wildImp.exists)
                   recurAndCheckNewOrShadowed(wildImp, WildImport, ctx)(using outer)