Compute mixin application constructors in the ClassElement.constructors getter.

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 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 404 matching lines @@
             !_checkForAllMixinErrorCodes(withClause)) {
           _checkForExtendsDeferredClass(extendsClause);
           _checkForImplementsDeferredClass(implementsClause);
           _checkForNonAbstractClassInheritsAbstractMember(node.name);
           _checkForInconsistentMethodInheritance();
           _checkForRecursiveInterfaceInheritance(_enclosingClass);
           _checkForConflictingGetterAndMethod();
           _checkForConflictingInstanceGetterAndSuperclassMember();
           _checkImplementsSuperClass(node);
           _checkImplementsFunctionWithoutCall(node);
+          _checkForMixinHasNoConstructors(node);
         }
       }
       visitClassDeclarationIncrementally(node);
       _checkForFinalNotInitializedInClass(node);
       _checkForDuplicateDefinitionInheritance();
       _checkForConflictingInstanceMethodSetter(node);
       return super.visitClassDeclaration(node);
     } finally {
       _isInNativeClass = false;
       _initialFieldElementsMap = null;
@@ skipping 32 matching lines @@
       // Only check for all of the inheritance logic around clauses if there
       // isn't an error code such as "Cannot extend double" already on the
       // class.
       if (!_checkForExtendsDisallowedClassInTypeAlias(node) &&
           !_checkForImplementsDisallowedClass(implementsClause) &&
           !_checkForAllMixinErrorCodes(node.withClause)) {
         _checkForExtendsDeferredClassInTypeAlias(node);
         _checkForImplementsDeferredClass(implementsClause);
         _checkForRecursiveInterfaceInheritance(_enclosingClass);
         _checkForNonAbstractClassInheritsAbstractMember(node.name);
+        _checkForMixinHasNoConstructors(node);
       }
     } finally {
       _enclosingClass = outerClassElement;
     }
     return super.visitClassTypeAlias(node);
   }
 
   @override
   Object visitComment(Comment node) {
     _isInComment = true;
@@ skipping 3671 matching lines @@
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName,
             [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Report the error [CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS] if
+   * appropriate.
+   */
+  void _checkForMixinHasNoConstructors(AstNode node) {
+    if ((_enclosingClass as ClassElementImpl).doesMixinLackConstructors) {
+      ErrorCode errorCode = CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS;
+      _errorReporter.reportErrorForNode(
+          errorCode, node, [_enclosingClass.supertype]);
+    }
+  }
+
+  /**
    * Verify that the given mixin has the 'Object' superclass. The [mixinName] is
    * the node to report problem on. The [mixinElement] is the mixing to
    * evaluate.
    *
    * See [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT].
    */
   bool _checkForMixinInheritsNotFromObject(
       TypeName mixinName, ClassElement mixinElement) {
     InterfaceType mixinSupertype = mixinElement.supertype;
     if (mixinSupertype != null) {
@@ skipping 105 matching lines @@
    * Check that if the given class [declaration] implicitly calls default
    * constructor of its superclass, there should be such default constructor -
    * implicit or explicit.
    *
    * See [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT].
    */
   bool _checkForNoDefaultSuperConstructorImplicit(
       ClassDeclaration declaration) {
     // do nothing if mixin errors have already been reported for this class.
     ClassElementImpl enclosingClass = _enclosingClass;
-    if (enclosingClass.mixinErrorsReported) {
+    if (enclosingClass.doesMixinLackConstructors) {
       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) {
@@ skipping 872 matching lines @@
    * [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR], and
    * [StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT].
    */
   bool _checkForUndefinedConstructorInInitializerImplicit(
       ConstructorDeclaration constructor) {
     if (_enclosingClass == null) {
       return false;
     }
     // do nothing if mixin errors have already been reported for this class.
     ClassElementImpl enclosingClass = _enclosingClass;
-    if (enclosingClass.mixinErrorsReported) {
+    if (enclosingClass.doesMixinLackConstructors) {
       return false;
     }
     //
     // Ignore if the constructor is not generative.
     //
     if (constructor.factoryKeyword != null) {
       return false;
     }
     //
     // Ignore if the constructor has either an implicit super constructor
@@ skipping 774 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }