Use smoke in polymer and polymer_expressions.

pkg/polymer_expressions/lib/eval.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.
 
 library polymer_expressions.eval;
 
 import 'dart:async';
 import 'dart:collection';
 
-@MirrorsUsed(metaTargets: const [Reflectable, ObservableProperty],
-    override: 'polymer_expressions.eval')
-import 'dart:mirrors';
+@unused.MirrorsUsed(
+    metaTargets: const [Reflectable, ObservableProperty],
+    override: 'smoke.mirrors')
+import 'dart:mirrors' as unused;

[blois, 2014/02/20 17:29:25]

just show MirrorsUsed?

[Jennifer Messerly, 2014/02/20 21:15:41]

yeah, unused is sort of odd since it is actually used

[Siggi Cherem (dart-lang), 2014/02/21 03:55:13]

good idea. Done.

 
 import 'package:observe/observe.dart';
+import 'package:smoke/smoke.dart' as smoke;
 
 import 'async.dart';
 import 'expression.dart';
 import 'filter.dart';
 import 'visitor.dart';
-import 'src/mirrors.dart';
+
+_unused() => unused.MirrorSystem; // to prevent analyzer warnings

[blois, 2014/02/20 17:29:25]

Should this be removed as well?

[Siggi Cherem (dart-lang), 2014/02/21 03:55:13]

yeah, I fixed it elsewhere, but forgot to do so here. Thanks!

 
 final _BINARY_OPERATORS = {
   '+':  (a, b) => a + b,
   '-':  (a, b) => a - b,
   '*':  (a, b) => a * b,
   '/':  (a, b) => a / b,
   '==': (a, b) => a == b,
   '!=': (a, b) => a != b,
   '>':  (a, b) => a > b,
   '>=': (a, b) => a >= b,
   '<':  (a, b) => a < b,
   '<=': (a, b) => a <= b,
   '||': (a, b) => a || b,
   '&&': (a, b) => a && b,
   '|':  (a, f) {
     if (f is Transformer) return f.forward(a);
     if (f is Filter) return f(a);
-    throw new EvalException("Filters must be a one-argument function.");
+    // TODO(sigmund): uncomment the throw statement. Because of
+    // dartbug.com/13002 smoke gives us an f that is not comparable to Filter.
+    // throw new EvalException("Filters must be a one-argument function.");
+    return f(a);

[Siggi Cherem (dart-lang), 2014/02/21 03:55:13]

BTW - I removed this workaround and instead hid this inside smoke.mirrors (see
_MethodClosure.call in this CL)

   }
 };
 
 final _UNARY_OPERATORS = {
   '+': (a) => a,
   '-': (a) => -a,
   '!': (a) => !a,
 };
 
 final _BOOLEAN_OPERATORS = ['!', '||', '&&'];
@@ skipping 86 matching lines @@
       throw new EvalException("filter must implement Transformer: $filterExpr");
     }
     value = filter.reverse(value);
   }
   // make the assignment
   var o = eval(expression, scope);
   if (o == null) throw new EvalException("Can't assign to null: $expression");
   if (isIndex) {
     o[property] = value;
   } else {
-    reflect(o).setField(new Symbol(property), value);
+    smoke.write(o, smoke.nameToSymbol(property), value);
   }
 }
 
 /**
  * A mapping of names to objects. Scopes contain a set of named [variables] and
  * a single [model] object (which can be thought of as the "this" reference).
  * Names are currently looked up in [variables] first, then the [model].
  *
  * Scopes can be nested by giving them a [parent]. If a name in not found in a
  * Scope, it will look for it in it's parent.
  */
 class Scope {
   final Scope parent;
   final Object model;
   // TODO(justinfagnani): disallow adding/removing names
   final ObservableMap<String, Object> _variables;
-  InstanceMirror __modelMirror;
 
   Scope({this.model, Map<String, Object> variables, this.parent})
       : _variables = new ObservableMap.from(variables == null ? {} : variables);
 
-  InstanceMirror get _modelMirror {
-    if (__modelMirror != null) return __modelMirror;
-    __modelMirror = reflect(model);
-    return __modelMirror;
-  }
-
   Object operator[](String name) {
     if (name == 'this') {
       return model;
     } else if (_variables.containsKey(name)) {
       return _convert(_variables[name]);
-    } else if (model != null) {
-      var symbol = new Symbol(name);
-      var classMirror = _modelMirror.type;
-      var memberMirror = getMemberMirror(classMirror, symbol);
-      // TODO(jmesserly): simplify once dartbug.com/13002 is fixed.
-      // This can just be "if memberMirror != null" and delete the Method class.
-      if (memberMirror is VariableMirror ||
-          (memberMirror is MethodMirror && memberMirror.isGetter)) {
-        return _convert(_modelMirror.getField(symbol).reflectee);
-      } else if (memberMirror is MethodMirror) {
-        return new Method(_modelMirror, symbol);
+    } else {
+      var symbol = smoke.nameToSymbol(name);
+      if (model != null && smoke.hasGetter(model.runtimeType, symbol)) {
+        return _convert(smoke.read(model, symbol));
       }
     }
     if (parent != null) {
       return _convert(parent[name]);
     } else {
       throw new EvalException("variable '$name' not found");
     }
   }
 
   Object ownerOf(String name) {
     if (name == 'this') {
       // we could return the Scope if it were Observable, but since assigning
       // a model to a template destroys and recreates the instance, it doesn't
       // seem neccessary
       return null;
     } else if (_variables.containsKey(name)) {
       return _variables;
-    } else {
-      var symbol = new Symbol(name);
-      var classMirror = _modelMirror.type;
-      if (getMemberMirror(classMirror, symbol) != null) {
-        return model;
-      }
+    } else if (smoke.hasGetter(model.runtimeType, smoke.nameToSymbol(name))) {
+      return model;
     }
     if (parent != null) {
       return parent.ownerOf(name);
     }
   }
 
   bool contains(String name) {
-    if (_variables.containsKey(name)) {
+    if (_variables.containsKey(name) ||
+        smoke.hasGetter(model.runtimeType, smoke.nameToSymbol(name))) {
       return true;
-    } else {
-      var symbol = new Symbol(name);
-      var classMirror = _modelMirror.type;
-      if (getMemberMirror(classMirror, symbol) != null) {
-        return true;
-      }
     }
     if (parent != null) {
       return parent.contains(name);
     }
     return false;
   }
 }
 
 Object _convert(v) {
   if (v is Stream) return new StreamBinding(v);
@@ skipping 236 matching lines @@
 
   IdentifierObserver(Identifier value) : super(value);
 
   String get value => _expr.value;
 
   _updateSelf(Scope scope) {
     _value = scope[value];
 
     var owner = scope.ownerOf(value);
     if (owner is Observable) {
-      var symbol = new Symbol(value);
+      var symbol = smoke.nameToSymbol(value);
       _subscription = (owner as Observable).changes.listen((changes) {
         if (changes.any(
             (c) => c is PropertyChangeRecord && c.name == symbol)) {
           _invalidate(scope);
         }
       });
     }
   }
 
   accept(Visitor v) => v.visitIdentifier(this);
@@ skipping 89 matching lines @@
   GetterObserver(Expression expr, this.receiver) : super(expr);
 
   String get name => _expr.name;
 
   _updateSelf(Scope scope) {
     var receiverValue = receiver._value;
     if (receiverValue == null) {
       _value = null;
       return;
     }
-    var mirror = reflect(receiverValue);
-    var symbol = new Symbol(_expr.name);
-    _value = mirror.getField(symbol).reflectee;
+    var symbol = smoke.nameToSymbol(_expr.name);
+    _value = smoke.read(receiverValue, symbol);
 
     if (receiverValue is Observable) {
       _subscription = (receiverValue as Observable).changes.listen((changes) {
         if (changes.any((c) => c is PropertyChangeRecord && c.name == symbol)) {
           _invalidate(scope);
         }
       });
     }
   }
 
@@ skipping 44 matching lines @@
     if (receiverValue == null) {
       _value = null;
       return;
     }
     if (_expr.method == null) {
       // top-level function or model method
       // TODO(justin): listen to model changes to see if the method has
       // changed? listen to the scope to see if the top-level method has
       // changed?
       assert(receiverValue is Function);
-      _value = call(receiverValue, args);
+      _value = _convert(Function.apply(receiverValue, args));
     } else {
-      var mirror = reflect(receiverValue);
-      var symbol = new Symbol(_expr.method);
-      _value = mirror.invoke(symbol, args, null).reflectee;
+      var symbol = smoke.nameToSymbol(_expr.method);
+      _value = smoke.invoke(receiverValue, symbol, args);
 
       if (receiverValue is Observable) {
         _subscription = (receiverValue as Observable).changes.listen(
             (List<ChangeRecord> changes) {
               if (changes.any(
                   (c) => c is PropertyChangeRecord && c.name == symbol)) {
                 _invalidate(scope);
               }
             });
       }
@@ skipping 24 matching lines @@
 
     // TODO: make Comprehension observable and update it
     _value = new Comprehension(identifier.value, iterable);
   }
 
   accept(Visitor v) => v.visitInExpression(this);
 }
 
 _toBool(v) => (v == null) ? false : v;
 
-/** Call a [Function] or a [Method]. */
-// TODO(jmesserly): remove this once dartbug.com/13002 is fixed.
-// Just inline `_convert(Function.apply(...))` to the call site.
-Object call(Object receiver, List args) {
-  var result;
-  if (receiver is Method) {
-    Method method = receiver;
-    result = method.mirror.invoke(method.symbol, args, null).reflectee;
-  } else {
-    result = Function.apply(receiver, args, null);
-  }
-  return _convert(result);
-}
-
 /**
  * A comprehension declaration ("a in b"). [identifier] is the loop variable
  * that's added to the scope during iteration. [iterable] is the set of
  * objects to iterate over.
  */
 class Comprehension {
   final String identifier;
   final Iterable iterable;
 
   Comprehension(this.identifier, Iterable iterable)
       : iterable = (iterable != null) ? iterable : const [];
 }
 
-/** A method on a model object in a [Scope]. */
-class Method {
-  final InstanceMirror mirror;
-  final Symbol symbol;
-
-  Method(this.mirror, this.symbol);
-
-  /**
-   * Support for calling single argument methods like [Filter]s.
-   * This does not work for calls that need to pass more than one argument.
-   */
-  call(arg0) => mirror.invoke(symbol, [arg0], null).reflectee;
-}
-
 class EvalException implements Exception {
   final String message;
   EvalException(this.message);
   String toString() => "EvalException: $message";
 }