fix observe package to be strong mode clean

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';
 
 import 'package:analyzer/analyzer.dart';
+import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/scanner.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/messages/build_logger.dart';
 import 'package:source_maps/refactor.dart';
 import 'package:source_span/source_span.dart';
 
 import 'src/messages.dart';
 
 /// A [Transformer] that replaces observables based on dirty-checking with an
 /// implementation based on change notifications.
 ///
 /// The transformation adds hooks for field setters and notifies the observation
 /// system of the change.
 class ObservableTransformer extends Transformer {
   final bool releaseMode;
   final bool injectBuildLogsInOutput;
   final List<String> _files;
+
   ObservableTransformer(
       {List<String> files, bool releaseMode, bool injectBuildLogsInOutput})
       : _files = files,
         releaseMode = releaseMode == true,
         injectBuildLogsInOutput = injectBuildLogsInOutput == null
             ? releaseMode != true
             : injectBuildLogsInOutput;
+
   ObservableTransformer.asPlugin(BarbackSettings settings)
       : _files = _readFiles(settings.configuration['files']),
         releaseMode = settings.mode == BarbackMode.RELEASE,
         injectBuildLogsInOutput = settings.mode != BarbackMode.RELEASE;
 
   static List<String> _readFiles(value) {
     if (value == null) return null;
-    var files = [];
+    var files = <String>[];
     bool error;
     if (value is List) {
-      files = value;
+      files = new List<String>.from(value);
       error = value.any((e) => e is! String);
     } else if (value is String) {
       files = [value];
       error = false;
     } else {
       error = true;
     }
     if (error) print('Invalid value for "files" in the observe transformer.');
     return files;
   }
 
   // TODO(nweiz): This should just take an AssetId when barback <0.13.0 support
   // is dropped.
-  Future<bool> isPrimary(idOrAsset) {
-    var id = idOrAsset is AssetId ? idOrAsset : idOrAsset.id;
+  Future<bool> isPrimary(Object idOrAsset) {
+    var id = idOrAsset is AssetId ? idOrAsset : (idOrAsset as Asset).id;
     return new Future.value(id.extension == '.dart' &&
         (_files == null || _files.contains(id.path)));
   }
 
   Future apply(Transform transform) {
     return transform.primaryInput.readAsString().then((content) {
       // Do a quick string check to determine if this is this file even
       // plausibly might need to be transformed. If not, we can avoid an
       // expensive parse.
       if (!observableMatcher.hasMatch(content)) return null;
@@ skipping 176 matching lines @@
     var params = cls.typeParameters;
     var pos = params != null ? params.end : cls.name.end;
     code.edit(pos, pos, ' extends ChangeNotifier ');
   }
 }
 
 SimpleIdentifier _getSimpleIdentifier(Identifier id) =>
     id is PrefixedIdentifier ? id.identifier : id;
 
 bool _hasKeyword(Token token, Keyword keyword) =>
-    token is KeywordToken && token.keyword == keyword;
+    token?.type == TokenType.KEYWORD && token.lexeme == keyword.syntax;
 
 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}');
       }
     }
   }
 
   // Fix "this." initializer in parameter list. These are tricky:
   // we need to preserve the name and add an initializer.
   // Preserving the name is important for named args, and for dartdoc.
   // BEFORE: Foo(this.bar, this.baz) { ... }
   // AFTER:  Foo(bar, baz) : __$bar = bar, __$baz = baz { ... }
 
   var thisInit = [];
   for (var param in ctor.parameters.parameters) {
     if (param is DefaultFormalParameter) {
-      param = param.parameter;
+      param = (param as DefaultFormalParameter).parameter;
     }
     if (param is FieldFormalParameter) {
       var name = param.identifier.name;
       if (changedFields.contains(name)) {
         thisInit.add(name);
         // Remove "this." but keep everything else.
         code.edit(param.thisKeyword.offset, param.period.end, '');
       }
     }
   }
@@ skipping 111 matching lines @@
     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)");