fix for #520, ListMixin should work again

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';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 849 matching lines @@
 
         if (m.element is PropertyAccessorElement) {
           jsMethods.add(_emitSuperAccessorWrapper(m, type, superclasses));
         }
 
         if (!hasJsPeer && m.isGetter && m.name.name == 'iterator') {
           hasIterator = true;
           jsMethods.add(_emitIterable(type));
         }
       } else if (m is FieldDeclaration) {
-        if (_extensionTypes.contains(element)) {
+        if (_extensionTypes.isNativeClass(element)) {
           jsMethods.addAll(_emitNativeFieldAccessors(m));
           continue;
         }
         if (m.isStatic) continue;
         for (VariableDeclaration field in m.fields.variables) {
           if (virtualFields.containsKey(field.element)) {
             jsMethods.addAll(_emitVirtualFieldAccessor(field, virtualFields));
           }
         }
       }
@@ skipping 49 matching lines @@
   JS.Method _emitSuperAccessorWrapper(MethodDeclaration method,
       InterfaceType type, List<ClassElement> superclasses) {
     var methodElement = method.element as PropertyAccessorElement;
     var field = methodElement.variable;
     if (!field.isSynthetic) return null;
     var propertyOverrideResult = checkForPropertyOverride(
         methodElement.variable, superclasses, _extensionTypes);
 
     // Generate a corresponding virtual getter / setter.
     var name = _elementMemberName(methodElement,
-        allowExtensions: _extensionTypes.contains(type.element));
+        allowExtensions: _extensionTypes.isNativeClass(type.element));
     if (method.isGetter) {
       // Generate a setter
       if (field.setter != null || !propertyOverrideResult.foundSetter)
         return null;
       var fn = js.call('function(value) { super[#] = value; }', [name]);
       return new JS.Method(name, fn, isSetter: true);
     } else {
       // Generate a getter
       if (field.getter != null || !propertyOverrideResult.foundGetter)
         return null;
@@ skipping 42 matching lines @@
 
   /// Gets the JS peer for this Dart type if any, otherwise null.
   ///
   /// For example for dart:_interceptors `JSArray` this will return "Array",
   /// referring to the JavaScript built-in `Array` type.
   String _getJSPeerName(ClassElement classElem) {
     var jsPeerName = getAnnotationName(
         classElem,
         (a) =>
             isJsPeerInterface(a) ||
-            isNativeAnnotation(a) && _extensionTypes.contains(classElem));
+            isNativeAnnotation(a) && _extensionTypes.isNativeClass(classElem));
     if (jsPeerName != null && jsPeerName.contains(',')) {
       jsPeerName = jsPeerName.split(',')[0];
     }
     return jsPeerName;
   }
 
   void _registerExtensionType(ClassElement classElem, List<JS.Statement> body) {
     var jsPeerName = _getJSPeerName(classElem);
     if (jsPeerName != null) {
       // TODO(jmesserly): this copies the dynamic members.
@@ skipping 70 matching lines @@
 
   /// If a concrete class implements one of our extensions, we might need to
   /// add forwarders.
   void _defineExtensionMembers(List<ExecutableElement> extensions,
       JS.Expression className, List<JS.Statement> body) {
     // If a concrete class implements one of our extensions, we might need to
     // add forwarders.
     if (extensions.isNotEmpty) {
       var methodNames = <JS.Expression>[];
       for (var e in extensions) {
-        methodNames.add(_elementMemberName(e));
+        methodNames.add(_elementMemberName(e, allowExtensions: false));
       }
       body.add(js.statement('dart.defineExtensionMembers(#, #);', [
         className,
         new JS.ArrayInitializer(methodNames, multiline: methodNames.length > 4)
       ]));
     }
   }
 
   /// Emit the signature on the class recording the runtime type information
   void _emitClassSignature(
@@ skipping 16 matching lines @@
     var sNames = <JS.Expression>[];
     for (MethodDeclaration node in methods) {
       if (!(node.isSetter || node.isGetter || node.isAbstract)) {
         var name = node.name.name;
         var element = node.element;
         var inheritedElement =
             classElem.lookUpInheritedConcreteMethod(name, currentLibrary);
         if (inheritedElement != null && inheritedElement.type == element.type) {
           continue;
         }
-        var memberName = _elementMemberName(element);
+        var memberName = _elementMemberName(element,
+            allowExtensions: _extensionTypes.isNativeClass(classElem));
         var parts = _emitFunctionTypeParts(element.type);
         var property =
             new JS.Property(memberName, new JS.ArrayInitializer(parts));
         if (node.isStatic) {
           tStatics.add(property);
           sNames.add(memberName);
         } else {
           tMethods.add(property);
         }
       }
@@ skipping 31 matching lines @@
       body.add(js.statement('dart.setSignature(#, #);', [className, sig]));
     }
   }
 
   /// Ensure `dartx.` symbols we will use are present.
   void _initExtensionSymbols(
       ClassElement classElem,
       List<MethodDeclaration> methods,
       List<FieldDeclaration> fields,
       List<JS.Statement> body) {
-    if (_extensionTypes.contains(classElem)) {
+    if (_extensionTypes.hasNativeSubtype(classElem.type)) {
       var dartxNames = <JS.Expression>[];
       for (var m in methods) {
         if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
           dartxNames.add(_elementMemberName(m.element, allowExtensions: false));
         }
       }
       for (var f in fields) {
         if (!f.isStatic) {
           for (var d in f.fields.variables) {
             if (d.element.isPublic) {
               dartxNames.add(
                   _elementMemberName(d.element.getter, allowExtensions: false));
             }
           }
         }
       }
       if (dartxNames.isNotEmpty) {
         body.add(js.statement('dart.defineExtensionNames(#)',
             [new JS.ArrayInitializer(dartxNames, multiline: true)]));
       }
     }
   }
 
   List<ExecutableElement> _extensionsToImplement(ClassElement element) {
     var members = <ExecutableElement>[];
-    if (_extensionTypes.contains(element)) return members;
+    if (_extensionTypes.isNativeClass(element)) return members;
 
     // Collect all extension types we implement.
     var type = element.type;
-    var types = new Set<ClassElement>();
-    _collectExtensions(type, types);
+    var types = _extensionTypes.collectNativeInterfaces(element);
     if (types.isEmpty) return members;
 
     // 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) 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;
   }
 
-  /// Collections the type and all supertypes, including interfaces, but
-  /// excluding [Object].
-  void _collectExtensions(InterfaceType type, Set<ClassElement> types) {
-    if (type.isObject) return;
-    var element = type.element;
-    if (_extensionTypes.contains(element)) types.add(element);
-    for (var m in type.mixins.reversed) {
-      _collectExtensions(m, types);
-    }
-    for (var i in type.interfaces) {
-      _collectExtensions(i, types);
-    }
-    _collectExtensions(type.superclass, types);
-  }
-
   /// 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) {
     assert(_hasUnnamedConstructor(node.element) == fields.isNotEmpty);
 
     // If we don't have a method body, skip this.
     var superCall = _superConstructorCall(node.element);
@@ skipping 399 matching lines @@
           fn.params.isNotEmpty) {
         // []= methods need to return the value. We could also address this at
         // call sites, but it's cleaner to instead transform the operator method.
         fn = _alwaysReturnLastParameter(fn);
       }
 
       fn = _makeGenericFunction(fn);
     }
 
     return annotate(
-        new JS.Method(_elementMemberName(node.element), fn,
+        new JS.Method(
+            _elementMemberName(node.element,
+                allowExtensions: _extensionTypes.isNativeClass(type.element)),
+            fn,
             isGetter: node.isGetter,
             isSetter: node.isSetter,
             isStatic: node.isStatic),
         node,
         node.element);
   }
 
   /// Transform the function so the last parameter is always returned.
   ///
   /// This is useful for indexed set methods, which otherwise would not have
@@ skipping 1855 matching lines @@
     // Is this a member on `Object`?
     if (!isObjectProperty(memberName)) {
       return false;
     }
 
     // Check if the target could be `null`, is dynamic, or may be an extension
     // native type. In all of those cases we need defensive code generation.
     var type = getStaticType(target);
     return isNullable(target) ||
         type.isDynamic ||
-        (_extensionTypes.contains(type.element) && target is! SuperExpression);
+        (_extensionTypes.hasNativeSubtype(type) && target is! SuperExpression);
   }
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   JS.Expression _emitAccess(
       Expression target, SimpleIdentifier memberId, DartType resultType) {
     Element member = memberId.staticElement;
     if (member is PropertyAccessorElement) {
       member = (member as PropertyAccessorElement).variable;
     }
     bool isStatic = member is ClassMemberElement && member.isStatic;
@@ skipping 582 matching lines @@
       name = '+$name';
     }
 
     // Dart "extension" methods. Used for JS Array, Boolean, Number, String.
     var baseType = type;
     while (baseType is TypeParameterType) {
       baseType = baseType.element.bound;
     }
     if (allowExtensions &&
         baseType != null &&
-        _extensionTypes.contains(baseType.element) &&
+        _extensionTypes.hasNativeSubtype(baseType) &&
         !isObjectProperty(name)) {
       return js.call('dartx.#', _propertyName(name));
     }
 
     return _propertyName(name);
   }
 
   JS.TemporaryId _emitPrivateNameSymbol(LibraryElement library, String name) {
     return _privateNames
         .putIfAbsent(library, () => new HashMap())
@@ skipping 141 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';