Remove support for interface in dart2js.

sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 284 matching lines @@
       return compiler.withCurrentElement(element, () {
         FunctionExpression tree = element.parseNode(compiler);
         if (tree.modifiers.isExternal()) {
           error(tree, MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
           return;
         }
         if (isConstructor) {
           if (tree.returnType != null) {
             error(tree, MessageKind.CONSTRUCTOR_WITH_RETURN_TYPE);
           }
-          resolveConstructorImplementation(element, tree);
         }
         ResolverVisitor visitor = visitorFor(element);
         visitor.useElement(tree, element);
         visitor.setupFunction(tree, element);
 
         if (isConstructor) {
           // Even if there is no initializer list we still have to do the
           // resolution in case there is an implicit super constructor call.
           InitializerResolver resolver = new InitializerResolver(visitor);
           FunctionElement redirection =
@@ skipping 34 matching lines @@
     var mapping = new TreeElementMapping(element);
     return new ResolverVisitor(compiler, element, mapping);
   }
 
   void visitBody(ResolverVisitor visitor, Statement body) {
     if (!compiler.analyzeSignaturesOnly) {
       visitor.visit(body);
     }
   }
 
-  void resolveConstructorImplementation(FunctionElement constructor,

[ahe, 2013/05/03 13:57:34]

YAY!

-                                        FunctionExpression node) {
-    if (!identical(constructor.defaultImplementation, constructor)) return;
-    ClassElement intrface = constructor.getEnclosingClass();
-    if (!intrface.isInterface()) return;
-    DartType defaultType = intrface.defaultClass;
-    if (defaultType == null) {
-      error(node, MessageKind.NO_DEFAULT_CLASS,
-            {'interfaceName': intrface.name});
-    }
-    ClassElement defaultClass = defaultType.element;
-    defaultClass.ensureResolved(compiler);
-    assert(defaultClass.resolutionState == STATE_DONE);
-    assert(defaultClass.supertypeLoadState == STATE_DONE);
-    if (defaultClass.isInterface()) {
-      error(node, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
-            {'interfaceName': defaultClass.name});
-    }
-    // We have now established the following:
-    // [intrface] is an interface, let's say "MyInterface".
-    // [defaultClass] is a class, let's say "MyClass".
-
-    Selector selector;
-    // If the default class implements the interface then we must use the
-    // default class' name. Otherwise we look for a factory with the name
-    // of the interface.
-    if (defaultClass.implementsInterface(intrface)) {
-      var constructorNameString = constructor.name.slowToString();
-      // Create selector based on constructor.name but where interface
-      // is replaced with default class name.
-      // TODO(ahe): Don't use string manipulations here.
-      int classNameSeparatorIndex = constructorNameString.indexOf('\$');
-      if (classNameSeparatorIndex < 0) {
-        selector = new Selector.callDefaultConstructor(
-            defaultClass.getLibrary());
-      } else {
-        selector = new Selector.callConstructor(
-            new SourceString(
-                constructorNameString.substring(classNameSeparatorIndex + 1)),
-            defaultClass.getLibrary());
-      }
-      constructor.defaultImplementation =
-          defaultClass.lookupConstructor(selector);
-    } else {
-      selector =
-          new Selector.callConstructor(constructor.name,
-                                       defaultClass.getLibrary());
-      constructor.defaultImplementation =
-          defaultClass.lookupFactoryConstructor(selector);
-    }
-    if (constructor.defaultImplementation == null) {
-      // We failed to find a constructor named either
-      // "MyInterface.name" or "MyClass.name".
-      // TODO(aprelev@gmail.com): Use constructorNameForDiagnostics in
-      // the error message below.
-      error(node,
-            MessageKind.CANNOT_FIND_CONSTRUCTOR2,
-            {'constructorName': selector.name, 'className': defaultClass.name});
-    }
-  }
-
   TreeElements resolveField(VariableElement element) {
     Node tree = element.parseNode(compiler);
     if(element.modifiers.isStatic() && element.variables.isTopLevel()) {
       error(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
     // TODO(johnniwinther): Avoid analyzing initializers if
     // [Compiler.analyzeSignaturesOnly] is set.
     initializerDo(tree, visitor.visit);
@@ skipping 128 matching lines @@
         element.patch.ensureResolved(compiler);
       }
     } else { // Handle patch classes:
       element.resolutionState = STATE_STARTED;
       // Ensure handling origin before patch.
       element.origin.ensureResolved(compiler);
       // Ensure that the type is computed.
       element.computeType(compiler);
       // Copy class hiearchy from origin.
       element.supertype = element.origin.supertype;
-      element.defaultClass = element.origin.defaultClass;
       element.interfaces = element.origin.interfaces;
       element.allSupertypes = element.origin.allSupertypes;
       // Stepwise assignment to ensure invariant.
       element.supertypeLoadState = STATE_STARTED;
       element.supertypeLoadState = STATE_DONE;
       element.resolutionState = STATE_DONE;
       // TODO(johnniwinther): Check matching type variables and
       // empty extends/implements clauses.
     }
     for (MetadataAnnotation metadata in element.metadata) {
@@ skipping 1987 matching lines @@
     }
     resolveSelector(node.send, constructor);
     resolveArguments(node.send.argumentsNode);
     useElement(node.send, constructor);
     if (Elements.isUnresolved(constructor)) return constructor;
     Selector callSelector = mapping.getSelector(node.send);
     if (!callSelector.applies(constructor, compiler)) {
       warnArgumentMismatch(node.send, constructor);
       compiler.backend.registerThrowNoSuchMethod(mapping);
     }
-    compiler.withCurrentElement(constructor, () {
-      FunctionExpression tree = constructor.parseNode(compiler);
-      compiler.resolver.resolveConstructorImplementation(constructor, tree);
-    });
 
-    if (constructor.defaultImplementation != constructor) {
-      // Support for deprecated interface support.
-      // TODO(ngeoffray): Remove once we remove such support.
-      world.registerStaticUse(constructor.declaration);
-      world.registerInstantiatedClass(
-          constructor.getEnclosingClass().declaration, mapping);
-      constructor = constructor.defaultImplementation;
-    }
-    // [constructor.defaultImplementation] might be the implementation element
+    // [constructor] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.declaration);
     ClassElement cls = constructor.getEnclosingClass();
     InterfaceType type = mapping.getType(node);
     world.registerInstantiatedType(type, mapping);
     if (constructor.isFactoryConstructor() && !type.typeArguments.isEmpty) {
       world.registerFactoryWithTypeArguments(mapping);
     }
     if (cls.isAbstract(compiler)) {
       compiler.backend.registerAbstractClassInstantiation(mapping);
@@ skipping 629 matching lines @@
           superElement.ensureResolved(compiler);
         }
         element.supertype = superElement.computeType(compiler);
       }
     }
 
     assert(element.interfaces == null);
     element.interfaces = resolveInterfaces(node.interfaces, node.superclass);
     calculateAllSupertypes(element);
 
-    if (node.defaultClause != null) {
-      element.defaultClass = visit(node.defaultClause);
-    }
     element.addDefaultConstructorIfNeeded(compiler);
     return element.computeType(compiler);
   }
 
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
     compiler.ensure(element != null);
     compiler.ensure(element.resolutionState == STATE_STARTED);
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
@@ skipping 72 matching lines @@
         // infinite recursion when traversing members.
         return null;
       }
       previous = current;
       current = currentMixinApplication.mixin;
     }
     compiler.world.registerMixinUse(mixinApplication, mixin);
     return mixin;
   }
 
-  // TODO(johnniwinther): Remove when default class is no longer supported.
-  DartType visitTypeAnnotation(TypeAnnotation node) {
-    return visit(node.typeName);
-  }
-
   DartType resolveType(TypeAnnotation node) {
     // TODO(johnniwinther): Report errors/warnings on resolution failures.
     return typeResolver.resolveTypeAnnotation(this, node);
   }
 
-  // TODO(johnniwinther): Remove when default class is no longer supported.
-  DartType visitIdentifier(Identifier node) {
-    Element element = scope.lookup(node.source);
-    if (element == null) {
-      error(node, MessageKind.CANNOT_RESOLVE_TYPE,  {'typeName': node});
-      return null;
-    } else if (!element.impliesType() && !element.isTypeVariable()) {
-      error(node, MessageKind.NOT_A_TYPE, {'node': node});
-      return null;
-    } else {
-      if (element.isTypeVariable()) {
-        TypeVariableElement variableElement = element;
-        return variableElement.type;
-      } else if (element.isTypedef()) {
-        compiler.unimplemented('visitIdentifier for typedefs', node: node);
-      } else {
-        // TODO(ngeoffray): Use type variables.
-        return element.computeType(compiler);
-      }
-    }
-    return null;
-  }
-
-  // TODO(johnniwinther): Remove when default class is no longer supported.
-  DartType visitSend(Send node) {
-    Identifier prefix = node.receiver.asIdentifier();
-    if (prefix == null) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
-      return null;
-    }
-    Element element = scope.lookup(prefix.source);
-    if (element == null || !identical(element.kind, ElementKind.PREFIX)) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
-      return null;
-    }
-    PrefixElement prefixElement = element;
-    Identifier selector = node.selector.asIdentifier();
-    var e = prefixElement.lookupLocalMember(selector.source);
-    if (e == null || !e.impliesType()) {
-      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
-            {'typeName': node.selector});
-      return null;
-    }
-    return e.computeType(compiler);
-  }
-
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
     DartType supertype = typeResolver.resolveTypeAnnotation(
         this, superclass, onFailure: error);
     if (supertype != null) {
       if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
         // Error has already been reported.
         return null;
       } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
         // TODO(johnniwinther): Handle dynamic.
         error(superclass.typeName, MessageKind.CLASS_NAME_EXPECTED);
@@ skipping 511 matching lines @@
   /// Finishes resolution of a constructor reference and records the
   /// type of the constructed instance on [expression].
   FunctionElement finishConstructorReference(Element e,
                                              Node diagnosticNode,
                                              Node expression) {
     // Find the unnamed constructor if the reference resolved to a
     // class.
     if (!Elements.isUnresolved(e) && e.isClass()) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
-      if (cls.isInterface() && (cls.defaultClass == null)) {
-        // TODO(ahe): Remove this check and error message when we
-        // don't have interfaces anymore.
-        error(diagnosticNode,
-              MessageKind.CANNOT_INSTANTIATE_INTERFACE,
-              {'interfaceName': cls.name});
-      }
       // The unnamed constructor may not exist, so [e] may become unresolved.
       e = lookupConstructor(cls, diagnosticNode, const SourceString(''));
     }
     if (type == null) {
       if (Elements.isUnresolved(e)) {
         type = compiler.dynamicClass.computeType(compiler);
       } else {
         type = e.getEnclosingClass().computeType(compiler).asRaw();
       }
     }
     resolver.mapping.setType(expression, type);
     return e;
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     assert(invariant(node, type == null));
     type = resolver.resolveTypeRequired(node);
     return resolver.mapping[node];
   }
 
   visitSend(Send node) {
     Element e = visit(node.receiver);
     if (Elements.isUnresolved(e)) return e;
     Identifier name = node.selector.asIdentifier();
     if (name == null) internalError(node.selector, 'unexpected node');
 
     if (identical(e.kind, ElementKind.CLASS)) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
-      if (cls.isInterface() && (cls.defaultClass == null)) {
-        error(node.receiver,
-              MessageKind.CANNOT_INSTANTIATE_INTERFACE,
-              {'interfaceName': cls.name});
-      }
       return lookupConstructor(cls, name, name.source);
     } else if (identical(e.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = e;
       e = prefix.lookupLocalMember(name.source);
       if (e == null) {
         return failOrReturnErroneousElement(resolver.enclosingElement, name,
                                             name.source,
                                             MessageKind.CANNOT_RESOLVE,
                                             {'name': name});
       } else if (!identical(e.kind, ElementKind.CLASS)) {
@@ skipping 28 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }