1 files changed, 39 insertions, 15 deletions
diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
index 04af436ea3..e4366b8758 100644
--- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala
@@ -232,21 +232,21 @@ class MutableSettings(val errorFn: String => Unit) extends AbsSettings with Scal
   }
 
   def BooleanSetting(name: String, descr: String) = add(new BooleanSetting(name, descr))
-  def ChoiceSetting(name: String, descr: String, choices: List[String], default: String) =
-    add(new ChoiceSetting(name, descr, choices, default))
+  def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String) =
+    add(new ChoiceSetting(name, helpArg, descr, choices, default))
   def DefinesSetting() = add(new DefinesSetting())
   def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]) = add(new IntSetting(name, descr, default, range, parser))
   def MultiStringSetting(name: String, arg: String, descr: String) = add(new MultiStringSetting(name, arg, descr))
   def OutputSetting(outputDirs: OutputDirs, default: String) = add(new OutputSetting(outputDirs, default))
   def PhasesSetting(name: String, descr: String) = add(new PhasesSetting(name, descr))
   def StringSetting(name: String, arg: String, descr: String, default: String) = add(new StringSetting(name, arg, descr, default))
-  def PathSetting(name: String, arg: String, descr: String, default: String): PathSetting = {
+  def PathSetting(name: String, descr: String, default: String): PathSetting = {
     val prepend = new StringSetting(name + "/p", "", "", "") with InternalSetting
     val append = new StringSetting(name + "/a", "", "", "") with InternalSetting
 
     add[StringSetting](prepend)
     add[StringSetting](append)
-    add(new PathSetting(name, arg, descr, default, prepend, append))
+    add(new PathSetting(name, descr, default, prepend, append))
   }
 
   // basically this is a value which remembers if it's been modified
@@ -489,12 +489,11 @@ class MutableSettings(val errorFn: String => Unit) extends AbsSettings with Scal
 
   class PathSetting private[nsc](
     name: String,
-    arg: String,
     descr: String,
     default: String,
     prependPath: StringSetting,
     appendPath: StringSetting)
-  extends StringSetting(name, arg, descr, default) {
+  extends StringSetting(name, "path", descr, default) {
     import util.ClassPath.join
     def prepend(s: String) = prependPath.value = join(s, prependPath.value)
     def append(s: String) = appendPath.value = join(appendPath.value, s)
@@ -547,19 +546,19 @@ class MutableSettings(val errorFn: String => Unit) extends AbsSettings with Scal
    */
   class ChoiceSetting private[nsc](
     name: String,
+    helpArg: String,
     descr: String,
     override val choices: List[String],
     val default: String)
-  extends Setting(name, descr + choices.mkString(" (", ",", ")")) {
+  extends Setting(name, descr + choices.mkString(" (", ",", ") default:" + default)) {
     type T = String
     protected var v: String = default
-    protected def argument: String = name drop 1
     def indexOfChoice: Int = choices indexOf value
 
     def tryToSet(args: List[String]) = { value = default ; Some(args) }
 
     override def tryToSetColon(args: List[String]) = args match {
-      case Nil                            => errorAndValue("missing " + argument, None)
+      case Nil                            => errorAndValue("missing " + helpArg, None)
       case List(x) if choices contains x  => value = x ; Some(Nil)
       case List(x)                        => errorAndValue("'" + x + "' is not a valid choice for '" + name + "'", None)
       case xs                             => errorAndValue("'" + name + "' does not accept multiple arguments.", None)
@@ -567,7 +566,7 @@ class MutableSettings(val errorFn: String => Unit) extends AbsSettings with Scal
     def unparse: List[String] =
       if (value == default) Nil else List(name + ":" + value)
 
-    withHelpSyntax(name + ":<" + argument + ">")
+    withHelpSyntax(name + ":<" + helpArg + ">")
   }
 
   /** A setting represented by a list of strings which should be prefixes of
@@ -578,10 +577,33 @@ class MutableSettings(val errorFn: String => Unit) extends AbsSettings with Scal
   class PhasesSetting private[nsc](
     name: String,
     descr: String)
-  extends Setting(name, descr + " <phase> or \"all\"") {
+  extends Setting(name, descr + " <phase>.") {
     type T = List[String]
     protected var v: List[String] = Nil
     override def value = if (v contains "all") List("all") else super.value
+    private lazy val (numericValues, stringValues) =
+      value partition (_ forall (ch => ch.isDigit || ch == '-'))
+
+    /** A little ad-hoc parsing.  If a string is not the name of a phase, it can also be:
+     *    a phase id: 5
+     *    a phase id range: 5-10 (inclusive of both ends)
+     *    a range with no start: -5 means up to and including 5
+     *    a range with no end: 10- means 10 until completion.
+     */
+    private def stringToPhaseIdTest(s: String): Int => Boolean = (s indexOf '-') match {
+      case -1  => (_ == s.toInt)
+      case 0   => (_ <= s.tail.toInt)
+      case idx =>
+        if (s.last == '-') (_ >= s.init.toInt)
+        else (s splitAt idx) match {
+          case (s1, s2) => (id => id >= s1.toInt && id <= s2.tail.toInt)
+        }
+    }
+    private lazy val phaseIdTest: Int => Boolean =
+      (numericValues map stringToPhaseIdTest) match {
+        case Nil    => _ => false
+        case fns    => fns.reduceLeft((f1, f2) => id => f1(id) || f2(id))
+      }
 
     def tryToSet(args: List[String]) = errorAndValue("missing phase", None)
     override def tryToSetColon(args: List[String]) = args match {
@@ -590,11 +612,13 @@ class MutableSettings(val errorFn: String => Unit) extends AbsSettings with Scal
     }
     // we slightly abuse the usual meaning of "contains" here by returning
     // true if our phase list contains "all", regardless of the incoming argument
-    def contains(phasename: String): Boolean =
-      doAllPhases || (value exists { phasename startsWith _ } )
+    def contains(phName: String)     = doAllPhases || containsName(phName)
+    def containsName(phName: String) = stringValues exists (phName startsWith _)
+    def containsId(phaseId: Int)     = phaseIdTest(phaseId)
+    def containsPhase(ph: Phase)     = contains(ph.name) || containsId(ph.id)
 
-    def doAllPhases() = value contains "all"
-    def unparse: List[String] = value map { name + ":" + _ }
+    def doAllPhases = stringValues contains "all"
+    def unparse: List[String] = value map (name + ":" + _)
 
     withHelpSyntax(name + ":<phase>")
   }