Fix the way generated code is made strong mode clean

pkg/analysis_server/lib/src/protocol/protocol_internal.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 analysis_server.src.protocol.protocol_internal;
 
 import 'dart:collection';
 import 'dart:convert' hide JsonDecoder;
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
@@ skipping 204 matching lines @@
     return new RenameOptions.fromJson(jsonDecoder, jsonPath, json);
   }
   return null;
 }
 
 /**
  * Type of callbacks used to decode parts of JSON objects.  [jsonPath] is a
  * string describing the part of the JSON object being decoded, and [value] is
  * the part to decode.
  */
-typedef Object JsonDecoderCallback(String jsonPath, Object value);
+typedef E JsonDecoderCallback<E>(String jsonPath, Object value);
 
 /**
  * Instances of the class [HasToJson] implement [toJson] method that returns
  * a JSON presentation.
  */
 abstract class HasToJson {
   /**
    * Returns a JSON presentation of the object.
    */
   Map<String, Object> toJson();
@@ skipping 60 matching lines @@
       return json;
     } else if (json is String) {
       return int.parse(json, onError: (String value) {
         throw mismatch(jsonPath, 'int', json);
       });
     }
     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.
+   * Decode a JSON object that is expected to be a List. The [decoder] is used
+   * to decode the items in the list.
+   *
+   * The type parameter [E] is the expected type of the elements in the list.
    */
-  List decodeList(String jsonPath, Object json, [JsonDecoderCallback decoder]) {
+  List/*<E>*/ decodeList/*<E>*/(String jsonPath, Object json,
+      [JsonDecoderCallback/*<E>*/ decoder]) {
     if (json == null) {
-      return [];
+      return/*<E>*/ [];
     } else if (json is List) {
-      List result = [];
+      List/*<E>*/ result = /*<E>*/ [];
       for (int i = 0; i < json.length; i++) {
         result.add(decoder('$jsonPath[$i]', json[i]));
       }
       return result;
     } else {
       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}) {
+  Map/*<K, V>*/ decodeMap/*<K, V>*/(String jsonPath, Object json,
+      {JsonDecoderCallback/*<K>*/ keyDecoder,
+      JsonDecoderCallback/*<V>*/ valueDecoder}) {
     if (json == null) {
       return {};
     } else if (json is Map) {
-      Map result = {};
+      Map/*<K, V>*/ result = /*<K, V>*/ {};
       json.forEach((String key, value) {
-        Object decodedKey;
+        Object/*=K*/ decodedKey;
         if (keyDecoder != null) {
           decodedKey = keyDecoder('$jsonPath.key', key);
         } else {
-          decodedKey = key;
+          decodedKey = key as Object/*=K*/;
         }
         if (valueDecoder != null) {
           value = valueDecoder('$jsonPath[${JSON.encode(key)}]', value);
         }
-        result[decodedKey] = value;
+        result[decodedKey] = value as Object/*=V*/;
       });
       return result;
     } else {
       throw mismatch(jsonPath, 'Map', json);
     }
   }
 
   /**
    * Decode a JSON object that is expected to be a string.
    */
@@ skipping 102 matching lines @@
     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');
   }
 }