Fix type error in js_dart2js.dart caught by DDC.

pkg/dev_compiler/lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1487 matching lines @@
       } else if (property.isSetter) {
         addProperty('isSetter', js.boolean(true));
 
         fnArgs.add(args);
         positionalArgs = new JS.ArrayInitializer([args]);
       }
     }
 
     var fnBody = js.call('this.noSuchMethod(new #.InvocationImpl(#, #, #))', [
       _runtimeModule,
-      _declareMemberName(method),
+      _declareMemberName(method, useDisplayName: true),
       positionalArgs,
       new JS.ObjectInitializer(invocationProps)
     ]);
 
     if (!method.returnType.isDynamic) {
       fnBody = js.call('#._check(#)', [_emitType(method.returnType), fnBody]);
     }
 
     var fn = new JS.Fun(fnArgs, js.statement('{ return #; }', [fnBody]),
         typeParams: _emitTypeFormals(method.type.typeFormals));
@@ skipping 413 matching lines @@
         }
       }
       if (dartxNames.isNotEmpty) {
         body.add(_callHelperStatement('defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
   }
 
   List<ExecutableElement> _extensionsToImplement(ClassElement element) {
-    var members = <ExecutableElement>[];
-    if (_extensionTypes.isNativeClass(element)) return members;
+    if (_extensionTypes.isNativeClass(element)) return [];
 
     // Collect all extension types we implement.
     var type = element.type;
     var types = _extensionTypes.collectNativeInterfaces(element);
-    if (types.isEmpty) return members;
+    if (types.isEmpty) return [];
 
+    var members = new Set<ExecutableElement>();
     // Collect all possible extension method names.
     var extensionMembers = new HashSet<String>();
     for (var t in types) {
       for (var m in [t.methods, t.accessors].expand((e) => e)) {
         if (!m.isStatic && m.isPublic) extensionMembers.add(m.name);
       }
     }
 
     // Collect all of extension methods this type implements.
     for (var m in [type.methods, type.accessors].expand((e) => e)) {
       if (!m.isStatic && !m.isAbstract && extensionMembers.contains(m.name)) {
         members.add(m);
       }
     }
-    return members;
+    members.addAll(_collectMockMethods(type)
+        .where((m) => extensionMembers.contains(m.name)));
+    return members.toList();
   }
 
   /// Generates the implicit default constructor for class C of the form
   /// `C() : super() {}`.
   JS.Method _emitImplicitConstructor(
       ClassDeclaration node,
       List<FieldDeclaration> fields,
       Map<FieldElement, JS.TemporaryId> virtualFields) {
     // If we don't have a method body, skip this.
     var superCall = _superConstructorCall(node.element);
@@ skipping 3481 matching lines @@
     }
     JS.Expression result = _visit(node);
     if (isNullable(node)) result = _callHelper('test(#)', result);
     return result;
   }
 
   /// Like [_emitMemberName], but for declaration sites.
   ///
   /// Unlike call sites, we always have an element available, so we can use it
   /// directly rather than computing the relevant options for [_emitMemberName].
-  JS.Expression _declareMemberName(ExecutableElement e, {bool useExtension}) {
-    String name;
-    if (e is PropertyAccessorElement) {
-      name = e.variable.name;
-    } else {
-      name = e.name;
-    }
+  JS.Expression _declareMemberName(ExecutableElement e,
+      {bool useExtension, useDisplayName = false}) {
+    var name = (e is PropertyAccessorElement) ? e.variable.name : e.name;
     return _emitMemberName(name,
         isStatic: e.isStatic,
         useExtension:
-            useExtension ?? _extensionTypes.isNativeClass(e.enclosingElement));
+            useExtension ?? _extensionTypes.isNativeClass(e.enclosingElement),
+        useDisplayName: useDisplayName);
   }
 
   /// This handles member renaming for private names and operators.
   ///
   /// Private names are generated using ES6 symbols:
   ///
   ///     // At the top of the module:
   ///     let _x = Symbol('_x');
   ///     let _y = Symbol('_y');
   ///     ...
@@ skipping 26 matching lines @@
   ///
   /// Unary minus looks like: `x._negate()`.
   ///
   /// Equality is a bit special, it is generated via the Dart `equals` runtime
   /// helper, that checks for null. The user defined method is called '=='.
   ///
   JS.Expression _emitMemberName(String name,
       {DartType type,
       bool isStatic: false,
       bool useExtension,
+      bool useDisplayName: false,
       Element element}) {
     // Static members skip the rename steps and may require JS interop renames.
     if (isStatic) {
       return _emitJSInteropStaticMemberName(element) ?? _propertyName(name);
     }
 
     if (name.startsWith('_')) {
       return _emitPrivateNameSymbol(currentLibrary, name);
     }
 
     // When generating synthetic names, we use _ as the prefix, since Dart names
     // won't have this (eliminated above), nor will static names reach here.
-    switch (name) {
-      case '[]':
-        name = '_get';
-        break;
-      case '[]=':
-        name = '_set';
-        break;
-      case 'unary-':
-        name = '_negate';
-        break;
-      case 'constructor':
-      case 'prototype':
-        name = '_$name';
-        break;
+    if (!useDisplayName) {
+      switch (name) {
+        case '[]':
+          name = '_get';
+          break;
+        case '[]=':
+          name = '_set';
+          break;
+        case 'unary-':
+          name = '_negate';
+          break;
+        case 'constructor':
+        case 'prototype':
+          name = '_$name';
+          break;
+      }
     }
 
     var result = _propertyName(name);
 
     if (useExtension == null) {
       // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
       var baseType = type;
       while (baseType is TypeParameterType) {
         baseType = (baseType.element as TypeParameterElement).bound;
       }
@@ skipping 256 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }