cps_ir: interceptor calling convention, operator== prologue

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 39 matching lines @@
 
   String get name => 'IR builder';
 
   bool hasIr(Element element) => nodes.containsKey(element.implementation);
 
   ir.ExecutableDefinition getIr(ExecutableElement element) {
     return nodes[element.implementation];
   }
 
   ir.ExecutableDefinition buildNode(AstElement element) {
+    return measure(() => _buildNode(element));
+  }
+
+  ir.ExecutableDefinition _buildNode(AstElement element) {
     if (!canBuild(element)) return null;
 
     TreeElements elementsMapping = element.resolvedAst.elements;
     element = element.implementation;
     return compiler.withCurrentElement(element, () {
       SourceInformationBuilder sourceInformationBuilder = generateSourceMap
           ? new PositionSourceInformationBuilder(element)
           : const SourceInformationBuilder();
 
       IrBuilderVisitor builder =
           compiler.backend is JavaScriptBackend
           ? new JsIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder)
           : new DartIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder);
       ir.ExecutableDefinition definition =
             builder.buildExecutable(element);
       if (definition != null) {
         nodes[element] = definition;
       }
       return definition;
     });
   }
 
   void buildNodes() {
     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
-      resolved.forEach(buildNode);
+      resolved.forEach(_buildNode);
     });
   }
 
   bool canBuild(Element element) {
     if (element is TypedefElement) return false;
     if (element is FunctionElement) {
       // TODO(sigurdm): Support native functions for dart2js.
       assert(invariant(element, !element.isNative));
 
       if (element is ConstructorElement) {
@@ skipping 2363 matching lines @@
 
     return withBuilder(builder, () {
       irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
                                            getClosureScopeForNode(node));
       visit(node.body);
       return irBuilder.makeFunctionDefinition([]);
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
+    Selector selector = new Selector.fromElement(element);

[Kevin Millikin (Google), 2015/03/26 15:14:16]

Inadvertent change?  selector is only used in the commented-out code below.

+      //if (glue.isInterceptedSelector(selector)) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     assert(!element.isSynthesized);
     assert(node != null);
     assert(elements[node] != null);
 
     closureMap = compiler.closureToClassMapper.computeClosureToClassMapping(
         element,
         node,
@@ skipping 122 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }