Make JSON stringify throw a JsonUnsupportedObjectError on cycles.

sdk/lib/json/json.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart.json;
 
 // JSON parsing and serialization.
 
 /**
  * Error thrown by JSON serialization if an object cannot be serialized.
  *
  * The [unsupportedObject] field holds that object that failed to be serialized.
  *
  * If an object isn't directly serializable, the serializer calls the 'toJson'
  * method on the object. If that call fails, the error will be stored in the
  * [cause] field. If the call returns an object that isn't directly
  * serializable, the [cause] will be null.
  */
 class JsonUnsupportedObjectError implements Error {
   /** The object that could not be serialized. */
   final unsupportedObject;
   /** The exception thrown by object's [:toJson:] method, if any. */
   final cause;
-  JsonUnsupportedObjectError(this.unsupportedObject) : cause = null;
-  JsonUnsupportedObjectError.withCause(this.unsupportedObject, this.cause);
+
+  JsonUnsupportedObjectError(this.unsupportedObject, { this.cause });
 
   String toString() {
     if (cause != null) {
       return "Calling toJson method on object failed.";
     } else {
       return "Object toJson method returns non-serializable value.";
     }
   }
 }
 
 
 /**
+ * Reports that an object could not be stringified due to cyclic references.
+ *
+ * An object that references itself cannot be serialized by [stringify].
+ * When the cycle is detected, a [JsonCyclicError] is thrown.
+ */
+class JsonCyclicError extends JsonUnsupportedObjectError {
+  /** The first object that was detected as part of a cycle. */
+  JsonCyclicError(Object object): super(object);
+  String toString() => "Cyclic error in JSON stringify";
+}
+
+
+/**
  * Parses [json] and build the corresponding parsed JSON value.
  *
  * Parsed JSON values are of the types [num], [String], [bool], [Null],
  * [List]s of parsed JSON values or [Map]s from [String] to parsed
  * JSON values.
  *
  * The optional [revivier] function, if provided, is called once for each
  * object or list property parsed. The arguments are the property name
  * ([String]) or list index ([int]), and the value is the parsed value.
  * The return value of the revivier will be used as the value of that property
@@ skipping 10 matching lines @@
   } else {
     listener = new ReviverJsonListener(reviver);
   }
   new JsonParser(json, listener).parse();
   return listener.result;
 }
 
 /**
  * Serializes [object] into a JSON string.
  *
- * Directly serializable types are [num], [String], [bool], [Null], [List]
- * and [Map].
+ * Directly serializable values are [num], [String], [bool], and [Null], as well
+ * as some [List] and [Map] values.
  * For [List], the elements must all be serializable.
  * For [Map], the keys must be [String] and the values must be serializable.
+ *
  * If a value is any other type is attempted serialized, a "toJson()" method
  * is invoked on the object and the result, which must be a directly
- * serializable type, is serialized instead of the original value.
+ * serializable value, is serialized instead of the original value.
+ *
  * If the object does not support this method, throws, or returns a
  * value that is not directly serializable, a [JsonUnsupportedObjectError]
  * exception is thrown. If the call throws (including the case where there
  * is no nullary "toJson" method, the error is caught and stored in the
  * [JsonUnsupportedObjectError]'s [:cause:] field.
- *Json
- * Objects should not change during serialization.
+ *
+ * If a [List] or [Map] contains a reference to itself, directly or through
+ * other lists or maps, it cannot be serialized and a [JsonCyclicError] is
+ * thrown.
+ *
+ * Json Objects should not change during serialization.
  * If an object is serialized more than once, [stringify] is allowed to cache
  * the JSON text for it. I.e., if an object changes after it is first
  * serialized, the new values may or may not be reflected in the result.
  */
 String stringify(Object object) {
   return _JsonStringifier.stringify(object);
 }
 
 /**
  * Serializes [object] into [output] stream.
@@ skipping 618 matching lines @@
         charCodes.add(charCode);
       }
     }
     sb.write(needsEscape ? new String.fromCharCodes(charCodes) : s);
   }
 
   void checkCycle(final object) {
     // TODO: use Iterables.
     for (int i = 0; i < seen.length; i++) {
       if (identical(seen[i], object)) {
-        throw 'Cyclic structure';
+        throw new JsonCyclicError(object);
       }
     }
     seen.add(object);
   }
 
   void stringifyValue(final object) {
     // Tries stringifying object directly. If it's not a simple value, List or
     // Map, call toJson() to get a custom representation and try serializing
     // that.
     if (!stringifyJsonValue(object)) {
       checkCycle(object);
       try {
         var customJson = object.toJson();
         if (!stringifyJsonValue(customJson)) {
           throw new JsonUnsupportedObjectError(object);
         }
         seen.removeLast();
       } catch (e) {
-        throw new JsonUnsupportedObjectError.withCause(object, e);
+        throw new JsonUnsupportedObjectError(object, cause: e);
       }
     }
   }
 
   /**
    * Serializes a [num], [String], [bool], [Null], [List] or [Map] value.
    *
    * Returns true if the value is one of these types, and false if not.
    * If a value is both a [List] and a [Map], it's serialized as a [List].
    */
@@ skipping 48 matching lines @@
         first = false;
       });
       sb.write('}');
       seen.removeLast();
       return true;
     } else {
       return false;
     }
   }
 }