Use JavaScript runtime semantics when constant folding.

lib/compiler/implementation/ssa/optimize.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.
 
 interface OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaOptimizerTask(JavaScriptBackend backend)
     : this.backend = backend,
       super(backend.compiler);
   String get name() => 'SSA optimizer';
   Compiler get compiler() => backend.compiler;
 
   void runPhases(HGraph graph, List<OptimizationPhase> phases) {
     for (OptimizationPhase phase in phases) {
       phase.visitGraph(graph);
       compiler.tracer.traceGraph(phase.name, graph);
     }
   }
 
   void optimize(WorkItem work, HGraph graph) {
+    FoldingOperations foldingOperations =
+        compiler.constantHandler.foldingOperations;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
           // Run trivial constant folding first to optimize
           // some patterns useful for type conversion.
-          new SsaConstantFolder(backend, work),
+          new SsaConstantFolder(foldingOperations, backend, work),
           new SsaTypeConversionInserter(compiler),
           new SsaTypePropagator(compiler),
           new SsaCheckInserter(backend),
-          new SsaConstantFolder(backend, work),
+          new SsaConstantFolder(foldingOperations, backend, work),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaGlobalValueNumberer(compiler),
           new SsaCodeMotion(),
           new SsaDeadCodeEliminator(),
           new SsaRegisterRecompilationCandidates(backend, work)];
       runPhases(graph, phases);
     });
   }
 
@@ skipping 41 matching lines @@
 }
 
 /**
  * If both inputs to known operations are available execute the operation at
  * compile-time.
  */
 class SsaConstantFolder extends HBaseVisitor implements OptimizationPhase {
   final String name = "SsaConstantFolder";
   final JavaScriptBackend backend;
   final WorkItem work;
+  final FoldingOperations foldingOperations;
   HGraph graph;
   Compiler get compiler() => backend.compiler;
 
-  SsaConstantFolder(this.backend, this.work);
+  SsaConstantFolder(this.foldingOperations, this.backend, this.work);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction !== null) {
       HInstruction next = instruction.next;
@@ skipping 48 matching lines @@
       return graph.addConstantBool(!isTrue);
     } else if (input is HNot) {
       return input.inputs[0];
     }
     return node;
   }
 
   HInstruction visitInvokeUnary(HInvokeUnary node) {
     HInstruction operand = node.operand;
     if (operand is HConstant) {
-      UnaryOperation operation = node.operation;
+      UnaryOperation operation = node.operation(foldingOperations);
       HConstant receiver = operand;
       Constant folded = operation.fold(receiver.constant);
       if (folded !== null) return graph.addConstant(folded);
     }
     return node;
   }
 
   HInstruction visitInvokeInterceptor(HInvokeInterceptor node) {
     HInstruction input = node.inputs[1];
     if (node.isLengthGetter()) {
@@ skipping 133 matching lines @@
     if (!node.receiver.canBePrimitive()) {
       Selector selector = new Selector.indexSet();
       return fromInterceptorToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   HInstruction visitInvokeBinary(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
+    BinaryOperation operation = node.operation(foldingOperations);
     if (left is HConstant && right is HConstant) {
-      BinaryOperation operation = node.operation;
       HConstant op1 = left;
       HConstant op2 = right;
       Constant folded = operation.fold(op1.constant, op2.constant);
       if (folded !== null) return graph.addConstant(folded);
     }
 
     if (!left.canBePrimitive()
-        && node.operation.isUserDefinable()
+        && operation.isUserDefinable()
         // The equals operation is being optimized in visitEquals.
-        && node.operation !== const EqualsOperation()) {
-      Selector selector = new Selector.binaryOperator(node.operation.name);
+        && node is! HEquals) {
+      Selector selector = new Selector.binaryOperator(operation.name);
       return fromInterceptorToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   bool allUsersAreBoolifies(HInstruction instruction) {
     List<HInstruction> users = instruction.usedBy;
     int length = users.length;
     for (int i = 0; i < length; i++) {
       if (users[i] is! HBoolify) return false;
@@ skipping 961 matching lines @@
       // this type for the field is still a strong signal
       // indicating the expected type of the field.
       field.propagatedType = type;
     } else {
       // If there are no invoked setters we know the type of
       // this field for sure.
       field.guaranteedType = type;
     }
   }
 }