Update charted to 0.4.8 and roll

packages/initialize/lib/transformer.dart

 // Copyright (c) 2015, 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 initialize.transformer;
 
 import 'dart:async';
 import 'dart:collection' show Queue;
-import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:barback/barback.dart';
 import 'package:code_transformers/assets.dart';
 import 'package:code_transformers/resolver.dart';
 import 'package:code_transformers/src/dart_sdk.dart' as dart_sdk;
 import 'package:dart_style/dart_style.dart';
 import 'package:glob/glob.dart';
 import 'package:html/dom.dart' as dom;
 import 'package:html/parser.dart' show parse;
 import 'package:path/path.dart' as path;
 
 import 'build/initializer_plugin.dart';
 export 'build/initializer_plugin.dart';
 
 /// Create a new [Asset] which inlines your [Initializer] annotations into
 /// a new file that bootstraps your application.
 Asset generateBootstrapFile(Resolver resolver, Transform transform,
     AssetId primaryAssetId, AssetId newEntryPointId,
-    {bool errorIfNotFound: true, List<InitializerPlugin> plugins,
+    {bool errorIfNotFound: true,
+    List<InitializerPlugin> plugins,
     bool appendDefaultPlugin: true}) {
   if (appendDefaultPlugin) {
     if (plugins == null) plugins = [];
     plugins.add(const DefaultInitializerPlugin());
   }
   return new _BootstrapFileBuilder(
-      resolver, transform, primaryAssetId, newEntryPointId, errorIfNotFound,
-      plugins: plugins).run();
+          resolver, transform, primaryAssetId, newEntryPointId, errorIfNotFound,
+          plugins: plugins)
+      .run();
 }
 
 /// Transformer which removes the mirror-based initialization logic and replaces
 /// it with static logic.
 class InitializeTransformer extends Transformer {
   final Resolvers _resolvers;
   final Iterable<Glob> _entryPointGlobs;
   final bool _errorIfNotFound;
   final List<InitializerPlugin> plugins;
 
@@ skipping 45 matching lines @@
 
       return _resolvers.get(transform, [primaryId]).then((resolver) {
         transform.addOutput(generateBootstrapFile(
             resolver, transform, primaryId, newEntryPointId,
             errorIfNotFound: _errorIfNotFound, plugins: plugins));
         resolver.release();
         return newEntryPointId;
       });
     });
   }
+
   // Finds the first (and only) dart script on an html page and returns the
   // [AssetId] that points to it
   AssetId _findMainScript(
       dom.Document document, AssetId entryPoint, Transform transform) {
-    var scripts = document.querySelectorAll('script[type="application/dart"]');
+    var scripts = _getScripts(document);
     if (scripts.length != 1) {
       transform.logger.error('Expected exactly one dart script in $entryPoint '
           'but found ${scripts.length}.');
       return null;
     }
 
-    var src = scripts[0].attributes['src'];
+    var src = _getScriptAttribute(scripts[0]);
     if (src == null) {
       // TODO(jakemac): Support inline scripts,
       transform.logger.error('Inline scripts are not supported at this time, '
           'see https://github.com/dart-lang/initialize/issues/20.');
       return null;
     }
 
     return uriToAssetId(
         entryPoint, src, transform.logger, scripts[0].sourceSpan);
   }
 
   // Replaces script tags pointing to [originalDartFile] with [newDartFile] in
   // [entryPoint].
   void _replaceEntryWithBootstrap(Transform transform, dom.Document document,
       AssetId entryPoint, AssetId originalDartFile, AssetId newDartFile) {
-    var found = false;
-
-    var scripts = document
-        .querySelectorAll('script[type="application/dart"]')
+    var scripts = _getScripts(document)
         .where((script) {
-      var assetId = uriToAssetId(entryPoint, script.attributes['src'],
+      var assetId = uriToAssetId(entryPoint, _getScriptAttribute(script),
           transform.logger, script.sourceSpan);
       return assetId == originalDartFile;
     }).toList();
 
     if (scripts.length != 1) {
-      transform.logger.error(
-          'Expected exactly one script pointing to $originalDartFile in '
-          '$entryPoint, but found ${scripts.length}.');
+      transform.logger
+          .error('Expected exactly one script pointing to $originalDartFile in '
+              '$entryPoint, but found ${scripts.length}.');
       return;
     }
-    scripts[0].attributes['src'] = path.url.relative(newDartFile.path,
-        from: path.dirname(entryPoint.path));
+    _setScriptAttribute(
+        scripts[0],
+        path.url
+            .relative(newDartFile.path, from: path.dirname(entryPoint.path)));
     transform.addOutput(new Asset.fromString(entryPoint, document.outerHtml));
   }
+
+  String _getScriptAttribute(dom.Element element) {
+    switch (element.localName) {
+      case 'script':
+        return element.attributes['src'];
+      case 'link':
+        return element.attributes['href'];
+      default:
+        throw 'Unrecognized element $element';
+    }
+  }
+
+  void _setScriptAttribute(dom.Element element, String path) {
+    switch (element.localName) {
+      case 'script':
+        element.attributes['src'] = path;
+        break;
+      case 'link':
+        element.attributes['href'] = path;
+        break;
+    }
+  }
+
+  List<dom.Element> _getScripts(dom.Document document) =>
+      document.querySelectorAll(
+          'script[type="application/dart"], link[rel="x-dart-test"]');
 }
 
 // Class which builds a bootstrap file.
 class _BootstrapFileBuilder {
   final Resolver _resolver;
   final Transform _transform;
   final bool _errorIfNotFound;
   AssetId _entryPoint;
   AssetId _newEntryPoint;
 
   /// The resolved initialize library.
   LibraryElement _initializeLibrary;
+
   /// The resolved Initializer class from the initialize library.
   ClassElement _initializer;
 
   /// Queue for intialization annotations.
   final _initQueue = new Queue<InitializerData>();
+
   /// All the annotations we have seen for each element
   final _seenAnnotations = new Map<Element, Set<ElementAnnotation>>();
 
   /// The list of [InitializerPlugin]s to apply. The first plugin which asks to
   /// be applied to a given initializer is the only one that will apply.
   List<InitializerPlugin> _plugins;
 
   TransformLogger _logger;
 
   _BootstrapFileBuilder(this._resolver, this._transform, this._entryPoint,
@@ skipping 52 matching lines @@
               '(possibly transitive).');
         }
       }
       readSuperClassAnnotations(clazz.supertype);
       _readAnnotations(clazz);
     }
   }
 
   bool _readAnnotations(Element element) {
     var found = false;
-    if (element.metadata.isEmpty) return found;
+    // analyzer 0.29 doesn't allow this optimization :
+    //if (element.metadata.isEmpty) return found;
 
     var metaNodes;
-    var node = element.node;
+    var node = element.computeNode();
     if (node is SimpleIdentifier && node.parent is LibraryIdentifier) {
       metaNodes = node.parent.parent.metadata;
     } else if (node is ClassDeclaration || node is FunctionDeclaration) {
       metaNodes = node.metadata;
     } else {
       return found;
     }
 
     metaNodes.where((Annotation metaNode) {
       // First filter out anything that is not a Initializer.
@@ skipping 68 matching lines @@
   _writeImport(LibraryElement lib, String prefix, StringBuffer buffer) {
     AssetId id = (lib.source as dynamic).assetId;
 
     if (id.path.startsWith('lib/')) {
       var packagePath = id.path.replaceFirst('lib/', '');
       buffer.write("import 'package:${id.package}/${packagePath}'");
     } else if (id.package != _newEntryPoint.package) {
       _logger.error("Can't import `${id}` from `${_newEntryPoint}`");
     } else if (path.url.split(id.path)[0] ==
         path.url.split(_newEntryPoint.path)[0]) {
-      var relativePath = path.url.relative(id.path,
-          from: path.url.dirname(_newEntryPoint.path));
+      var relativePath = path.url
+          .relative(id.path, from: path.url.dirname(_newEntryPoint.path));
       buffer.write("import '${relativePath}'");
     } else {
       _logger.error("Can't import `${id}` from `${_newEntryPoint}`");
     }
     buffer.writeln(' as $prefix;');
   }
 
   bool _isInitializer(InterfaceType type) {
     // If `_initializer` wasn't found then it was never loaded (even
     // transitively), and so no annotations can be initializers.
@@ skipping 61 matching lines @@
   }
 
   Iterable<LibraryElement> _sortedLibraryDependencies(LibraryElement library) {
     // TODO(jakemac): Investigate supporting annotations on part-of directives.
     getLibrary(UriReferencedElement element) {
       if (element is ImportElement) return element.importedLibrary;
       if (element is ExportElement) return element.exportedLibrary;
     }
 
     return (new List.from(library.imports)
-      ..addAll(library.exports)
-      ..sort((a, b) => a.nameOffset.compareTo(b.nameOffset))).map(getLibrary);
+          ..addAll(library.exports)
+          ..sort((a, b) => a.nameOffset.compareTo(b.nameOffset)))
+        .map(getLibrary);
   }
 }
 
 /// An [Initializer] annotation and the target of that annotation.
 class InitializerData {
   /// The target [AstNode] of the annotation.
   final AstNode targetNode;
 
   /// The [Annotation] representing the annotation itself.
   final Annotation annotationNode;
@@ skipping 31 matching lines @@
     error = false;
   } else {
     error = true;
   }
   if (error) {
     print('Bad value for "$field" in the initialize transformer. '
         'Expected either one String or a list of Strings.');
   }
   return files;
 }