Fix "break" vs "continue" bug in js interop codegen that was the real source of missing js interop …

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.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.
 
 library dart2js.js_emitter.program_builder;
 
 import '../../closure.dart' show ClosureFieldElement;
 import '../../common.dart';
 import '../../common/names.dart' show Names, Selectors;
 import '../../compiler.dart' show Compiler;
@@ skipping 305 matching lines @@
   List<Library> _buildLibraries(LibrariesMap librariesMap) {
     List<Library> libraries = new List<Library>(librariesMap.length);
     int count = 0;
     librariesMap.forEach((LibraryElement library, List<Element> elements) {
       libraries[count++] = _buildLibrary(library, elements);
     });
     return libraries;
   }
 
   void _addJsInteropStubs(LibrariesMap librariesMap) {
-    // TODO(26456): we should be using codegenWorld instead of resolverWorld
-    // to determine what invocations could be live but codegenWorld has a bug
-    // resulting in it missing some invocations.
     if (_classes.containsKey(_compiler.coreClasses.objectClass)) {
       var toStringInvocation = namer.invocationName(Selectors.toString_);
       // TODO(jacobr): register toString as used so that it is always accessible
       // from JavaScript.
       _classes[_compiler.coreClasses.objectClass].callStubs.add(
           _buildStubMethod(new StringBackedName("toString"),
               js.js('function() { return this.#(this) }', toStringInvocation)));
     }
 
     // We add all members from classes marked with isJsInterop to the base
     // Interceptor class with implementations that directly call the
     // corresponding JavaScript member. We do not attempt to bind this when
     // tearing off JavaScript methods as we cannot distinguish between calling
     // a regular getter that returns a JavaScript function and tearing off
     // a method in the case where there exist multiple JavaScript classes
     // that conflict on whether the member is a getter or a method.
     var interceptorClass = _classes[helpers.jsJavaScriptObjectClass];
     var stubNames = new Set<String>();
     librariesMap.forEach((LibraryElement library, List<Element> elements) {
       for (Element e in elements) {
         if (e is ClassElement && backend.isJsInterop(e)) {
           e.declaration.forEachMember((_, Element member) {
             if (!member.isInstanceMember) return;
             if (member.isGetter || member.isField || member.isFunction) {
               var selectors =
-                  _compiler.resolverWorld.getterInvocationsByName(member.name);
+                  _compiler.codegenWorld.getterInvocationsByName(member.name);
               if (selectors != null && !selectors.isEmpty) {
                 for (var selector in selectors.keys) {
                   var stubName = namer.invocationName(selector);
                   if (stubNames.add(stubName.key)) {
                     interceptorClass.callStubs.add(_buildStubMethod(stubName,
                         js.js('function(obj) { return obj.# }', [member.name]),
                         element: member));
                   }
                 }
               }
             }
 
             if (member.isSetter || (member.isField && !member.isConst)) {
               var selectors =
-                  _compiler.resolverWorld.setterInvocationsByName(member.name);
+                  _compiler.codegenWorld.setterInvocationsByName(member.name);
               if (selectors != null && !selectors.isEmpty) {
                 var stubName = namer.setterForElement(member);
                 if (stubNames.add(stubName.key)) {
                   interceptorClass.callStubs.add(_buildStubMethod(
                       stubName,
                       js.js('function(obj, v) { return obj.# = v }',
                           [member.name]),
                       element: member));
                 }
               }
@@ skipping 35 matching lines @@
               int minArgs;
               int maxArgs;
               if (functionType != null) {
                 minArgs = functionType.parameterTypes.length;
                 maxArgs = minArgs + functionType.optionalParameterTypes.length;
               } else {
                 minArgs = 0;
                 maxArgs = 32767;
               }
               var selectors =
-                  _compiler.resolverWorld.invocationsByName(member.name);
+                  _compiler.codegenWorld.invocationsByName(member.name);
+
               // Named arguments are not yet supported. In the future we
               // may want to map named arguments to an object literal containing
               // all named arguments.
               if (selectors != null && !selectors.isEmpty) {
                 for (var selector in selectors.keys) {
                   // Check whether the arity matches this member.
                   var argumentCount = selector.argumentCount;
                   // JS interop does not support named arguments.
-                  if (selector.namedArgumentCount > 0) break;
-                  if (argumentCount < minArgs) break;
-                  if (argumentCount > maxArgs) break;
+                  if (selector.namedArgumentCount > 0) continue;
+                  if (argumentCount < minArgs) continue;
+                  if (argumentCount > maxArgs) continue;
                   var stubName = namer.invocationName(selector);
-                  if (!stubNames.add(stubName.key)) break;
+                  if (!stubNames.add(stubName.key)) continue;
                   var parameters =
                       new List<String>.generate(argumentCount, (i) => 'p$i');
 
                   // We intentionally generate the same stub method for direct
                   // calls and call-throughs of getters so that calling a
                   // getter that returns a function behaves the same as calling
                   // a method. This is helpful as many typed JavaScript APIs
                   // specify member functions with getters that return
                   // functions. The behavior of this solution matches JavaScript
                   // behavior implicitly binding this only when JavaScript
@@ skipping 529 matching lines @@
       Constant constant = new Constant(name, holder, constantValue);
       _constants[constantValue] = constant;
     }
   }
 
   Holder _registerStaticStateHolder() {
     return _registry.registerHolder(namer.staticStateHolder,
         isStaticStateHolder: true);
   }
 }