Use smoke in polymer and polymer_expressions.

pkg/polymer/lib/src/instance.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;
 
 /**
  * Use this annotation to publish a field as an attribute. For example:
  *
  *     class MyPlaybackElement extends PolymerElement {
@@ skipping 345 matching lines @@
     attributes.forEach(attributeToProperty);
   }
 
   /**
    * If attribute [name] is mapped to a property, deserialize
    * [value] into that property.
    */
   void attributeToProperty(String name, String value) {
     // try to match this attribute to a property (attributes are
     // all lower-case, so this is case-insensitive search)
-    var property = propertyForAttribute(name);
-    if (property == null) return;
+    var decl = propertyForAttribute(name);
+    if (decl == null) return;
 
     // filter out 'mustached' values, these are to be
     // replaced with bound-data and are not yet values
     // themselves.
     if (value == null || value.contains(Polymer.bindPattern)) return;
 
-    // get original value
-    final self = reflect(this);
-    final currentValue = self.getField(property.simpleName).reflectee;
+    final currentValue = smoke.read(this, decl.name);
 
     // deserialize Boolean or Number values from attribute
-    final newValue = deserializeValue(value, currentValue,
-        _inferPropertyType(currentValue, property));
+    var type = decl.type;
+    if ((type == Object || type == dynamic) && currentValue != null) {
+      // Attempt to infer field type from the current value.
+      type = currentValue.runtimeType;
+    }
+    final newValue = deserializeValue(value, currentValue, type);
 
     // only act if the value has changed
     if (!identical(newValue, currentValue)) {
       // install new value (has side-effects)
-      self.setField(property.simpleName, newValue);
+      smoke.write(this, decl.name, newValue);
     }
   }
 
   /** Return the published property matching name, or null. */
   // TODO(jmesserly): should we just return Symbol here?
-  DeclarationMirror propertyForAttribute(String name) {
+  smoke.Declaration propertyForAttribute(String name) {
     final publishLC = _declaration._publishLC;
     if (publishLC == null) return null;
     //console.log('propertyForAttribute:', name, 'matches', match);
     return publishLC[name];
   }
 
   /**
    * Convert representation of [value] based on [type] and [currentValue].
    */
-  // TODO(jmesserly): this should probably take a ClassMirror instead of
-  // TypeMirror, but it is currently impossible to get from a TypeMirror to a
-  // ClassMirror.
-  Object deserializeValue(String value, Object currentValue, TypeMirror type) =>
+  Object deserializeValue(String value, Object currentValue, Type type) =>
       deserialize.deserializeValue(value, currentValue, type);
 
   String serializeValue(Object value) {
     if (value == null) return null;
 
     if (value is bool) {
       return _toBoolean(value) ? '' : null;
     } else if (value is String || value is num) {
       return '$value';
     }
@@ skipping 36 matching lines @@
   DocumentFragment instanceTemplate(Element template) =>
       templateBind(template).createInstance(this, syntax);
 
   // TODO(jmesserly): Polymer does not seem to implement the oneTime flag
   // correctly. File bug.
   Bindable bind(String name, Bindable bindable, {bool oneTime: false}) {
     // note: binding is a prepare signal. This allows us to be sure that any
     // property changes that occur as a result of binding will be observed.
     if (!_elementPrepared) prepareElement();
 
-    var property = propertyForAttribute(name);
-    if (property == null) {
+    var decl = propertyForAttribute(name);
+    if (decl == null) {
       // Cannot call super.bind because template_binding is its own package
       return nodeBindFallback(this).bind(name, bindable, oneTime: oneTime);
     } else {
       // clean out the closets
       unbind(name);
       // use n-way Polymer binding
-      var observer = bindProperty(property.simpleName, bindable);
+      var observer = bindProperty(decl.name, bindable);
 
       // reflect bound property to attribute when binding
       // to ensure binding is not left on attribute if property
       // does not update due to not changing.
       // Dart note: we include this patch:
       // https://github.com/Polymer/polymer/pull/319
 
       // TODO(jmesserly): polymer has the path_ in their observer object, should
       // we use that too instead of allocating it here?
-      reflectPropertyToAttribute(new PropertyPath([property.simpleName]));
+      reflectPropertyToAttribute(new PropertyPath([decl.name]));
       return bindings[name] = observer;
     }
   }
 
   Map<String, Bindable> get bindings => nodeBindFallback(this).bindings;
   TemplateInstance get templateInstance =>
       nodeBindFallback(this).templateInstance;
 
   void unbind(String name) => nodeBindFallback(this).unbind(name);
 
@@ skipping 101 matching lines @@
       var methods = observe[path];
       if (methods == null) return;
 
       for (var method in methods) {
         if (!called.add(method)) continue; // don't invoke more than once.
 
         final newValue = newValues[i];
         // observes the value if it is an array
         observeArrayValue(path, newValue, oldValue);
         // Dart note: JS passes "arguments", so we pass along our args.
-        invokeMethod(method, [oldValue, newValue, newValues, oldValues, paths]);
+        smoke.invoke(this, method,
+            [oldValue, newValue, newValues, oldValues, paths], adjust: true);
       }
     });
   }
 
   void observeArrayValue(PropertyPath name, Object value, Object old) {
     final observe = _declaration._observe;
     if (observe == null) return;
 
     // we only care if there are registered side-effects
     var callbacks = observe[name];
     if (callbacks == null) return;
 
     // if we are observing the previous value, stop
     if (old is ObservableList) {
       if (_observeLog.isLoggable(Level.FINE)) {
         _observeLog.fine('[$localName] observeArrayValue: unregister observer '
             '$name');
       }
 
       unregisterObserver('${name}__array');
     }
     // if the new value is an array, being observing it
     if (value is ObservableList) {
       if (_observeLog.isLoggable(Level.FINE)) {
         _observeLog.fine('[$localName] observeArrayValue: register observer '
             '$name');
       }
       var sub = value.listChanges.listen((changes) {
         for (var callback in callbacks) {
-          invokeMethod(callback, [old]);
+          smoke.invoke(this, callback, [old], adjust: true);
         }
       });
       registerObserver('${name}__array', sub);
     }
   }
 
   bool unbindProperty(String name) => unregisterObserver(name);
 
   void unbindAllProperties() {
     if (_propertyObserver != null) {
@@ skipping 112 matching lines @@
 
   /**
    * Calls [methodOrCallback] with [args] if it is a closure, otherwise, treat
    * it as a method name in [object], and invoke it.
    */
   void dispatchMethod(object, callbackOrMethod, List args) {
     bool log = _eventsLog.isLoggable(Level.FINE);
     if (log) _eventsLog.fine('>>> [$localName]: dispatch $callbackOrMethod');
 
     if (callbackOrMethod is Function) {
+      int maxArgs = smoke.maxArgs(callbackOrMethod);
+      if (maxArgs == -1) {
+        _eventsLog.warning(
+            'invalid callback: expected callback of 0, 1, 2, or 3 arguments');
+      }
+      args.length = maxArgs;
       Function.apply(callbackOrMethod, args);
     } else if (callbackOrMethod is String) {
-      _invokeMethod(object, new Symbol(callbackOrMethod), args);
+      smoke.invoke(object, smoke.nameToSymbol(callbackOrMethod), args,
+          adjust: true);
     } else {
       _eventsLog.warning('invalid callback');
     }
 
     if (log) _eventsLog.info('<<< [$localName]: dispatch $callbackOrMethod');
   }
 
   /**
    * Bind events via attributes of the form `on-eventName`. This method can be
    * use to hooks into the model syntax and adds event listeners as needed. By
@@ skipping 15 matching lines @@
       // TODO(sigmund): polymer.js dropped event translations. reconcile?
       var translated = _eventTranslations[eventName];
       eventName = translated != null ? translated : eventName;
 
       return new _EventBindable(node, eventName, model, path);
     };
   }
 
   /** Call [methodName] method on this object with [args]. */
   invokeMethod(Symbol methodName, List args) =>
-      _invokeMethod(this, methodName, args);
-
-  /** Call [methodName] method on [receiver] with [args]. */
-  static _invokeMethod(receiver, Symbol methodName, List args) {
-    // TODO(jmesserly): use function type tests instead of mirrors for dispatch.
-    var receiverMirror = reflect(receiver);
-    var method = _findMethod(receiverMirror.type, methodName);
-    if (method != null) {
-      // This will either truncate the argument list or extend it with extra
-      // null arguments, so it will match the signature.
-      // TODO(sigmund): consider accepting optional arguments when we can tell
-      // them appart from named arguments (see http://dartbug.com/11334)
-      args.length = method.parameters.where((p) => !p.isOptional).length;
-    }
-    return receiverMirror.invoke(methodName, args).reflectee;
-  }
-
-  static MethodMirror _findMethod(ClassMirror type, Symbol name) {
-    do {
-      var member = type.declarations[name];
-      if (member is MethodMirror) return member;
-      type = type.superclass;
-    } while (type != null);
-    return null; // unreachable
-  }
+      smoke.invoke(this, methodName, args, adjust: true);
 
   /**
    * Invokes a function asynchronously.
    * This will call `Platform.flush()` and then return a `new Timer`
    * with the provided [method] and [timeout].
    *
    * If you would prefer to run the callback using
    * [window.requestAnimationFrame], see the [async] method.
    */
   // Dart note: "async" is split into 2 methods so it can have a sensible type
@@ skipping 158 matching lines @@
   }
 }
 
 // Dart note: Polymer addresses n-way bindings by metaprogramming: redefine
 // the property on the PolymerElement instance to always get its value from the
 // model@path. We can't replicate this in Dart so we do the next best thing:
 // listen to changes on both sides and update the values.
 // TODO(jmesserly): our approach leads to race conditions in the bindings.
 // See http://code.google.com/p/dart/issues/detail?id=13567
 class _PolymerBinding extends Bindable {
-  final InstanceMirror _target;
+  final Polymer _target;
   final Symbol _property;
   final Bindable _bindable;
   StreamSubscription _sub;
   Object _lastValue;
 
-  _PolymerBinding(Polymer node, this._property, this._bindable)
-      : _target = reflect(node) {
-
-    _sub = node.changes.listen(_propertyValueChanged);
+  _PolymerBinding(this._target, this._property, this._bindable) {
+    _sub = _target.changes.listen(_propertyValueChanged);
     _updateNode(open(_updateNode));
   }
 
   void _updateNode(newValue) {
     _lastValue = newValue;
-    _target.setField(_property, newValue);
+    smoke.write(_target, _property, newValue);
   }
 
   void _propertyValueChanged(List<ChangeRecord> records) {
     for (var record in records) {
       if (record is PropertyChangeRecord && record.name == _property) {
-        final newValue = _target.getField(_property).reflectee;
+        final newValue = smoke.read(_target, _property);
         if (!identical(_lastValue, newValue)) {
           this.value = newValue;
         }
         return;
       }
     }
   }
 
   open(callback(value)) => _bindable.open(callback);
   get value => _bindable.value;
   set value(newValue) => _bindable.value = newValue;
 
   void close() {
     if (_sub != null) {
       _sub.cancel();
       _sub = null;
     }
     _bindable.close();
   }
 }
 
 bool _toBoolean(value) => null != value && false != value;
 
-TypeMirror _propertyType(DeclarationMirror property) =>
-    property is VariableMirror ? property.type
-        : (property as MethodMirror).returnType;
-
-TypeMirror _inferPropertyType(Object value, DeclarationMirror property) {
-  var type = _propertyType(property);
-  if (type.qualifiedName == #dart.core.Object ||
-      type.qualifiedName == #dynamic) {
-    // Attempt to infer field type from the default value.
-    if (value != null) {
-      Type t = _getCoreType(value);
-      if (t != null) return reflectClass(t);
-      return reflect(value).type;
-    }
-  }
-  return type;
-}
-
-Type _getCoreType(Object value) {
-  if (value == null) return Null;
-  if (value is int) return int;
-  // Avoid "is double" to prevent warning that it won't work in dart2js.
-  if (value is num) return double;
-  if (value is bool) return bool;
-  if (value is String) return String;
-  if (value is DateTime) return DateTime;
-  return null;
-}
-
 final Logger _observeLog = new Logger('polymer.observe');
 final Logger _eventsLog = new Logger('polymer.events');
 final Logger _unbindLog = new Logger('polymer.unbind');
 final Logger _bindLog = new Logger('polymer.bind');
 
 final Expando _shadowHost = new Expando<Polymer>();
 
 final Expando _eventHandledTable = new Expando<Set<Node>>();
 
 /**
@@ skipping 60 matching lines @@
   close() {
     if (_sub != null) {
       if (_eventsLog.isLoggable(Level.FINE)) {
         _eventsLog.fine(
             'event.remove: [$_node].$_eventName => [$_model].$_path())');
       }
      _sub.cancel();
       _sub = null;
     }
   }
-}
+}