Eliminate Modifier.TYPEDEF and deprecate ClassElement.isTypedef.

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 197 matching lines @@
    * annotation from a supertype.
    */
   bool get isOrInheritsProxy;
 
   /**
    * Return `true` if this element has an annotation of the form '@proxy'.
    */
   bool get isProxy;
 
   /**
-   * Return `true` if this class is defined by a typedef construct.
+   * Return `true` if this class is a mixin application.  Deprecated--please
+   * use [isMixinApplication] instead.
    */
+  @deprecated
   bool get isTypedef;
 
   /**
    * Return `true` if this class can validly be used as a mixin when defining
    * another class. The behavior of this method is defined by the Dart Language
    * Specification in section 9:
    * <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
@@ skipping 466 matching lines @@
   bool get isProxy {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isProxy) {
         return true;
       }
     }
     return false;
   }
 
   @override
-  bool get isTypedef => hasModifier(Modifier.TYPEDEF);
+  @deprecated
+  bool get isTypedef => isMixinApplication;
 
   @override
   bool get isValidMixin => hasModifier(Modifier.MIXIN);
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
   @override
   List<MethodElement> get methods => _methods;
 
@@ skipping 17 matching lines @@
   bool get mixinErrorsReported => hasModifier(Modifier.MIXIN_ERRORS_REPORTED);
 
   /**
    * 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.
-   */
-  void set typedef(bool isTypedef) {
-    setModifier(Modifier.TYPEDEF, isTypedef);
-  }
-
   @override
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the type parameters defined for this class to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
@@ skipping 7287 matching lines @@
   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', 18);
 
-  /**
-   * Indicates that a class was defined using an alias.
-   * TODO(brianwilkerson) This should be renamed to 'ALIAS'.
-   */
-  static const Modifier TYPEDEF = const Modifier('TYPEDEF', 19);
-
   static const List<Modifier> values = const [
     ABSTRACT,
     ASYNCHRONOUS,
     CONST,
     DEFERRED,
     ENUM,
     FACTORY,
     FINAL,
     GENERATOR,
     GETTER,
     HAS_EXT_URI,
     MIXIN,
     MIXIN_APPLICATION,
     MIXIN_ERRORS_REPORTED,
     POTENTIALLY_MUTATED_IN_CONTEXT,
     POTENTIALLY_MUTATED_IN_SCOPE,
     REFERENCES_SUPER,
     SETTER,
     STATIC,
-    SYNTHETIC,
-    TYPEDEF
+    SYNTHETIC
   ];
 
   const Modifier(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * A pseudo-element that represents multiple elements defined within a single
  * scope that have the same name. This situation is not allowed by the language,
  * so objects implementing this interface always represent an error. As a
  * result, most of the normal operations on elements do not make sense and will
@@ skipping 2330 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }