Improve error reporting when a mixin application is invalid.

pkg/analyzer/lib/src/generated/element.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 1038 matching lines @@
    * <blockquote>It is a compile-time error if a declared or derived mixin refers to super. It is a
    * compile-time error if a declared or derived mixin explicitly declares a constructor. It is a
    * compile-time error if a mixin is derived from a class whose superclass is not
    * Object.</blockquote>
    *
    * @return `true` if this class can validly be used as a mixin
    */
   bool get isValidMixin;
 
   /**
+   * Return `true` if this mixin errors have already been reported for this
+   * class.
+   */
+  bool get mixinErrorsReported;

[scheglov, 2014/11/13 23:02:46]

Do we really need to add it to the API?
Can we add it only to the implementation, or even better - to one of the
resolution classes?

+
+  /**
    * Return the element representing the method that results from looking up the given method in
    * this class with respect to the given library, ignoring abstract methods, or `null` if the
    * look up fails. The behavior of this method is defined by the Dart Language Specification in
    * section 12.15.1: <blockquote> The result of looking up method <i>m</i> in class <i>C</i> with
    * respect to library <i>L</i> is:
    * * If <i>C</i> declares an instance method named <i>m</i> that is accessible to <i>L</i>, then
    * that method is the result of the lookup. Otherwise, if <i>C</i> has a superclass <i>S</i>, then
    * the result of the lookup is the result of looking up method <i>m</i> in <i>S</i> with respect
    * to <i>L</i>. Otherwise, we say that the lookup has failed.
    * </blockquote>
@@ skipping 454 matching lines @@
     return true;
   }
 
   @override
   bool get isTypedef => hasModifier(Modifier.TYPEDEF);
 
   @override
   bool get isValidMixin => hasModifier(Modifier.MIXIN);
 
   @override
+  bool get mixinErrorsReported => hasModifier(Modifier.MIXIN_ERRORS_REPORTED);
+
+  @override
   MethodElement lookUpConcreteMethod(String methodName, LibraryElement library) => _internalLookUpConcreteMethod(methodName, library, true);
 
   @override
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) => _internalLookUpGetter(getterName, library, true);
 
   @override
   PropertyAccessorElement lookUpInheritedConcreteGetter(String getterName, LibraryElement library) => _internalLookUpConcreteGetter(getterName, library, false);
 
   @override
   MethodElement lookUpInheritedConcreteMethod(String methodName, LibraryElement library) => _internalLookUpConcreteMethod(methodName, library, false);
@@ skipping 79 matching lines @@
    * @param methods the methods contained in this class
    */
   void set methods(List<MethodElement> methods) {
     for (MethodElement method in methods) {
       (method as MethodElementImpl).enclosingElement = this;
     }
     this._methods = methods;
   }
 
   /**
+   * Set whether an error has reported explaining why this class is an
+   * invalid mixin application.
+   */
+  void set mixinErrorsReported(bool value) {
+    setModifier(Modifier.MIXIN_ERRORS_REPORTED, value);
+  }
+
+  /**
    * Set whether this class is defined by a typedef construct to correspond to the given value.
    *
    * @param isTypedef `true` if the class is defined by a typedef construct
    */
   void set typedef(bool isTypedef) {
     setModifier(Modifier.TYPEDEF, isTypedef);
   }
 
   /**
    * Set the type parameters defined for this class to the given type parameters.
@@ skipping 7088 matching lines @@
    * import directive whose URI uses the "dart-ext" scheme.
    */
   static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 9);
 
   /**
    * Indicates that a class can validly be used as a mixin.
    */
   static const Modifier MIXIN = const Modifier('MIXIN', 10);
 
   /**
+   * Indicates that an error has reported explaining why this class is an
+   * invalid mixin application.
+   */
+  static const Modifier MIXIN_ERRORS_REPORTED =
+      const Modifier('MIXIN_ERRORS_REPORTED', 11);
+
+  /**
    * Indicates that the value of a parameter or local variable might be mutated within the context.
    */
-  static const Modifier POTENTIALLY_MUTATED_IN_CONTEXT = const Modifier('POTENTIALLY_MUTATED_IN_CONTEXT', 11);
+  static const Modifier POTENTIALLY_MUTATED_IN_CONTEXT = const Modifier('POTENTIALLY_MUTATED_IN_CONTEXT', 12);
 
   /**
    * Indicates that the value of a parameter or local variable might be mutated within the scope.
    */
-  static const Modifier POTENTIALLY_MUTATED_IN_SCOPE = const Modifier('POTENTIALLY_MUTATED_IN_SCOPE', 12);
+  static const Modifier POTENTIALLY_MUTATED_IN_SCOPE = const Modifier('POTENTIALLY_MUTATED_IN_SCOPE', 13);
 
   /**
    * Indicates that a class contains an explicit reference to 'super'.
    */
-  static const Modifier REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 13);
+  static const Modifier REFERENCES_SUPER = const Modifier('REFERENCES_SUPER', 14);
 
   /**
    * Indicates that the pseudo-modifier 'set' was applied to the element.
    */
-  static const Modifier SETTER = const Modifier('SETTER', 14);
+  static const Modifier SETTER = const Modifier('SETTER', 15);
 
   /**
    * Indicates that the modifier 'static' was applied to the element.
    */
-  static const Modifier STATIC = const Modifier('STATIC', 15);
+  static const Modifier STATIC = const Modifier('STATIC', 16);
 
   /**
    * Indicates that the element does not appear in the source code but was implicitly created. For
    * example, if a class does not define any constructors, an implicit zero-argument constructor
    * will be created and it will be marked as being synthetic.
    */
-  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 16);
+  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 17);
 
   /**
    * Indicates that a class was defined using an alias. TODO(brianwilkerson) This should be renamed
    * to 'ALIAS'.
    */
-  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 17);
+  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 18);
 
   static const List<Modifier> values = const [
       ABSTRACT,
       ASYNCHRONOUS,
       CONST,
       DEFERRED,
       ENUM,
       FACTORY,
       FINAL,
       GENERATOR,
       GETTER,
       HAS_EXT_URI,
       MIXIN,
+      MIXIN_ERRORS_REPORTED,
       POTENTIALLY_MUTATED_IN_CONTEXT,
       POTENTIALLY_MUTATED_IN_SCOPE,
       REFERENCES_SUPER,
       SETTER,
       STATIC,
       SYNTHETIC,
       TYPEDEF];
 
   const Modifier(String name, int ordinal) : super(name, ordinal);
 }
@@ skipping 2940 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 }