interceptedNames should include all interceptor method generated, not just the ones called.

dart/sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 57 matching lines @@
   /** Shorter access to [isolatePropertiesName]. Both here in the code, as
       well as in the generated code. */
   String isolateProperties;
   String classesCollector;
   final Set<ClassElement> neededClasses = new Set<ClassElement>();
   final List<ClassElement> regularClasses = <ClassElement>[];
   final List<ClassElement> deferredClasses = <ClassElement>[];
   final List<ClassElement> nativeClasses = <ClassElement>[];
   final List<Selector> trivialNsmHandlers = <Selector>[];
   final Map<String, String> mangledFieldNames = <String, String>{};
+  final Set<String> interceptorInvocationNames = new Set<String>();
 
   // TODO(ngeoffray): remove this field.
   Set<ClassElement> instantiatedClasses;
 
   final List<jsAst.Expression> boundClosures = <jsAst.Expression>[];
 
   JavaScriptBackend get backend => compiler.backend;
 
   String get _ => compiler.enableMinification ? "" : " ";
   String get n => compiler.enableMinification ? "" : "\n";
@@ skipping 863 matching lines @@
     // The arguments that will be passed to the real method.
     List<jsAst.Expression> argumentsBuffer =
         new List<jsAst.Expression>(
             parameters.parameterCount + extraArgumentCount);
 
     int count = 0;
     if (isInterceptedMethod) {
       count++;
       parametersBuffer[0] = new jsAst.Parameter(receiverArgumentName);
       argumentsBuffer[0] = js(receiverArgumentName);
+      interceptorInvocationNames.add(invocationName);
     }
 
     int optionalParameterStart = positionalArgumentCount + extraArgumentCount;
     // Includes extra receiver argument when using interceptor convention
     int indexOfLastOptionalArgumentInParameters = optionalParameterStart - 1;
 
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(member);
 
     parameters.orderedForEachParameter((Element element) {
@@ skipping 197 matching lines @@
     // TODO(floitsch): we don't need to deal with members of
     // uninstantiated classes, that have been overwritten by subclasses.
 
     if (member.isFunction()
         || member.isGenerativeConstructorBody()
         || member.isAccessor()) {
       if (member.isAbstract(compiler)) return;
       jsAst.Expression code = backend.generatedCode[member];
       if (code == null) return;
       String name = namer.getName(member);
+      if (backend.isInterceptedMethod(member)) {
+        interceptorInvocationNames.add(name);
+      }
       builder.addProperty(name, code);
       var metadata = buildMetadataFunction(member);
       if (metadata != null) {
         builder.addProperty('@$name', metadata);
       }
       String reflectionName = getReflectionName(member);
       if (reflectionName != null) {
         builder.addProperty('+$reflectionName', js('0'));
       }
       code = backend.generatedBailoutCode[member];
@@ skipping 1782 matching lines @@
   }
 
   /**
    * If [JSInvocationMirror._invokeOn] has been compiled, emit all the
    * possible selector names that are intercepted into the
    * [interceptedNames] top-level variable. The implementation of
    * [_invokeOn] will use it to determine whether it should call the
    * method with an extra parameter.
    */
   void emitInterceptedNames(CodeBuffer buffer) {
+    // TODO(ahe): We should not generate the list of intercepted names at
+    // compile time, it can be generated automatically at runtime given
+    // subclasses of Interceptor (which can easily be identified).
     if (!compiler.enabledInvokeOn) return;
     String name = backend.namer.getName(backend.interceptedNames);
 
     int index = 0;
-    List<jsAst.ArrayElement> elements = backend.usedInterceptors.map(
-      (Selector selector) {
-        jsAst.Literal str = js.string(namer.invocationName(selector));
+    var invocationNames = interceptorInvocationNames.toList()..sort();
+    List<jsAst.ArrayElement> elements = invocationNames.map(
+      (String invocationName) {
+        jsAst.Literal str = js.string(invocationName);
         return new jsAst.ArrayElement(index++, str);
       }).toList();
-    jsAst.ArrayInitializer array = new jsAst.ArrayInitializer(
-        backend.usedInterceptors.length,
-        elements);
+    jsAst.ArrayInitializer array =
+        new jsAst.ArrayInitializer(invocationNames.length, elements);
 
     jsAst.Expression assignment = js('$isolateProperties.$name = #', array);
 
     buffer.write(jsAst.prettyPrint(assignment, compiler));
     buffer.write(N);
   }
 
   void emitInitFunction(CodeBuffer buffer) {
     jsAst.Fun fun = js.fun([], [
       js('$isolateProperties = {}'),
@@ skipping 383 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;