Improve error reporting when a mixin application is invalid.

pkg/analyzer/lib/src/generated/error_verifier.dart

 // Copyright (c) 2014, 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 engine.resolver.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'java_engine.dart';
@@ skipping 3978 matching lines @@
 
   /**
    * This checks that if the passed class declaration implicitly calls default constructor of its
    * superclass, there should be such default constructor - implicit or explicit.
    *
    * @param node the [ClassDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT].
    */
   bool _checkForNoDefaultSuperConstructorImplicit(ClassDeclaration node) {
+    // do nothing if mixin errors have already been reported for this class.
+    if (_enclosingClass.mixinErrorsReported) {
+      return false;
+    }
     // do nothing if there is explicit constructor
     List<ConstructorElement> constructors = _enclosingClass.constructors;
     if (!constructors[0].isSynthetic) {
       return false;
     }
     // prepare super
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
@@ skipping 819 matching lines @@
    * invocation nor a redirecting constructor invocation, that the superclass has a default
    * generative constructor.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT],
    * [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR], and
    * [StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT].
    */
   bool _checkForUndefinedConstructorInInitializerImplicit(ConstructorDeclaration node) {
+    if (_enclosingClass == null) {
+      return false;
+    }
+    // do nothing if mixin errors have already been reported for this class.
+    if (_enclosingClass.mixinErrorsReported) {
+      return false;
+    }
     //
     // Ignore if the constructor is not generative.
     //
     if (node.factoryKeyword != null) {
       return false;
     }
     //
     // Ignore if the constructor has either an implicit super constructor invocation or a
     // redirecting constructor invocation.
     //
     for (ConstructorInitializer constructorInitializer in node.initializers) {
       if (constructorInitializer is SuperConstructorInvocation || constructorInitializer is RedirectingConstructorInvocation) {
         return false;
       }
     }
     //
     // Check to see whether the superclass has a non-factory unnamed constructor.
     //
-    if (_enclosingClass == null) {
-      return false;
-    }
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     ConstructorElement superUnnamedConstructor = superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType, [superUnnamedConstructor]);
         return true;
@@ skipping 598 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }