Fix all strong mode warnings in protoc-plugin

test/message_test.dart

 #!/usr/bin/env 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.
 
 library message_test;
 
 import 'package:test/test.dart';
 
 import 'test_util.dart';
 
-import '../out/protos/descriptor_2_5_opensource.pb.dart'
-    show DescriptorProto;
+import '../out/protos/descriptor_2_5_opensource.pb.dart' show DescriptorProto;
 import '../out/protos/google/protobuf/unittest.pb.dart';
 
 void main() {
   TestRequired TEST_REQUIRED_UNINITIALIZED = new TestRequired();
 
   TestRequired TEST_REQUIRED_INITIALIZED = new TestRequired()
-      ..a = 1
-      ..b = 2
-      ..c = 3;
+    ..a = 1
+    ..b = 2
+    ..c = 3;
 
   test('testMergeFrom', () {
     TestAllTypes mergeSource = new TestAllTypes()
-        ..optionalInt32 = 1
-        ..optionalString = 'foo'
-        ..optionalForeignMessage = new ForeignMessage()
-        ..repeatedString.add('bar');
+      ..optionalInt32 = 1
+      ..optionalString = 'foo'
+      ..optionalForeignMessage = new ForeignMessage()
+      ..repeatedString.add('bar');
 
     TestAllTypes mergeDest = new TestAllTypes()
-        ..optionalInt64 = make64(2)
-        ..optionalString = 'baz'
-        ..optionalForeignMessage = new ForeignMessage()
-        ..optionalForeignMessage = (new ForeignMessage()..c = 3)
-        ..repeatedString.add('qux');
+      ..optionalInt64 = make64(2)
+      ..optionalString = 'baz'
+      ..optionalForeignMessage = new ForeignMessage()
+      ..optionalForeignMessage = (new ForeignMessage()..c = 3)
+      ..repeatedString.add('qux');
 
     String mergeResultExpected = '''
 optionalInt32: 1
 optionalInt64: 2
 optionalString: baz
 optionalForeignMessage: {
   c: 3
 }
 repeatedString: bar
 repeatedString: qux
 ''';
 
     TestAllTypes result = new TestAllTypes()
-        ..mergeFromMessage(mergeSource)
-        ..mergeFromMessage(mergeDest);
+      ..mergeFromMessage(mergeSource)
+      ..mergeFromMessage(mergeDest);
 
     expect(result.toString(), mergeResultExpected);
   });
 
   test('testRequired', () {
     TestRequired message = new TestRequired();
 
     expect(message.isInitialized(), isFalse, reason: 'no required fields set');
     message.a = 1;
     expect(message.isInitialized(), isFalse,
         reason: 'single required field set');
     message.b = 1;
     expect(message.isInitialized(), isFalse,
         reason: 'all but one required field set');
     message.c = 1;
     expect(message.isInitialized(), isTrue, reason: 'required fields set');
   });
 
   test('testRequiredForeign', () {
     TestRequiredForeign message = new TestRequiredForeign();
     expect(message.isInitialized(), isTrue,
         reason: 'TestRequiredForeign without children should be initialized');
 
     message.optionalMessage = TEST_REQUIRED_UNINITIALIZED;
-    expect(message.isInitialized(), isFalse, reason:
-        'TestRequiredForeign with optional TEST_REQUIRED_UNINITIALIZED '
-        'should not be initialized');
+    expect(message.isInitialized(), isFalse,
+        reason: 'TestRequiredForeign with optional TEST_REQUIRED_UNINITIALIZED '
+            'should not be initialized');
 
     message.optionalMessage = TEST_REQUIRED_INITIALIZED;
     expect(message.isInitialized(), isTrue,
-      reason: 'TestRequiredForeign with optional TEST_REQUIRED_INITIALIZED '
-      'should be initialized');
+        reason: 'TestRequiredForeign with optional TEST_REQUIRED_INITIALIZED '
+            'should be initialized');
 
     message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
-    expect(message.isInitialized(), isFalse, reason:
-        'TestRequiredForeign with repeating TEST_REQUIRED_UNINITIALIZED '
-        'should not be initialized');
+    expect(message.isInitialized(), isFalse,
+        reason:
+            'TestRequiredForeign with repeating TEST_REQUIRED_UNINITIALIZED '
+            'should not be initialized');
 
     message.repeatedMessage[0] = TEST_REQUIRED_INITIALIZED;
     expect(message.isInitialized(), isTrue,
         reason: 'TestRequiredForeign with repeating TEST_REQUIRED_INITIALIZED '
-        'should be initialized');
+            'should be initialized');
   });
 
   test('testRequiredExtension', () {
     TestAllExtensions message = new TestAllExtensions();
     expect(message.isInitialized(), isTrue);
 
     message.setExtension(TestRequired.single, TEST_REQUIRED_UNINITIALIZED);
     expect(message.isInitialized(), isFalse);
 
     message.setExtension(TestRequired.single, TEST_REQUIRED_INITIALIZED);
@@ skipping 26 matching lines @@
       TestRequiredForeign message = new TestRequiredForeign();
       message.optionalMessage = TEST_REQUIRED_UNINITIALIZED;
       message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
       message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
       message.check();
       fail('Should have thrown an exception.');
     } on StateError catch (e) {
       // NOTE: error message differs from Java in that
       // fields are referenced using Dart fieldnames r.t.
       // proto field names.
-      expect(e.message,
-        'Message missing required fields: '
-        'optionalMessage.a, '
-        'optionalMessage.b, '
-        'optionalMessage.c, '
-        'repeatedMessage[0].a, '
-        'repeatedMessage[0].b, '
-        'repeatedMessage[0].c, '
-        'repeatedMessage[1].a, '
-        'repeatedMessage[1].b, '
-        'repeatedMessage[1].c');
+      expect(
+          e.message,
+          'Message missing required fields: '
+          'optionalMessage.a, '
+          'optionalMessage.b, '
+          'optionalMessage.c, '
+          'repeatedMessage[0].a, '
+          'repeatedMessage[0].b, '
+          'repeatedMessage[0].c, '
+          'repeatedMessage[1].a, '
+          'repeatedMessage[1].b, '
+          'repeatedMessage[1].c');
     }
   });
 
   test('testBuildNestedPartial', () {
     // We're mostly testing that no exception is thrown.
     TestRequiredForeign message = new TestRequiredForeign();
     message.optionalMessage = TEST_REQUIRED_UNINITIALIZED;
     message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
     message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
     expect(message.isInitialized(), isFalse);
@@ skipping 15 matching lines @@
     message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED);
     List<int> buffer = message.writeToBuffer();
 
     try {
       (new TestRequiredForeign.fromBuffer(buffer)).check();
       fail('Should have thrown an exception.');
     } on StateError catch (e) {
       // NOTE: error message differs from Java in that
       // fields are referenced using Dart fieldnames r.t.
       // proto field names.
-      expect(e.message,
+      expect(
+          e.message,
           'Message missing required fields: '
           'optionalMessage.a, '
           'optionalMessage.b, '
           'optionalMessage.c, '
           'repeatedMessage[0].a, '
           'repeatedMessage[0].b, '
           'repeatedMessage[0].c, '
           'repeatedMessage[1].a, '
           'repeatedMessage[1].b, '
           'repeatedMessage[1].c');
     }
   });
 
   test('testClearField', () {
-      int fieldNo;
-      TestAllTypes message = new TestAllTypes();
+    int fieldNo;
+    TestAllTypes message = new TestAllTypes();
 
-      // Singular field with no default.
-      fieldNo = 1;
-      expect(message.hasField(fieldNo), isFalse);
-      expect(message.getField(fieldNo), 0);
-      message.clearField(fieldNo);
-      expect(message.hasField(fieldNo), isFalse);
-      message.setField(fieldNo, 0);
-      expect(message.getField(fieldNo), 0);
-      expect(message.hasField(fieldNo), isTrue);
-      message.clearField(fieldNo);
-      expect(message.hasField(fieldNo), isFalse);
+    // Singular field with no default.
+    fieldNo = 1;
+    expect(message.hasField(fieldNo), isFalse);
+    expect(message.getField(fieldNo), 0);
+    message.clearField(fieldNo);
+    expect(message.hasField(fieldNo), isFalse);
+    message.setField(fieldNo, 0);
+    expect(message.getField(fieldNo), 0);
+    expect(message.hasField(fieldNo), isTrue);
+    message.clearField(fieldNo);
+    expect(message.hasField(fieldNo), isFalse);
 
-      // Repeated field.
-      fieldNo = 31;
-      expect(message.hasField(fieldNo), isFalse);
-      message.getField(fieldNo).add(1);
-      expect(message.hasField(fieldNo), isTrue);
+    // Repeated field.
+    fieldNo = 31;
+    expect(message.hasField(fieldNo), isFalse);
+    message.getField(fieldNo).add(1);
+    expect(message.hasField(fieldNo), isTrue);
 
-      // Singular field with default.
-      fieldNo = 61;
-      expect(message.hasField(fieldNo), isFalse);
-      expect(message.getField(fieldNo), 41);
-      message.clearField(fieldNo);
-      message.setField(fieldNo, 41);
-      expect(message.hasField(fieldNo), isTrue);
-      message.setField(fieldNo, 42);
-      expect(message.hasField(fieldNo), isTrue);
-      expect(message.getField(fieldNo), 42);
-      message.clearField(fieldNo);
-      expect(message.hasField(fieldNo), isFalse);
-      expect(message.getField(fieldNo), 41);
+    // Singular field with default.
+    fieldNo = 61;
+    expect(message.hasField(fieldNo), isFalse);
+    expect(message.getField(fieldNo), 41);
+    message.clearField(fieldNo);
+    message.setField(fieldNo, 41);
+    expect(message.hasField(fieldNo), isTrue);
+    message.setField(fieldNo, 42);
+    expect(message.hasField(fieldNo), isTrue);
+    expect(message.getField(fieldNo), 42);
+    message.clearField(fieldNo);
+    expect(message.hasField(fieldNo), isFalse);
+    expect(message.getField(fieldNo), 41);
   });
 
   test('JSON constants share structure', () {
     const nestedTypeTag = 3;
-    expect(TestAllTypes$json['$nestedTypeTag'][0],
-        same(TestAllTypes_NestedMessage$json));
+    List fields = TestAllTypes$json['$nestedTypeTag'];
+    expect(fields[0], same(TestAllTypes_NestedMessage$json));
 
     const enumTypeTag = 4;
-    expect(TestAllTypes$json['$enumTypeTag'][0],
-        same(TestAllTypes_NestedEnum$json));
+    fields = TestAllTypes$json['$enumTypeTag'];
+    expect(fields[0], same(TestAllTypes_NestedEnum$json));
   });
 
   test('Can read JSON constant into DescriptorProto', () {
     var d = new DescriptorProto()..mergeFromJsonMap(TestAllTypes$json);
     expect(d.name, "TestAllTypes");
     expect(d.field[0].name, "optional_int32");
     expect(d.nestedType[0].name, "NestedMessage");
   });
 }