Make more use of generated code in analysis server.

pkg/analysis_server/tool/spec/codegen_dart_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 codegen.protocol;
 
 import 'dart:convert';
 
 import 'api.dart';
 import 'codegen_tools.dart';
@@ skipping 181 matching lines @@
   static const Map<String, String> _typeRenames = const {
     'object': 'Object',
   };
 
   /**
    * Class members for which the constructor argument should be optional, even
    * if the member is not an optional part of the protocol.  For list types,
    * the constructor will default the member to the empty list.
    */
   static const Map<String, List<String>> _optionalConstructorArguments = const {
+    'ErrorFixes': const ['fixes'],
+    'SourceChange': const ['edits', 'linkedEditGroups'],
     'SourceFileEdit': const ['edits'],
-    'TypeHierarchyItem': const ['interfaces', 'mixins', 'subclasses']
+    'TypeHierarchyItem': const ['interfaces', 'mixins', 'subclasses'],
   };
 
   /**
    * Visitor used to produce doc comments.
    */
   final ToHtmlVisitor toHtmlVisitor;
 
   /**
    * Types implied by the API.  This includes types explicitly named in the
    * API as well as those implied by the definitions of requests, responses,
@@ skipping 29 matching lines @@
           writeln();
           emitEnumClass(dartTypeName, type, impliedType);
         }
       }
     }
   }
 
   /**
    * Emit the class to encapsulate an object type.
    */
-  void emitObjectClass(String className, TypeObject type, ImpliedType
-      impliedType) {
+  void emitObjectClass(String className, TypeObject type,
+      ImpliedType impliedType) {
     docComment(toHtmlVisitor.collectHtml(() {
       toHtmlVisitor.p(() {
         toHtmlVisitor.write(impliedType.humanReadableName);
       });
       if (impliedType.type != null) {
         toHtmlVisitor.showType(null, impliedType.type);
       }
     }));
     writeln('class $className implements HasToJson {');
     indent(() {
@@ skipping 24 matching lines @@
         writeln();
       }
       emitToJsonMember(type);
       writeln();
       if (emitToRequestMember(impliedType)) {
         writeln();
       }
       if (emitToResponseMember(impliedType)) {
         writeln();
       }
-      if (emitSpecialMembers(className)) {
+      if (emitToNotificationMember(impliedType)) {
+        writeln();
+      }
+      if (emitSpecialMethods(className)) {
         writeln();
       }
       writeln('@override');
       writeln('String toString() => JSON.encode(toJson());');
       writeln();
       emitObjectEqualsMember(type, className);
       writeln();
       emitObjectHashCode(type);
     });
     writeln('}');
   }
 
   /**
    * If the class named [className] requires special static members, emit them
    * and return true.
    */
   bool emitSpecialStaticMembers(String className) {
     switch (className) {
+      case 'AnalysisError':
+        docComment(
+            [
+                new dom.Text(
+                    'Returns a list of AnalysisErrors ' +
+                        'correponding to the given list of Engine errors.')]);
+        writeln(
+            'static List<AnalysisError> listFromEngine(engine.LineInfo lineInfo, List<engine.AnalysisError> errors) =>');
+        writeln('    _analysisErrorListFromEngine(lineInfo, errors);');
+        return true;
       case 'Element':
         List<String> makeFlagsArgs = <String>[];
         List<String> makeFlagsStatements = <String>[];
         specialElementFlags.forEach((String name, String value) {
           String flag = 'FLAG_${name.toUpperCase()}';
           String camelName = camelJoin(['is', name]);
           writeln('static const int $flag = $value;');
           makeFlagsArgs.add('$camelName: false');
           makeFlagsStatements.add('if ($camelName) flags |= $flag;');
         });
         writeln();
         writeln('static int makeFlags({${makeFlagsArgs.join(', ')}}) {');
         indent(() {
           writeln('int flags = 0;');
           for (String statement in makeFlagsStatements) {
             writeln(statement);
           }
           writeln('return flags;');
         });
         writeln('}');
         return true;
       case 'SourceEdit':
-        docComment([new dom.Text('Get the result of applying a set of ' +
-            '[edits] to the given [code].  Edits are applied in the order ' +
-            'they appear in [edits].')]);
+        docComment(
+            [
+                new dom.Text(
+                    'Get the result of applying a set of ' +
+                        '[edits] to the given [code].  Edits are applied in the order ' +
+                        'they appear in [edits].')]);
         writeln(
             'static String applySequence(String code, Iterable<SourceEdit> edits) =>');
         writeln('    _applySequence(code, edits);');
         return true;
       default:
         return false;
     }
   }
 
   /**
    * If the class named [className] requires special constructors, emit them
    * and return true.
    */
   bool emitSpecialConstructors(String className) {
     switch (className) {
       case 'AnalysisError':
-        docComment([new dom.Text(
-            'Construct based on error information from the analyzer engine.')]);
+        docComment(
+            [
+                new dom.Text(
+                    'Construct based on error information from the analyzer engine.')]);
         writeln(
-            'factory AnalysisError.fromEngine(engine.LineInfo lineInfo, engine.AnalysisError error) =>'
-            );
+            'factory AnalysisError.fromEngine(engine.LineInfo lineInfo, engine.AnalysisError error) =>');
         writeln('    _analysisErrorFromEngine(lineInfo, error);');
         return true;
+      case 'CompletionSuggestionKind':
+        docComment(
+            [new dom.Text('Construct from an analyzer engine element kind.')]);
+        writeln(
+            'factory CompletionSuggestionKind.fromElementKind(engine.ElementKind kind) =>');
+        writeln('    _completionSuggestionKindFromElementKind(kind);');
+        return true;
       case 'Element':
-        docComment([new dom.Text('Construct based on a value from the analyzer engine.')]);
+        docComment(
+            [new dom.Text('Construct based on a value from the analyzer engine.')]);
         writeln('factory Element.fromEngine(engine.Element element) =>');
         writeln('    elementFromEngine(element);');
         return true;
       case 'ElementKind':
-        docComment([new dom.Text(
-            'Construct based on a value from the analyzer engine.')]);
+        docComment(
+            [new dom.Text('Construct based on a value from the analyzer engine.')]);
         writeln('factory ElementKind.fromEngine(engine.ElementKind kind) =>');
         writeln('    _elementKindFromEngine(kind);');
         return true;
+      case 'LinkedEditGroup':
+        docComment([new dom.Text('Construct an empty LinkedEditGroup.')]);
+        writeln(
+            'LinkedEditGroup.empty() : this(<Position>[], 0, <LinkedEditSuggestion>[]);');
+        return true;
       case 'Location':
-        docComment([new dom.Text(
-            'Create a Location based on an [engine.Element].')]);
+        docComment(
+            [new dom.Text('Create a Location based on an [engine.Element].')]);
         writeln('factory Location.fromElement(engine.Element element) =>');
         writeln('    _locationFromElement(element);');
         writeln();
-        docComment([new dom.Text('Create a Location based on an [engine.SearchMatch].')]);
+        docComment(
+            [new dom.Text('Create a Location based on an [engine.SearchMatch].')]);
         writeln('factory Location.fromMatch(engine.SearchMatch match) =>');
         writeln('    _locationFromMatch(match);');
         writeln();
-        docComment([new dom.Text('Create a Location based on an [engine.AstNode].')]);
+        docComment(
+            [new dom.Text('Create a Location based on an [engine.AstNode].')]);
         writeln('factory Location.fromNode(engine.AstNode node) =>');
         writeln('    _locationFromNode(node);');
         writeln();
-        docComment([new dom.Text('Create a Location based on an [engine.CompilationUnit].')]);
-        writeln('factory Location.fromUnit(engine.CompilationUnit unit, engine.SourceRange range) =>');
+        docComment(
+            [new dom.Text('Create a Location based on an [engine.CompilationUnit].')]);
+        writeln(
+            'factory Location.fromUnit(engine.CompilationUnit unit, engine.SourceRange range) =>');
         writeln('    _locationFromUnit(unit, range);');
         return true;
       case 'OverriddenMember':
-        docComment([new dom.Text('Construct based on an element from the analyzer engine.')]);
-        writeln('factory OverriddenMember.fromEngine(engine.Element member) =>');
+        docComment(
+            [new dom.Text('Construct based on an element from the analyzer engine.')]);
+        writeln(
+            'factory OverriddenMember.fromEngine(engine.Element member) =>');
         writeln('    _overriddenMemberFromEngine(member);');
         return true;
       case 'RefactoringProblemSeverity':
-        docComment([new dom.Text('Returns the [RefactoringProblemSeverity] with the maximal severity.')]);
-        writeln('static RefactoringProblemSeverity max(RefactoringProblemSeverity a, RefactoringProblemSeverity b) =>');
+        docComment(
+            [
+                new dom.Text(
+                    'Returns the [RefactoringProblemSeverity] with the maximal severity.')]);
+        writeln(
+            'static RefactoringProblemSeverity max(RefactoringProblemSeverity a, RefactoringProblemSeverity b) =>');
         writeln('    _maxRefactoringProblemSeverity(a, b);');
         return true;
       case 'SearchResult':
-        docComment([new dom.Text('Construct based on a value from the search engine.')]);
+        docComment(
+            [new dom.Text('Construct based on a value from the search engine.')]);
         writeln('factory SearchResult.fromMatch(engine.SearchMatch match) =>');
         writeln('    searchResultFromMatch(match);');
         return true;
       case 'SearchResultKind':
-        docComment([new dom.Text('Construct based on a value from the search engine.')]);
-        writeln('factory SearchResultKind.fromEngine(engine.MatchKind kind) =>');
+        docComment(
+            [new dom.Text('Construct based on a value from the search engine.')]);
+        writeln(
+            'factory SearchResultKind.fromEngine(engine.MatchKind kind) =>');
         writeln('    _searchResultKindFromEngine(kind);');
         return true;
       case 'SourceEdit':
         docComment([new dom.Text('Construct based on a SourceRange.')]);
         writeln(
             'SourceEdit.range(engine.SourceRange range, String replacement, {String id})');
         writeln('    : this(range.offset, range.length, replacement, id: id);');
         return true;
       default:
         return false;
     }
   }
 
   /**
    * If the class named [className] requires special getters, emit them and
    * return true.
    */
   bool emitSpecialGetters(String className) {
     switch (className) {
       case 'Element':
         for (String name in specialElementFlags.keys) {
           String flag = 'FLAG_${name.toUpperCase()}';
-          writeln('bool get ${camelJoin(['is', name])} => (flags & $flag) != 0;'
-              );
+          writeln(
+              'bool get ${camelJoin(['is', name])} => (flags & $flag) != 0;');
         }
         return true;
       case 'SourceEdit':
         docComment([new dom.Text('The end of the region to be modified.')]);
         writeln('int get end => offset + length;');
         return true;
       default:
         return false;
     }
   }
 
   /**
-   * If the class named [className] requires special members, emit them and
+   * If the class named [className] requires special methods, emit them and
    * return true.
    */
-  bool emitSpecialMembers(String className) {
+  bool emitSpecialMethods(String className) {
     switch (className) {
+      case 'ErrorFixes':
+        docComment([new dom.Text('Add a [Fix]')]);
+        writeln('void addFix(Fix fix) {');
+        indent(() {
+          writeln('fixes.add(fix.change);');
+        });
+        writeln('}');
+        return true;
+      case 'LinkedEditGroup':
+        docComment([new dom.Text('Add a new position and change the length.')]);
+        writeln('void addPosition(Position position, int length) {');
+        indent(() {
+          writeln('positions.add(position);');
+          writeln('this.length = length;');
+        });
+        writeln('}');
+        writeln();
+        docComment([new dom.Text('Add a new suggestion.')]);
+        writeln('void addSuggestion(LinkedEditSuggestion suggestion) {');
+        indent(() {
+          writeln('suggestions.add(suggestion);');
+        });
+        writeln('}');
+        return true;
+      case 'SourceChange':
+        docComment(
+            [new dom.Text('Adds [edit] to the [FileEdit] for the given [file].')]);
+        writeln('void addEdit(String file, SourceEdit edit) =>');
+        writeln('    _addEditToSourceChange(this, file, edit);');
+        writeln();
+        docComment([new dom.Text('Adds the given [FileEdit].')]);
+        writeln('void addFileEdit(SourceFileEdit edit) {');
+        indent(() {
+          writeln('edits.add(edit);');
+        });
+        writeln('}');
+        writeln();
+        docComment([new dom.Text('Adds the given [LinkedEditGroup].')]);
+        writeln('void addLinkedEditGroup(LinkedEditGroup linkedEditGroup) {');
+        indent(() {
+          writeln('linkedEditGroups.add(linkedEditGroup);');
+        });
+        writeln('}');
+        writeln();
+        docComment(
+            [new dom.Text('Returns the [FileEdit] for the given [file], maybe `null`.')]);
+        writeln('SourceFileEdit getFileEdit(String file) =>');
+        writeln('    _getChangeFileEdit(this, file);');
+        return true;
       case 'SourceEdit':
-        docComment([new dom.Text(
-            'Get the result of applying the edit to the given [code].')]);
+        docComment(
+            [new dom.Text('Get the result of applying the edit to the given [code].')]);
         writeln('String apply(String code) => _applyEdit(code, this);');
         return true;
       case 'SourceFileEdit':
         docComment([new dom.Text('Adds the given [Edit] to the list.')]);
         writeln('void add(SourceEdit edit) => _addEditForSource(this, edit);');
         writeln();
         docComment([new dom.Text('Adds the given [Edit]s.')]);
         writeln('void addAll(Iterable<SourceEdit> edits) =>');
         writeln('    _addAllEditsForSource(this, edits);');
         return true;
@@ skipping 98 matching lines @@
   }
 
   /**
    * Emit the toRequest() code for a class, if appropriate.  Returns true if
    * code was emitted.
    */
   bool emitToRequestMember(ImpliedType impliedType) {
     if (impliedType.kind == 'requestParams') {
       writeln('Request toRequest(String id) {');
       indent(() {
-        String methodString = literalString((impliedType.apiNode as
-            Request).longMethod);
+        String methodString =
+            literalString((impliedType.apiNode as Request).longMethod);
         writeln('return new Request(id, $methodString, toJson());');
       });
       writeln('}');
       return true;
     }
     return false;
   }
 
   /**
    * Emit the toResponse() code for a class, if appropriate.  Returns true if
    * code was emitted.
    */
   bool emitToResponseMember(ImpliedType impliedType) {
     if (impliedType.kind == 'requestResult') {
       writeln('Response toResponse(String id) {');
       indent(() {
         writeln('return new Response(id, result: toJson());');
       });
       writeln('}');
       return true;
     }
     return false;
   }
 
   /**
+   * Emit the toNotification() code for a class, if appropriate.  Returns true
+   * if code was emitted.
+   */
+  bool emitToNotificationMember(ImpliedType impliedType) {
+    if (impliedType.kind == 'notificationParams') {
+      writeln('Notification toNotification() {');
+      indent(() {
+        String eventString =
+            literalString((impliedType.apiNode as Notification).longEvent);
+        writeln('return new Notification($eventString, toJson());');
+      });
+      writeln('}');
+      return true;
+    }
+    return false;
+  }
+
+  /**
    * Emit the operator== code for an object class.
    */
   void emitObjectEqualsMember(TypeObject type, String className) {
     writeln('@override');
     writeln('bool operator==(other) {');
     indent(() {
       writeln('if (other is $className) {');
       indent(() {
         var comparisons = <String>[];
         for (TypeObjectField field in type.fields) {
           if (field.value != null) {
             continue;
           }
-          comparisons.add(compareEqualsCode(field.type, field.name,
-              'other.${field.name}'));
+          comparisons.add(
+              compareEqualsCode(field.type, field.name, 'other.${field.name}'));
         }
         if (comparisons.isEmpty) {
           writeln('return true;');
         } else {
           String concatenated = comparisons.join(' &&\n    ');
           writeln('return $concatenated;');
         }
       });
       writeln('}');
       writeln('return false;');
@@ skipping 56 matching lines @@
       emitEnumClassConstructor(className, type);
       writeln();
       emitEnumFromJsonConstructor(className, type, impliedType);
       writeln();
       if (emitSpecialConstructors(className)) {
         writeln();
       }
       if (emitSpecialGetters(className)) {
         writeln();
       }
-      if (emitSpecialMembers(className)) {
+      if (emitSpecialMethods(className)) {
         writeln();
       }
       writeln('@override');
       writeln('String toString() => "$className.\$name";');
       writeln();
       writeln('String toJson() => name;');
     });
     writeln('}');
   }
 
@@ skipping 24 matching lines @@
    */
   ToJsonCode toJsonCode(TypeDecl type) {
     TypeDecl resolvedType = resolveTypeReferenceChain(type);
     if (resolvedType is TypeReference) {
       return new ToJsonIdentity(dartType(type));
     } else if (resolvedType is TypeList) {
       ToJsonCode itemCode = toJsonCode(resolvedType.itemType);
       if (itemCode.isIdentity) {
         return new ToJsonIdentity(dartType(type));
       } else {
-        return new ToJsonSnippet(dartType(type), (String value) =>
-            '$value.map(${itemCode.asClosure}).toList()');
+        return new ToJsonSnippet(
+            dartType(type),
+            (String value) => '$value.map(${itemCode.asClosure}).toList()');
       }
     } else if (resolvedType is TypeMap) {
       ToJsonCode keyCode;
       if (dartType(resolvedType.keyType) != 'String') {
         keyCode = toJsonCode(resolvedType.keyType);
       } else {
         keyCode = new ToJsonIdentity(dartType(resolvedType.keyType));
       }
       ToJsonCode valueCode = toJsonCode(resolvedType.valueType);
       if (keyCode.isIdentity && valueCode.isIdentity) {
@@ skipping 11 matching lines @@
           result.write(')');
           return result.toString();
         });
       }
     } else if (resolvedType is TypeUnion) {
       for (TypeDecl choice in resolvedType.choices) {
         if (resolveTypeReferenceChain(choice) is! TypeObject) {
           throw new Exception('Union types must be unions of objects');
         }
       }
-      return new ToJsonSnippet(dartType(type), (String value) =>
-          '$value.toJson()');
+      return new ToJsonSnippet(
+          dartType(type),
+          (String value) => '$value.toJson()');
     } else if (resolvedType is TypeObject || resolvedType is TypeEnum) {
-      return new ToJsonSnippet(dartType(type), (String value) =>
-          '$value.toJson()');
+      return new ToJsonSnippet(
+          dartType(type),
+          (String value) => '$value.toJson()');
     } else {
       throw new Exception("Can't convert $resolvedType from JSON");
     }
   }
 
   /**
    * Compute the code necessary to compare two objects for equality.
    */
   String compareEqualsCode(TypeDecl type, String thisVar, String otherVar) {
     TypeDecl resolvedType = resolveTypeReferenceChain(type);
-    if (resolvedType is TypeReference || resolvedType is TypeEnum ||
-        resolvedType is TypeObject || resolvedType is TypeUnion) {
+    if (resolvedType is TypeReference ||
+        resolvedType is TypeEnum ||
+        resolvedType is TypeObject ||
+        resolvedType is TypeUnion) {
       return '$thisVar == $otherVar';
     } else if (resolvedType is TypeList) {
       String itemTypeName = dartType(resolvedType.itemType);
       String subComparison = compareEqualsCode(resolvedType.itemType, 'a', 'b');
       String closure = '($itemTypeName a, $itemTypeName b) => $subComparison';
       return '_listEqual($thisVar, $otherVar, $closure)';
     } else if (resolvedType is TypeMap) {
       String valueTypeName = dartType(resolvedType.valueType);
-      String subComparison = compareEqualsCode(resolvedType.valueType, 'a', 'b'
-          );
+      String subComparison =
+          compareEqualsCode(resolvedType.valueType, 'a', 'b');
       String closure = '($valueTypeName a, $valueTypeName b) => $subComparison';
       return '_mapEqual($thisVar, $otherVar, $closure)';
     }
-    throw new Exception("Don't know how to compare for equality: $resolvedType"
-        );
+    throw new Exception(
+        "Don't know how to compare for equality: $resolvedType");
   }
 
   /**
    * Emit the method for decoding an object from JSON.
    */
-  void emitObjectFromJsonConstructor(String className, TypeObject
-      type, ImpliedType impliedType) {
-    String humanReadableNameString = literalString(impliedType.humanReadableName
-        );
+  void emitObjectFromJsonConstructor(String className, TypeObject type,
+      ImpliedType impliedType) {
+    String humanReadableNameString =
+        literalString(impliedType.humanReadableName);
     writeln(
-        'factory $className.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {'
-        );
+        'factory $className.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {');
     indent(() {
       writeln('if (json == null) {');
       indent(() {
         writeln('json = {};');
       });
       writeln('}');
       writeln('if (json is Map) {');
       indent(() {
         List<String> args = <String>[];
         List<String> optionalArgs = <String>[];
@@ skipping 14 matching lines @@
           if (isOptionalConstructorArg(className, field)) {
             optionalArgs.add('${field.name}: ${field.name}');
           } else {
             args.add(field.name);
           }
           TypeDecl fieldType = field.type;
           String fieldDartType = dartType(fieldType);
           writeln('$fieldDartType ${field.name};');
           writeln('if (json.containsKey($fieldNameString)) {');
           indent(() {
-            String toJson = fromJsonCode(fieldType).asSnippet(jsonPath,
-                fieldAccessor);
+            String toJson =
+                fromJsonCode(fieldType).asSnippet(jsonPath, fieldAccessor);
             writeln('${field.name} = $toJson;');
           });
           write('}');
           if (!field.optional) {
             writeln(' else {');
             indent(() {
               writeln(
                   "throw jsonDecoder.missingKey(jsonPath, $fieldNameString);");
             });
             writeln('}');
@@ skipping 16 matching lines @@
             'throw jsonDecoder.mismatch(jsonPath, $humanReadableNameString);');
       });
       writeln('}');
     });
     writeln('}');
   }
 
   /**
    * Emit the method for decoding an enum from JSON.
    */
-  void emitEnumFromJsonConstructor(String className, TypeEnum type, ImpliedType
-      impliedType) {
+  void emitEnumFromJsonConstructor(String className, TypeEnum type,
+      ImpliedType impliedType) {
     writeln(
-        'factory $className.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {'
-        );
+        'factory $className.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {');
     indent(() {
       writeln('if (json is String) {');
       indent(() {
         writeln('try {');
         indent(() {
           writeln('return new $className(json);');
         });
         writeln('} catch(_) {');
         indent(() {
           writeln('// Fall through');
         });
         writeln('}');
       });
       writeln('}');
-      String humanReadableNameString = literalString(
-          impliedType.humanReadableName);
-      writeln('throw jsonDecoder.mismatch(jsonPath, $humanReadableNameString);'
-          );
+      String humanReadableNameString =
+          literalString(impliedType.humanReadableName);
+      writeln(
+          'throw jsonDecoder.mismatch(jsonPath, $humanReadableNameString);');
     });
     writeln('}');
   }
 
   /**
    * Compute the code necessary to translate [type] from JSON.
    */
   FromJsonCode fromJsonCode(TypeDecl type) {
     if (type is TypeReference) {
       TypeDefinition referencedDefinition = api.types[type.typeName];
       if (referencedDefinition != null) {
         TypeDecl referencedType = referencedDefinition.type;
         if (referencedType is TypeObject || referencedType is TypeEnum) {
-          return new FromJsonSnippet((String jsonPath, String json) =>
-              'new ${dartType(type)}.fromJson(jsonDecoder, $jsonPath, $json)');
+          return new FromJsonSnippet(
+              (String jsonPath, String json) =>
+                  'new ${dartType(type)}.fromJson(jsonDecoder, $jsonPath, $json)');
         } else {
           return fromJsonCode(referencedType);
         }
       } else {
         switch (type.typeName) {
           case 'String':
             return new FromJsonFunction('jsonDecoder._decodeString');
           case 'bool':
             return new FromJsonFunction('jsonDecoder._decodeBool');
           case 'int':
@@ skipping 26 matching lines @@
           }
           result.write(')');
           return result.toString();
         });
       }
     } else if (type is TypeList) {
       FromJsonCode itemCode = fromJsonCode(type.itemType);
       if (itemCode.isIdentity) {
         return new FromJsonFunction('jsonDecoder._decodeList');
       } else {
-        return new FromJsonSnippet((String jsonPath, String json) =>
-            'jsonDecoder._decodeList($jsonPath, $json, ${itemCode.asClosure})');
+        return new FromJsonSnippet(
+            (String jsonPath, String json) =>
+                'jsonDecoder._decodeList($jsonPath, $json, ${itemCode.asClosure})');
       }
     } else if (type is TypeUnion) {
       List<String> decoders = <String>[];
       for (TypeDecl choice in type.choices) {
         TypeDecl resolvedChoice = resolveTypeReferenceChain(choice);
         if (resolvedChoice is TypeObject) {
           TypeObjectField field = resolvedChoice.getField(type.field);
           if (field == null) {
             throw new Exception(
                 'Each choice in the union needs a field named ${type.field}');
           }
           if (field.value == null) {
             throw new Exception(
                 'Each choice in the union needs a constant value for the field ${type.field}');
           }
           String closure = fromJsonCode(choice).asClosure;
           decoders.add('${literalString(field.value)}: $closure');
         } else {
           throw new Exception('Union types must be unions of objects.');
         }
       }
-      return new FromJsonSnippet((String jsonPath, String json) =>
-          'jsonDecoder._decodeUnion($jsonPath, $json, ${literalString(type.field)}, {${decoders.join(', ')}})'
-          );
+      return new FromJsonSnippet(
+          (String jsonPath, String json) =>
+              'jsonDecoder._decodeUnion($jsonPath, $json, ${literalString(type.field)}, {${decoders.join(', ')}})');
     } else {
       throw new Exception("Can't convert $type from JSON");
     }
   }
 
   /**
    * Emit a convenience constructor for decoding a piece of protocol, if
    * appropriate.  Return true if a constructor was emitted.
    */
   bool emitConvenienceConstructor(String className, ImpliedType impliedType) {
@@ skipping 91 matching lines @@
     } else if (type is TypeMap) {
       return 'Map<${dartType(type.keyType)}, ${dartType(type.valueType)}>';
     } else if (type is TypeUnion) {
       return 'dynamic';
     } else {
       throw new Exception("Can't convert to a dart type");
     }
   }
 }
 
-final GeneratedFile target = new GeneratedFile(
-    '../../lib/src/generated_protocol.dart', () {
+final GeneratedFile target =
+    new GeneratedFile('../../lib/src/generated_protocol.dart', () {
   CodegenProtocolVisitor visitor = new CodegenProtocolVisitor(readApi());
   return visitor.collectCode(visitor.visitApi);
 });
 
 /**
  * Translate spec_input.html into protocol_matchers.dart.
  */
 main() {
   target.generate();
 }