Move dart2js from sdk/lib/_internal/compiler to pkg/compiler

sdk/lib/_internal/compiler/implementation/resolution/class_members.dart

Index: sdk/lib/_internal/compiler/implementation/resolution/class_members.dart
diff --git a/sdk/lib/_internal/compiler/implementation/resolution/class_members.dart b/sdk/lib/_internal/compiler/implementation/resolution/class_members.dart
deleted file mode 100644
index 5e753f8c812b4219625d94d5199b184da27c701c..0000000000000000000000000000000000000000
--- a/sdk/lib/_internal/compiler/implementation/resolution/class_members.dart
+++ /dev/null
@@ -1,898 +0,0 @@
-// 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.
-
-library resolution.compute_members;
-
-import '../elements/elements.dart'
-    show Element,
-         Name,
-         PublicName,
-         Member,
-         MemberSignature,
-         LibraryElement,
-         ClassElement,
-         MixinApplicationElement;
-import '../dart_types.dart';
-import '../dart2jslib.dart'
-    show Compiler,
-         MessageKind,
-         invariant,
-         isPrivateName;
-import '../helpers/helpers.dart';  // Included for debug helpers.
-import '../util/util.dart';
-
-part 'member_impl.dart';
-
-abstract class MembersCreator {
-  final ClassElement cls;
-  final Compiler compiler;
-
-  final Iterable<String> computedMemberNames;
-  final Map<Name, Member> classMembers;
-
-  Map<dynamic/* Member | Element */, Set<MessageKind>> reportedMessages =
-      new Map<dynamic, Set<MessageKind>>();
-
-  MembersCreator(Compiler this.compiler,
-                 ClassElement this.cls,
-                 Iterable<String> this.computedMemberNames,
-                 Map<Name, Member> this.classMembers) {
-    assert(invariant(cls, cls.isDeclaration,
-        message: "Members may only be computed on declarations."));
-  }
-
-  void reportMessage(var marker, MessageKind kind, report()) {
-    Set<MessageKind> messages =
-        reportedMessages.putIfAbsent(marker,
-            () => new Set<MessageKind>());
-    if (messages.add(kind)) {
-      report();
-    }
-  }
-
-  bool shouldSkipMember(MemberSignature member) {
-    return member == null || shouldSkipName(member.name.text);
-
-  }
-
-  bool shouldSkipName(String name) {
-    return computedMemberNames != null &&
-           computedMemberNames.contains(name);
-  }
-
-  /// Compute all members of [cls] with the given names.
-  void computeMembersByName(String name, Setlet<Name> names) {
-    computeMembers(name, names);
-  }
-
-  /// Compute all members of [cls] and checked that [cls] implements its
-  /// interface unless it is abstract or declares a `noSuchMethod` method.
-  void computeAllMembers() {
-    Map<Name, Member> declaredMembers = computeMembers(null, null);
-    if (!cls.isAbstract &&
-        !declaredMembers.containsKey(const PublicName('noSuchMethod'))) {
-      // Check for unimplemented members on concrete classes that neither have
-      // a `@proxy` annotation nor declare a `noSuchMethod` method.
-      checkInterfaceImplementation();
-    }
-  }
-
-  /// Compute declared and inherited members of [cls] and return a map of the
-  /// declared members.
-  ///
-  /// If [name] and [names] are not null, the computation is restricted to
-  /// members with these names.
-  Map<Name, Member> computeMembers(String name, Setlet<Name> names);
-
-  /// Compute the members of the super type(s) of [cls] and store them in
-  /// [classMembers].
-  ///
-  /// If [name] and [names] are not null, the computation is restricted to
-  /// members with these names.
-  void computeSuperMembers(String name, Setlet<Name> names);
-
-  /// Compute the members of the super class of [cls] and store them in
-  /// [classMembers].
-  ///
-  /// If [name] and [names] are not null, the computation is restricted to
-  /// members with these names.
-  void computeSuperClassMembers(String name, Setlet<Name> names) {
-    InterfaceType supertype = cls.supertype;
-    if (supertype == null) return;
-    ClassElement superclass = supertype.element;
-
-    // Inherit class and interface members from superclass.
-    void inheritClassMember(DeclaredMember member) {
-      if (shouldSkipMember(member)) return;
-      if (!member.isStatic) {
-        DeclaredMember inherited = member.inheritFrom(supertype);
-        classMembers[member.name] = inherited;
-      }
-    }
-
-    if (names != null) {
-      _computeClassMember(compiler, superclass, name, names);
-      for (Name memberName in names) {
-        inheritClassMember(superclass.lookupClassMember(memberName));
-      }
-    } else {
-      computeAllClassMembers(compiler, superclass);
-      superclass.forEachClassMember(inheritClassMember);
-    }
-  }
-
-  /// Compute the members declared or directly mixed in [cls].
-  ///
-  /// If [name] and [names] are not null, the computation is restricted to
-  /// members with these names.
-  Map<Name, Member> computeClassMembers(String nameText, Setlet<Name> names) {
-    Map<Name, Member> declaredMembers = new Map<Name, Member>();
-
-    if (cls.isMixinApplication) {
-      MixinApplicationElement mixinApplication = cls;
-      if (mixinApplication.mixin != null) {
-        // Only mix in class members when the mixin type is not malformed.
-
-        void inheritMixinMember(DeclaredMember member) {
-          if (shouldSkipMember(member)) return;
-          Name name = member.name;
-          if (!member.isAbstract && !member.isStatic) {
-            // Abstract and static members are not mixed in.
-            DeclaredMember mixedInMember =
-                member.inheritFrom(mixinApplication.mixinType);
-            DeclaredMember inherited = classMembers[name];
-            classMembers[name] = mixedInMember;
-            checkValidOverride(mixedInMember, inherited);
-          }
-        }
-
-        if (names != null) {
-          _computeClassMember(compiler, mixinApplication.mixin,
-                              nameText, names);
-          for (Name memberName in names) {
-            inheritMixinMember(
-                mixinApplication.mixin.lookupClassMember(memberName));
-          }
-        } else {
-          computeAllClassMembers(compiler, mixinApplication.mixin);
-          mixinApplication.mixin.forEachClassMember(inheritMixinMember);
-        }
-      }
-    } else {
-      LibraryElement library = cls.library;
-      InterfaceType thisType = cls.thisType;
-
-      void createMember(Element element) {
-        if (element.isConstructor) return;
-        String elementName = element.name;
-        if (shouldSkipName(elementName)) return;
-        if (nameText != null && elementName != nameText) return;
-
-        void addDeclaredMember(Name name,
-                               DartType type, FunctionType functionType) {
-          DeclaredMember inherited = classMembers[name];
-          DeclaredMember declared;
-          if (element.isAbstract) {
-            declared = new DeclaredAbstractMember(
-                name, element, thisType, type, functionType,
-                inherited);
-          } else {
-            declared =
-                new DeclaredMember(name, element, thisType, type, functionType);
-          }
-          declaredMembers[name] = declared;
-          classMembers[name] = declared;
-          checkValidOverride(declared, inherited);
-        }
-
-        Name name = new Name(element.name, library);
-        if (element.isField) {
-          DartType type = element.computeType(compiler);
-          addDeclaredMember(name, type, new FunctionType.synthesized(type));
-          if (!element.isConst && !element.isFinal) {
-            addDeclaredMember(name.setter, type,
-                new FunctionType.synthesized(
-                                 const VoidType(),
-                                 <DartType>[type]));
-          }
-        } else if (element.isGetter) {
-          FunctionType functionType = element.computeType(compiler);
-          DartType type = functionType.returnType;
-          addDeclaredMember(name, type, functionType);
-        } else if (element.isSetter) {
-          FunctionType functionType = element.computeType(compiler);
-          DartType type;
-          if (!functionType.parameterTypes.isEmpty) {
-            type = functionType.parameterTypes.first;
-          } else {
-            type = const DynamicType();
-          }
-          name = name.setter;
-          addDeclaredMember(name, type, functionType);
-        } else {
-          assert(invariant(element, element.isFunction));
-          FunctionType type = element.computeType(compiler);
-          addDeclaredMember(name, type, type);
-        }
-      }
-
-      cls.forEachLocalMember(createMember);
-      if (cls.isPatched) {
-        cls.implementation.forEachLocalMember((Element element) {
-          if (element.isDeclaration) {
-            createMember(element);
-          }
-        });
-      }
-    }
-
-    return declaredMembers;
-  }
-
-  /// Checks that [classMember] is a valid implementation for [interfaceMember].
-  void checkInterfaceMember(Name name,
-                            MemberSignature interfaceMember,
-                            Member classMember) {
-    if (classMember != null) {
-      // TODO(johnniwinther): Check that the class member is a valid override
-      // of the interface member.
-      return;
-    }
-    if (interfaceMember is DeclaredMember &&
-        interfaceMember.declarer.element == cls) {
-      // Abstract method declared in [cls].
-      MessageKind kind = MessageKind.ABSTRACT_METHOD;
-      if (interfaceMember.isSetter) {
-        kind = MessageKind.ABSTRACT_SETTER;
-      } else if (interfaceMember.isGetter) {
-        kind = MessageKind.ABSTRACT_GETTER;
-      }
-      reportMessage(
-          interfaceMember.element, MessageKind.ABSTRACT_METHOD, () {
-        compiler.reportWarning(
-            interfaceMember.element, kind,
-            {'class': cls.name, 'name': name.text});
-      });
-    } else {
-       reportWarning(MessageKind singleKind,
-                     MessageKind multipleKind,
-                     MessageKind explicitlyDeclaredKind,
-                     [MessageKind implicitlyDeclaredKind]) {
-        Member inherited = interfaceMember.declarations.first;
-        reportMessage(
-            interfaceMember, MessageKind.UNIMPLEMENTED_METHOD, () {
-          compiler.reportWarning(cls,
-              interfaceMember.declarations.length == 1
-                  ? singleKind : multipleKind,
-              {'class': cls.name,
-               'name': name.text,
-               'method': interfaceMember,
-               'declarer': inherited.declarer});
-          for (Member inherited in interfaceMember.declarations) {
-            compiler.reportInfo(inherited.element,
-                inherited.isDeclaredByField ?
-                    implicitlyDeclaredKind : explicitlyDeclaredKind,
-                {'class': inherited.declarer.name,
-                 'name': name.text});
-          }
-        });
-      }
-      if (interfaceMember.isSetter) {
-        reportWarning(MessageKind.UNIMPLEMENTED_SETTER_ONE,
-                      MessageKind.UNIMPLEMENTED_SETTER,
-                      MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER,
-                      MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER);
-      } else if (interfaceMember.isGetter) {
-        reportWarning(MessageKind.UNIMPLEMENTED_GETTER_ONE,
-                      MessageKind.UNIMPLEMENTED_GETTER,
-                      MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER,
-                      MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER);
-      } else if (interfaceMember.isMethod) {
-        reportWarning(MessageKind.UNIMPLEMENTED_METHOD_ONE,
-                      MessageKind.UNIMPLEMENTED_METHOD,
-                      MessageKind.UNIMPLEMENTED_METHOD_CONT);
-      }
-    }
-    // TODO(johnniwinther): If [cls] is not abstract, check that for all
-    // interface members, there is a class member whose type is a subtype of
-    // the interface member.
-  }
-
-  /// Checks that [cls], if it implements Function, has defined call().
-  void checkImplementsFunctionWithCall() {
-    assert(!cls.isAbstract);
-
-    if (cls.asInstanceOf(compiler.functionClass) == null) return;
-    if (cls.lookupMember(Compiler.CALL_OPERATOR_NAME) != null) return;
-    // TODO(johnniwinther): Make separate methods for backend exceptions.
-    // Avoid warnings on backend implementation classes for closures.
-    if (compiler.backend.isBackendLibrary(cls.library)) return;
-
-    reportMessage(compiler.functionClass, MessageKind.UNIMPLEMENTED_METHOD, () {
-      compiler.reportWarning(cls, MessageKind.UNIMPLEMENTED_METHOD_ONE,
-          {'class': cls.name,
-           'name': Compiler.CALL_OPERATOR_NAME,
-           'method': Compiler.CALL_OPERATOR_NAME,
-           'declarer': compiler.functionClass.name});
-    });
-  }
-
-  /// Checks that a class member exists for every interface member.
-  void checkInterfaceImplementation();
-
-  /// Check that [declared] is a valid override of [superMember].
-  void checkValidOverride(Member declared, MemberSignature superMember) {
-    if (superMember == null) {
-      // No override.
-      if (!declared.isStatic) {
-        ClassElement superclass = cls.superclass;
-        while (superclass != null) {
-          Member superMember =
-              superclass.lookupClassMember(declared.name);
-          if (superMember != null && superMember.isStatic) {
-            reportMessage(superMember, MessageKind.INSTANCE_STATIC_SAME_NAME,
-                () {
-              compiler.reportWarning(
-                  declared.element,
-                  MessageKind.INSTANCE_STATIC_SAME_NAME,
-                  {'memberName': declared.name,
-                    'className': superclass.name});
-              compiler.reportInfo(superMember.element,
-                  MessageKind.INSTANCE_STATIC_SAME_NAME_CONT);
-            });
-            break;
-          }
-          superclass = superclass.superclass;
-        }
-      }
-    } else {
-      assert(declared.name == superMember.name);
-      if (declared.isStatic) {
-        for (Member inherited in superMember.declarations) {
-          reportMessage(
-              inherited.element, MessageKind.NO_STATIC_OVERRIDE, () {
-            reportErrorWithContext(
-                declared.element, MessageKind.NO_STATIC_OVERRIDE,
-                inherited.element, MessageKind.NO_STATIC_OVERRIDE_CONT);
-          });
-        }
-      }
-
-      DartType declaredType = declared.functionType;
-      for (Member inherited in superMember.declarations) {
-
-        void reportError(MessageKind errorKind, MessageKind infoKind) {
-          reportMessage(
-              inherited.element, MessageKind.INVALID_OVERRIDE_METHOD, () {
-            compiler.reportError(declared.element, errorKind,
-                {'name': declared.name.text,
-                 'class': cls.thisType,
-                 'inheritedClass': inherited.declarer});
-            compiler.reportInfo(inherited.element, infoKind,
-                {'name': declared.name.text,
-                 'class': inherited.declarer});
-          });
-        }
-
-        if (declared.isDeclaredByField && inherited.isMethod) {
-          reportError(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD,
-              MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT);
-        } else if (declared.isMethod && inherited.isDeclaredByField) {
-          reportError(MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD,
-              MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT);
-        } else if (declared.isGetter && inherited.isMethod) {
-          reportError(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER,
-                      MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT);
-        } else if (declared.isMethod && inherited.isGetter) {
-          reportError(MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD,
-                      MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT);
-        } else {
-          DartType inheritedType = inherited.functionType;
-          if (!compiler.types.isSubtype(declaredType, inheritedType)) {
-            void reportWarning(var marker,
-                               MessageKind warningKind,
-                               MessageKind infoKind) {
-              reportMessage(marker, MessageKind.INVALID_OVERRIDE_METHOD, () {
-                compiler.reportWarning(declared.element, warningKind,
-                    {'declaredType': declared.type,
-                     'name': declared.name.text,
-                     'class': cls.thisType,
-                     'inheritedType': inherited.type,
-                     'inheritedClass': inherited.declarer});
-                compiler.reportInfo(inherited.element, infoKind,
-                    {'name': declared.name.text,
-                     'class': inherited.declarer});
-              });
-            }
-            if (declared.isDeclaredByField) {
-              if (inherited.isDeclaredByField) {
-                reportWarning(inherited.element,
-                              MessageKind.INVALID_OVERRIDE_FIELD,
-                              MessageKind.INVALID_OVERRIDDEN_FIELD);
-              } else if (inherited.isGetter) {
-                reportWarning(inherited,
-                              MessageKind.INVALID_OVERRIDE_GETTER_WITH_FIELD,
-                              MessageKind.INVALID_OVERRIDDEN_GETTER);
-              } else if (inherited.isSetter) {
-                reportWarning(inherited,
-                              MessageKind.INVALID_OVERRIDE_SETTER_WITH_FIELD,
-                              MessageKind.INVALID_OVERRIDDEN_SETTER);
-              }
-            } else if (declared.isGetter) {
-              if (inherited.isDeclaredByField) {
-                reportWarning(inherited,
-                              MessageKind.INVALID_OVERRIDE_FIELD_WITH_GETTER,
-                              MessageKind.INVALID_OVERRIDDEN_FIELD);
-              } else {
-                reportWarning(inherited,
-                              MessageKind.INVALID_OVERRIDE_GETTER,
-                              MessageKind.INVALID_OVERRIDDEN_GETTER);
-              }
-            } else if (declared.isSetter) {
-              if (inherited.isDeclaredByField) {
-                reportWarning(inherited,
-                              MessageKind.INVALID_OVERRIDE_FIELD_WITH_SETTER,
-                              MessageKind.INVALID_OVERRIDDEN_FIELD);
-              } else {
-                reportWarning(inherited,
-                              MessageKind.INVALID_OVERRIDE_SETTER,
-                              MessageKind.INVALID_OVERRIDDEN_SETTER);
-              }
-            } else {
-              reportWarning(inherited,
-                            MessageKind.INVALID_OVERRIDE_METHOD,
-                            MessageKind.INVALID_OVERRIDDEN_METHOD);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  void reportErrorWithContext(Element errorneousElement,
-                              MessageKind errorMessage,
-                              Element contextElement,
-                              MessageKind contextMessage) {
-    compiler.reportError(
-        errorneousElement,
-        errorMessage,
-        {'memberName': contextElement.name,
-         'className': contextElement.enclosingClass.name});
-    compiler.reportInfo(contextElement, contextMessage);
-  }
-
-  /// Compute all class and interface names by the [name] in [cls].
-  static void computeClassMembersByName(Compiler compiler,
-                                        ClassMemberMixin cls,
-                                        String name) {
-    if (cls.isMemberComputed(name)) return;
-    LibraryElement library = cls.library;
-    _computeClassMember(compiler, cls, name,
-        new Setlet<Name>()..add(new Name(name, library))
-                          ..add(new Name(name, library, isSetter: true)));
-  }
-
-  static void _computeClassMember(Compiler compiler,
-                                  ClassMemberMixin cls,
-                                  String name,
-                                  Setlet<Name> names) {
-    cls.computeClassMember(compiler, name, names);
-  }
-
-  /// Compute all class and interface names in [cls].
-  static void computeAllClassMembers(Compiler compiler, ClassMemberMixin cls) {
-    cls.computeAllClassMembers(compiler);
-  }
-}
-
-/// Class member creator for classes where the interface members are known to
-/// be a subset of the class members.
-class ClassMembersCreator extends MembersCreator {
-  ClassMembersCreator(Compiler compiler,
-                      ClassElement cls,
-                      Iterable<String> computedMemberNames,
-                      Map<Name, Member> classMembers)
-      : super(compiler, cls, computedMemberNames, classMembers);
-
-  Map<Name, Member> computeMembers(String name, Setlet<Name> names) {
-    computeSuperMembers(name, names);
-    return computeClassMembers(name, names);
-  }
-
-  void computeSuperMembers(String name, Setlet<Name> names) {
-    computeSuperClassMembers(name, names);
-  }
-
-  void checkInterfaceImplementation() {
-    LibraryElement library = cls.library;
-    classMembers.forEach((Name name, Member classMember) {
-      if (!name.isAccessibleFrom(library)) return;
-     checkInterfaceMember(name, classMember, classMember.implementation);
-    });
-  }
-}
-
-/// Class Member creator for classes where the interface members might be
-/// different from the class members.
-class InterfaceMembersCreator extends MembersCreator {
-  final Map<Name, MemberSignature> interfaceMembers;
-
-  InterfaceMembersCreator(Compiler compiler,
-                          ClassElement cls,
-                          Iterable<String> computedMemberNames,
-                          Map<Name, Member> classMembers,
-                          Map<Name, MemberSignature> this.interfaceMembers)
-      : super(compiler, cls, computedMemberNames, classMembers);
-
-  Map<Name, Member> computeMembers(String name, Setlet<Name> names) {
-    Map<Name, Setlet<Member>> inheritedInterfaceMembers =
-        computeSuperMembers(name, names);
-    Map<Name, Member> declaredMembers = computeClassMembers(name, names);
-    computeInterfaceMembers(inheritedInterfaceMembers, declaredMembers);
-    return declaredMembers;
-  }
-
-  /// Compute the members of the super type(s) of [cls]. The class members are
-  /// stored if the [classMembers] map and the inherited interface members are
-  /// returned.
-  ///
-  /// If [name] and [names] are not null, the computation is restricted to
-  /// members with these names.
-  Map<Name, Setlet<Member>> computeSuperMembers(String name,
-                                                Setlet<Name> names) {
-    computeSuperClassMembers(name, names);
-    return computeSuperInterfaceMembers(name, names);
-  }
-
-  Map<Name, Setlet<Member>> computeSuperInterfaceMembers(String name,
-                                                         Setlet<Name> names) {
-
-
-    InterfaceType supertype = cls.supertype;
-    assert(invariant(cls, supertype != null,
-        message: "Interface members computed for $cls."));
-    ClassElement superclass = supertype.element;
-
-    Map<Name, Setlet<Member>> inheritedInterfaceMembers =
-        new Map<Name, Setlet<Member>>();
-
-    void inheritInterfaceMember(InterfaceType supertype,
-                                MemberSignature member) {
-      if (shouldSkipMember(member)) return;
-      Setlet<Member> members =
-          inheritedInterfaceMembers.putIfAbsent(
-              member.name, () => new Setlet<Member>());
-      for (DeclaredMember declaredMember in member.declarations) {
-        members.add(declaredMember.inheritFrom(supertype));
-      }
-    }
-
-    void inheritInterfaceMembers(InterfaceType supertype) {
-      supertype.element.forEachInterfaceMember((MemberSignature member) {
-        inheritInterfaceMember(supertype, member);
-      });
-    }
-
-    if (names != null) {
-      for (Name memberName in names) {
-        inheritInterfaceMember(supertype,
-            superclass.lookupInterfaceMember(memberName));
-      }
-    } else {
-      inheritInterfaceMembers(supertype);
-    }
-
-    // Inherit interface members from superinterfaces.
-    for (Link<DartType> link = cls.interfaces;
-         !link.isEmpty;
-         link = link.tail) {
-      InterfaceType superinterface = link.head;
-      if (names != null) {
-        MembersCreator._computeClassMember(
-            compiler, superinterface.element, name, names);
-        for (Name memberName in names) {
-          inheritInterfaceMember(superinterface,
-              superinterface.element.lookupInterfaceMember(memberName));
-        }
-      } else {
-        MembersCreator.computeAllClassMembers(compiler, superinterface.element);
-        inheritInterfaceMembers(superinterface);
-      }
-    }
-
-    return inheritedInterfaceMembers;
-  }
-
-  /// Checks that a class member exists for every interface member.
-  void checkInterfaceImplementation() {
-    LibraryElement library = cls.library;
-    checkImplementsFunctionWithCall();
-    interfaceMembers.forEach((Name name, MemberSignature interfaceMember) {
-      if (!name.isAccessibleFrom(library)) return;
-      Member classMember = classMembers[name];
-      if (classMember != null) classMember = classMember.implementation;
-      checkInterfaceMember(name, interfaceMember, classMember);
-    });
-  }
-
-  /// Compute the interface members of [cls] given the set of inherited
-  /// interface members [inheritedInterfaceMembers] and declared members
-  /// [declaredMembers]. The computed members are stored in [interfaceMembers].
-  void computeInterfaceMembers(
-        Map<Name, Setlet<Member>> inheritedInterfaceMembers,
-        Map<Name, Member> declaredMembers) {
-    InterfaceType thisType = cls.thisType;
-    // Compute the interface members by overriding the inherited members with
-    // a declared member or by computing a single, possibly synthesized,
-    // inherited member.
-    inheritedInterfaceMembers.forEach(
-        (Name name, Setlet<Member> inheritedMembers) {
-      Member declared = declaredMembers[name];
-      if (declared != null) {
-        // Check that [declaredMember] is a valid override
-        for (Member inherited in inheritedMembers) {
-          checkValidOverride(declared, inherited);
-        }
-        if (!declared.isStatic) {
-          interfaceMembers[name] = declared;
-        }
-      } else if (inheritedMembers.length == 1) {
-        interfaceMembers[name] = inheritedMembers.single;
-      } else {
-        bool someAreGetters = false;
-        bool allAreGetters = true;
-        Map<DartType, Setlet<Member>> subtypesOfAllInherited =
-            new Map<DartType, Setlet<Member>>();
-        outer: for (Member inherited in inheritedMembers) {
-          if (inherited.isGetter) {
-            someAreGetters = true;
-            if (!allAreGetters) break outer;
-          } else {
-            allAreGetters = false;
-            if (someAreGetters) break outer;
-          }
-          for (MemberSignature other in inheritedMembers) {
-            if (!compiler.types.isSubtype(inherited.functionType,
-                                          other.functionType)) {
-              continue outer;
-            }
-          }
-          subtypesOfAllInherited.putIfAbsent(inherited.functionType,
-              () => new Setlet<Member>()).add(inherited);
-        }
-        if (someAreGetters && !allAreGetters) {
-          compiler.reportWarning(cls,
-                                 MessageKind.INHERIT_GETTER_AND_METHOD,
-                                 {'class': thisType, 'name': name.text });
-          for (Member inherited in inheritedMembers) {
-            MessageKind kind;
-            if (inherited.isMethod) {
-              kind = MessageKind.INHERITED_METHOD;
-            } else {
-              assert(invariant(cls, inherited.isGetter,
-                  message: 'Conflicting member is neither a method nor a '
-                           'getter.'));
-              if (inherited.isDeclaredByField) {
-                kind = MessageKind.INHERITED_IMPLICIT_GETTER;
-              } else {
-                kind = MessageKind.INHERITED_EXPLICIT_GETTER;
-              }
-            }
-            compiler.reportInfo(inherited.element, kind,
-                {'class': inherited.declarer, 'name': name.text });
-          }
-          interfaceMembers[name] = new ErroneousMember(inheritedMembers);
-        } else if (subtypesOfAllInherited.length == 1) {
-          // All signatures have the same type.
-          Setlet<Member> members = subtypesOfAllInherited.values.first;
-          MemberSignature inherited = members.first;
-          if (members.length != 1) {
-            // Multiple signatures with the same type => return a
-            // synthesized signature.
-            inherited = new SyntheticMember(
-                members, inherited.type, inherited.functionType);
-          }
-          interfaceMembers[name] = inherited;
-        } else {
-          _inheritedSynthesizedMember(name, inheritedMembers);
-        }
-      }
-    });
-
-    // Add the non-overriding instance methods to the interface members.
-    declaredMembers.forEach((Name name, Member member) {
-      if (!member.isStatic) {
-        interfaceMembers.putIfAbsent(name, () => member);
-      }
-    });
-  }
-
-  /// Create and inherit a synthesized member for [inheritedMembers].
-  void _inheritedSynthesizedMember(Name name,
-                                   Setlet<Member> inheritedMembers) {
-    // Multiple signatures with different types => create the synthesized
-    // version.
-    int minRequiredParameters;
-    int maxPositionalParameters;
-    Set<String> names = new Set<String>();
-    for (MemberSignature member in inheritedMembers) {
-      int requiredParameters = 0;
-      int optionalParameters = 0;
-      if (member.isSetter) {
-        requiredParameters = 1;
-      }
-      if (member.type.isFunctionType) {
-        FunctionType type = member.type;
-        type.namedParameters.forEach(
-            (String name) => names.add(name));
-        requiredParameters = type.parameterTypes.length;
-        optionalParameters = type.optionalParameterTypes.length;
-      }
-      int positionalParameters = requiredParameters + optionalParameters;
-      if (minRequiredParameters == null ||
-          minRequiredParameters > requiredParameters) {
-        minRequiredParameters = requiredParameters;
-      }
-      if (maxPositionalParameters == null ||
-          maxPositionalParameters < positionalParameters) {
-        maxPositionalParameters = positionalParameters;
-      }
-    }
-    int optionalParameters =
-        maxPositionalParameters - minRequiredParameters;
-    // TODO(johnniwinther): Support function types with both optional
-    // and named parameters?
-    if (optionalParameters == 0 || names.isEmpty) {
-      DartType dynamic = const DynamicType();
-      List<DartType> requiredParameterTypes =
-          new List.filled(minRequiredParameters, dynamic);
-      List<DartType> optionalParameterTypes =
-          new List.filled(optionalParameters, dynamic);
-      List<String> namedParameters =
-          names.toList()..sort((a, b) => a.compareTo(b));
-      List<DartType> namedParameterTypes =
-          new List.filled(namedParameters.length, dynamic);
-      FunctionType memberType = new FunctionType.synthesized(
-          const DynamicType(),
-          requiredParameterTypes,
-          optionalParameterTypes,
-          namedParameters, namedParameterTypes);
-      DartType type = memberType;
-      if (inheritedMembers.first.isGetter ||
-          inheritedMembers.first.isSetter) {
-        type = const DynamicType();
-      }
-      interfaceMembers[name] =
-          new SyntheticMember(inheritedMembers, type, memberType);
-    }
-  }
-}
-
-abstract class ClassMemberMixin implements ClassElement {
-  /// When [classMembers] and [interfaceMembers] have not been fully computed
-  /// [computedMembersNames] holds the names for which members have already been
-  /// computed.
-  ///
-  /// If [computedMemberNames], [classMembers] and [interfaceMembers] are `null`
-  /// no members have been computed, if only [computedMemberNames] is `null` all
-  /// members have been computed. A non-null [computedMemberNames] implicitly
-  /// includes `call`.
-  Iterable<String> computedMemberNames;
-
-  /// If `true` interface members are the non-static class member.
-  bool interfaceMembersAreClassMembers = true;
-
-  Map<Name, Member> classMembers;
-  Map<Name, MemberSignature> interfaceMembers;
-
-  /// Creates the necessary maps and [MembersCreator] for compute members of
-  /// this class.
-  MembersCreator _prepareCreator(Compiler compiler) {
-    if (classMembers == null) {
-      classMembers = new Map<Name, Member>();
-
-      if (interfaceMembersAreClassMembers) {
-        ClassMemberMixin superclass = this.superclass;
-        if ((superclass != null &&
-             (!superclass.interfaceMembersAreClassMembers ||
-              superclass.isMixinApplication)) ||
-             !interfaces.isEmpty) {
-          interfaceMembersAreClassMembers = false;
-        }
-      }
-      if (!interfaceMembersAreClassMembers) {
-        interfaceMembers = new Map<Name, MemberSignature>();
-      }
-    }
-    return interfaceMembersAreClassMembers
-        ? new ClassMembersCreator(compiler, this,
-            computedMemberNames, classMembers)
-        : new InterfaceMembersCreator(compiler, this,
-            computedMemberNames, classMembers, interfaceMembers);
-  }
-
-  static Iterable<String> _EMPTY_MEMBERS_NAMES = const <String>[];
-
-  /// Compute the members by the name [name] for this class. [names] collects
-  /// the set of possible variations of [name], including getter, setter and
-  /// and private names.
-  void computeClassMember(Compiler compiler, String name, Setlet<Name> names) {
-    if (isMemberComputed(name)) return;
-    if (isPrivateName(name)) {
-      names..add(new Name(name, library))
-           ..add(new Name(name, library, isSetter: true));
-    }
-    MembersCreator creator = _prepareCreator(compiler);
-    creator.computeMembersByName(name, names);
-    if (computedMemberNames == null) {
-      computedMemberNames = _EMPTY_MEMBERS_NAMES;
-    }
-    if (name != Compiler.CALL_OPERATOR_NAME) {
-      Setlet<String> set;
-      if (identical(computedMemberNames, _EMPTY_MEMBERS_NAMES)) {
-        computedMemberNames = set = new Setlet<String>();
-      } else {
-        set = computedMemberNames;
-      }
-      set.add(name);
-    }
-  }
-
-  void computeAllClassMembers(Compiler compiler) {
-    if (areAllMembersComputed()) return;
-    MembersCreator creator = _prepareCreator(compiler);
-    creator.computeAllMembers();
-    computedMemberNames = null;
-    assert(invariant(this, areAllMembersComputed()));
-  }
-
-  bool areAllMembersComputed() {
-    return computedMemberNames == null && classMembers != null;
-  }
-
-  bool isMemberComputed(String name) {
-    if (computedMemberNames == null) {
-      return classMembers != null;
-    } else {
-      return name == Compiler.CALL_OPERATOR_NAME ||
-             computedMemberNames.contains(name);
-    }
-  }
-
-  Member lookupClassMember(Name name) {
-    assert(invariant(this,
-        isMemberComputed(name.text),
-        message: "Member ${name} has not been computed for $this."));
-    return classMembers[name];
-  }
-
-  void forEachClassMember(f(Member member)) {
-    assert(invariant(this, areAllMembersComputed(),
-        message: "Members have not been fully computed for $this."));
-    classMembers.forEach((_, member) => f(member));
-  }
-
-  MemberSignature lookupInterfaceMember(Name name) {
-    assert(invariant(this, isMemberComputed(name.text),
-        message: "Member ${name.text} has not been computed for $this."));
-    if (interfaceMembersAreClassMembers) {
-      Member member = classMembers[name];
-      if (member != null && member.isStatic) return null;
-      return member;
-    }
-    return interfaceMembers[name];
-  }
-
-  void forEachInterfaceMember(f(MemberSignature member)) {
-    assert(invariant(this, areAllMembersComputed(),
-        message: "Members have not been fully computed for $this."));
-    if (interfaceMembersAreClassMembers) {
-      classMembers.forEach((_, member) {
-        if (!member.isStatic) f(member);
-      });
-    } else {
-      interfaceMembers.forEach((_, member) => f(member));
-    }
-  }
-}