dart2js cps: Introduce some built-in operators in type propagation.

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.dart

 // Copyright (c) 2014, 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 tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../universe/universe.dart' show Selector;
 
+import '../cps_ir/builtin_operator.dart';
+export '../cps_ir/builtin_operator.dart';
+
 // The Tree language is the target of translation out of the CPS-based IR.
 //
 // The translation from CPS to Dart consists of several stages.  Among the
 // stages are translation to direct style, translation out of SSA, eliminating
 // unnecessary names, recognizing high-level control constructs.  Combining
 // these separate concerns is complicated and the constraints of the CPS-based
 // language do not permit a multi-stage translation.
 //
 // For that reason, CPS is translated to the direct-style language Tree.
 // Translation out of SSA, unnaming, and control-flow, as well as 'instruction
@@ skipping 313 matching lines @@
                {bool this.isTypeTest});
 
   accept(ExpressionVisitor visitor) => visitor.visitTypeOperator(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitTypeOperator(this, arg);
   }
 
   String get operator => isTypeTest ? 'is' : 'as';
 }
 
+/**
+ * Apply a built-in operator.
+ *
+ * It must be known that the arguments have the proper types.
+ * Null is not a valid argument to any of the built-in operators.
+ */
+class ApplyBuiltinOperator extends Expression {
+  BuiltinOperator operator;
+  List<Expression> arguments;
+
+  ApplyBuiltinOperator(this.operator, this.arguments);
+
+  accept(ExpressionVisitor visitor) {
+    return visitor.visitApplyBuiltinOperator(this);
+  }
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitApplyBuiltinOperator(this, arg);
+  }
+}
+
 /// A conditional expression.
 class Conditional extends Expression {
   Expression condition;
   Expression thenExpression;
   Expression elseExpression;
 
   Conditional(this.condition, this.thenExpression, this.elseExpression);
 
   accept(ExpressionVisitor visitor) => visitor.visitConditional(this);
   accept1(ExpressionVisitor1 visitor, arg) {
@@ skipping 14 matching lines @@
 
   String get operator => isAnd ? '&&' : '||';
 
   accept(ExpressionVisitor visitor) => visitor.visitLogicalOperator(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitLogicalOperator(this, arg);
   }
 }
 
 /// Logical negation.
+// TODO(asgerf): Replace this class with the IsFalsy builtin operator?
+//               Right now the tree builder compiles IsFalsy to Not.
 class Not extends Expression {
   Expression operand;
 
   Not(this.operand);
 
   accept(ExpressionVisitor visitor) => visitor.visitNot(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitNot(this, arg);
 }
 
 /// Currently unused.
@@ skipping 399 matching lines @@
   E visitGetField(GetField node);
   E visitSetField(SetField node);
   E visitGetStatic(GetStatic node);
   E visitSetStatic(SetStatic node);
   E visitCreateBox(CreateBox node);
   E visitCreateInstance(CreateInstance node);
   E visitReifyRuntimeType(ReifyRuntimeType node);
   E visitReadTypeVariable(ReadTypeVariable node);
   E visitTypeExpression(TypeExpression node);
   E visitCreateInvocationMirror(CreateInvocationMirror node);
+  E visitApplyBuiltinOperator(ApplyBuiltinOperator node);
 }
 
 abstract class ExpressionVisitor1<E, A> {
   E visitExpression(Expression node, A arg) => node.accept1(this, arg);
   E visitVariableUse(VariableUse node, A arg);
   E visitAssign(Assign node, A arg);
   E visitInvokeStatic(InvokeStatic node, A arg);
   E visitInvokeMethod(InvokeMethod node, A arg);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
@@ skipping 10 matching lines @@
   E visitGetField(GetField node, A arg);
   E visitSetField(SetField node, A arg);
   E visitGetStatic(GetStatic node, A arg);
   E visitSetStatic(SetStatic node, A arg);
   E visitCreateBox(CreateBox node, A arg);
   E visitCreateInstance(CreateInstance node, A arg);
   E visitReifyRuntimeType(ReifyRuntimeType node, A arg);
   E visitReadTypeVariable(ReadTypeVariable node, A arg);
   E visitTypeExpression(TypeExpression node, A arg);
   E visitCreateInvocationMirror(CreateInvocationMirror node, A arg);
+  E visitApplyBuiltinOperator(ApplyBuiltinOperator node, A arg);
 }
 
 abstract class StatementVisitor<S> {
   S visitStatement(Statement node) => node.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitReturn(Return node);
   S visitThrow(Throw node);
   S visitRethrow(Rethrow node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
@@ skipping 178 matching lines @@
 
   visitTypeExpression(TypeExpression node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitUnreachable(Unreachable node) {}
+
+  visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
+    node.arguments.forEach(visitExpression);
+  }
 }
 
 abstract class Transformer implements ExpressionVisitor<Expression>,
                                       StatementVisitor<Statement> {
    Expression visitExpression(Expression e) => e.accept(this);
    Statement visitStatement(Statement s) => s.accept(this);
 }
 
 class RecursiveTransformer extends Transformer {
   void visitInnerFunction(FunctionDefinition node) {
@@ skipping 180 matching lines @@
   }
 
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitUnreachable(Unreachable node) {
     return node;
   }
+
+  visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
+    _replaceExpressions(node.arguments);
+    return node;
+  }
 }