Add Accessor, Getter, and Setter elements.

pkg/compiler/lib/src/native/enqueue.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.
 
 part of native;
 
 /**
  * This could be an abstract class but we use it as a stub for the dart_backend.
  */
 class NativeEnqueuer {
@@ skipping 207 matching lines @@
     nativeClasses.forEach(walkPotentialSubclasses);
 
     nativeClasses.addAll(nativeClassesAndSubclasses);
     unusedClasses.addAll(nativeClassesAndSubclasses);
   }
 
   /**
    * Returns the source string of the class named in the extends clause, or
    * `null` if there is no extends clause.
    */
-  String findExtendsNameOfClass(ClassElement classElement) {
+  String findExtendsNameOfClass(BaseClassElementX classElement) {
     //  "class B extends A ... {}"  --> "A"
     //  "class B extends foo.A ... {}"  --> "A"
     //  "class B<T> extends foo.A<T,T> with M1, M2 ... {}"  --> "A"
 
     // We want to avoid calling classElement.parseNode on every class.  Doing so
     // will slightly increase parse time and size and cause compiler errors and
     // warnings to me emitted in more unused code.
 
     // An alternative to this code is to extend the API of ClassElement to
     // expose the name of the extended element.
@@ skipping 114 matching lines @@
 
   void flushQueue() {
     if (flushing) return;
     flushing = true;
     while (!queue.isEmpty) {
       (queue.removeFirst())();
     }
     flushing = false;
   }
 
-  processClass(ClassElementX classElement, cause) {
+  processClass(BaseClassElementX classElement, cause) {
     // TODO(ahe): Fix this assertion to work in incremental compilation.
     assert(compiler.hasIncrementalSupport ||
            !registeredClasses.contains(classElement));
 
     bool firstTime = registeredClasses.isEmpty;
     pendingClasses.remove(classElement);
     registeredClasses.add(classElement);
 
     // TODO(ahe): Is this really a global dependency?
     world.registerInstantiatedClass(classElement, compiler.globalDependencies);
@@ skipping 41 matching lines @@
       if (method.isStatic) {
         setNativeNameForStaticMethod(method);
       } else {
         setNativeName(method);
       }
     }
   }
 
   /// Sets the native name of [element], either from an annotation, or
   /// defaulting to the Dart name.
-  void setNativeName(Element element) {
+  void setNativeName(ElementX element) {
     String name = findJsNameFromAnnotation(element);
     if (name == null) name = element.name;
     element.setNative(name);
   }
 
   /// Sets the native name of the static native method [element], using the
   /// following rules:
   /// 1. If [element] has a @JSName annotation that is an identifier, qualify
   ///    that identifier to the @Native name of the enclosing class
   /// 2. If [element] has a @JSName annotation that is not an identifier,
   ///    use the declared @JSName as the expression
   /// 3. If [element] does not have a @JSName annotation, qualify the name of
   ///    the method with the @Native name of the enclosing class.
-  void setNativeNameForStaticMethod(Element element) {
+  void setNativeNameForStaticMethod(ElementX element) {
     String name = findJsNameFromAnnotation(element);
     if (name == null) name = element.name;
     if (isIdentifier(name)) {
       List<String> nativeNames = nativeTagsOfClassRaw(element.enclosingClass);
       if (nativeNames.length != 1) {
         compiler.internalError(element,
             'Unable to determine a native name for the enclosing class, '
             'options: $nativeNames');
       }
       element.setNative('${nativeNames[0]}.$name');
@@ skipping 233 matching lines @@
         superclass,
         () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
     log('Compiled ${registeredClasses.length} native classes, '
         '${unusedClasses.length} native classes omitted.');
   }
 }