Fix tests in bots (handle 'is' as an invalid binary operator)

pkg/compiler/lib/src/compile_time_constants.dart

 // Copyright (c) 2012, 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 dart2js.compile_time_constant_evaluator;
 
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
@@ skipping 574 matching lines @@
       AstConstant left = evaluate(send.receiver);
       AstConstant right = evaluate(send.argumentsNode.nodes.head);
       if (left == null || right == null) {
         return null;
       }
       ConstantValue leftValue = left.value;
       ConstantValue rightValue = right.value;
       Operator node = send.selector.asOperator();
       BinaryOperator operator = BinaryOperator.parse(node.source);
       ConstantValue folded = null;
-      switch (operator.kind) {
-        case BinaryOperatorKind.EQ:
-          if (leftValue.isPrimitive && rightValue.isPrimitive) {
-            folded = constantSystem.equal.fold(leftValue, rightValue);
-          }
-          break;
-        case BinaryOperatorKind.NOT_EQ:
-          if (leftValue.isPrimitive && rightValue.isPrimitive) {
-            BoolConstantValue areEquals =
-                constantSystem.equal.fold(leftValue, rightValue);
-            if (areEquals == null) {
-              folded = null;
-            } else {
-              folded = areEquals.negate();
+      // operator is null when `node=="is"`
+      if (operator != null) {
+        switch (operator.kind) {

[Siggi Cherem (dart-lang), 2015/04/17 19:19:23]

FYI - no changes below besides indentation

[Johnni Winther, 2015/04/17 20:31:15]

Thanks. I think `node=="as"` also ends here.

+          case BinaryOperatorKind.EQ:
+            if (leftValue.isPrimitive && rightValue.isPrimitive) {
+              folded = constantSystem.equal.fold(leftValue, rightValue);
             }
-          }
-          break;
-        default:
-          BinaryOperation operation = constantSystem.lookupBinary(operator);
-          if (operation != null) {
-            folded = operation.fold(leftValue, rightValue);
-          }
+            break;
+          case BinaryOperatorKind.NOT_EQ:
+            if (leftValue.isPrimitive && rightValue.isPrimitive) {
+              BoolConstantValue areEquals =
+                  constantSystem.equal.fold(leftValue, rightValue);
+              if (areEquals == null) {
+                folded = null;
+              } else {
+                folded = areEquals.negate();
+              }
+            }
+            break;
+          default:
+            BinaryOperation operation = constantSystem.lookupBinary(operator);
+            if (operation != null) {
+              folded = operation.fold(leftValue, rightValue);
+            }
+        }
       }
       if (folded == null) {
         return signalNotCompileTimeConstant(send);
       }
       return new AstConstant(
           context, send, new BinaryConstantExpression(folded,
               left.expression, operator, right.expression));
     }
     return signalNotCompileTimeConstant(send);
   }
@@ skipping 508 matching lines @@
   ConstantValue get value => expression.value;
 
   String toString() => expression.toString();
 }
 
 /// A synthetic constant used to recover from errors.
 class ErroneousAstConstant extends AstConstant {
   ErroneousAstConstant(Element element, Node node)
       : super(element, node, new ErroneousConstantExpression());
 }