Syntactic/organizational optimizations in Settings.

5 files changed, 49 insertions, 73 deletions

diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index a20853adc8..3ce8829af6 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -448,7 +448,7 @@ trait Types extends api.Types { self: SymbolTable =>
     def resultType(actuals: List[Type]) = this
 
     /** Only used for dependent method types. */
-    def resultApprox: Type = ApproximateDependentMap(resultType) // if (!settings.YdepMethTpes.value) resultType else
+    def resultApprox: Type = ApproximateDependentMap(resultType)
 
     /** If this is a TypeRef `clazz`[`T`], return the argument `T`
      *  otherwise return this type
@@ -2268,7 +2268,7 @@ trait Types extends api.Types { self: SymbolTable =>
     override def isTrivial: Boolean = isTrivial0 && (resultType eq resultType.withoutAnnotations)
     private lazy val isTrivial0 =
       resultType.isTrivial && params.forall{p => p.tpe.isTrivial &&  (
-        /*!settings.YdepMethTpes.value ||*/ !(params.exists(_.tpe.contains(p)) || resultType.contains(p)))
+        !(params.exists(_.tpe.contains(p)) || resultType.contains(p)))
       }
 
     def isImplicit = params.nonEmpty && params.head.isImplicit
@@ -2292,8 +2292,9 @@ trait Types extends api.Types { self: SymbolTable =>
       }
       else existentialAbstraction(params, resultType)
 
-    // implicit args can only be depended on in result type: TODO this may be generalised so that the only constraint is dependencies are acyclic
-    def approximate: MethodType = MethodType(params, resultApprox) // if (!settings.YdepMethTpes.value) this else
+    // implicit args can only be depended on in result type:
+    //TODO this may be generalised so that the only constraint is dependencies are acyclic
+    def approximate: MethodType = MethodType(params, resultApprox)
 
     override def finalResultType: Type = resultType.finalResultType
 
diff --git a/src/compiler/scala/reflect/runtime/Settings.scala b/src/compiler/scala/reflect/runtime/Settings.scala
index b4f0123114..8b475da0d3 100644
--- a/src/compiler/scala/reflect/runtime/Settings.scala
+++ b/src/compiler/scala/reflect/runtime/Settings.scala
@@ -23,7 +23,6 @@ class Settings extends internal.settings.MutableSettings {
 
   val overrideObjects = new BooleanSetting(false)
   val debug = new BooleanSetting(false)
-  // val YdepMethTpes = new BooleanSetting(true)
   val Ynotnull = new BooleanSetting(false)
   val explaintypes = new BooleanSetting(false)
   val verbose = new BooleanSetting(false)
@@ -34,4 +33,5 @@ class Settings extends internal.settings.MutableSettings {
   val Yrecursion = new IntSetting(0)
   val maxClassfileName = new IntSetting(255)
   val Xexperimental = new BooleanSetting(false)
+  val deepCloning = new BooleanSetting (false)
 }
diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index ccebcfa54d..45325b4694 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -1394,13 +1394,7 @@ self =>
             }
           }
         } else if (in.token == MATCH) {
-          t = atPos(t.pos.startOrPoint, in.skipToken()) {
-            /** For debugging pattern matcher transition issues */
-            if (settings.Ypmatnaive.value)
-              makeSequencedMatch(stripParens(t), inBracesOrNil(caseClauses()))
-            else
-              Match(stripParens(t), inBracesOrNil(caseClauses()))
-          }
+          t = atPos(t.pos.startOrPoint, in.skipToken())(Match(stripParens(t), inBracesOrNil(caseClauses())))
         }
         // in order to allow anonymous functions as statements (as opposed to expressions) inside
         // templates, we have to disambiguate them from self type declarations - bug #1565
diff --git a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
index 0bc88d1efd..3a6e26d3b5 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/TreeBuilder.scala
@@ -505,37 +505,6 @@ abstract class TreeBuilder {
   def makePatDef(pat: Tree, rhs: Tree): List[Tree] =
     makePatDef(Modifiers(0), pat, rhs)
 
-  /** For debugging only.  Desugar a match statement like so:
-   *  val x = scrutinee
-   *  x match {
-   *    case case1 => ...
-   *    case _ => x match {
-   *       case case2 => ...
-   *       case _ => x match ...
-   *    }
-   *  }
-   *
-   *  This way there are never transitions between nontrivial casedefs.
-   *  Of course many things break: exhaustiveness and unreachable checking
-   *  do not work, no switches will be generated, etc.
-   */
-  def makeSequencedMatch(selector: Tree, cases: List[CaseDef]): Tree = {
-    require(cases.nonEmpty)
-
-    val selectorName = freshTermName()
-    val valdef = atPos(selector.pos)(ValDef(Modifiers(PrivateLocal | SYNTHETIC), selectorName, TypeTree(), selector))
-    val nselector = Ident(selectorName)
-
-    def loop(cds: List[CaseDef]): Match = {
-      def mkNext = CaseDef(Ident(nme.WILDCARD), EmptyTree, loop(cds.tail))
-
-      if (cds.size == 1) Match(nselector, cds)
-      else Match(selector, List(cds.head, mkNext))
-    }
-
-    Block(List(valdef), loop(cases))
-  }
-
   /** Create tree for pattern definition <mods val pat0 = rhs> */
   def makePatDef(mods: Modifiers, pat: Tree, rhs: Tree): List[Tree] = matchVarPattern(pat) match {
     case Some((name, tpt)) =>
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index d1224fc79d..fdde8f9990 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -30,6 +30,22 @@ trait ScalaSettings extends AbsScalaSettings
    */
   protected def defaultClasspath = sys.env.getOrElse("CLASSPATH", ".")
 
+  /** Enabled under -Xexperimental. */
+  protected def experimentalSettings = List[BooleanSetting](YmethodInfer, overrideObjects)
+
+  /** Enabled under -Xfuture. */
+  protected def futureSettings = List[BooleanSetting]()
+
+  /** Enabled under -optimise. */
+  protected def optimiseSettings = List[BooleanSetting](inline, inlineHandlers, Xcloselim, Xdce)
+
+  /** Internal use - syntax enhancements. */
+  private class EnableSettings[T <: Setting](val s: T) {
+    def enabling(toEnable: List[BooleanSetting]): s.type = s withPostSetHook (_ => toEnable foreach (_.value = true))
+    def andThen(f: s.T => Unit): s.type                  = s withPostSetHook (setting => f(setting.value))
+  }
+  private implicit def installEnableSettings[T <: Setting](s: T) = new EnableSettings(s)
+
   /** Disable a setting */
   def disable(s: Setting) = allSettings -= s
 
@@ -43,12 +59,8 @@ trait ScalaSettings extends AbsScalaSettings
    */
   // argfiles is only for the help message
   val argfiles      = BooleanSetting    ("@<file>", "A text file containing compiler arguments (options and source files)")
-  val classpath     = PathSetting       ("-classpath", "Specify where to find user class files.", defaultClasspath) .
-                                            withAbbreviation ("-cp")
+  val classpath     = PathSetting       ("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp"
   val d             = OutputSetting     (outputDirs, ".")
-  val optimise      = BooleanSetting    ("-optimise", "Generates faster bytecode by applying optimisations to the program") .
-                                            withAbbreviation("-optimize") .
-                                            withPostSetHook(set => List(inline, inlineHandlers, Xcloselim, Xdce) foreach (_.value = set.value))
   val nospecialization = BooleanSetting    ("-no-specialization", "Ignore @specialize annotations.")
 
   /**
@@ -64,7 +76,6 @@ trait ScalaSettings extends AbsScalaSettings
   val elidebelow    = IntSetting        ("-Xelide-below", "Calls to @elidable methods are omitted if method priority is lower than argument",
                                                 elidable.MINIMUM, None, elidable.byName get _)
   val noForwarders  = BooleanSetting    ("-Xno-forwarders", "Do not generate static forwarders in mirror classes.")
-  val future        = BooleanSetting    ("-Xfuture", "Turn on future language features.")
   val genPhaseGraph = StringSetting     ("-Xgenerate-phase-graph", "file", "Generate the phase graphs (outputs .dot files) to fileX.dot.", "")
   val XlogImplicits = BooleanSetting    ("-Xlog-implicits", "Show more detail on why some implicits are not applicable.")
   val logImplicitConv = BooleanSetting  ("-Xlog-implicit-conversions", "Print a message whenever an implicit conversion is inserted.")
@@ -92,12 +103,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.", "")
 
-  // Experimental Extensions
-  val Xexperimental = BooleanSetting    ("-Xexperimental", "Enable experimental extensions.") .
-                          withPostSetHook(set => List(YmethodInfer, overrideObjects) foreach (_.value = set.value))
-                                                   // YdepMethTpes, YvirtClasses,
-  val Xmacros       = BooleanSetting    ("-Xmacros", "Enable macros.")
-
   /** Compatibility stubs for options whose value name did
    *  not previously match the option name.
    */
@@ -145,8 +150,7 @@ trait ScalaSettings extends AbsScalaSettings
   val Ygenjavap     = StringSetting     ("-Ygen-javap", "dir", "Generate a parallel output directory of .javap files.", "")
   val Ydumpclasses  = StringSetting     ("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "")
   val Ynosqueeze    = BooleanSetting    ("-Yno-squeeze", "Disable creation of compact code in matching.")
-  val Ystatistics   = BooleanSetting    ("-Ystatistics", "Print compiler statistics.") .
-                                          withPostSetHook(set => util.Statistics.enabled = set.value)
+  val Ystatistics   = BooleanSetting    ("-Ystatistics", "Print compiler statistics.") andThen (util.Statistics.enabled = _)
   val stopAfter     = PhasesSetting     ("-Ystop-after", "Stop after") withAbbreviation ("-stop") // backward compat
   val stopBefore    = PhasesSetting     ("-Ystop-before", "Stop before")
   val refinementMethodDispatch =
@@ -157,26 +161,11 @@ trait ScalaSettings extends AbsScalaSettings
   val YrichExes     = BooleanSetting    ("-Yrich-exceptions",
                                             "Fancier exceptions.  Set source search path with -D" +
                                             sys.SystemProperties.traceSourcePath.key)
-  val Yidedebug     = BooleanSetting    ("-Yide-debug", "Generate, validate and output trees using the interactive compiler.")
-  val Ybuilderdebug = ChoiceSetting     ("-Ybuilder-debug", "manager", "Compile using the specified build manager.", List("none", "refined", "simple"), "none")
-  val Ybuildmanagerdebug =
-                      BooleanSetting    ("-Ybuild-manager-debug", "Generate debug information for the Refined Build Manager compiler.")
-  val Ytyperdebug   = BooleanSetting    ("-Ytyper-debug", "Trace all type assignments.")
-  val Yposdebug     = BooleanSetting    ("-Ypos-debug", "Trace position validation.")
-  val Yinferdebug   = BooleanSetting    ("-Yinfer-debug", "Trace type inference and implicit search.")
-  val Ypmatdebug    = BooleanSetting    ("-Ypmat-debug", "Trace all pattern matcher activity.")
+  val Ybuilderdebug   =  ChoiceSetting("-Ybuilder-debug", "manager", "Compile using the specified build manager.", List("none", "refined", "simple"), "none")
   val Yreifycopypaste =
                       BooleanSetting    ("-Yreify-copypaste", "Dump the reified trees in copypasteable representation.")
-  val Yreifydebug   = BooleanSetting    ("-Yreify-debug", "Trace reification.")
-  val Ymacrodebug   = BooleanSetting    ("-Ymacro-debug", "Trace macro-related activities: generation of synthetics, expansion, exceptions.")
   val Yreplsync     = BooleanSetting    ("-Yrepl-sync", "Do not use asynchronous code for repl startup")
-  val Yrepldebug    = BooleanSetting    ("-Yrepl-debug", "Trace all repl activity.") .
-                                          withPostSetHook(_ => interpreter.replProps.debug setValue true)
-  val Ycompletion   = BooleanSetting    ("-Ycompletion-debug", "Trace all tab completion activity.")
-  val Ydocdebug     = BooleanSetting    ("-Ydoc-debug", "Trace all scaladoc activity.")
-  val Ypmatnaive    = BooleanSetting    ("-Ypmat-naive", "Desugar matches as naively as possible.")
   val Ynotnull      = BooleanSetting    ("-Ynotnull", "Enable (experimental and incomplete) scala.NotNull.")
-  // val YdepMethTpes  = BooleanSetting    ("-Ydependent-method-types", "Allow dependent method types.")
   val YmethodInfer  = BooleanSetting    ("-Yinfer-argument-types", "Infer types for arguments of overriden methods.")
   val etaExpandKeepsStar = BooleanSetting("-Yeta-expand-keeps-star", "Eta-expand varargs methods to T* rather than Seq[T].  This is a temporary option to ease transition.")
   val noSelfCheck   = BooleanSetting    ("-Yno-self-type-checks", "Suppress check for self-type conformance among inherited members.")
@@ -188,6 +177,29 @@ trait ScalaSettings extends AbsScalaSettings
 
   def stop = stopAfter
 
+  /** Area-specific debug output.
+   */
+  val Ybuildmanagerdebug = BooleanSetting("-Ybuild-manager-debug", "Generate debug information for the Refined Build Manager compiler.")
+  val Ycompletion        = BooleanSetting("-Ycompletion-debug", "Trace all tab completion activity.")
+  val Ydocdebug          = BooleanSetting("-Ydoc-debug", "Trace all scaladoc activity.")
+  val Yidedebug          = BooleanSetting("-Yide-debug", "Generate, validate and output trees using the interactive compiler.")
+  val Yinferdebug        = BooleanSetting("-Yinfer-debug", "Trace type inference and implicit search.")
+  val Ymacrodebug        = BooleanSetting("-Ymacro-debug", "Trace macro-related activities: generation of synthetics, expansion, exceptions.")
+  val Ypmatdebug         = BooleanSetting("-Ypmat-debug", "Trace all pattern matcher activity.")
+  val Yposdebug          = BooleanSetting("-Ypos-debug", "Trace position validation.")
+  val Yreifydebug        = BooleanSetting("-Yreify-debug", "Trace reification.")
+  val Yrepldebug         = BooleanSetting("-Yrepl-debug", "Trace all repl activity.") andThen (interpreter.replProps.debug setValue _)
+  val Ytyperdebug        = BooleanSetting("-Ytyper-debug", "Trace all type assignments.")
+
+  /** Groups of Settings.
+   */
+  val future        = BooleanSetting    ("-Xfuture", "Turn on future language features.") enabling futureSettings
+  val optimise      = BooleanSetting    ("-optimise", "Generates faster bytecode by applying optimisations to the program") withAbbreviation "-optimize" enabling optimiseSettings
+  val Xexperimental = BooleanSetting    ("-Xexperimental", "Enable experimental extensions.") enabling experimentalSettings
+
+  // Feature extensions
+  val Xmacros       = BooleanSetting    ("-Xmacros", "Enable macros.")
+
   /**
    * IDE-specific settings
    */