Add language feature mechanism

Add a method "featureEnabled" that checks whether a feature is enabled. Features can be enabled
by imports or by command-line options. The Scala 2.10 way of enabling features by implicits got
dropped, because the use of the feature mechanism is now different.

Previously, features imposed restrictions on what used to work. So it was important to offer
way to avoid the restrictions it that was as smooth as possible, and implicits fit the bill.
Furthermore, features did not change the way things were compiled, so it was OK to test them
only once all types were compiled.

Now, features are essentially switches that change compile time behavior. keepUnions and
noAutoTupling, if on, will modify the way type inference works. So we need to interprete a
switch on the spot, and doing an implicit search to determine a switch value is too dangerous
in what concerns causing cyclic references. At the same time, because we are dealing with
new functionality, there is less of a concern for being able to set or reset features for large
pieces of code with some implicit. You could argue that's not even desirable, and that an
explicit import or command line option is preferable.

Conflicts:
	src/dotty/tools/dotc/core/SymDenotations.scala

1 files changed, 34 insertions, 0 deletions

diff --git a/src/dotty/tools/dotc/core/TypeOps.scala b/src/dotty/tools/dotc/core/TypeOps.scala
index 152f8d1b7..4ace0bebe 100644
--- a/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/src/dotty/tools/dotc/core/TypeOps.scala
@@ -266,6 +266,40 @@ trait TypeOps { this: Context =>
     }
     parentRefs
   }
+
+  /** Is `feature` enabled in class `owner`?
+   *  This is the case if one of the following two alternatives holds:
+   *
+   *  1. The feature is imported by a named import
+   *
+   *       import owner.feature
+   *
+   *  (the feature may be bunched with others, or renamed, but wildcard imports
+   *  don't count).
+   *
+   *  2. The feature is enabled by a compiler option
+   *
+   *       - language:<prefix>feature
+   *
+   *  where <prefix> is the full name of the owner followed by a "." minus
+   *  the prefix "dotty.language.".
+   */
+  def featureEnabled(owner: ClassSymbol, feature: TermName): Boolean = {
+    def toPrefix(sym: Symbol): String =
+      if (sym eq defn.LanguageModuleClass) "" else toPrefix(sym.owner) + sym.name + "."
+    def featureName = toPrefix(owner) + feature
+    def hasImport(implicit ctx: Context): Boolean = (
+         ctx.importInfo != null
+      && (   (ctx.importInfo.site.widen.typeSymbol eq owner)
+          && ctx.importInfo.originals.contains(feature)
+          ||
+          { var c = ctx.outer
+            while (c.importInfo eq ctx.importInfo) c = c.outer
+            hasImport(c)
+          }))
+    def hasOption = ctx.base.settings.language.value exists (s => s == featureName || s == "_")
+    hasImport || hasOption
+  }
 }
 
 object TypeOps {