Improve error messages for invalid requests

pkg/analysis_server/lib/src/protocol.dart

 // Copyright (c) 2014, 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 protocol;
 
 import 'dart:collection';
 import 'dart:convert';
 
 part 'generated_protocol.dart';
@@ skipping 263 matching lines @@
    * Retrieve the RefactoringKind that should be assumed when decoding
    * refactoring feedback objects, or null if no refactoring feedback object is
    * expected to be encountered.
    */
   RefactoringKind get refactoringKind;
 
   /**
    * Create an exception to throw if the JSON object at [jsonPath] fails to
    * match the API definition of [expected].
    */
-  dynamic mismatch(String jsonPath, String expected);
+  dynamic mismatch(String jsonPath, String expected, [Object actual]);
 
   /**
    * Create an exception to throw if the JSON object at [jsonPath] is missing
    * the key [key].
    */
   dynamic missingKey(String jsonPath, String key);
 
   /**
    * Decode a JSON object that is expected to be a boolean.  The strings "true"
    * and "false" are also accepted.
    */
   bool _decodeBool(String jsonPath, Object json) {
     if (json is bool) {
       return json;
     } else if (json == 'true') {
       return true;
     } else if (json == 'false') {
       return false;
     }
-    throw mismatch(jsonPath, 'bool');
+    throw mismatch(jsonPath, 'bool', json);
   }
 
   /**
    * Decode a JSON object that is expected to be an integer.  A string
    * representation of an integer is also accepted.
    */
   int _decodeInt(String jsonPath, Object json) {
     if (json is int) {
       return json;
     } else if (json is String) {
       return int.parse(json, onError: (String value) {
-        throw mismatch(jsonPath, 'int');
+        throw mismatch(jsonPath, 'int', json);
       });
     }
-    throw mismatch(jsonPath, 'int');
+    throw mismatch(jsonPath, 'int', json);
   }
 
   /**
    * Decode a JSON object that is expected to be a List.  [decoder] is used to
    * decode the items in the list.
    */
   List _decodeList(String jsonPath, Object json,
       [JsonDecoderCallback decoder]) {
     if (json == null) {
       return [];
     } else if (json is List) {
       List result = [];
       for (int i = 0; i < json.length; i++) {
         result.add(decoder('$jsonPath[$i]', json[i]));
       }
       return result;
     } else {
-      throw mismatch(jsonPath, 'List');
+      throw mismatch(jsonPath, 'List', json);
     }
   }
 
   /**
    * Decode a JSON object that is expected to be a Map.  [keyDecoder] is used
    * to decode the keys, and [valueDecoder] is used to decode the values.
    */
   Map _decodeMap(String jsonPath, Object json,
       {JsonDecoderCallback keyDecoder, JsonDecoderCallback valueDecoder}) {
     if (json == null) {
       return {};
     } else if (json is Map) {
       Map result = {};
       json.forEach((String key, value) {
         Object decodedKey;
         if (keyDecoder != null) {
           decodedKey = keyDecoder('$jsonPath.key', key);
         } else {
           decodedKey = key;
         }
         if (valueDecoder != null) {
           value = valueDecoder('$jsonPath[${JSON.encode(key)}]', value);
         }
         result[decodedKey] = value;
       });
       return result;
     } else {
-      throw mismatch(jsonPath, 'Map');
+      throw mismatch(jsonPath, 'Map', json);
     }
   }
 
   /**
    * Decode a JSON object that is expected to be a string.
    */
   String _decodeString(String jsonPath, Object json) {
     if (json is String) {
       return json;
     } else {
-      throw mismatch(jsonPath, 'String');
+      throw mismatch(jsonPath, 'String', json);
     }
   }
 
   /**
    * Decode a JSON object that is expected to be one of several choices,
    * where the choices are disambiguated by the contents of the field [field].
    * [decoders] is a map from each possible string in the field to the decoder
    * that should be used to decode the JSON object.
    */
   Object _decodeUnion(String jsonPath, Map json, String field,
       Map<String, JsonDecoderCallback> decoders) {
     if (json is Map) {
       if (!json.containsKey(field)) {
         throw missingKey(jsonPath, field);
       }
       var disambiguatorPath = '$jsonPath[${JSON.encode(field)}]';
       String disambiguator = _decodeString(disambiguatorPath, json[field]);
       if (!decoders.containsKey(disambiguator)) {
-        throw mismatch(disambiguatorPath, 'One of: ${decoders.keys.toList()}');
+        throw mismatch(disambiguatorPath, 'One of: ${decoders.keys.toList()}', json);
       }
       return decoders[disambiguator](jsonPath, json);
     } else {
-      throw mismatch(jsonPath, 'Map');
+      throw mismatch(jsonPath, 'Map', json);
     }
   }
 }
 
 /**
  * Instances of the class [Notification] represent a notification from the
  * server about an event that occurred.
  */
 class Notification {
   /**
@@ skipping 199 matching lines @@
   final Request _request;
 
   RequestDecoder(this._request);
 
   RefactoringKind get refactoringKind {
     // Refactoring feedback objects should never appear in requests.
     return null;
   }
 
   @override
-  dynamic mismatch(String jsonPath, String expected) {
+  dynamic mismatch(String jsonPath, String expected, [Object actual]) {
+    StringBuffer buffer = new StringBuffer();
+    buffer.write('Expected to be ');
+    buffer.write(expected);
+    if (actual != null) {
+      buffer.write('; found "');
+      buffer.write(JSON.encode(actual));
+      buffer.write('"');
+    }
     return new RequestFailure(new Response.invalidParameter(
-        _request, jsonPath, 'Expected to be $expected'));
+        _request, jsonPath, buffer.toString()));
   }
 
   @override
   dynamic missingKey(String jsonPath, String key) {
     return new RequestFailure(new Response.invalidParameter(
         _request, jsonPath, 'Expected to contain key ${JSON.encode(key)}'));
   }
 }
 
 /**
@@ skipping 276 matching lines @@
 /**
  * JsonDecoder for decoding responses from the server.  This is intended to be
  * used only for testing.  Errors are reported using bare [Exception] objects.
  */
 class ResponseDecoder extends JsonDecoder {
   final RefactoringKind refactoringKind;
 
   ResponseDecoder(this.refactoringKind);
 
   @override
-  dynamic mismatch(String jsonPath, String expected) {
-    return new Exception('Expected $expected at $jsonPath');
+  dynamic mismatch(String jsonPath, String expected, [Object actual]) {
+    StringBuffer buffer = new StringBuffer();
+    buffer.write('Expected ');
+    buffer.write(expected);
+    if (actual != null) {
+      buffer.write(' found "');
+      buffer.write(JSON.encode(actual));
+      buffer.write('"');
+    }
+    buffer.write(' at ');
+    buffer.write(jsonPath);
+    return new Exception(buffer.toString());
   }
 
   @override
   dynamic missingKey(String jsonPath, String key) {
     return new Exception('Missing key $key at $jsonPath');
   }
 }
 
 /**
  * Jenkins hash function, optimized for small integers.  Borrowed from
@@ skipping 12 matching lines @@
     hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
     hash = hash ^ (hash >> 11);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
   static int hash2(a, b) => finish(combine(combine(0, a), b));
 
   static int hash4(a, b, c, d) =>
       finish(combine(combine(combine(combine(0, a), b), c), d));
 }