Use type annotations everywhere in analysis_server/lib.

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 51 matching lines @@
    *     'params': {
    *       paramter_name: value
    *     }
    *   }
    *
    * where the parameters are optional and can contain any number of name/value
    * pairs.
    */
   factory Request.fromString(String data) {
     try {
-      var result = DECODER.convert(data);
+      dynamic result = DECODER.convert(data);

[Brian Wilkerson, 2014/05/24 17:36:52]

Hm. It might be better to leave 'var' in places where we don't *have* type
information (which is everywhere it previously was in this file) as a marker
that we're using an untyped API. Not sure about that...

[scheglov, 2014/05/24 17:45:50]

I rolled back places where we use "dynamic" type.

       if (result is! Map) {
         return null;
       }
-      var id = result[Request.ID];
-      var method = result[Request.METHOD];
+      dynamic id = result[Request.ID];
+      dynamic method = result[Request.METHOD];
       if (id is! String || method is! String) {
         return null;
       }
-      var params = result[Request.PARAMS];
+      dynamic params = result[Request.PARAMS];
       Request request = new Request(id, method);
       if (params is Map) {
         params.forEach((String key, Object value) {
           request.setParameter(key, value);
         });
       } else if (params != null) {
         return null;
       }
       return request;
     } catch (exception) {
@@ skipping 164 matching lines @@
     return datum;
   }
 
   /**
    * Determine if the datum is a list of strings.
    */
   bool isStringList() {
     if (datum is! List) {
       return false;
     }
-    for (var element in datum) {
+    for (dynamic element in datum) {
       if (element is! String) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Validate that the datum is a list of strings, and return it.
    */
   List<String> asStringList() {
     if (!isStringList()) {
       throw new RequestFailure(new Response.invalidParameter(request, path,
           "be a list of strings"));
     }
     return datum;
   }
 
   /**
    * Determine if the datum is a map whose values are all strings.
    *
    * Note: we can safely assume that the keys are all strings, since JSON maps
    * cannot have any other key type.
    */
   bool isStringMap() {
     if (datum is! Map) {
       return false;
     }
-    for (var value in datum.values) {
+    for (dynamic value in datum.values) {
       if (value is! String) {
         return false;
       }
     }
     return true;
   }
 
   /**
    * Validate that the datum is a map from strings to strings, and return it.
    */
@@ skipping 99 matching lines @@
     : this(request.id, new RequestError(-7, 'Unknown request'));
 
   Response.contextAlreadyExists(Request request)
     : this(request.id, new RequestError(-8, 'Context already exists'));
 
   /**
    * Initialize a newly created instance based upon the given JSON data
    */
   factory Response.fromJson(Map<String, Object> json) {
     try {
-      var id = json[Response.ID];
+      Object id = json[Response.ID];
       if (id is! String) {
         return null;
       }
-      var error = json[Response.ERROR];
-      var result = json[Response.RESULT];
+      Object error = json[Response.ERROR];
+      Object result = json[Response.RESULT];
       Response response;
       if (error is Map) {
         response = new Response(id, new RequestError.fromJson(error));
       } else {
         response = new Response(id);
       }
       if (result is Map) {
         result.forEach((String key, Object value) {
           response.setResult(key, value);
         });
@@ skipping 236 matching lines @@
    * Initialize a newly created [Notification] to have the given [event] name.
    */
   Notification(this.event);
 
   /**
    * Initialize a newly created instance based upon the given JSON data
    */
   factory Notification.fromJson(Map<String, Object> json) {
     try {
       String event = json[Notification.EVENT];
-      var params = json[Notification.PARAMS];
+      Object params = json[Notification.PARAMS];
       Notification notification = new Notification(event);
       if (params is Map) {
         params.forEach((String key, Object value) {
           notification.setParameter(key, value);
         });
       }
       return notification;
     } catch (exception) {
       return null;
     }
@@ skipping 49 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);
 }