Roll polymer packages to version 0.3.4

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 122 matching lines @@
 
   /// Resolved types used for analyzing the user's sources and generating code.
   _ResolvedTypes types;
 
   /// The resolver instance associated with a single run of this transformer.
   Resolver resolver;
 
   /// Code generator used to create the static initialization for smoke.
   final generator = new SmokeCodeGenerator();
 
+  _SubExpressionVisitor expressionVisitor;
+
   _ScriptCompactor(Transform transform, this.options, this.resolvers)
       : transform = transform,
         logger = transform.logger,
         docId = transform.primaryInput.id,
         bootstrapId = transform.primaryInput.id.addExtension('_bootstrap.dart');
 
   Future apply() =>
       _loadDocument()
       .then(_loadEntryLibraries)
       .then(_processHtml)
@@ skipping 68 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(logger, generator, publishedAttributes).visit(document);
+    expressionVisitor = new _SubExpressionVisitor(generator, logger);
+    new _HtmlExtractor(logger, generator, publishedAttributes,
+        expressionVisitor).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 59 matching lines @@
           withAnnotations: [types.observePropertyElement]));
 
     // Include @published and @observable properties.
     // Symbols in @published are used when resolving bindings on published
     // attributes, symbols for @observable are used via path observers when
     // implementing *Changed an @ObserveProperty.
     // TODO(sigmund): consider including only those symbols mentioned in
     // *Changed and @ObserveProperty instead.
     recorder.runQuery(cls, new QueryOptions(
           includeUpTo: types.htmlElementElement,
-          withAnnotations: [types.publishedElement, types.observableElement]));
+          withAnnotations: [types.publishedElement, types.observableElement,
+          types.computedPropertyElement]));
+
+    // Include @ComputedProperty and process their expressions
+    var computed = [];
+    recorder.runQuery(cls, new QueryOptions(
+          includeUpTo: types.htmlElementElement,
+          withAnnotations: [types.computedPropertyElement]),
+          results: computed);
+    _processComputedExpressions(computed);
 
     for (var tagName in tagNames) {
       // Include an initializer that will call Polymer.register
       initializers.add(new _CustomTagInitializer(id, tagName, cls.displayName));
 
       // Include also properties published via the `attributes` attribute.
       var attrs = publishedAttributes[tagName];
       if (attrs == null) continue;
       for (var attr in attrs) {
         recorder.lookupMember(cls, attr, recursive: true,
@@ skipping 10 matching lines @@
       }
       if (cls.supertype == null) return false;
       cls = cls.supertype.element;
     }
     return false;
   }
 
   /// If [meta] is [CustomTag], extract the name associated with the tag.
   String _extractTagName(Annotation meta, ClassElement cls) {
     if (meta.element != types.customTagConstructor) return null;
+    return _extractFirstAnnotationArgument(meta, 'CustomTag', cls);
+  }
+
+  /// Extract the first argument of an annotation and validate that it's type is
+  /// String. For instance, return "bar" from `@Foo("bar")`.
+  String _extractFirstAnnotationArgument(Annotation meta, String name,
+      analyzer.Element context) {
 
     // Read argument from the AST
     var args = meta.arguments.arguments;
     if (args == null || args.length == 0) {
-      logger.warning('Missing argument in @CustomTag annotation',
-          span: _spanForNode(cls, meta));
+      logger.warning('Missing argument in @$name annotation',
+          span: _spanForNode(context, meta));
       return null;
     }
 
-    var res = resolver.evaluateConstant(
-        cls.enclosingElement.enclosingElement, args[0]);
+    var lib = context;
+    while (lib is! LibraryElement) lib = lib.enclosingElement;
+    var res = resolver.evaluateConstant(lib, args[0]);
     if (!res.isValid || res.value.type != types.stringType) {
-      logger.warning('The parameter to @CustomTag seems to be invalid.',
-          span: _spanForNode(cls, args[0]));
+      logger.warning('The parameter to @$name seems to be invalid.',
+          span: _spanForNode(context, args[0]));
       return null;
     }
     return res.value.stringValue;
   }
 
   /// Adds the top-level [function] as an initalizer if it's marked with
   /// `@initMethod`.
   _processFunction(FunctionElement function, AssetId id) {
     bool initMethodFound = false;
     for (var meta in function.metadata) {
       var e = meta.element;
       if (e is PropertyAccessorElement &&
           e.variable == types.initMethodElement) {
         initMethodFound = true;
         break;
       }
     }
     if (!initMethodFound) return;
     if (function.isPrivate) {
       logger.error('@initMethod is no longer supported on private '
           'functions: ${function.displayName}',
           span: _spanForNode(function, function.node.name));
       return;
     }
     initializers.add(new _InitMethodInitializer(id, function.displayName));
   }
 
+  /// Process members that are annotated with `@ComputedProperty` and records
+  /// the accessors of their expressions.
+  _processComputedExpressions(List<analyzer.Element> computed) {
+    var constructor = types.computedPropertyElement.constructors.first;
+    for (var member in computed) {
+      for (var meta in member.node.metadata) {
+        if (meta.element != constructor) continue;
+        var expr = _extractFirstAnnotationArgument(
+            meta, 'ComputedProperty', member);
+        if (expr == null) continue;
+        expressionVisitor.run(pe.parse(expr), true,
+            _spanForNode(member.enclosingElement, meta.arguments.arguments[0]));
+      }
+    }
+  }
+
   /// Writes the final output for the bootstrap Dart file and entrypoint HTML
   /// file.
   void _emitFiles(_) {
     StringBuffer code = new StringBuffer()..writeln(MAIN_HEADER);
     Map<AssetId, String> prefixes = {};
     int i = 0;
     for (var id in entryLibraries) {
       var url = assetUrlFor(id, bootstrapId, logger);
       if (url == null) continue;
       code.writeln("import '$url' as i$i;");
@@ skipping 88 matching lines @@
     'package:polymer/polymer.dart).';
 
 /// 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 _SubExpressionVisitor expressionVisitor;
   final TransformLogger logger;
   bool _inTemplate = false;
 
-  _HtmlExtractor(TransformLogger logger, SmokeCodeGenerator generator,
-      this.publishedAttributes)
-      : logger = logger, generator = generator,
-        visitor = new _SubExpressionVisitor(generator, logger);
+  _HtmlExtractor(this.logger, this.generator, this.publishedAttributes,
+      this.expressionVisitor);
 
   void visitElement(Element node) {
     if (_inTemplate) _processNormalElement(node);
     if (node.localName == 'polymer-element') {
       _processPolymerElement(node);
       _processNormalElement(node);
     }
 
     if (node.localName == 'template') {
       var last = _inTemplate;
@@ skipping 62 matching lines @@
 
       if (stringExpression == '') return;
       if (stringExpression.startsWith('_')) {
         logger.warning('private symbols cannot be used in event handlers',
             span: span);
         return;
       }
       generator.addGetter(stringExpression);
       generator.addSymbol(stringExpression);
     }
-    visitor.run(pe.parse(stringExpression), isTwoWay, span);
+    expressionVisitor.run(pe.parse(stringExpression), isTwoWay, span);
   }
 }
 
 /// 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;
   final TransformLogger logger;
   bool _includeSetter;
   Span _currentSpan;
@@ skipping 91 matching lines @@
 
   /// Element representing the type of `@published`.
   final ClassElement publishedElement;
 
   /// Element representing the type of `@observable`.
   final ClassElement observableElement;
 
   /// Element representing the type of `@ObserveProperty`.
   final ClassElement observePropertyElement;
 
+  /// Element representing the type of `@ComputedProperty`.
+  final ClassElement computedPropertyElement;
+
   /// Element representing the `@initMethod` annotation.
   final TopLevelVariableElement initMethodElement;
 
 
   factory _ResolvedTypes(Resolver resolver) {
     // Load class elements that are used in queries for codegen.
     var polymerLib = resolver.getLibrary(
         new AssetId('polymer', 'lib/polymer.dart'));
     if (polymerLib == null) _definitionError('the polymer library');
 
@@ skipping 13 matching lines @@
         initMethodElement = unit.topLevelVariables.firstWhere(
             (t) => t.displayName == 'initMethod');
         break;
       }
     }
     var customTagConstructor =
         _lookupType(polymerLib, 'CustomTag').constructors.first;
     var publishedElement = _lookupType(polymerLib, 'PublishedProperty');
     var observableElement = _lookupType(observeLib, 'ObservableProperty');
     var observePropertyElement = _lookupType(polymerLib, 'ObserveProperty');
+    var computedPropertyElement = _lookupType(polymerLib, 'ComputedProperty');
     var polymerClassElement = _lookupType(polymerLib, 'Polymer');
     var htmlElementElement = _lookupType(htmlLib, 'HtmlElement');
     var stringType = _lookupType(coreLib, 'String').type;
     if (initMethodElement == null) _definitionError('@initMethod');
 
     return new _ResolvedTypes.internal(htmlElementElement, stringType,
       polymerClassElement, customTagConstructor, publishedElement,
-      observableElement, observePropertyElement, initMethodElement);
+      observableElement, observePropertyElement, computedPropertyElement,
+      initMethodElement);
   }
 
   _ResolvedTypes.internal(this.htmlElementElement, this.stringType,
       this.polymerClassElement, this.customTagConstructor,
       this.publishedElement, this.observableElement,
-      this.observePropertyElement, this.initMethodElement);
+      this.observePropertyElement, this.computedPropertyElement,
+      this.initMethodElement);
 
   static _lookupType(LibraryElement lib, String typeName) {
     var result = lib.getType(typeName);
     if (result == null) _definitionError(typeName);
     return result;
   }
 
   static _definitionError(name) {
     throw new StateError("Internal error in polymer-builder: couldn't find "
         "definition of $name.");
@@ skipping 34 matching lines @@
   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));
     }
   }
 }