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

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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 dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
 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, SelectorKind;
 
+import 'builtin_operator.dart';
+export 'builtin_operator.dart';
+
 abstract class Node {
   /// A pointer to the parent node. Is null until set by optimization passes.
   Node parent;
 
   accept(Visitor visitor);
 }
 
 /// Expressions can be evaluated, and may diverge, throw, and/or have
 /// side-effects.
 ///
@@ skipping 89 matching lines @@
   }
 }
 
 /// Evaluates a primitive and binds it to variable: `let val x = V in E`.
 ///
 /// The bound value is in scope in the body.
 ///
 /// During one-pass construction a LetPrim with an empty body is used to
 /// represent the one-hole context `let val x = V in []`.
 class LetPrim extends Expression implements InteriorNode {
-  final Primitive primitive;
+  Primitive primitive;
   Expression body;
 
   LetPrim(this.primitive, [this.body = null]);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetPrim(this);
@@ skipping 297 matching lines @@
   final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
 
   ConcatenateStrings(List<Primitive> args, Continuation cont)
       : arguments = _referenceList(args),
         continuation = new Reference<Continuation>(cont);
 
   accept(Visitor visitor) => visitor.visitConcatenateStrings(this);
 }
 
+/// Apply a built-in operator.
+///
+/// It must be known that the arguments have the proper types.
+class ApplyBuiltinOperator extends Primitive {
+  BuiltinOperator operator;
+  List<Reference<Primitive>> arguments;
+
+  ApplyBuiltinOperator(this.operator, List<Primitive> arguments)
+      : this.arguments = _referenceList(arguments);
+
+  accept(Visitor visitor) => visitor.visitApplyBuiltinOperator(this);
+}
+
 /// Throw a value.
 ///
 /// Throw is an expression, i.e., it always occurs in tail position with
 /// respect to a body or expression.
 class Throw extends Expression {
   Reference<Primitive> value;
 
   Throw(Primitive value) : value = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitThrow(this);
@@ skipping 79 matching lines @@
   bool isRecursive;
 
   InvokeContinuation(Continuation cont, List<Primitive> args,
                      {this.isRecursive: false})
       : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args) {
     assert(cont.parameters == null || cont.parameters.length == args.length);
     if (isRecursive) cont.isRecursive = true;
   }
 
-  /// Build a one-argument InvokeContinuation using existing reference objects.
-  ///
-  /// This is useful for converting call continuations to local continuations.
-  InvokeContinuation.fromCall(this.continuation,
-                              Reference<Primitive> argument)
-    : arguments = <Reference<Primitive>>[argument],
-      isRecursive = false;
-
   /// A continuation invocation whose target and arguments will be filled
   /// in later.
   ///
   /// Used as a placeholder for a jump whose target is not yet created
   /// (e.g., in the translation of break and continue).
   InvokeContinuation.uninitialized({this.isRecursive: false})
       : continuation = null,
         arguments = null;
 
   accept(Visitor visitor) => visitor.visitInvokeContinuation(this);
@@ skipping 388 matching lines @@
   T visitIdentical(Identical node);
   T visitInterceptor(Interceptor node);
   T visitCreateInstance(CreateInstance node);
   T visitGetField(GetField node);
   T visitCreateBox(CreateBox node);
   T visitReifyRuntimeType(ReifyRuntimeType node);
   T visitReadTypeVariable(ReadTypeVariable node);
   T visitTypeExpression(TypeExpression node);
   T visitCreateInvocationMirror(CreateInvocationMirror node);
   T visitTypeTest(TypeTest node);
+  T visitApplyBuiltinOperator(ApplyBuiltinOperator node);
 
   // Conditions.
   T visitIsTrue(IsTrue node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
 /// (i.e. `processLetPrim`) functions in pre-order.
 class RecursiveVisitor implements Visitor {
   const RecursiveVisitor();
 
@@ skipping 262 matching lines @@
     processNonTailThrow(node);
     processReference(node.value);
   }
 
   processCreateInvocationMirror(CreateInvocationMirror node) {}
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     processCreateInvocationMirror(node);
     node.arguments.forEach(processReference);
   }
 
+  processApplyBuiltinOperator(ApplyBuiltinOperator node) {}
+  visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
+    processApplyBuiltinOperator(node);
+    node.arguments.forEach(processReference);
+  }
+
   processUnreachable(Unreachable node) {}
   visitUnreachable(Unreachable node) {
     processUnreachable(node);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends RecursiveVisitor {
   const RemovalVisitor();
 
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (const RemovalVisitor()).visit(node);
   }
 }