Fix a bad merge that lead to unused optimization: implement the dataEquals in HInterceptor in order…

sdk/lib/_internal/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.
 
 part of ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 27 matching lines @@
           // some patterns useful for type conversion.
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaTypeConversionInserter(compiler),
           new SsaTypePropagator(compiler, types),
           new SsaCheckInserter(backend, work, types, context.boundsChecked),
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaTypePropagator(compiler, types),
+          new SsaReceiverSpecialization(compiler),
           new SsaGlobalValueNumberer(compiler, types),
           new SsaCodeMotion(),
           new SsaValueRangeAnalyzer(constantSystem, types, work),
           // Previous optimizations may have generated new
           // opportunities for constant folding.
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaDeadCodeEliminator(types)];
       runPhases(graph, phases);
       if (!speculative) {
         runPhase(graph, new SsaConstructionFieldTypes(backend, work, types));
@@ skipping 1351 matching lines @@
     }
 
     // For other fields having setters in the generative constructor body, set
     // the type to UNKNOWN to avoid relying on the type set in the initializer
     // list.
     allSetters.forEach((Element element) {
       backend.registerFieldConstructor(element, HType.UNKNOWN);
     });
   }
 }
+
+/**
+ * This phase specializes dominated uses of a call, where the call
+ * can give us some type information of what the receiver might be.
+ * For example, after a call to [:a.foo():], if [:foo:] is only
+ * in class [:A:], a can be of type [:A:].
+ */
+class SsaReceiverSpecialization extends HBaseVisitor
+    implements OptimizationPhase {
+  final String name = "SsaReceiverSpecialization";
+  final Compiler compiler;
+
+  SsaReceiverSpecialization(this.compiler);
+
+  void visitGraph(HGraph graph) {
+    visitDominatorTree(graph);
+  }
+
+  void visitInterceptor(HInterceptor interceptor) {
+    HInstruction receiver = interceptor.receiver;
+    for (var user in receiver.usedBy) {
+      if (user is HInterceptor && interceptor.dominates(user)) {

[kasperl, 2012/11/29 08:22:27]

This is probably fine, but an alternative implementation would be to keep a
scoped mapping from interceptor receivers to intercepted classes -- and let the
dominator tree walk eliminate the need for calling interceptor.dominates(user).

[ngeoffray, 2012/11/29 08:31:56]

Good point. Filed http://code.google.com/p/dart/issues/detail?id=7022 to not
forget about it.

+        user.interceptedClasses = interceptor.interceptedClasses;
+      }
+    }
+  }
+
+  // TODO(ngeoffray): Also implement it for non-intercepted calls.
+}