Fix all strong mode warnings in protoc-plugin

lib/message_generator.dart

 // Copyright (c) 2013, 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.
 
 part of protoc;
 
 /// A Dart function called on each item added to a repeated list
 /// to check its type and range.
 const checkItem = '\$checkItem';
 
 class MessageGenerator extends ProtobufContainer {
   // List of Dart language reserved words in names which cannot be used in a
   // subclass of GeneratedMessage.
-  static final List<String> reservedWords =
-      ['assert', 'break', 'case', 'catch', 'class', 'const', 'continue',
-       'default', 'do', 'else', 'enum', 'extends', 'false', 'final',
-       'finally', 'for', 'if', 'in', 'is', 'new', 'null', 'rethrow', 'return',
-       'super', 'switch', 'this', 'throw', 'true', 'try', 'var', 'void',
-       'while', 'with'];
+  static final List<String> reservedWords = [
+    'assert',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'default',
+    'do',
+    'else',
+    'enum',
+    'extends',
+    'false',
+    'final',
+    'finally',
+    'for',
+    'if',
+    'in',
+    'is',
+    'new',
+    'null',
+    'rethrow',
+    'return',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'var',
+    'void',
+    'while',
+    'with'
+  ];
 
   // List of names used in the generated class itself
-  static final List<String> generatedNames =
-      ['create', 'createRepeated', 'getDefault', checkItem];
+  static final List<String> generatedNames = [
+    'create',
+    'createRepeated',
+    'getDefault',
+    checkItem
+  ];
 
   // Returns the mixin for this message, or null if none.
   static PbMixin _getMixin(DescriptorProto desc, PbMixin defaultValue) {
     if (!desc.hasOptions()) return defaultValue;
     if (!desc.options.hasExtension(Dart_options.mixin)) return defaultValue;
 
     String name = desc.options.getExtension(Dart_options.mixin);
     if (name.isEmpty) return null; // don't use a mixin (override any default)
     var mixin = findMixin(name);
     if (mixin == null) {
-      throw("unknown mixin class: ${name}");
+      throw ("unknown mixin class: ${name}");
     }
     return mixin;
   }
 
   final String classname;
   final String fqname;
   final PbMixin mixin;
 
   final ProtobufContainer _parent;
   final DescriptorProto _descriptor;
   final List<EnumGenerator> _enumGenerators = <EnumGenerator>[];
   final List<MessageGenerator> _messageGenerators = <MessageGenerator>[];
   final List<ExtensionGenerator> _extensionGenerators = <ExtensionGenerator>[];
 
   // populated by resolve()
   List<ProtobufField> _fieldList;
 
   // Used during generation.
   final Set<String> _methodNames = new Set<String>();
 
-  MessageGenerator(
-      DescriptorProto descriptor, ProtobufContainer parent, PbMixin defaultMixin)
+  MessageGenerator(DescriptorProto descriptor, ProtobufContainer parent,
+      PbMixin defaultMixin)
       : _descriptor = descriptor,
         _parent = parent,
-        classname = (parent.classname == '') ?
-            descriptor.name : '${parent.classname}_${descriptor.name}',
-        fqname = (parent == null || parent.fqname == null) ? descriptor.name :
-            (parent.fqname == '.' ?
-                '.${descriptor.name}' : '${parent.fqname}.${descriptor.name}'),
+        classname = (parent.classname == '')
+            ? descriptor.name
+            : '${parent.classname}_${descriptor.name}',
+        fqname = (parent == null || parent.fqname == null)
+            ? descriptor.name
+            : (parent.fqname == '.'
+                ? '.${descriptor.name}'
+                : '${parent.fqname}.${descriptor.name}'),
         mixin = _getMixin(descriptor, defaultMixin) {
-
     for (EnumDescriptorProto e in _descriptor.enumType) {
       _enumGenerators.add(new EnumGenerator(e, this));
     }
 
     for (DescriptorProto n in _descriptor.nestedType) {
-      _messageGenerators.add(
-          new MessageGenerator(n, this, defaultMixin));
+      _messageGenerators.add(new MessageGenerator(n, this, defaultMixin));
     }
 
     for (FieldDescriptorProto x in _descriptor.extension) {
       _extensionGenerators.add(new ExtensionGenerator(x, this));
     }
   }
 
   String get package => _parent.package;
 
   /// The generator of the .pb.dart file that will declare this type.
@@ skipping 22 matching lines @@
       output.addAll(mixin.findMixinsToApply());
     }
     for (var m in _messageGenerators) {
       m.addMixinsTo(output);
     }
   }
 
   // Registers message and enum types that can be used elsewhere.
   void register(GenerationContext ctx) {
     ctx.registerFieldType(fqname, this);
-    for (var m  in _messageGenerators) {
+    for (var m in _messageGenerators) {
       m.register(ctx);
     }
     for (var e in _enumGenerators) {
       e.register(ctx);
     }
   }
 
   // Creates fields and resolves extension targets.
   void resolve(GenerationContext ctx) {
     if (_fieldList != null) throw new StateError("message already resolved");
 
     var sorted = new List<FieldDescriptorProto>.from(_descriptor.field)
       ..sort((FieldDescriptorProto a, FieldDescriptorProto b) {
-      if (a.number < b.number) return -1;
-      if (a.number > b.number) return 1;
-      throw "multiple fields defined for tag ${a.number} in $fqname";
-    });
+        if (a.number < b.number) return -1;
+        if (a.number > b.number) return 1;
+        throw "multiple fields defined for tag ${a.number} in $fqname";
+      });
 
     _fieldList = <ProtobufField>[];
     for (FieldDescriptorProto field in sorted) {
       int index = _fieldList.length;
       _fieldList.add(new ProtobufField(field, index, this, ctx));
     }
 
     for (var m in _messageGenerators) {
       m.resolve(ctx);
     }
@@ skipping 54 matching lines @@
     for (MessageGenerator m in _messageGenerators) {
       m.generate(out);
     }
 
     var mixinClause = '';
     if (mixin != null) {
       var mixinNames = mixin.findMixinsToApply().map((m) => m.name);
       mixinClause = ' with ${mixinNames.join(", ")}';
     }
 
-    out.addBlock('class ${classname} extends GeneratedMessage${mixinClause} {',
-        '}', ()
-      {
+    out.addBlock(
+        'class ${classname} extends GeneratedMessage${mixinClause} {', '}', () {
       out.addBlock(
           'static final BuilderInfo _i = new BuilderInfo(\'${classname}\')',
           ';', () {
         for (ProtobufField field in _fieldList) {
           out.println(field.generateBuilderInfoCall(package));
         }
 
         if (_descriptor.extensionRange.length > 0) {
           out.println('..hasExtensions = true');
         }
@@ skipping 18 matching lines @@
       out.println('${classname} clone() =>'
           ' new ${classname}()..mergeFromMessage(this);');
 
       out.println('BuilderInfo get info_ => _i;');
 
       // Factory functions which can be used as default value closures.
       out.println('static ${classname} create() =>'
           ' new ${classname}();');
       out.println('static PbList<${classname}> createRepeated() =>'
           ' new PbList<${classname}>();');
-      out.addBlock('static ${classname} getDefault() {',
-          '}', () {
-        out.println('if (_defaultInstance == null) _defaultInstance = new _Readonly${classname}();');
+      out.addBlock('static ${classname} getDefault() {', '}', () {
+        out.println(
+            'if (_defaultInstance == null) _defaultInstance = new _Readonly${classname}();');
         out.println('return _defaultInstance;');
       });
       out.println('static ${classname} _defaultInstance;');
       out.addBlock('static void $checkItem($classname v) {', '}', () {
-          out.println('if (v is !$classname)'
-              " checkItemFailed(v, '$classname');");
+        out.println('if (v is !$classname)'
+            " checkItemFailed(v, '$classname');");
       });
       generateFieldsAccessorsMutators(out);
     });
     out.println();
 
-    out.println('class _Readonly${classname} extends ${classname} with ReadonlyMessageMixin {}');
+    out.println(
+        'class _Readonly${classname} extends ${classname} with ReadonlyMessageMixin {}');
     out.println();
   }
 
   // Returns true if the message type has any required fields.  If it doesn't,
   // we can optimize out calls to its isInitialized()/_findInvalidFields()
   // methods.
   //
   // already_seen is used to avoid checking the same type multiple times
   // (and also to protect against unbounded recursion).
   bool _hasRequiredFields(MessageGenerator type, Set alreadySeen) {
@@ skipping 35 matching lines @@
   void generateFieldsAccessorsMutators(IndentingWriter out) {
     for (ProtobufField field in _fieldList) {
       out.println();
 
       // Choose non-conflicting names.
       String identifier = field.dartFieldName;
       String hasIdentifier = field.hasMethodName;
       String clearIdentifier = field.clearMethodName;
       if (!field.isRepeated) {
         while (_methodNames.contains(identifier) ||
-               _methodNames.contains(hasIdentifier) ||
-               _methodNames.contains(clearIdentifier)) {
+            _methodNames.contains(hasIdentifier) ||
+            _methodNames.contains(clearIdentifier)) {
           identifier += '_' + field.number.toString();
           hasIdentifier += '_' + field.number.toString();
           clearIdentifier += '_' + field.number.toString();
         }
         _methodNames.add(identifier);
         _methodNames.add(hasIdentifier);
         _methodNames.add(clearIdentifier);
       } else {
         while (_methodNames.contains(identifier)) {
           identifier += '_' + field.number.toString();
         }
         _methodNames.add(identifier);
       }
 
       var fieldTypeString = field.getDartType(package);
       var defaultExpr = field.getDefaultExpr();
       out.println('${fieldTypeString} get ${identifier}'
-          ' => \$_get(${field.index}, ${field.number}, $defaultExpr);');
+          ' => \$_get('
+          '${field.index}, ${field.number}, $defaultExpr);');
       if (!field.isRepeated) {
         var fastSetter = field.baseType.setter;
         if (fastSetter != null) {
           out.println('void set $identifier'
               '($fieldTypeString v) { '
               '$fastSetter(${field.index}, ${field.number}, v);'
               ' }');
         } else {
           out.println('void set $identifier'
               '($fieldTypeString v) { '
@@ skipping 13 matching lines @@
   /// to avoid duplication.
   void generateConstants(IndentingWriter out) {
     const nestedTypeTag = 3;
     const enumTypeTag = 4;
     assert(_descriptor.info_.fieldInfo[nestedTypeTag].name == "nestedType");
     assert(_descriptor.info_.fieldInfo[enumTypeTag].name == "enumType");
 
     var name = getJsonConstant(fileGen);
     var json = _descriptor.writeToJsonMap();
     var nestedTypeNames =
-        _messageGenerators.map((m) => m.getJsonConstant(fileGen))
-        .toList();
+        _messageGenerators.map((m) => m.getJsonConstant(fileGen)).toList();
     var nestedEnumNames =
-        _enumGenerators.map((e) => e.getJsonConstant(fileGen))
-        .toList();
+        _enumGenerators.map((e) => e.getJsonConstant(fileGen)).toList();
 
     out.addBlock("const $name = const {", "};", () {
       for (var key in json.keys) {
         out.print("'$key': ");
         if (key == "$nestedTypeTag") {
           // refer to message constants by name instead of repeating each value
           out.println("const [${nestedTypeNames.join(", ")}],");
           continue;
         } else if (key == "$enumTypeTag") {
           // refer to enum constants by name
           out.println("const [${nestedEnumNames.join(", ")}],");
           continue;
         }
         writeJsonConst(out, json[key]);
         out.println(",");
       }
     });
     out.println();
 
     for (var m in _messageGenerators) {
       m.generateConstants(out);
     }
 
     for (var e in _enumGenerators) {
       e.generateConstants(out);
     }
   }
 }