Consistently type check analysis server request parameters.

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:convert' show JsonDecoder;
 
 /**
  * Instances of the class [Request] represent a request that was received.
@@ skipping 76 matching lines @@
       } else if (params != null) {
         return null;
       }
       return request;
     } catch (exception) {
       return null;
     }
   }
 
   /**
-   * Return the value of the parameter with the given [name], or `null` if there
-   * is no such parameter associated with this request.
+   * Return the value of the parameter with the given [name], or defaultValue

[Brian Wilkerson, 2014/04/21 22:12:32]

"defaultValue" --> "[defaultValue]"

[Paul Berry, 2014/04/21 22:22:21]

Done.

+   * if there is no such parameter associated with this request.
    */
-  Object getParameter(String name) => params[name];
+  RequestDatum getParameter(String name, dynamic defaultValue) {

[Brian Wilkerson, 2014/04/21 22:12:32]

Do we want a default default value, such as
  RequestDatum getParameter(String name, [dynamic defaultValue = null])

[Paul Berry, 2014/04/21 22:22:21]

I don't know.  Currently there's not really a need for it, since the only use of
this method is for server.createContext's packageMap parameter, and the default
that makes sense for that is {}.

I'll keep this in mind as I'm getting more commands implemented.

+    Object value = params[name];
+    if (value == null) {
+      return new RequestDatum(this, "default for $name", defaultValue);
+    }
+    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.
    */
-  Object getRequiredParameter(String name) {
+  RequestDatum getRequiredParameter(String name) {
     Object value = params[name];
     if (value == null) {
       throw new RequestFailure(new Response.missingRequiredParameter(this, name));
     }
-    return value;
+    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;
   }
 
   /**
-   * Convert the given [value] to a boolean, or throw a [RequestFailure]
-   * exception if the [value] could not be converted.
-   *
-   * The value is typically the result of invoking either [getParameter] or
-   * [getRequiredParameter].
-   */
-  bool toBool(Object value) {
-    if (value is bool) {
-      return value;
-    } else if (value is String) {
-      return value == 'true';
-    }
-    throw new RequestFailure(new Response.expectedBoolean(this, value));
-  }
-
-  /**
-   * Convert the given [value] to an integer, or throw a [RequestFailure]
-   * exception if the [value] could not be converted.
-   *
-   * The value is typically the result of invoking either [getParameter] or
-   * [getRequiredParameter].
-   */
-  int toInt(Object value) {
-    if (value is int) {
-      return value;
-    } else if (value is String) {
-      return int.parse(value, onError: (String value) {
-        throw new RequestFailure(new Response.expectedInteger(this, value));
-      });
-    }
-    throw new RequestFailure(new Response.expectedInteger(this, value));
-  }
-
-  /**
    * Return a table representing the structure of the Json object that will be
    * sent to the client to represent this response.
    */
   Map<String, Object> toJson() {
     Map<String, Object> jsonObject = new Map<String, Object>();
     jsonObject[ID] = id;
     jsonObject[METHOD] = method;
     if (params.isNotEmpty) {
       jsonObject[PARAMS] = params;
     }
     return jsonObject;
   }
 }
 
+/**
+ * Instances of the class [RequestDatum] wrap a piece of data from a
+ * request parameter, and contain accessor methods which automatically validate
+ * and convert the data into the appropriate form.
+ */
+class RequestDatum {
+  /**
+   * Request object that should be referred to in any errors that are
+   * generated.
+   */
+  final Request request;
+
+  /**
+   * String description of how [datum] was obtained from the request.
+   */
+  final String path;
+
+  /**
+   * Value to be decoded and validated.
+   */
+  final dynamic datum;
+
+  /**
+   * 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<String, dynamic>) {
+      throw new RequestFailure(new Response.invalidParameter(request, path,
+          "be a map"));
+    }
+    if (!datum.containsKey(key)) {
+      throw new RequestFailure(new Response.invalidParameter(request, path,
+          "contain key '$key'"));
+    }
+    return new RequestDatum(request, "$path.$key", datum[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<String, dynamic>) {
+      throw new RequestFailure(new Response.invalidParameter(request, path,
+          "be a map"));
+    }
+    datum.forEach((String key, dynamic 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) {
+      return datum;
+    } else if (datum is String) {
+      return int.parse(datum, onError: (String value) {
+        throw new RequestFailure(new Response.invalidParameter(request, path,
+            "be an integer"));
+      });
+    }
+    throw new RequestFailure(new Response.invalidParameter(request, path,
+        "be an integer"));
+  }
+
+  /**
+   * Validate that the datum is a boolean (or a string that can be parsed
+   * as a boolean), and return the bool.
+   *
+   * The value is typically the result of invoking either [getParameter] or
+   * [getRequiredParameter].
+   */
+  bool asBool() {
+    if (datum is bool) {
+      return datum;
+    } else if (datum == 'true') {
+      return datum == 'true';
+    } else if (datum == 'false') {
+      return datum == 'false';
+    }
+    throw new RequestFailure(new Response.invalidParameter(request, datum,
+        "be a boolean"));
+  }
+
+  /**
+   * 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;
+  }
+
+  /**
+   * Validate that the datum is a list of strings, and return it.
+   */
+  List<String> asStringList() {
+    if (datum is! List<String>) {
+      throw new RequestFailure(new Response.invalidParameter(request, path,
+          "be a list of strings"));
+    }
+    return datum;
+  }
+
+  /**
+   * Validate that the datum is a map from strings to strings, and return it.
+   */
+  Map<String, String> asStringMap() {
+    if (datum is! Map<String, String>) {
+      throw new RequestFailure(new Response.invalidParameter(request, path,
+          "be a string map"));
+    }
+    return datum;
+  }
+}
+
 /**
  * Instances of the class [Response] represent a response to a request.
  */
 class Response {
   /**
    * The name of the JSON attribute containing the id of the request for which
    * this is a response.
    */
   static const String ID = 'id';
 
@@ skipping 34 matching lines @@
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a [request] referencing a context that does not exist.
    */
   Response.contextDoesNotExist(Request request)
     : this(request.id, new RequestError(-1, 'Context does not exist'));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
-   * by a [request] that was expected to have a boolean-valued parameter but was
-   * passed a non-boolean value.
+   * by a [request] that had invalid parameter.  [path] is the path to the
+   * invalid parameter, in Javascript notation (e.g. "foo.bar" means that the
+   * parameter "foo" contained a key "bar" whose value was the wrong type).
+   * [expectation] is a description of the type of data that was expected.
    */
-  Response.expectedBoolean(Request request, Object value)
-    : this(request.id, new RequestError(-2, 'Expected a boolean value, but found "$value"'));
+  Response.invalidParameter(Request request, String path, String expectation)
+      : this(request.id, new RequestError(-2,
+          "Expected parameter $path to $expectation"));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
-   * by a [request] that was expected to have a integer-valued parameter but was
-   * passed a non-integer value.
-   */
-  Response.expectedInteger(Request request, Object value)
-    : this(request.id, new RequestError(-3, 'Expected an integer value, but found "$value"'));
-
-  /**
-   * Initialize a newly created instance to represent an error condition caused
    * by a malformed request.
    */
   Response.invalidRequestFormat()
     : this('', new RequestError(-4, 'Invalid request'));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a [request] that does not have a required parameter.
    */
   Response.missingRequiredParameter(Request request, String parameterName)
@@ skipping 349 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);
 }