Eliminating some dart2js warnings from 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';
 import 'dart:mirrors';
 
@@ skipping 56 matching lines @@
 void assign(Expression expr, Object value, Scope scope) {
 
   notAssignable() =>
       throw new EvalException("Expression is not assignable: $expr");
 
   Expression expression;
   var property;
   bool isIndex = false;
   var filters = <Expression>[]; // reversed order for assignment
 
-  while (expr is BinaryOperator && expr.operator == '|') {
-    filters.add(expr.right);
-    expr = expr.left;
+  while (expr is BinaryOperator && (expr as BinaryOperator).operator == '|') {
+    filters.add((expr as BinaryOperator).right);

[justinfagnani, 2013/08/29 18:31:49]

I'd prefer not use casts when they can be avoided. How about:

while (expr is BinaryOperator) {
  BinaryOperator op = expr;
  if (op.operator == '|') continue;
  filters.add(op.right);
  expr = op.left;
}

[blois, 2013/08/29 19:43:22]

Done.

+    expr = (expr as BinaryOperator).left;
   }
 
   if (expr is Identifier) {
     expression = empty();
-    property = expr.value;
+    property = (expr as Identifier).value;

[justinfagnani, 2013/08/29 18:31:49]

Identifier ident = expr;
property = ident.value;

[blois, 2013/08/29 19:43:22]

Done.

   } else if (expr is Invoke) {
-    expression = expr.receiver;
-    if (expr.method == '[]') {
-      if (expr.arguments[0] is! Literal) notAssignable();
-      Literal l = expr.arguments[0];
+    Invoke invoke = expr;
+    expression = invoke.receiver;
+    if (invoke.method == '[]') {
+      if (invoke.arguments[0] is! Literal) notAssignable();
+      Literal l = invoke.arguments[0];
       property = l.value;
       isIndex = true;
-    } else if (expr.method != null) {
-      if (expr.arguments != null) notAssignable();
-      property = expr.method;
+    } else if (invoke.method != null) {
+      if (invoke.arguments != null) notAssignable();
+      property = invoke.method;
     } else {
       notAssignable();
     }
   } else {
     notAssignable();
   }
 
   // transform the values backwards through the filters
   for (var filterExpr in filters) {
     var filter = eval(filterExpr, scope);
@@ skipping 306 matching lines @@
     }
   }
 
   accept(Visitor v) => v.visitIdentifier(this);
 }
 
 class ParenthesizedObserver extends ExpressionObserver<ParenthesizedExpression>
     implements ParenthesizedExpression {
   final ExpressionObserver child;
 
-  ParenthesizedObserver(ExpressionObserver expr, this.child) : super(expr);
+  ParenthesizedObserver(ParenthesizedExpression expr, this.child) : super(expr);
 
 
   _updateSelf(Scope scope) {
     _value = child._value;
   }
 
   accept(Visitor v) => v.visitParenthesizedExpression(this);
 }
 
 class UnaryObserver extends ExpressionObserver<UnaryOperator>
@@ skipping 172 matching lines @@
   Method(this.mirror, this.symbol);
 
   dynamic call(List args) => mirror.invoke(symbol, args, null).reflectee;
 }
 
 class EvalException implements Exception {
   final String message;
   EvalException(this.message);
   String toString() => "EvalException: $message";
 }