Fixed strong mode errors and warnings reachable from lib/observe.dart

lib/transformer.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.
 
 /// Code transform for @observable. The core transformation is relatively
 /// straightforward, and essentially like an editor refactoring.
 library observe.transformer;
 
 import 'dart:async';
 
@@ skipping 115 matching lines @@
 /// True if the node has the `@observable` or `@published` annotation.
 // TODO(jmesserly): it is not good to be hard coding Polymer support here.
 bool _hasObservable(AnnotatedNode node) =>
     node.metadata.any(_isObservableAnnotation);
 
 // TODO(jmesserly): this isn't correct if the annotation has been imported
 // with a prefix, or cases like that. We should technically be resolving, but
 // that is expensive in analyzer, so it isn't feasible yet.
 bool _isObservableAnnotation(Annotation node) =>
     _isAnnotationContant(node, 'observable') ||
-        _isAnnotationContant(node, 'published') ||
-        _isAnnotationType(node, 'ObservableProperty') ||
-        _isAnnotationType(node, 'PublishedProperty');
+    _isAnnotationContant(node, 'published') ||
+    _isAnnotationType(node, 'ObservableProperty') ||
+    _isAnnotationType(node, 'PublishedProperty');
 
 bool _isAnnotationContant(Annotation m, String name) =>
     m.name.name == name && m.constructorName == null && m.arguments == null;
 
 bool _isAnnotationType(Annotation m, String name) => m.name.name == name;
 
 void _transformClass(ClassDeclaration cls, TextEditTransaction code,
     SourceFile file, BuildLogger logger) {
   if (_hasObservable(cls)) {
     logger.warning(NO_OBSERVABLE_ON_CLASS, span: _getSpan(file, cls));
@@ skipping 107 matching lines @@
     id is PrefixedIdentifier ? id.identifier : id;
 
 bool _hasKeyword(Token token, Keyword keyword) =>
     token is KeywordToken && token.keyword == keyword;
 
 String _getOriginalCode(TextEditTransaction code, AstNode node) =>
     code.original.substring(node.offset, node.end);
 
 void _fixConstructor(ConstructorDeclaration ctor, TextEditTransaction code,
     Set<String> changedFields) {
-
   // Fix normal initializers
   for (var initializer in ctor.initializers) {
     if (initializer is ConstructorFieldInitializer) {
       var field = initializer.fieldName;
       if (changedFields.contains(field.name)) {
         code.edit(field.offset, field.end, '__\$${field.name}');
       }
     }
   }
 
@@ skipping 108 matching lines @@
     } else {
       beforeInit = '$metadata $type $beforeInit';
     }
 
     code.edit(field.name.offset, field.name.end, beforeInit);
 
     // Replace comma with semicolon
     final end = _findFieldSeperator(field.endToken.next);
     if (end.type == TokenType.COMMA) code.edit(end.offset, end.end, ';');
 
-    code.edit(end.end, end.end, ' @reflectable set $name($type value) { '
+    code.edit(
+        end.end,
+        end.end,
+        ' @reflectable set $name($type value) { '
         '__\$$name = notifyPropertyChange(#$name, __\$$name, value); }');
   }
 }
 
 Token _findFieldSeperator(Token token) {
   while (token != null) {
     if (token.type == TokenType.COMMA || token.type == TokenType.SEMICOLON) {
       break;
     }
     token = token.next;
   }
   return token;
 }
 
 // TODO(sigmund): remove hard coded Polymer support (@published). The proper way
 // to do this would be to switch to use the analyzer to resolve whether
 // annotations are subtypes of ObservableProperty.
 final observableMatcher =
     new RegExp("@(published|observable|PublishedProperty|ObservableProperty)");