merge to trunk all changes from 36817 until 37378 under the packages: polymer,

pkg/polymer/lib/src/build/script_compactor.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.
 
 /// Transfomer that combines multiple dart script tags into a single one.
 library polymer.src.build.script_compactor;
 
 import 'dart:async';
 import 'dart:convert';
 
@@ skipping 27 matching lines @@
 /// [ImportInliner] on an earlier phase.
 ///
 /// Internally, this transformer will convert each script tag into an import
 /// statement to a library, and then uses `initPolymer` (see polymer.dart)  to
 /// process `@initMethod` and `@CustomTag` annotations in those libraries.
 class ScriptCompactor extends Transformer {
   final Resolvers resolvers;
   final TransformOptions options;
 
   ScriptCompactor(this.options, {String sdkDir})
-      : resolvers = new Resolvers(sdkDir != null ? sdkDir : dartSdkDirectory);
+      // TODO(sigmund): consider restoring here a resolver that uses the real
+      // SDK once the analyzer is lazy and only an resolves what it needs:
+      //: resolvers = new Resolvers(sdkDir != null ? sdkDir : dartSdkDirectory);
+      : resolvers = new Resolvers.fromMock({
+        // The list of types below is derived from:
+        //   * types we use via our smoke queries, including HtmlElement and
+        //     types from `_typeHandlers` (deserialize.dart)
+        //   * types that are used internally by the resolver (see
+        //   _initializeFrom in resolver.dart).
+        'dart:core': '''
+            library dart.core;
+            class Object {}
+            class Function {}
+            class StackTrace {}
+            class Symbol {}
+            class Type {}
+
+            class String extends Object {}
+            class bool extends Object {}
+            class num extends Object {}
+            class int extends num {}
+            class double extends num {}
+            class DateTime extends Object {}
+            class Null extends Object {}
+
+            class Deprecated extends Object {
+              final String expires;
+              const Deprecated(this.expires);
+            }
+            const Object deprecated = const Deprecated("next release");
+
+            class List<V> extends Object {}
+            class Map<K, V> extends Object {}
+            ''',
+        'dart:html': '''
+            library dart.html;
+            class HtmlElement {}
+            ''',
+      });
+
+
 
   /// Only run on entry point .html 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;
     return new Future.value(options.isHtmlEntryPoint(id));
   }
 
   Future apply(Transform transform) =>
@@ skipping 118 matching lines @@
   /// package. This includes:
   ///
   ///   * visiting entry-libraries to extract initializers,
   ///   * visiting polymer-expressions to extract getters and setters,
   ///   * looking for published fields of custom elements, and
   ///   * looking for event handlers and callbacks of change notifications.
   ///
   void _extractUsesOfMirrors(_) {
     // Generate getters and setters needed to evaluate polymer expressions, and
     // extract information about published attributes.
-    new _HtmlExtractor(generator, publishedAttributes).visit(document);
+    new _HtmlExtractor(logger, generator, publishedAttributes).visit(document);
 
     // Create a recorder that uses analyzer data to feed data to [generator].
     var recorder = new Recorder(generator,
         (lib) => resolver.getImportUri(lib, from: bootstrapId).toString());
 
     // Process all classes and top-level functions to include initializers,
     // register custom elements, and include special fields and methods in
     // custom element classes.
     for (var id in entryLibraries) {
       var lib = resolver.getLibrary(id);
@@ skipping 238 matching lines @@
 
 /// An html visitor that:
 ///   * finds all polymer expressions and records the getters and setters that
 ///     will be needed to evaluate them at runtime.
 ///   * extracts all attributes declared in the `attribute` attributes of
 ///     polymer elements.
 class _HtmlExtractor extends TreeVisitor {
   final Map<String, List<String>> publishedAttributes;
   final SmokeCodeGenerator generator;
   final _SubExpressionVisitor visitor;
+  final TransformLogger logger;
   bool _inTemplate = false;
 
-  _HtmlExtractor(SmokeCodeGenerator generator, this.publishedAttributes)
+  _HtmlExtractor(this.logger, SmokeCodeGenerator generator,
+      this.publishedAttributes)
       : generator = generator,
         visitor = new _SubExpressionVisitor(generator);
 
   void visitElement(Element node) {
     if (_inTemplate) _processNormalElement(node);
     if (node.localName == 'polymer-element') {
       _processPolymerElement(node);
       _processNormalElement(node);
     }
 
     if (node.localName == 'template') {
       var last = _inTemplate;
       _inTemplate = true;
       super.visitElement(node);
       _inTemplate = last;
     } else {
       super.visitElement(node);
     }
   }
 
   void visitText(Text node) {
     if (!_inTemplate) return;
     var bindings = _Mustaches.parse(node.data);
     if (bindings == null) return;
     for (var e in bindings.expressions) {
-      _addExpression(e, false, false);
+      _addExpression(e, false, false, node.sourceSpan);
     }
   }
 
   /// Registers getters and setters for all published attributes.
   void _processPolymerElement(Element node) {
     var tagName = node.attributes['name'];
     var value = node.attributes['attributes'];
     if (value != null) {
       publishedAttributes[tagName] =
           value.split(ATTRIBUTES_REGEX).map((a) => a.trim()).toList();
@@ skipping 14 matching lines @@
       var isTwoWay = false;
       if (name is String) {
         name = name.toLowerCase();
         isEvent = name.startsWith('on-');
         isTwoWay = !isEvent && bindings.isWhole && (isCustomTag ||
             tag == 'input' && (name == 'value' || name =='checked') ||
             tag == 'select' && (name == 'selectedindex' || name == 'value') ||
             tag == 'textarea' && name == 'value');
       }
       for (var exp in bindings.expressions) {
-        _addExpression(exp, isEvent, isTwoWay);
+        _addExpression(exp, isEvent, isTwoWay, node.sourceSpan);
       }
     });
   }
 
-  void _addExpression(String stringExpression, bool inEvent, bool isTwoWay) {
+  void _addExpression(String stringExpression, bool inEvent, bool isTwoWay,
+      span) {
+
     if (inEvent) {
-      if (!stringExpression.startsWith("@")) {
-        if (stringExpression == '') return;
-        generator.addGetter(stringExpression);
-        generator.addSymbol(stringExpression);
+      if (stringExpression.startsWith('@')) {
+        logger.warning('event bindings with @ are no longer supported',
+            span: span);
         return;
       }
-      stringExpression = stringExpression.substring(1);
+
+      if (stringExpression == '') return;
+      generator.addGetter(stringExpression);
+      generator.addSymbol(stringExpression);
     }
     visitor.run(pe.parse(stringExpression), isTwoWay);
   }
 }
 
 /// A polymer-expression visitor that records every getter and setter that will
 /// be needed to evaluate a single expression at runtime.
 class _SubExpressionVisitor extends pe.RecursiveVisitor {
   final SmokeCodeGenerator generator;
   bool _includeSetter;
@@ skipping 161 matching lines @@
   for (var e in lib.exports) {
     var exported = e.exportedLibrary.units.expand((u) => u.types).toList();
     _filter(exported, e.combinators);
     result.addAll(exported);
   }
   return result;
 }
 
 /// Retrieves all top-level methods that are visible if you were to import
 /// [lib]. This includes exported methods from other libraries too.
-List<ClassElement> _visibleTopLevelMethodsOf(LibraryElement lib) {
+List<FunctionElement> _visibleTopLevelMethodsOf(LibraryElement lib) {
   var result = [];
   result.addAll(lib.units.expand((u) => u.functions));
   for (var e in lib.exports) {
     var exported = e.exportedLibrary.units
         .expand((u) => u.functions).toList();
     _filter(exported, e.combinators);
     result.addAll(exported);
   }
   return result;
 }
 
 /// Filters [elements] that come from an export, according to its show/hide
 /// combinators. This modifies [elements] in place.
 void _filter(List<analyzer.Element> elements,
     List<NamespaceCombinator> combinators) {
   for (var c in combinators) {
     if (c is ShowElementCombinator) {
       var show = c.shownNames.toSet();
       elements.retainWhere((e) => show.contains(e.displayName));
     } else if (c is HideElementCombinator) {
       var hide = c.hiddenNames.toSet();
       elements.removeWhere((e) => hide.contains(e.displayName));
     }
   }
 }