Roll to pickup pool changes

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/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 111 matching lines @@
     }
 
     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 scripts = _getScripts(document)
-        .where((script) {
+    var scripts = _getScripts(document).where((script) {
       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}.');
       return;
@@ skipping 107 matching lines @@
         readSuperClassAnnotations(superClass.superclass);
         if (_readAnnotations(superClass.element) &&
             superClass.element.library != clazz.library) {
           _logger.warning(
               'We have detected a cycle in your import graph when running '
               'initializers on ${clazz.name}. This means the super class '
               '${superClass.name} has a dependency on this library '
               '(possibly transitive).');
         }
       }
+
       readSuperClassAnnotations(clazz.supertype);
       _readAnnotations(clazz);
     }
   }
 
   bool _readAnnotations(Element element) {
     var found = false;
     // analyzer 0.29 doesn't allow this optimization :
     //if (element.metadata.isEmpty) return found;
 
     var metaNodes;
     var node = element.computeNode();
     if (node is SimpleIdentifier && node.parent is LibraryIdentifier) {
-      metaNodes = node.parent.parent.metadata;
+      metaNodes = (node.parent.parent as AnnotatedNode).metadata;
     } else if (node is ClassDeclaration || node is FunctionDeclaration) {
-      metaNodes = node.metadata;
+      metaNodes = (node as AnnotatedNode).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);
+        // 'as dynamic' is because evaluationResult is a property on an impl class, e.g. one that
+        // isn't supposed to be used externally.
+        return _isInitializer(
+            (e.variable as dynamic).evaluationResult.value.type);
       } else if (e is ConstructorElement) {
         return _isInitializer(e.returnType);
       }
       return false;
     }).where((Annotation metaNode) {
       var meta = metaNode.elementAnnotation;
       _seenAnnotations.putIfAbsent(element, () => new Set<ElementAnnotation>());
       return !_seenAnnotations[element].contains(meta);
     }).forEach((Annotation metaNode) {
       var meta = metaNode.elementAnnotation;
@@ skipping 191 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;
 }