Tweak location sdk summary is accessed from

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 2837 matching lines @@
           isStatic: isStatic, type: type, element: element);
 
       if (isStatic) {
         var dynType = _emitStaticAccess(type);
         return new JS.PropertyAccess(dynType, member);
       }
 
       // For instance members, we add implicit-this.
       // For method tear-offs, we ensure it's a bound method.
       var tearOff = element is MethodElement && !inInvocationContext(node);
-      if (tearOff) return _callHelper('bind(this, #)', member);
+      if (tearOff) {
+        // To be safe always use the symbolized name when binding on a native
+        // class as bind assumes the name will match the name class sigatures
+        // which is symbolized for native classes.
+        var safeName = _emitMemberName(name,
+            isStatic: isStatic,
+            type: type,
+            element: element,
+            alwaysSymbolizeNative: true);
+        return _callHelper('bind(this, #)', safeName);
+      }
       return js.call('this.#', member);
     }
 
     if (element is ParameterElement) {
       return _emitParameter(element);
     }
 
     // If this is one of our compiler's temporary variables, return its JS form.
     if (element is TemporaryVariableElement) {
       return element.jsVariable;
@@ skipping 2146 matching lines @@
         member is FieldElementImpl &&
         !member.isVirtual) {
       // If super.x is a sealed field, then x is an instance property since
       // subclasses cannot override x.
       jsTarget = new JS.This();
     }
 
     JS.Expression result;
     if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
+      // To be safe always use the symbolized name when binding on a native
+      // class as bind assumes the name will match the name class sigatures
+      // which is symbolized for native classes.
+      var safeName = _emitMemberName(memberName,
+          type: getStaticType(target),
+          isStatic: isStatic,
+          element: member,
+          alwaysSymbolizeNative: true);
       if (isSuper) {
-        result = _callHelper('bind(this, #, #.#)', [name, jsTarget, name]);
+        result =
+            _callHelper('bind(this, #, #.#)', [safeName, jsTarget, safeName]);
       } else if (_isObjectMemberCall(target, memberName)) {
         result = _callHelper('bind(#, #, #.#)',
             [jsTarget, _propertyName(memberName), _runtimeModule, memberName]);
       } else {
-        result = _callHelper('bind(#, #)', [jsTarget, name]);
+        result = _callHelper('bind(#, #)', [jsTarget, safeName]);
       }
     } else if (_isObjectMemberCall(target, memberName)) {
       result = _callHelper('#(#)', [memberName, jsTarget]);
     } else {
       result = js.call('#.#', [jsTarget, name]);
     }
     if (typeArgs == null) {
       return result;
     }
     return _callHelper('gbind(#, #)', [result, typeArgs]);
@@ skipping 576 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,
+      bool alwaysSymbolizeNative: 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);
     }
 
@@ skipping 18 matching lines @@
     }
 
     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;
       }
-      useExtension =
-          baseType is InterfaceType && _isSymbolizedMember(baseType, name);
+      useExtension = baseType is InterfaceType &&
+          _isSymbolizedMember(baseType, name, alwaysSymbolizeNative);
     }
 
     return useExtension
         ? js.call('#.#', [_extensionSymbolsModule, result])
         : result;
   }
 
   var _forwardingCache = new HashMap<Element, Map<String, ExecutableElement>>();
   Element _lookupForwardedMember(ClassElement element, String name) {
     // We only care about public methods.
@@ skipping 16 matching lines @@
     return member;
   }
 
   /// Don't symbolize native members that just forward to the underlying
   /// native member.  We limit this to non-renamed members as the receiver
   /// may be a mock type.
   ///
   /// Note, this is an underlying assumption here that, if another native type
   /// subtypes this one, it also forwards this member to its underlying native
   /// one without renaming.
-  bool _isSymbolizedMember(InterfaceType type, String name) {
+  bool _isSymbolizedMember(
+      InterfaceType type, String name, bool alwaysSymbolizeNative) {
     // Object members are handled separately.
     if (isObjectMember(name)) {
       return false;
     }
 
     var element = type.element;
     if (_extensionTypes.isNativeClass(element)) {
       var member = _lookupForwardedMember(element, name);
 
       // Fields on a native class are implicitly native.
       // Methods/getters/setters are marked external/native.
       if (member is FieldElement ||
           member is ExecutableElement && member.isExternal) {
         var jsName = getAnnotationName(member, isJsName);
-        return jsName != null && jsName != name;
+        return alwaysSymbolizeNative || (jsName != null && jsName != name);
       } else {
         // Non-external members must be symbolized.
         return true;
       }
     }
     // If the receiver *may* be a native type (i.e., an interface allowed to
     // be implemented by a native class), conservatively symbolize - we don't
     // whether it'll be implemented via forwarding.
     // TODO(vsm): Consider CHA here to be less conservative.
     return _extensionTypes.isNativeInterface(element);
@@ skipping 287 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;
 }