dart2js: Use the NoInline annotation on getInterceptor in the JS runtime.

pkg/compiler/lib/src/cps_ir/type_propagation.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.
 
 import 'optimizers.dart';
 
 import '../common/names.dart' show
     Selectors;
 import '../compiler.dart' as dart2js show
     Compiler;
@@ skipping 1654 matching lines @@
     if (!node.target.hasNode) return false;
 
     // An expression is non-expansive (in a sense) if it is just a call to
     // a foreign function.
     bool isNonExpansive(ast.Expression expr) {
       if (expr is ast.Send) {
         SendStructure structure =
             node.target.treeElements.getSendStructure(expr);
         if (structure is InvokeStructure) {
           return structure.semantics.kind == AccessKind.TOPLEVEL_METHOD &&
-              compiler.backend.isForeign(structure.semantics.element);
+              backend.isForeign(structure.semantics.element);
         }
       }
       return false;
     }
 
     ast.Statement body = node.target.node.body;
     bool shouldInline() {
-      // At compile time, 'getInterceptor' from the Javascript runtime has a
-      // foreign body that returns undefined.  It is later mutated by replacing
-      // it with a specialized version.  Inlining undefined would be wrong.
-      // TODO(kmillikin): matching the name prevents inlining other functions
-      // with the same name.
-      if (node.target.name == 'getInterceptor') return false;
+      if (backend.annotations.noInline(node.target)) {
+        return false;
+      }
 
       // Inline functions that are a single return statement, expression
       // statement, or block containing a return statement or expression
       // statement.
       if (body is ast.Return) {
         return isNonExpansive(body.expression);
       } else if (body is ast.ExpressionStatement) {
         return isNonExpansive(body.expression);
       } else if (body is ast.Block) {
         var link = body.statements.nodes;
@@ skipping 973 matching lines @@
   }
 
   processLetPrim(LetPrim node) {
     values.remove(node.primitive);
   }
 
   processLetMutable(LetMutable node) {
     values.remove(node.variable);
   }
 }