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

sdk/lib/_internal/compiler/implementation/elements/modelx.dart

 // Copyright (c) 2013, 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 elements.modelx;
 
 import 'dart:uri';
 import 'dart:collection' show LinkedHashMap;
 
 import 'elements.dart';
@@ skipping 1480 matching lines @@
   void addDefaultConstructorIfNeeded(Compiler compiler) {
     if (hasConstructor) return;
     FunctionElement constructor =
         new SynthesizedConstructorElementX.forDefault(this, compiler);
     setDefaultConstructor(constructor, compiler);
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler);
 
   void addBackendMember(Element member) {
+    // TODO(ngeoffray): Deprecate this method.
+    assert(member.isGenerativeConstructorBody());
     backendMembers = backendMembers.prepend(member);
   }
 
   void reverseBackendMembers() {
     backendMembers = backendMembers.reverse();
   }
 
   /**
    * Lookup local members in the class. This will ignore constructors.
    */
@@ skipping 72 matching lines @@
   }
 
   Element internalLookupSelector(Selector selector, bool isSuperLookup) {
     SourceString name = selector.name;
     bool isPrivate = name.isPrivate();
     LibraryElement library = selector.library;
     for (ClassElement current = isSuperLookup ? superclass : this;
          current != null;
          current = current.superclass) {
       Element member = current.lookupLocalMember(name);
+      if (member == null && current.isPatched) {
+        // Doing lookups on selectors is done after resolution, so it
+        // is safe to look in the patch class.
+        member = current.patch.lookupLocalMember(name);
+      }
       if (member == null) continue;
       // Private members from a different library are not visible.
       if (isPrivate && !identical(library, member.getLibrary())) continue;
       // Static members are not inherited.
       if (member.modifiers.isStatic() && !identical(this, current)) continue;
       // If we find an abstract field we have to make sure that it has
       // the getter or setter part we're actually looking
       // for. Otherwise, we continue up the superclass chain.
       if (member.isAbstractField()) {
         AbstractFieldElement field = member;
@@ skipping 105 matching lines @@
    */
   ClassElement get superclass {
     assert(supertypeLoadState == STATE_DONE);
     return supertype == null ? null : supertype.element;
   }
 
   /**
    * Runs through all members of this class.
    *
    * The enclosing class is passed to the callback. This is useful when
-   * [includeSuperMembers] is [:true:].
+   * [includeSuperAndInjectedMembers] is [:true:].
    *
    * When called on an implementation element both the members in the origin
    * and patch class are included.
    */
   // TODO(johnniwinther): Clean up lookup to get rid of the include predicates.
   void forEachMember(void f(ClassElement enclosingClass, Element member),
                      {includeBackendMembers: false,
-                      includeSuperMembers: false}) {
-    bool includeInjectedMembers = isPatch;
+                      includeSuperAndInjectedMembers: false}) {
+    bool includeInjectedMembers = includeSuperAndInjectedMembers || isPatch;
     Set<ClassElement> seen = new Set<ClassElement>();
     ClassElement classElement = declaration;
     do {
       if (seen.contains(classElement)) return;
       seen.add(classElement);
 
       // Iterate through the members in textual order, which requires
       // to reverse the data structure [localMembers] we created.
       // Textual order may be important for certain operations, for
       // example when emitting the initializers of fields.
       classElement.forEachLocalMember((e) => f(classElement, e));
       if (includeBackendMembers) {
         classElement.forEachBackendMember((e) => f(classElement, e));
       }
       if (includeInjectedMembers) {
         if (classElement.patch != null) {
           classElement.patch.forEachLocalMember((e) {
             if (!e.isPatch) f(classElement, e);
           });
         }
       }
-      classElement = includeSuperMembers ? classElement.superclass : null;
+      classElement = includeSuperAndInjectedMembers
+          ? classElement.superclass
+          : null;
     } while(classElement != null);
   }
 
   /**
    * Runs through all instance-field members of this class.
    *
    * The enclosing class is passed to the callback. This is useful when
-   * [includeSuperMembers] is [:true:].
-   *
-   * When [includeBackendMembers] and [includeSuperMembers] are both [:true:]
-   * then the fields are visited in the same order as they need to be given
-   * to the JavaScript constructor.
+   * [includeSuperAndInjectedMembers] is [:true:].
    *
    * When called on the implementation element both the fields declared in the
    * origin and in the patch are included.
    */
   void forEachInstanceField(void f(ClassElement enclosingClass, Element field),
-                            {includeBackendMembers: false,
-                             includeSuperMembers: false}) {
+                            {includeSuperAndInjectedMembers: false}) {
     // Filters so that [f] is only invoked with instance fields.
     void fieldFilter(ClassElement enclosingClass, Element member) {
       if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
         f(enclosingClass, member);
       }
     }
 
     forEachMember(fieldFilter,
-                  includeBackendMembers: includeBackendMembers,
-                  includeSuperMembers: includeSuperMembers);
+        includeSuperAndInjectedMembers: includeSuperAndInjectedMembers);
   }
 
   void forEachBackendMember(void f(Element member)) {
     backendMembers.forEach(f);
   }
 
   bool implementsInterface(ClassElement intrface) {
     for (DartType implementedInterfaceType in allSupertypes) {
       ClassElement implementedInterface = implementedInterfaceType.element;
       if (identical(implementedInterface, intrface)) {
@@ skipping 297 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }