Use smoke in polymer and polymer_expressions.

pkg/polymer/lib/src/declaration.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.
 
 part of polymer;
 
 /**
  * **Warning**: this class is experiental and subject to change.
  *
  * The implementation for the `polymer-element` element.
@@ skipping 29 matching lines @@
   // each level of the __proto__ like JS does.
   PolymerDeclaration _super;
   PolymerDeclaration get superDeclaration => _super;
 
   String _extendsName;
 
   String _name;
   String get name => _name;
 
   /**
-   * Map of publish properties. Can be a [VariableMirror] or a [MethodMirror]
-   * representing a getter. If it is a getter, there will also be a setter.
+   * Map of publish properties. Can be a field or a property getter, but if this
+   * map contains a getter, is because it also has a corresponding setter.
    *
-   * Note: technically these are always single properties, so we could use
-   * a Symbol instead of a PropertyPath. However there are lookups between
-   * this map and [_observe] so it is easier to just track paths.
+   * Note: technically these are always single properties, so we could use a
+   * Symbol instead of a PropertyPath. However there are lookups between this
+   * map and [_observe] so it is easier to just track paths.
    */
-  Map<PropertyPath, DeclarationMirror> _publish;
+  Map<PropertyPath, smoke.Declaration> _publish;
 
   /** The names of published properties for this polymer-element. */
   Iterable<String> get publishedProperties =>
       _publish != null ? _publish.keys.map((p) => '$p') : const [];
 
   /** Same as [_publish] but with lower case names. */
-  Map<String, DeclarationMirror> _publishLC;
+  Map<String, smoke.Declaration> _publishLC;
 
   Map<PropertyPath, List<Symbol>> _observe;
 
   Map<String, Object> _instanceAttributes;
 
   List<Element> _sheets;
   List<Element> get sheets => _sheets;
 
   List<Element> _styles;
   List<Element> get styles => _styles;
@@ skipping 107 matching lines @@
    * prototype, which simplifies this method.
    */
   void buildType(String name, String extendee) {
     // get our custom type
     _type = _getRegisteredType(name);
 
     // get basal prototype
     _supertype = _getRegisteredType(extendee);
     if (_supertype != null) _super = _getDeclaration(extendee);
 
-    var cls = reflectClass(_type);
+    // transcribe `attributes` declarations onto own prototype's `publish`
+    publishAttributes(_super);
 
-    // transcribe `attributes` declarations onto own prototype's `publish`
-    publishAttributes(cls, _super);
+    publishProperties();
 
-    publishProperties(_type);
-
-    inferObservers(cls);
+    inferObservers();
 
     // desugar compound observer syntax, e.g. @ObserveProperty('a b c')
-    explodeObservers(cls);
+    explodeObservers();
 
     // Skip the rest in Dart:
     // chain various meta-data objects to inherited versions
     // chain custom api to inherited
     // build side-chained lists to optimize iterations
     // inherit publishing meta-data
     // x-platform fixup
   }
 
   /** Implement various declarative features. */
@@ skipping 10 matching lines @@
     // TODO(sorvell): install a helper method this.resolvePath to aid in
     // setting resource paths. e.g.
     // this.$.image.src = this.resolvePath('images/foo.png')
     // Potentially remove when spec bug is addressed.
     // https://www.w3.org/Bugs/Public/show_bug.cgi?id=21407
     // TODO(jmesserly): resolvePath not ported, see first comment in this class.
 
     // under ShadowDOMPolyfill, transforms to approximate missing CSS features
     _shimShadowDomStyling(templateContent, name, extendee);
 
-    var cls = reflectClass(type);
     // TODO(jmesserly): this feels unnatrual in Dart. Since we have convenient
     // lazy static initialization, can we get by without it?
-    var registered = cls.declarations[#registerCallback];
-    if (registered != null &&
-        registered is MethodMirror &&
-        registered.isStatic &&
-        registered.isRegularMethod) {
-      cls.invoke(#registerCallback, [this]);
+    if (smoke.hasStaticMethod(type, #registerCallback)) {
+      smoke.invoke(type, #registerCallback, [this]);
     }
   }
 
   // TODO(sorvell): remove when spec addressed:
   // https://www.w3.org/Bugs/Public/show_bug.cgi?id=22460
   // make <shadow></shadow> be <shadow><content></content></shadow>
   void adjustShadowElement() {
     // TODO(sorvell): avoid under SD polyfill until this bug is addressed:
     // https://github.com/Polymer/ShadowDOM/issues/297
     if (!_hasShadowDomPolyfill) {
       final content = templateContent;
       if (content == null) return;
 
       for (var s in content.querySelectorAll('shadow')) {
         if (s.nodes.isEmpty) s.append(new ContentElement());
       }
     }
   }
 
   void registerType(String name) {
     var baseTag;
     var decl = this;
     while (decl != null) {
       baseTag = decl.attributes['extends'];
       decl = decl.superDeclaration;
     }
     document.register(name, type, extendsTag: baseTag);
   }
 
-  void publishAttributes(ClassMirror cls, PolymerDeclaration superDecl) {
+  void publishAttributes(PolymerDeclaration superDecl) {
     // get properties to publish
     if (superDecl != null && superDecl._publish != null) {
       // Dart note: even though we walk the type hierarchy in
       // _getPublishedProperties, this will additionally include any names
       // published via the `attributes` attribute.
       _publish = new Map.from(superDecl._publish);
     }
 
-    _publish = _getPublishedProperties(cls, _publish);
+    _publish = _getPublishedProperties(_type, _publish);
 
     // merge names from 'attributes' attribute
     var attrs = attributes['attributes'];
     if (attrs != null) {
       // names='a b c' or names='a,b,c'
       // record each name for publishing
       for (var attr in attrs.split(_ATTRIBUTES_REGEX)) {
         // remove excess ws
         attr = attr.trim();
 
         // do not override explicit entries
         if (attr == '') continue;
 
         var property = new Symbol(attr);
         var path = new PropertyPath([property]);
         if (_publish != null && _publish.containsKey(path)) {
           continue;
         }
 
-        var mirror = _getProperty(cls, property);
-        if (mirror == null) {
+        var decl = smoke.getDeclaration(_type, property);
+        if (decl == null || !decl.isProperty || decl.isFinal) {
           window.console.warn('property for attribute $attr of polymer-element '
               'name=$name not found.');
           continue;
         }
         if (_publish == null) _publish = {};
-        _publish[path] = mirror;
+        _publish[path] = decl;
       }
     }
 
     // NOTE: the following is not possible in Dart; fields must be declared.
     // install 'attributes' as properties on the prototype,
     // but don't override
   }
 
   void accumulateInstanceAttributes() {
     // inherit instance attributes
@@ skipping 135 matching lines @@
 
     return new StyleElement()
         ..text = cssText
         ..attributes[_STYLE_SCOPE_ATTRIBUTE] = '$name-$scopeDescriptor';
   }
 
   /**
    * Fetch a list of all *Changed methods so we can observe the associated
    * properties.
    */
-  void inferObservers(ClassMirror cls) {
-    if (cls == _htmlElementType) return;
-    inferObservers(cls.superclass);
-    for (var method in cls.declarations.values) {
-      if (method is! MethodMirror || method.isStatic
-          || !method.isRegularMethod) continue;
-
-      String name = MirrorSystem.getName(method.simpleName);
+  void inferObservers() {
+    var options = const smoke.QueryOptions(includeProperties: false,
+        includeMethods: true, includeInherited: true);
+    for (var decl in smoke.query(_type, options)) {
+      String name = smoke.symbolToName(decl.name);
       if (name.endsWith(_OBSERVE_SUFFIX) && name != 'attributeChanged') {
         // TODO(jmesserly): now that we have a better system, should we
         // deprecate *Changed methods?
         if (_observe == null) _observe = new HashMap();
         name = name.substring(0, name.length - 7);
-        _observe[new PropertyPath(name)] = [method.simpleName];
+        _observe[new PropertyPath(name)] = [decl.name];
       }
     }
   }
 
   /**
    * Fetch a list of all methods annotated with [ObserveProperty] so we can
    * observe the associated properties.
    */
-  void explodeObservers(ClassMirror cls) {
-    if (cls == _htmlElementType) return;
-
-    explodeObservers(cls.superclass);
-    for (var method in cls.declarations.values) {
-      if (method is! MethodMirror || method.isStatic
-          || !method.isRegularMethod) continue;
-
-      for (var meta in method.metadata) {
-        if (meta.reflectee is! ObserveProperty) continue;
-
+  void explodeObservers() {
+    var options = const smoke.QueryOptions(includeProperties: false,
+        includeMethods: true, includeInherited: true,
+        withAnnotations: const [ObserveProperty]);
+    for (var decl in smoke.query(_type, options)) {
+      for (var meta in decl.annotations) {
+        if (meta is! ObserveProperty) continue;
         if (_observe == null) _observe = new HashMap();
-
-        for (String name in meta.reflectee.names) {
-          _observe.putIfAbsent(new PropertyPath(name), () => [])
-              .add(method.simpleName);
+        for (String name in meta.names) {
+          _observe.putIfAbsent(new PropertyPath(name), () => []).add(decl.name);
         }
       }
     }
   }
 
-  void publishProperties(Type type) {
+  void publishProperties() {
     // Dart note: _publish was already populated by publishAttributes
     if (_publish != null) _publishLC = _lowerCaseMap(_publish);
   }
 
   Map<String, dynamic> _lowerCaseMap(Map<PropertyPath, dynamic> properties) {
     final map = new Map<String, dynamic>();
     properties.forEach((PropertyPath path, value) {
       map['$path'.toLowerCase()] = value;
     });
     return map;
@@ skipping 24 matching lines @@
     }
   }
 }
 
 /// track document.register'ed tag names and their declarations
 final Map _declarations = new Map<String, PolymerDeclaration>();
 
 bool _isRegistered(String name) => _declarations.containsKey(name);
 PolymerDeclaration _getDeclaration(String name) => _declarations[name];
 
-final _objectType = reflectClass(Object);
-final _htmlElementType = reflectClass(HtmlElement);
-
-Map _getPublishedProperties(ClassMirror cls, Map props) {
-  if (cls == _htmlElementType) return props;
-  props = _getPublishedProperties(cls.superclass, props);
-  for (var member in cls.declarations.values) {
-    if (member.isStatic || member.isPrivate) continue;
-
-    if (member is VariableMirror && !member.isFinal
-        || member is MethodMirror && member.isGetter) {
-
-      for (var meta in member.metadata) {
-        if (meta.reflectee is PublishedProperty) {
-          // Note: we delay the setter check until we find @published because
-          // it's a tad expensive.
-          if (member is! MethodMirror || _hasSetter(cls, member)) {
-            if (props == null) props = {};
-            props[new PropertyPath([member.simpleName])] = member;
-          }
-          break;
-        }
-      }
-    }
+Map<PropertyPath, smoke.Declaration> _getPublishedProperties(
+    Type type, Map<PropertyPath, smoke.Declaration> props) {
+  var options = const smoke.QueryOptions(includeInherited: true,
+      withAnnotations: const [PublishedProperty]);
+  for (var decl in smoke.query(type, options)) {
+    if (decl.isFinal) continue;
+    if (props == null) props = {};
+    props[new PropertyPath([decl.name])] = decl;
   }
-
   return props;
 }
 
-DeclarationMirror _getProperty(ClassMirror cls, Symbol property) {
-  do {
-    var mirror = cls.declarations[property];
-    if (mirror is MethodMirror && mirror.isGetter && _hasSetter(cls, mirror)
-        || mirror is VariableMirror) {
-      return mirror;
-    }
-    cls = cls.superclass;
-
-    // It's generally a good idea to stop at Object, since we know it doesn't
-    // have what we want.
-    // TODO(jmesserly): This is also a workaround for what appears to be a V8
-    // bug introduced between Chrome 31 and 32. After 32
-    // JsClassMirror.declarations on Object calls
-    // JsClassMirror.typeVariables, which tries to get the _jsConstructor's
-    // .prototype["<>"]. This ends up getting the "" property instead, maybe
-    // because "<>" doesn't exist, and gets ";" which then blows up because
-    // the code later on expects a List of ints.
-  } while (cls != _objectType);
-  return null;
-}
-
-bool _hasSetter(ClassMirror cls, MethodMirror getter) {
-  var setterName = new Symbol('${MirrorSystem.getName(getter.simpleName)}=');
-  var mirror = cls.declarations[setterName];
-  return mirror is MethodMirror && mirror.isSetter;
-}
-
-
 /** Attribute prefix used for declarative event handlers. */
 const _EVENT_PREFIX = 'on-';
 
 /** Whether an attribute declares an event. */
 bool _hasEventPrefix(String attr) => attr.startsWith(_EVENT_PREFIX);
 
 String _removeEventPrefix(String name) => name.substring(_EVENT_PREFIX.length);
 
 /**
  * Using Polymer's platform/src/ShadowCSS.js passing the style tag's content.
@@ skipping 87 matching lines @@
 
 // Dart note: we need this function because we have additional renames JS does
 // not have. The JS renames are simply case differences, whereas we have ones
 // like doubleclick -> dblclick and stripping the webkit prefix.
 String _eventNameFromType(String eventType) {
   final result = _reverseEventTranslations[eventType];
   return result != null ? result : eventType;
 }
 
 final _ATTRIBUTES_REGEX = new RegExp(r'\s|,');