Invoke native methods directly

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 5644 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 != null &&
-          _extensionTypes.hasNativeSubtype(baseType) &&
-          !isObjectMember(name);
+      useExtension =
+          baseType is InterfaceType && _isSymbolizedMember(baseType, name);
     }
 
     return useExtension
         ? js.call('#.#', [_extensionSymbolsModule, result])
         : result;
   }
 
+  var _forwardingCache = <Element, Map<String, ExecutableElement>>{};

[Jennifer Messerly, 2017/03/13 21:21:32]

micro-opt:

    var _forwardingCache = new HashMap<Element, Map<String,
ExecutableElement>>();

if you don't care about order, it saves some linked list overhead

+  Element _lookupForwardedMember(ClassElement element, String name) {
+    // We only care about public methods.
+    if (name.startsWith('_')) return null;
+
+    var map = _forwardingCache.putIfAbsent(element, () => {});
+    if (map.containsKey(name)) return map[name];
+
+    // Note, for a public member, the library should not matter.
+    var library = element.library;
+    var member = element.lookUpMethod(name, library) ??
+        element.lookUpGetter(name, library) ??
+        element.lookUpSetter(name, library);
+    member = (member != null &&
+            member.isSynthetic &&
+            member is PropertyAccessorElement)
+        ? member.variable
+        : member;
+    map[name] = member;
+    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) {
+    // 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;
+      } 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);
+  }
+
   JS.TemporaryId _emitPrivateNameSymbol(LibraryElement library, String name) {
     return _privateNames
         .putIfAbsent(library, () => new HashMap())
         .putIfAbsent(name, () {
       var id = new JS.TemporaryId(name);
       _moduleItems.add(
           js.statement('const # = Symbol(#);', [id, js.string(id.name, "'")]));
       return id;
     });
   }
@@ skipping 275 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;
 }