Revert "Fix for #3284.

test/files/run/json.scala, and we need at least one good nightly before
the RC.

2 files changed, 21 insertions, 60 deletions

diff --git a/src/library/scala/util/parsing/json/JSON.scala b/src/library/scala/util/parsing/json/JSON.scala
index dfcc98d5df..1900044698 100644
--- a/src/library/scala/util/parsing/json/JSON.scala
+++ b/src/library/scala/util/parsing/json/JSON.scala
@@ -42,33 +42,8 @@ object JSON extends Parser {
    *
    * @param input the given JSON string.
    * @return      an optional list of of elements.
-   *
-   * @deprecated Use parseFull or parseRaw as needed.
-   */
-  def parse(input: String): Option[List[Any]] = parseRaw(input).map(unRaw).flatMap({
-    case l : List[_] => Some(l)
-    case _ => None
-  })
-
-  /**
-   * This method converts "raw" results back into the original, deprecated
-   * form.
    */
-  private def unRaw (in : Any) : Any = in match {
-    case JSONObject(obj) => obj.map({ case (k,v) => (k,unRaw(v))}).toList
-    case JSONArray(list) => list.map(unRaw)
-    case x => x
-  }
-
-  /**
-   * Parse the given JSON string and return a list of elements. If the
-   * string is a JSON object it will be a JSONObject. If it's a JSON
-   * array it will be be a JSONArray.
-   *
-   * @param input the given JSON string.
-   * @return      an optional JSONType element.
-   */
-  def parseRaw(input : String) : Option[JSONType] =
+  def parse(input: String): Option[List[Any]] =
     phrase(root)(new lexical.Scanner(input)) match {
       case Success(result, _) => Some(result)
       case _ => None
@@ -83,7 +58,7 @@ object JSON extends Parser {
    * @return      an optional list or map.
    */
   def parseFull(input: String): Option[Any] =
-    parseRaw(input) match {
+    parse(input) match {
       case Some(data) => Some(resolveType(data))
       case None => None
     }
@@ -92,12 +67,23 @@ object JSON extends Parser {
    * A utility method to resolve a parsed JSON list into objects or
    * arrays. See the parse method for details.
    */
-  def resolveType(input: Any): Any = input match {
-    case JSONObject(data) => data.transform {
-      case (k,v) => resolveType(v)
-    }
-    case JSONArray(data) => data.map(resolveType)
-    case x => x
+  def resolveType(input: List[_]): Any = {
+    var objMap = Map[String, Any]()
+
+    if (input.forall {
+      case (key: String, value: List[_]) =>
+        objMap = objMap.+[Any](key -> resolveType(value))
+        true
+      case (key : String, value) =>
+        objMap += key -> value
+        true
+      case _ => false
+    }) objMap
+    else
+      input.map {
+          case l : List[_] => resolveType(l)
+          case x => x
+      }
   }
 
   /**
diff --git a/src/library/scala/util/parsing/json/Parser.scala b/src/library/scala/util/parsing/json/Parser.scala
index 2a9d734760..46a556c0ee 100644
--- a/src/library/scala/util/parsing/json/Parser.scala
+++ b/src/library/scala/util/parsing/json/Parser.scala
@@ -16,31 +16,6 @@ import scala.util.parsing.combinator.syntactical._
 import scala.util.parsing.combinator.lexical._
 
 /**
- *  A marker class for the JSON result types.
- *
- *  @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
- */
-sealed abstract class JSONType
-
-/**
- *  Represents a JSON Object (map).
- *  @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
- */
-case class JSONObject (obj : Map[Any,Any]) extends JSONType {
-  override def toString = "JSONObject(" + obj.map({ case (k,v) => k + " -> " + v }).mkString(", ") + ")"
-}
-
-/**
- *  Represents a JSON Array (list).
- *  @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
- */
-case class JSONArray (list : List[Any]) extends JSONType {
-  override def toString = "JSONArray(" + list.mkString(", ") + ")"
-}
-
-/**
- *  The main JSON Parser.
- *
  *  @author Derek Chen-Becker <"java"+@+"chen-becker"+"."+"org">
  */
 class Parser extends StdTokenParsers with ImplicitConversions {
@@ -65,8 +40,8 @@ class Parser extends StdTokenParsers with ImplicitConversions {
 
   // Define the grammar
   def root       = jsonObj | jsonArray
-  def jsonObj    = "{" ~> repsep(objEntry, ",") <~ "}" ^^ { case vals : List[_] => JSONObject(Map(vals : _*)) }
-  def jsonArray  = "[" ~> repsep(value, ",") <~ "]" ^^ { case vals : List[_] => JSONArray(vals) }
+  def jsonObj    = "{" ~> repsep(objEntry, ",") <~ "}"
+  def jsonArray  = "[" ~> repsep(value, ",") <~ "]"
   def objEntry   = stringVal ~ (":" ~> value) ^^ { case x ~ y => (x, y) }
   def value: Parser[Any] = (jsonObj | jsonArray | number | "true" ^^^ true | "false" ^^^ false | "null" ^^^ null | stringVal)
   def stringVal  = accept("string", { case lexical.StringLit(n) => n} )