Remove support for interface in dart2js.

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 1070 matching lines @@
   DartType type;
   final Modifiers modifiers;
 
   FunctionSignature functionSignature;
 
   /**
    * A function declaration that should be parsed instead of the current one.
    * The patch should be parsed as if it was in the current scope. Its
    * signature must match this function's signature.
    */
-  // TODO(lrn): Consider using [defaultImplementation] to store the patch.
   FunctionElement patch = null;
   FunctionElement origin = null;
 
   /**
    * If this is a redirecting factory, [defaultImplementation] will be
-   * changed by the resolver to point to the redirection target.  If
-   * this is an interface constructor, [defaultImplementation] will be
-   * changed by the resolver to point to the default implementation.
+   * changed by the resolver to point to the redirection target.
    * Otherwise, [:identical(defaultImplementation, this):].
    */
-  // TODO(ahe): Rename this field to redirectionTarget and remove
-  // mention of interface constructors above.
+  // TODO(ahe): Rename this field to redirectionTarget.
   FunctionElement defaultImplementation;
 
   FunctionElementX(SourceString name,
                    ElementKind kind,
                    Modifiers modifiers,
                    Element enclosing)
       : this.tooMuchOverloading(name, null, kind, modifiers, enclosing, null);
 
   FunctionElementX.node(SourceString name,
                         FunctionExpression node,
@@ skipping 239 matching lines @@
    * type arguments. For instance should [:List:] be the [rawType] of the
    * [:List:] class element whereas [:List<dynamic>:] should be its own
    * instantiation of [InterfaceType] with [:dynamic:] as type argument. Using
    * this distinction, we can print the raw type with type arguments only when
    * the input source has used explicit type arguments.
    *
    * This type is computed together with [thisType] in [computeType].
    */
   InterfaceType rawTypeCache;
   DartType supertype;
-  DartType defaultClass;
   Link<DartType> interfaces;
   SourceString nativeTagInfo;
   int supertypeLoadState;
   int resolutionState;
 
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const Link<Element>();
 
   Link<DartType> allSupertypes;
@@ skipping 110 matching lines @@
     bool isPrivate = memberName.isPrivate();
     for (ClassElement s = superclass; s != null; s = s.superclass) {
       // Private members from a different library are not visible.
       if (isPrivate && !identical(library, s.getLibrary())) continue;
       Element e = s.lookupLocalMember(memberName);
       if (e == null) continue;
       // Static members are not inherited.
       if (e.modifiers.isStatic()) continue;
       return e;
     }
-    if (isInterface()) {
-      return lookupSuperInterfaceMember(memberName, getLibrary());
-    }
     return null;
   }
 
   Element lookupSuperInterfaceMember(SourceString memberName,
                                      LibraryElement fromLibrary) {
     bool isPrivate = memberName.isPrivate();
     for (InterfaceType t in interfaces) {
       ClassElement cls = t.element;
       Element e = cls.lookupLocalMember(memberName);
       if (e == null) continue;
@@ skipping 244 matching lines @@
   bool isSubclassOf(ClassElement cls) {
     // Use [declaration] for both [this] and [cls], because
     // declaration classes hold the superclass hierarchy.
     cls = cls.declaration;
     for (ClassElement s = declaration; s != null; s = s.superclass) {
       if (identical(s, cls)) return true;
     }
     return false;
   }
 
-  bool isInterface() => false;
   bool isNative() => nativeTagInfo != null;
   void setNative(String name) {
     nativeTagInfo = new SourceString(name);
   }
 }
 
 abstract class ClassElementX extends BaseClassElementX {
   // Lazily applied patch of class members.
   ClassElement patch = null;
   ClassElement origin = null;
@@ skipping 247 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }