Allow "null" as a synonym for [] or {} in the analysis server API.

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' show JsonDecoder;
 
 /**
@@ skipping 120 matching lines @@
     } catch (exception) {
       return null;
     }
   }
 
   /**
    * Return the value of the parameter with the given [name], or [defaultValue]
    * if there is no such parameter associated with this request.
    */
   RequestDatum getParameter(String name, defaultValue) {
-    Object value = params[name];
-    if (value == null) {
+    if (!params.containsKey(name)) {
       return new RequestDatum(this, "default for $name", defaultValue);
     }
+    Object value = params[name];

[Brian Wilkerson, 2014/06/21 03:24:51]

Remove this line, given that 'value' is never accessed?

[Paul Berry, 2014/06/23 16:51:45]

Done.

     return new RequestDatum(this, name, params[name]);
   }
 
   /**
    * Return the value of the parameter with the given [name], or throw a
    * [RequestFailure] exception with an appropriate error message if there is no
    * such parameter associated with this request.
    */
   RequestDatum getRequiredParameter(String name) {
-    Object value = params[name];
-    if (value == null) {
+    if (!params.containsKey(name)) {
       throw new RequestFailure(new Response.missingRequiredParameter(this, name));
     }
+    Object value = params[name];

[Brian Wilkerson, 2014/06/21 03:24:51]

Ditto.

[Paul Berry, 2014/06/23 16:51:45]

Done.

     return new RequestDatum(this, name, value);
   }
 
   /**
    * Set the value of the parameter with the given [name] to the given [value].
    */
   void setParameter(String name, Object value) {
     params[name] = value;
   }
 
@@ skipping 38 matching lines @@
    * Create a RequestDatum for decoding and validating [datum], which refers to
    * [request] in any errors it reports.
    */
   RequestDatum(this.request, this.path, this.datum);
 
   /**
    * Validate that the datum is a Map containing the given [key], and return
    * a [RequestDatum] containing the corresponding value.
    */
   RequestDatum operator [](String key) {
-    if (datum is! Map) {
-      throw new RequestFailure(new Response.invalidParameter(request, path,
-          "be a map"));
-    }
-    if (!datum.containsKey(key)) {
+    Map<String, Object> map = _asMap();
+    if (!map.containsKey(key)) {
       throw new RequestFailure(new Response.invalidParameter(request, path,
           "contain key '$key'"));
     }
-    return new RequestDatum(request, "$path.$key", datum[key]);
+    return new RequestDatum(request, "$path.$key", map[key]);
   }
 
   /**
    * Return `true` if the datum is a Map containing the given [key].
    */
   bool hasKey(String key) {
-    if (datum is! Map) {
-      throw new RequestFailure(new Response.invalidParameter(request, path,
-          "be a map"));
-    }
-    return datum.containsKey(key);
+    return _asMap().containsKey(key);
   }
 
   /**
    * Validate that the datum is a Map whose keys are strings, and call [f] on
    * each key/value pair in the map.
    */
   void forEachMap(void f(String key, RequestDatum value)) {
-    if (datum is! Map) {
-      throw new RequestFailure(new Response.invalidParameter(request, path,
-          "be a map"));
-    }
-    datum.forEach((String key, value) {
+    _asMap().forEach((String key, value) {
       f(key, new RequestDatum(request, "$path.$key", value));
     });
   }
 
   /**
    * Validate that the datum is an integer (or a string that can be parsed
    * as an integer), and return the int.
    */
   int asInt() {
     if (datum is int) {
@@ skipping 21 matching lines @@
     } else if (datum == 'true') {
       return true;
     } else if (datum == 'false') {
       return false;
     }
     throw new RequestFailure(new Response.invalidParameter(request, datum,
         "be a boolean"));
   }
 
   /**
+   * Determine if the datum is a list.  Note: null is considered a synonym for
+   * the empty list.
+   */
+  bool get isList {
+    return datum == null || datum is List;
+  }
+
+  /**
+   * Validate that the datum is a list, and return it in raw form.
+   */
+  List _asList() {
+    if (!isList) {
+      throw new RequestFailure(new Response.invalidParameter(request, path,
+          "be a list"));
+    }
+    if (datum == null) {
+      return [];
+    } else {
+      return datum;
+    }
+  }
+
+  /**
    * Validate that the datum is a list, and return a list where each element in
    * the datum has been converted using the provided function.
    */
   List asList(elementConverter(RequestDatum datum)) {
-    if (datum is! List) {
-      throw new RequestFailure(new Response.invalidParameter(request, path,
-          "be a list"));
-    }
-    List list = datum as List;
     List result = [];
+    List list = _asList();
     for (int i = 0; i < list.length; i++) {
       result.add(elementConverter(new RequestDatum(request, "$path.$i", list[i])));
     }
     return result;
   }
 
   /**
    * Validate that the datum is a string, and return it.
    */
   String asString() {
     if (datum is! String) {
       throw new RequestFailure(new Response.invalidParameter(request, path,
           "be a string"));
     }
     return datum;
   }
 
   /**
-   * Determine if the datum is a list of strings.
+   * Determine if the datum is a list of strings.  Note: null is considered a
+   * synonym for the empty list.
    */
   bool get isStringList {
-    if (datum is! List) {
+    if (!isList) {
       return false;
     }
-    for (var element in datum) {
+    for (var element in _asList()) {
       if (element is! String) {
         return false;
       }
     }
     return true;
   }
 
   /**
-   * Validate that the datum is a list of strings, and return it.
+   * Validate that the datum is a list of strings, and return it.  Note: null
+   * is considered a synonym for the empty list.
    */
   List<String> asStringList() {
     if (!isStringList) {
       throw new RequestFailure(new Response.invalidParameter(request, path,
           "be a list of strings"));
     }
-    return datum;
+    return _asList();
   }
 
   /**
    * Validate that the datum is a list of strings, and convert it into [Enum]s.
    */
   Set<Enum2> asEnumSet(List<Enum2> allValues) {
     Set values = new Set();
     for (String name in asStringList()) {
       Enum2 value = Enum2.valueOf(allValues, name);
       if (value == null) {
         throw new RequestFailure(new Response.invalidParameter(request, path,
             "be a list of names from the list $allValues"));
       }
       values.add(value);
     }
     return values;
   }
 
   /**
-   * Determine if the datum is a map whose values are all strings.
+   * Determine if the datum is a map.  Note: null is considered a synonym for
+   * the empty map.
+   */
+  bool get isMap {
+    return datum == null || datum is Map;
+  }
+
+  /**
+   * Validate that the datum is a map, and return it in raw form.
+   */
+  Map<String, Object> _asMap() {
+    if (!isMap) {
+      throw new RequestFailure(new Response.invalidParameter(request, path,
+          "be a map"));
+    }
+    if (datum == null) {
+      return {};
+    } else {
+      return datum;
+    }
+  }
+
+  /**
+   * Determine if the datum is a map whose values are all strings.  Note: null
+   * is considered a synonym for the empty map.
    *
    * Note: we can safely assume that the keys are all strings, since JSON maps
    * cannot have any other key type.
    */
   bool get isStringMap {
-    if (datum is! Map) {
+    if (!isMap) {
       return false;
     }
-    for (var value in datum.values) {
+    for (var value in _asMap().values) {
       if (value is! String) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Validate that the datum is a map from strings to strings, and return it.
    */
   Map<String, String> asStringMap() {
     if (!isStringMap) {
       throw new RequestFailure(new Response.invalidParameter(request, path,
           "be a string map"));
     }
-    return datum;
+    return _asMap();
   }
 
   /**
-   * Determine if the datum is a map whose values are all string lists.
+   * Determine if the datum is a map whose values are all string lists.  Note:
+   * null is considered a synonym for the empty map.
    *
    * Note: we can safely assume that the keys are all strings, since JSON maps
    * cannot have any other key type.
    */
-  bool isStringListMap() {
-    if (datum is! Map) {
+  bool get isStringListMap {
+    if (!isMap) {
       return false;
     }
-    for (var value in datum.values) {
+    for (var value in _asMap().values) {
       if (value is! List) {
         return false;
       }
       for (var listItem in value) {
         if (listItem is! String) {
           return false;
         }
       }
     }
     return true;
   }
 
   /**
-   * Validate that the datum is a map from strings to string listss, and return
+   * Validate that the datum is a map from strings to string lists, and return
    * it.
    */
   Map<String, List<String>> asStringListMap() {
-    if (!isStringListMap()) {
+    if (!isStringListMap) {
       throw new RequestFailure(new Response.invalidParameter(request, path,
           "be a string list map"));
     }
-    return datum;
+    return _asMap();
   }
 
   bool get isNull => datum == null;
 }
 
 /**
  * Instances of the class [Response] represent a response to a request.
  */
 class Response {
   /**
@@ skipping 447 matching lines @@
   /**
    * The response to be returned as a result of the failure.
    */
   final Response response;
 
   /**
    * Initialize a newly created exception to return the given reponse.
    */
   RequestFailure(this.response);
 }