Fix initialize transformer crash on some programs

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:barback/barback.dart';
@@ skipping 44 matching lines @@
   bool isPrimary(AssetId id) => _entryPointGlobs.any((g) => g.matches(id.path));
 
   Future apply(Transform transform) {
     if (transform.primaryInput.id.path.endsWith('.dart')) {
       return _buildBootstrapFile(transform);
     } else if (transform.primaryInput.id.path.endsWith('.html')) {
       return transform.primaryInput.readAsString().then((html) {
         var document = parse(html);
         var originalDartFile =
             _findMainScript(document, transform.primaryInput.id, transform);
-        return _buildBootstrapFile(transform, primaryId: originalDartFile).then(
-            (AssetId newDartFile) {
+        return _buildBootstrapFile(transform, primaryId: originalDartFile)
+            .then((AssetId newDartFile) {
           return _replaceEntryWithBootstrap(transform, document,
               transform.primaryInput.id, originalDartFile, newDartFile);
         });
       });
     } else {
       transform.logger.warning(
           'Invalid entry point ${transform.primaryInput.id}. Must be either a '
           '.dart or .html file.');
     }
     return new Future.value();
@@ skipping 149 matching lines @@
               '(possibly transitive).');
         }
         superClass = superClass.superclass;
       }
       _readAnnotations(clazz);
     }
   }
 
   bool _readAnnotations(Element element) {
     var found = false;
-    element.metadata.where((ElementAnnotation meta) {
+    if (element.metadata.isEmpty) return found;
+
+    var metaNodes;
+    var node = element.node;
+    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.
+      var meta = metaNode.elementAnnotation;
       var e = meta.element;
       if (e is PropertyAccessorElement) {
         return _isInitializer(e.variable.evaluationResult.value.type);
       } else if (e is ConstructorElement) {
         return _isInitializer(e.returnType);
       }
       return false;
-    }).where((ElementAnnotation meta) {
+    }).where((Annotation metaNode) {
+      var meta = metaNode.elementAnnotation;
       _seenAnnotations.putIfAbsent(element, () => new Set<ElementAnnotation>());
       return !_seenAnnotations[element].contains(meta);
-    }).forEach((ElementAnnotation meta) {
+    }).forEach((Annotation metaNode) {
+      var meta = metaNode.elementAnnotation;
       _seenAnnotations[element].add(meta);
-      _initQueue.addLast(new InitializerData._(element, meta));
+      _initQueue.addLast(new InitializerData._(node, metaNode));
       found = true;
     });
     return found;
   }
 
   String _buildNewEntryPoint(LibraryElement entryLib) {
     var importsBuffer = new StringBuffer();
     var initializersBuffer = new StringBuffer();
     var libraryPrefixes = new Map<LibraryElement, String>();
 
@@ skipping 42 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 56 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) {
-      // dart: imports don't have a uri
-      if (a.uri == null && b.uri != null) return -1;
-      if (b.uri == null && a.uri != null) return 1;
-      if (a.uri == null && b.uri == null) {
-        return getLibrary(a).name.compareTo(getLibrary(b).name);
-      }
+        // dart: imports don't have a uri
+        if (a.uri == null && b.uri != null) return -1;
+        if (b.uri == null && a.uri != null) return 1;
+        if (a.uri == null && b.uri == null) {
+          return getLibrary(a).name.compareTo(getLibrary(b).name);
+        }
 
-      // package: imports next
-      var aIsPackage = a.uri.startsWith('package:');
-      var bIsPackage = b.uri.startsWith('package:');
-      if (aIsPackage && !bIsPackage) {
-        return -1;
-      } else if (bIsPackage && !aIsPackage) {
-        return 1;
-      } else if (bIsPackage && aIsPackage) {
-        return a.uri.compareTo(b.uri);
-      }
+        // package: imports next
+        var aIsPackage = a.uri.startsWith('package:');
+        var bIsPackage = b.uri.startsWith('package:');
+        if (aIsPackage && !bIsPackage) {
+          return -1;
+        } else if (bIsPackage && !aIsPackage) {
+          return 1;
+        } else if (bIsPackage && aIsPackage) {
+          return a.uri.compareTo(b.uri);
+        }
 
-      // And finally compare based on the relative uri if both are file paths.
-      var aUri = path.url.relative(a.source.uri.path,
-          from: path.url.dirname(library.source.uri.path));
-      var bUri = path.url.relative(b.source.uri.path,
-          from: path.url.dirname(library.source.uri.path));
-      return aUri.compareTo(bUri);
-    })).map(getLibrary);
+        // And finally compare based on the relative uri if both are file paths.
+        var aUri = path.url.relative(a.source.uri.path,
+            from: path.url.dirname(library.source.uri.path));
+        var bUri = path.url.relative(b.source.uri.path,
+            from: path.url.dirname(library.source.uri.path));
+        return aUri.compareTo(bUri);
+      })).map(getLibrary);
   }
 }
 
 /// An [Initializer] annotation and the target of that annotation.
 class InitializerData {
-  /// The target [Element] of the annotation.
-  final Element targetElement;
+  /// The target [AstNode] of the annotation.
+  final AstNode targetNode;
+
+  /// The [Annotation] representing the annotation itself.
+  final Annotation annotationNode;
 
   /// The [ElementAnnotation] representing the annotation itself.
-  final ElementAnnotation annotationElement;
+  ElementAnnotation get annotationElement => annotationNode.elementAnnotation;
 
-  AstNode _targetNode;
-
-  /// The target [AstNode] of the annotation.
-  // TODO(jakemac): We at least cache this for now, but  ideally `targetElement`
-  // would actually be the getter, and `targetNode` would be the property.
-  AstNode get targetNode {
-    if (_targetNode == null) _targetNode = targetElement.node;
-    return _targetNode;
-  }
-
-  /// The [Annotation] representing the annotation itself.
-  Annotation get annotationNode {
-    var annotatedNode;
+  /// The target [Element] of the annotation.
+  Element get targetElement {
     if (targetNode is SimpleIdentifier &&
         targetNode.parent is LibraryIdentifier) {
-      annotatedNode = targetNode.parent.parent;
+      return targetNode.parent.parent.element;
     } else if (targetNode is ClassDeclaration ||
         targetNode is FunctionDeclaration) {
-      annotatedNode = targetNode;
+      return targetNode.element;
     } else {
       return null;
     }
-    if (annotatedNode is! AnnotatedNode) return null;
-    var astMeta = annotatedNode.metadata;
-
-    return astMeta.firstWhere((m) => m.elementAnnotation == annotationElement);
   }
 
-  InitializerData._(this.targetElement, this.annotationElement);
+  InitializerData._(this.targetNode, this.annotationNode);
 }
 
 // Reads a file list from a barback settings configuration field.
 _readFileList(BarbackSettings settings, String field) {
   var value = settings.configuration[field];
   if (value == null) return null;
   var files = [];
   bool error;
   if (value is List) {
     files = value;
     error = value.any((e) => e is! String);
   } else if (value is String) {
     files = [value];
     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;
 }