Fix a pretty bad bug of a class inheriting a patched class. The fix is

sdk/lib/_internal/compiler/implementation/world.dart

 // Copyright (c) 2012, 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.
 
 part of dart2js;
 
 class World {
   final Compiler compiler;
-  final Map<ClassElement, Set<MixinApplicationElement>> mixinUses;
-  final Map<ClassElement, Set<ClassElement>> typesImplementedBySubclasses;
   final FullFunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
 
+  final Map<ClassElement, Set<MixinApplicationElement>> mixinUses =
+      new Map<ClassElement, Set<MixinApplicationElement>>();
+
+  final Map<ClassElement, Set<ClassElement>> _typesImplementedBySubclasses =
+      new Map<ClassElement, Set<ClassElement>>();
+
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
-  final Map<ClassElement, Set<ClassElement>> subclasses =
+  final Map<ClassElement, Set<ClassElement>> _subclasses =
       new Map<ClassElement, Set<ClassElement>>();
-  final Map<ClassElement, Set<ClassElement>> superclasses =
+  final Map<ClassElement, Set<ClassElement>> _superclasses =
       new Map<ClassElement, Set<ClassElement>>();
-  final Map<ClassElement, Set<ClassElement>> subtypes =
+  final Map<ClassElement, Set<ClassElement>> _subtypes =
       new Map<ClassElement, Set<ClassElement>>();
-  final Map<ClassElement, Set<ClassElement>> supertypes =
+  final Map<ClassElement, Set<ClassElement>> _supertypes =
       new Map<ClassElement, Set<ClassElement>>();
 
+  Set<ClassElement> subclassesOf(ClassElement cls) {
+    return _subclasses[cls.declaration];
+  }
+
+  Set<ClassElement> subtypesOf(ClassElement cls) {
+    return _subtypes[cls.declaration];
+  }
+
+  Set<ClassElement> superclassesOf(ClassElement cls) {
+    return _superclasses[cls.declaration];
+  }
+
+  Set<ClassElement> supertypesOf(ClassElement cls) {
+    return _supertypes[cls.declaration];
+  }
+
+  Set<ClassElement> typesImplementedBySubclassesOf(ClassElement cls) {
+    return _typesImplementedBySubclasses[cls];
+  }
+
   World(Compiler compiler)
-      : mixinUses = new Map<ClassElement, Set<MixinApplicationElement>>(),
-        typesImplementedBySubclasses =
-            new Map<ClassElement, Set<ClassElement>>(),
-        allFunctions = new FullFunctionSet(compiler),
+      : allFunctions = new FullFunctionSet(compiler),
         this.compiler = compiler;
 
   void populate() {
     void addSubtypes(ClassElement cls) {
+      assert(cls.isDeclaration);
       if (cls.resolutionState != STATE_DONE) {
         compiler.internalErrorOnElement(
             cls, 'Class "${cls.name.slowToString()}" is not resolved.');
       }
 
       for (DartType type in cls.allSupertypes) {
         Set<Element> supertypesOfClass =
-            supertypes.putIfAbsent(cls, () => new Set<ClassElement>());
+            _supertypes.putIfAbsent(cls, () => new Set<ClassElement>());
         Set<Element> subtypesOfSupertype =
-            subtypes.putIfAbsent(type.element, () => new Set<ClassElement>());
+            _subtypes.putIfAbsent(type.element, () => new Set<ClassElement>());
         supertypesOfClass.add(type.element);
         subtypesOfSupertype.add(cls);
       }
 
       // Walk through the superclasses, and record the types
       // implemented by that type on the superclasses.
       DartType type = cls.supertype;
       while (type != null) {
         Set<Element> superclassesOfClass =
-            superclasses.putIfAbsent(cls, () => new Set<ClassElement>());
+            _superclasses.putIfAbsent(cls, () => new Set<ClassElement>());
         Set<Element> subclassesOfSuperclass =
-            subclasses.putIfAbsent(type.element, () => new Set<ClassElement>());
+            _subclasses.putIfAbsent(type.element, () => new Set<ClassElement>());
         superclassesOfClass.add(type.element);
         subclassesOfSuperclass.add(cls);
 
         Set<Element> typesImplementedBySubclassesOfCls =
-            typesImplementedBySubclasses.putIfAbsent(
+            _typesImplementedBySubclasses.putIfAbsent(
                 type.element, () => new Set<ClassElement>());
         for (DartType current in cls.allSupertypes) {
           typesImplementedBySubclassesOfCls.add(current.element);
         }
         ClassElement classElement = type.element;
         type = classElement.supertype;
       }
     }
 
     // Use the [:seenClasses:] set to include non-instantiated
     // classes: if the superclass of these classes require RTI, then
     // they also need RTI, so that a constructor passes the type
     // variables to the super constructor.
     compiler.enqueuer.resolution.seenClasses.forEach(addSubtypes);
   }
 
   Iterable<ClassElement> commonSupertypesOf(ClassElement x, ClassElement y) {
-    Set<ClassElement> xSet = supertypes[x];
+    Set<ClassElement> xSet = supertypesOf(x);
     if (xSet == null) return const <ClassElement>[];
-    Set<ClassElement> ySet = supertypes[y];
+    Set<ClassElement> ySet = supertypesOf(y);
     if (ySet == null) return const <ClassElement>[];
     Set<ClassElement> smallSet, largeSet;
     if (xSet.length <= ySet.length) {
       smallSet = xSet;
       largeSet = ySet;
     } else {
       smallSet = ySet;
       largeSet = xSet;
     }
     return smallSet.where((ClassElement each) => largeSet.contains(each));
   }
 
   void registerMixinUse(MixinApplicationElement mixinApplication,
                         ClassElement mixin) {
+    // We don't support patch classes as mixin.
+    assert(mixin.isDeclaration);
     Set<MixinApplicationElement> users =
         mixinUses.putIfAbsent(mixin, () =>
                               new Set<MixinApplicationElement>());
     users.add(mixinApplication);
   }
 
   bool isUsedAsMixin(ClassElement cls) {
     Set<MixinApplicationElement> uses = mixinUses[cls];
     return uses != null && !uses.isEmpty;
   }
 
   bool hasAnySubclass(ClassElement cls) {
-    Set<ClassElement> classes = subclasses[cls];
+    Set<ClassElement> classes = subclassesOf(cls);
     return classes != null && !classes.isEmpty;
   }
 
   bool hasAnySubtype(ClassElement cls) {
-    Set<ClassElement> classes = subtypes[cls];
+    Set<ClassElement> classes = subtypesOf(cls);
     return classes != null && !classes.isEmpty;
   }
 
   bool hasAnyUserDefinedGetter(Selector selector) {
     return allFunctions.filter(selector).any((each) => each.isGetter());
   }
 
   bool hasAnyUserDefinedSetter(Selector selector) {
      return allFunctions.filter(selector).any((each) => each.isSetter());
   }
 
   // Returns whether a subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassElement superclass, DartType type) {
-    Set<ClassElement> subclasses = typesImplementedBySubclasses[superclass];
+    Set<ClassElement> subclasses = typesImplementedBySubclassesOf(superclass);
     if (subclasses == null) return false;
     return subclasses.contains(type.element);
   }
 
   // Returns whether a subclass of [superclass] mixes in [other].
   bool hasAnySubclassThatMixes(ClassElement superclass, ClassElement other) {
     Set<MixinApplicationElement> uses = mixinUses[other];
     return (uses != null)
         ? uses.any((each) => each.isSubclassOf(superclass))
         : false;
@@ skipping 65 matching lines @@
           sideEffects.setDependsOnInstancePropertyStore();
         } else if (selector.isSetter()) {
           sideEffects.setChangesInstanceProperty();
         }
       }
       sideEffects.add(getSideEffectsOfElement(e));
     }
     return sideEffects;
   }
 }