Patches to support Dart VM patch files in dart2js.

pkg/compiler/lib/src/resolution/class_hierarchy.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.
 
 library dart2js.resolution.class_hierarchy;
 
 import '../common.dart';
 import '../common/resolution.dart' show Feature;
 import '../compiler.dart' show Compiler;
 import '../core_types.dart' show CoreClasses, CoreTypes;
@@ skipping 156 matching lines @@
           reporter.internalError(
               node, "Cannot resolve default superclass for $element.");
         } else {
           superElement.ensureResolved(resolution);
         }
         element.supertype = superElement.computeType(resolution);
       }
     }
 
     if (element.interfaces == null) {
-      element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
+      element.interfaces =
+          resolveInterfaces(element, node.interfaces, node.superclass);
     } else {
       assert(invariant(element, element.hasIncompleteHierarchy));
     }
     calculateAllSupertypes(element);
 
     if (!element.hasConstructor) {
       Element superMember = element.superclass.localLookup('');
       if (superMember == null) {
         MessageKind kind = MessageKind.CANNOT_FIND_UNNAMED_CONSTRUCTOR;
         Map arguments = {'className': element.superclass.name};
@@ skipping 177 matching lines @@
       assert(invariant(node, supertype.isObject));
     } else {
       mixinApplication.supertype = supertype;
     }
 
     // Named mixin application may have an 'implements' clause.
     NamedMixinApplication namedMixinApplication =
         node.asNamedMixinApplication();
     Link<DartType> interfaces = (namedMixinApplication != null)
         ? resolveInterfaces(
+            mixinApplication,
             namedMixinApplication.interfaces, namedMixinApplication.superclass)
         : const Link<DartType>();
 
     // The class that is the result of a mixin application implements
     // the interface of the class that was mixed in so always prepend
     // that to the interface list.
     if (mixinApplication.interfaces == null) {
       if (mixinType.isInterfaceType) {
         // Avoid malformed types in the interfaces.
         interfaces = interfaces.prepend(mixinType);
       }
       mixinApplication.interfaces = interfaces;
     } else {
       assert(
           invariant(mixinApplication, mixinApplication.hasIncompleteHierarchy));
     }
 
     ClassElement superclass = supertype.element;
     if (mixinType.kind != TypeKind.INTERFACE) {
       mixinApplication.hasIncompleteHierarchy = true;
-      mixinApplication.allSupertypesAndSelf = superclass.allSupertypesAndSelf;
-      return;
+      mixinType = objectType;
     }
 
     assert(mixinApplication.mixinType == null);
     mixinApplication.mixinType = resolveMixinFor(mixinApplication, mixinType);
 
     // Create forwarding constructors for constructor defined in the superclass
     // because they are now hidden by the mixin application.
     superclass.forEachLocalMember((Element member) {
       if (!member.isGenerativeConstructor) return;
       FunctionElement forwarder =
@@ skipping 43 matching lines @@
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
     DartType supertype = resolveType(superclass);
     if (supertype != null) {
       if (supertype.isMalformed) {
         reporter.reportErrorMessage(
             superclass,
             MessageKind.CANNOT_EXTEND_MALFORMED,
             {'className': element.name, 'malformedType': supertype});
+        cls.hasIncompleteHierarchy = true;
         return objectType;
       } else if (supertype.isEnumType) {
         reporter.reportErrorMessage(superclass, MessageKind.CANNOT_EXTEND_ENUM,
             {'className': element.name, 'enumType': supertype});
+        cls.hasIncompleteHierarchy = true;
         return objectType;
       } else if (!supertype.isInterfaceType) {
         reporter.reportErrorMessage(
             superclass.typeName, MessageKind.CLASS_NAME_EXPECTED);
+        cls.hasIncompleteHierarchy = true;
         return objectType;
       } else if (isBlackListed(supertype)) {
         reporter.reportErrorMessage(
             superclass, MessageKind.CANNOT_EXTEND, {'type': supertype});
+        cls.hasIncompleteHierarchy = true;
         return objectType;
       }
     }
     return supertype;
   }
 
-  Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
+  Link<DartType> resolveInterfaces(
+      BaseClassElementX cls,
+      NodeList interfaces,
+      Node superclass) {
     Link<DartType> result = const Link<DartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
       DartType interfaceType = resolveType(link.head);
       if (interfaceType != null) {
         if (interfaceType.isMalformed) {
           reporter.reportErrorMessage(
               superclass,
               MessageKind.CANNOT_IMPLEMENT_MALFORMED,
               {'className': element.name, 'malformedType': interfaceType});
+          cls.hasIncompleteHierarchy = true;
         } else if (interfaceType.isEnumType) {
           reporter.reportErrorMessage(
               superclass,
               MessageKind.CANNOT_IMPLEMENT_ENUM,
               {'className': element.name, 'enumType': interfaceType});
+          cls.hasIncompleteHierarchy = true;
         } else if (!interfaceType.isInterfaceType) {
           // TODO(johnniwinther): Handle dynamic.
           TypeAnnotation typeAnnotation = link.head;
           reporter.reportErrorMessage(
               typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
+          cls.hasIncompleteHierarchy = true;
         } else {
           if (interfaceType == element.supertype) {
             reporter.reportErrorMessage(
                 superclass,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
             reporter.reportErrorMessage(
                 link.head,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
+            cls.hasIncompleteHierarchy = true;
           }
           if (result.contains(interfaceType)) {
             reporter.reportErrorMessage(link.head,
                 MessageKind.DUPLICATE_IMPLEMENTS, {'type': interfaceType});
+            cls.hasIncompleteHierarchy = true;
           }
           result = result.prepend(interfaceType);
           if (isBlackListed(interfaceType)) {
             reporter.reportErrorMessage(link.head, MessageKind.CANNOT_IMPLEMENT,
                 {'type': interfaceType});
+            cls.hasIncompleteHierarchy = true;
           }
         }
       }
     }
     return result;
   }
 
   /**
    * Compute the list of all supertypes.
    *
@@ skipping 118 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType) {
       reporter.reportErrorMessage(node.selector,
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }