Change analysis server protocol to omit empty lists when optional.

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 160 matching lines @@
 const Map<String, String> specialElementFlags = const {
   'abstract': '0x01',
   'const': '0x02',
   'final': '0x04',
   'static': '0x08',
   'private': '0x10',
   'deprecated': '0x20'
 };
 
 /**
+ * Callback type used to represent arbitrary code generation.
+ */
+typedef void CodegenCallback();
+
+/**
  * Visitor which produces Dart code representing the API.
  */
 class CodegenProtocolVisitor extends HierarchicalApiVisitor with CodeGenerator {
   /**
    * Type references in the spec that are named something else in Dart.
    */
   static const Map<String, String> _typeRenames = const {
     'object': 'Object',
   };
 
@@ skipping 249 matching lines @@
         return false;
     }
   }
 
   /**
    * Emit the constructor for an object class.
    */
   void emitObjectConstructor(TypeObject type, String className) {
     List<String> args = <String>[];
     List<String> optionalArgs = <String>[];
+    List<CodegenCallback> extraInitCode = <CodegenCallback>[];
     for (TypeObjectField field in type.fields) {
       if (field.value != null) {
         continue;
       }
       String arg = 'this.${field.name}';
       if (field.optional) {
         optionalArgs.add(arg);
+        TypeDecl fieldType = field.type;
+        if (fieldType is TypeList) {
+          extraInitCode.add(() {
+            writeln('if (${field.name} == null) {');
+            indent(() {
+              writeln('${field.name} = <${dartType(fieldType.itemType)}>[];');
+            });
+            writeln('}');
+          });
+        }
       } else {
         args.add(arg);
       }
     }
     if (optionalArgs.isNotEmpty) {
       args.add('{${optionalArgs.join(', ')}}');
     }
-    writeln('$className(${args.join(', ')});');
+    write('$className(${args.join(', ')})');
+    if (extraInitCode.isEmpty) {
+      writeln(';');
+    } else {
+      writeln(' {');
+      indent(() {
+        for (CodegenCallback callback in extraInitCode) {
+          callback();
+        }
+      });
+      writeln('}');
+    }
   }
 
   /**
    * Emit the toJson() code for an object class.
    */
   void emitToJsonMember(TypeObject type) {
     writeln('Map<String, dynamic> toJson() {');
     indent(() {
       writeln('Map<String, dynamic> result = {};');
       for (TypeObjectField field in type.fields) {
         String fieldNameString = literalString(field.name);
         if (field.value != null) {
           writeln('result[$fieldNameString] = ${literalString(field.value)};');
           continue;
         }
         String fieldToJson = toJsonCode(field.type).asSnippet(field.name);
         String populateField = 'result[$fieldNameString] = $fieldToJson;';
         if (field.optional) {
-          writeln('if (${field.name} != null) {');
+          String condition;
+          if (field.type is TypeList) {
+            condition = '${field.name}.isNotEmpty';
+          } else {
+            condition = '${field.name} != null';
+          }
+          writeln('if ($condition) {');
           indent(() {
             writeln(populateField);
           });
           writeln('}');
         } else {
           writeln(populateField);
         }
       }
       writeln('return result;');
     });
@@ skipping 270 matching lines @@
                   'throw jsonDecoder.mismatch(jsonPath, "equal " + $valueString);');
             });
             writeln('}');
             continue;
           }
           if (field.optional) {
             optionalArgs.add('${field.name}: ${field.name}');
           } else {
             args.add(field.name);
           }
-          String fieldDartType = dartType(field.type);
+          TypeDecl fieldType = field.type;
+          String fieldDartType = dartType(fieldType);
           writeln('$fieldDartType ${field.name};');
           writeln('if (json.containsKey($fieldNameString)) {');
           indent(() {
-            String toJson = fromJsonCode(field.type).asSnippet(jsonPath,
+            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('}');
+          } else if (fieldType is TypeList) {
+            writeln(' else {');
+            indent(() {
+              writeln('${field.name} = <${dartType(fieldType.itemType)}>[];');
+            });
+            writeln('}');
           } else {
             writeln();
           }
         }
         args.addAll(optionalArgs);
         writeln('return new $className(${args.join(', ')});');
       });
       writeln('} else {');
       indent(() {
         writeln(
@@ skipping 233 matching lines @@
   CodegenProtocolVisitor visitor = new CodegenProtocolVisitor(readApi());
   return visitor.collectCode(visitor.visitApi);
 });
 
 /**
  * Translate spec_input.html into protocol_matchers.dart.
  */
 main() {
   target.generate();
 }