Stop precomputing ClassElement.isValidMixin.

pkg/analyzer/lib/dart/element/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.
 
 library analyzer.dart.element.element;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/generated/constant.dart' show DartObject;
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
@@ skipping 1530 matching lines @@
   static const Modifier HAS_EXT_URI = const Modifier('HAS_EXT_URI', 10);
 
   /**
    * Indicates that the associated element did not have an explicit type
    * associated with it. If the element is an [ExecutableElement], then the
    * type being referred to is the return type.
    */
   static const Modifier IMPLICIT_TYPE = const Modifier('IMPLICIT_TYPE', 11);
 
   /**
-   * Indicates that a class can validly be used as a mixin.
-   */
-  static const Modifier MIXIN = const Modifier('MIXIN', 12);

[Brian Wilkerson, 2016/01/26 15:03:21]

Technically, this is a breaking change. I'm guessing, though, that it isn't a
problem in practice.

[Paul Berry, 2016/01/26 15:27:10]

Agreed.  How would you feel if I submitted a follow-up CL that moved the class
Modifier into lib/src, so that it's no longer exposed as part of the public
interface?  AFAICT, all references to it are in lib/src, so I think it makes
sense for it to live in lib/src as well.

[Brian Wilkerson, 2016/01/26 15:33:50]

I wondered, when I reviewed this CL, why I had included it in the public API in
the first place. I need to take a closer look, but I suspect that would be a
good plan. I'd also be happy to move it so you don't get distracted.

[Paul Berry, 2016/01/26 16:35:09]

Ok, thanks!  I'll leave the ball in your court, then.

-
-  /**
    * Indicates that a class is a mixin application.
    */
   static const Modifier MIXIN_APPLICATION =
-      const Modifier('MIXIN_APPLICATION', 13);
+      const Modifier('MIXIN_APPLICATION', 12);
 
   /**
    * 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', 14);
+      const Modifier('POTENTIALLY_MUTATED_IN_CONTEXT', 13);
 
   /**
    * 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', 15);
+      const Modifier('POTENTIALLY_MUTATED_IN_SCOPE', 14);
 
   /**
    * Indicates that a class contains an explicit reference to 'super'.
    */
   static const Modifier REFERENCES_SUPER =
-      const Modifier('REFERENCES_SUPER', 16);
+      const Modifier('REFERENCES_SUPER', 15);
 
   /**
    * Indicates that the pseudo-modifier 'set' was applied to the element.
    */
-  static const Modifier SETTER = const Modifier('SETTER', 17);
+  static const Modifier SETTER = const Modifier('SETTER', 16);
 
   /**
    * Indicates that the modifier 'static' was applied to the element.
    */
-  static const Modifier STATIC = const Modifier('STATIC', 18);
+  static const Modifier STATIC = const Modifier('STATIC', 17);
 
   /**
    * 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', 19);
+  static const Modifier SYNTHETIC = const Modifier('SYNTHETIC', 18);
 
   static const List<Modifier> values = const [
     ABSTRACT,
     ASYNCHRONOUS,
     CONST,
     DEFERRED,
     ENUM,
     EXTERNAL,
     FACTORY,
     FINAL,
     GENERATOR,
     GETTER,
     HAS_EXT_URI,
     IMPLICIT_TYPE,
-    MIXIN,
     MIXIN_APPLICATION,
     POTENTIALLY_MUTATED_IN_CONTEXT,
     POTENTIALLY_MUTATED_IN_SCOPE,
     REFERENCES_SUPER,
     SETTER,
     STATIC,
     SYNTHETIC
   ];
 
   const Modifier(String name, int ordinal) : super(name, ordinal);
@@ skipping 426 matching lines @@
    */
   bool get isStatic;
 
   /**
    * Return the declared type of this variable, or `null` if the variable did
    * not have a declared type (such as if it was declared using the keyword
    * 'var').
    */
   DartType get type;
 }