Report compile-time error when extending, mixing in or implementing a malformed type.

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 1626 matching lines @@
 
     DartType reportFailureAndCreateType(DualKind messageKind,
                                         Map messageArguments,
                                         {DartType userProvidedBadType}) {
       if (malformedIsError) {
         visitor.error(node, messageKind.error, messageArguments);
       } else {
         compiler.backend.registerThrowRuntimeError(visitor.mapping);
         visitor.warning(node, messageKind.warning, messageArguments);
       }
-      var erroneousElement = new ErroneousElementX(
+      Element erroneousElement = new ErroneousElementX(
           messageKind.error, messageArguments, typeName.source,
           visitor.enclosingElement);
-      var arguments = new LinkBuilder<DartType>();
+      LinkBuilder<DartType> arguments = new LinkBuilder<DartType>();
       resolveTypeArguments(visitor, node, null, arguments);
       return new MalformedType(erroneousElement,
               userProvidedBadType, arguments.toLink());
     }
 
     DartType checkNoTypeArguments(DartType type) {
-      var arguments = new LinkBuilder<DartType>();
+      LinkBuilder<DartType> arguments = new LinkBuilder<DartType>();
       bool hasTypeArgumentMismatch = resolveTypeArguments(
           visitor, node, const Link<DartType>(), arguments);
       if (hasTypeArgumentMismatch) {
-        type = new MalformedType(
+        return new MalformedType(
             new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
                 {'type': node}, typeName.source, visitor.enclosingElement),
                 type, arguments.toLink());
       }
       return type;
     }
 
     if (element == null) {
       type = reportFailureAndCreateType(
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
@@ skipping 2099 matching lines @@
         compiler.backend.registerThrowNoSuchMethod(mapping);
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       element.setDefaultConstructor(constructor, compiler);
     }
     return element.computeType(compiler);
   }
 
   /// Resolves the mixed type for [mixinNode] and checks that the the mixin type
-  /// is not black-listed. The mixin type is returned.
+  /// is a valid, non-blacklisted interface type. The mixin type is returned.
   DartType checkMixinType(TypeAnnotation mixinNode) {
     DartType mixinType = resolveType(mixinNode);
     if (isBlackListed(mixinType)) {
       compiler.reportError(mixinNode,
           MessageKind.CANNOT_MIXIN, {'type': mixinType});
+    } else if (mixinType.kind == TypeKind.TYPE_VARIABLE) {
+      compiler.reportError(mixinNode, MessageKind.CLASS_NAME_EXPECTED);
+    } else if (mixinType.kind == TypeKind.MALFORMED_TYPE) {
+      compiler.reportError(mixinNode, MessageKind.CANNOT_MIXIN_MALFORMED);
     }
     return mixinType;
   }
 
   DartType visitNamedMixinApplication(NamedMixinApplication node) {
     compiler.ensure(element != null);
     compiler.ensure(element.resolutionState == STATE_STARTED);
 
     if (identical(node.classKeyword.stringValue, 'typedef')) {
       // TODO(aprelev@gmail.com): Remove this deprecation diagnostic
@@ skipping 66 matching lines @@
                             namedMixinApplication.superclass)
         : const Link<DartType>();
 
     // The class that is the result of a mixin application implements
     // the interface of the class that was mixed in so always prepend
     // that to the interface list.
     interfaces = interfaces.prepend(mixinType);
     assert(mixinApplication.interfaces == null);
     mixinApplication.interfaces = interfaces;
 
+    if (mixinType.kind != TypeKind.INTERFACE) {
+      mixinApplication.allSupertypes = const Link<DartType>();
+      return;
+    }
+
     assert(mixinApplication.mixin == null);
-    mixinApplication.mixin = resolveMixinFor(mixinApplication, mixinType);
+    Element mixin = resolveMixinFor(mixinApplication, mixinType);
+
+    mixinApplication.mixin = mixin;
 
     // Create forwarding constructors for constructor defined in the superclass
     // because they are now hidden by the mixin application.
     ClassElement superclass = supertype.element;
     superclass.forEachLocalMember((Element member) {
       if (!member.isGenerativeConstructor()) return;
       FunctionElement forwarder =
           createForwardingConstructor(member, mixinApplication);
       mixinApplication.addConstructor(forwarder);
     });
@@ skipping 20 matching lines @@
         return null;
       }
       previous = current;
       current = currentMixinApplication.mixin;
     }
     compiler.world.registerMixinUse(mixinApplication, mixin);
     return mixin;
   }
 
   DartType resolveType(TypeAnnotation node) {
-    // TODO(johnniwinther): Report errors/warnings on resolution failures.
     return typeResolver.resolveTypeAnnotation(this, node);
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
-    DartType supertype = typeResolver.resolveTypeAnnotation(
-        this, superclass, malformedIsError: true);
+    DartType supertype = resolveType(superclass);
     if (supertype != null) {
       if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
-        // Error has already been reported.
+        compiler.reportError(superclass, MessageKind.CANNOT_EXTEND_MALFORMED);
         return null;
       } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
-        // TODO(johnniwinther): Handle dynamic.
-        error(superclass.typeName, MessageKind.CLASS_NAME_EXPECTED);
+        compiler.reportError(superclass.typeName,
+            MessageKind.CLASS_NAME_EXPECTED);
         return null;
       } else if (isBlackListed(supertype)) {
-        error(superclass, MessageKind.CANNOT_EXTEND, {'type': supertype});
+        compiler.reportError(superclass, MessageKind.CANNOT_EXTEND,
+            {'type': supertype});
         return null;
       }
     }
     return supertype;
   }
 
   Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
     Link<DartType> result = const Link<DartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
-      DartType interfaceType = typeResolver.resolveTypeAnnotation(
-          this, link.head, malformedIsError: true);
+      DartType interfaceType = resolveType(link.head);
       if (interfaceType != null) {
         if (identical(interfaceType.kind, TypeKind.MALFORMED_TYPE)) {
-          // Error has already been reported.
+          compiler.reportError(superclass,
+              MessageKind.CANNOT_IMPLEMENT_MALFORMED);
         } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
           // TODO(johnniwinther): Handle dynamic.
           TypeAnnotation typeAnnotation = link.head;
           error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
         } else {
           if (interfaceType == element.supertype) {
             compiler.reportError(
                 superclass,
                 MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS,
                 {'type': interfaceType});
@@ skipping 152 matching lines @@
     visitNodeList(node.mixins);
     visitNodeList(node.interfaces);
   }
 
   void visitTypeAnnotation(TypeAnnotation node) {
     node.typeName.accept(this);
   }
 
   void visitIdentifier(Identifier node) {
     Element element = lookupInScope(compiler, node, context, node.source);
-    if (element == null) {
-      compiler.reportError(
-          node, MessageKind.CANNOT_RESOLVE_TYPE.error, {'typeName': node});
-    } else if (!element.impliesType()) {
-      compiler.reportError(node, MessageKind.NOT_A_TYPE.error, {'node': node});
-    } else {
-      if (element.isClass()) {
-        loadSupertype(element, node);
-      } else {
-        compiler.reportError(node, MessageKind.CLASS_NAME_EXPECTED);
-      }
+    if (element != null && element.isClass()) {
+      loadSupertype(element, node);
     }
   }
 
   void visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix == null) {
       error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
     Element element = lookupInScope(compiler, prefix, context, prefix.source);
@@ skipping 501 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, SourceString name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }