Add Accessor, Getter, and Setter elements.

pkg/compiler/lib/src/library_loader.dart

 // Copyright (c) 2012, 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 dart2js.library_loader;
 
 import 'dart:async';
 
 import 'dart2jslib.dart' show
     Compiler,
@@ skipping 353 matching lines @@
     });
   }
 
   /**
    * Processes the library tags in [library].
    *
    * The imported/exported libraries are loaded and processed recursively but
    * the import/export scopes are not set up.
    */
   Future processLibraryTags(LibraryDependencyHandler handler,
-                            LibraryElement library) {
+                            LibraryElementX library) {
     TagState tagState = new TagState();
 
     bool importsDartCore = false;
     var libraryDependencies = new LinkBuilder<LibraryDependency>();
     Uri base = library.entryCompilationUnit.script.readableUri;
 
     return Future.forEach(library.tags, (LibraryTag tag) {
       return compiler.withCurrentElement(library, () {
         if (tag.isImport) {
           Import import = tag;
@@ skipping 257 matching lines @@
  */
 class ImportLink {
   final Import import;
   final LibraryElement importedLibrary;
 
   ImportLink(this.import, this.importedLibrary);
 
   /**
    * Imports the library into the [importingLibrary].
    */
-  void importLibrary(Compiler compiler, LibraryElement importingLibrary) {
+  void importLibrary(Compiler compiler, LibraryElementX importingLibrary) {
     assert(invariant(importingLibrary,
                      importedLibrary.exportsHandled,
                      message: 'Exports not handled on $importedLibrary'));
     var combinatorFilter = new CombinatorFilter.fromTag(import);
     if (import != null && import.prefix != null) {
       String prefix = import.prefix.source;
       Element existingElement = importingLibrary.find(prefix);
       PrefixElement prefixElement;
       if (existingElement == null || !existingElement.isPrefix) {
         prefixElement = new PrefixElementX(prefix,
@@ skipping 52 matching lines @@
 }
 
 /**
  * A node in the library dependency graph.
  *
  * This class is used to collect the library dependencies expressed through
  * import and export tags, and as the work-list entry in computations of library
  * exports performed in [LibraryDependencyHandler.computeExports].
  */
 class LibraryDependencyNode {
-  final LibraryElement library;
+  final LibraryElementX library;
 
   // TODO(ahe): Remove [hashCodeCounter] and [hashCode] when
   // VM implementation of Object.hashCode is not slow.
   final int hashCode = ++hashCodeCounter;
   static int hashCodeCounter = 0;
 
 
   /**
    * A linked list of the import tags that import [library] mapped to the
    * corresponding libraries. This is used to propagate exports into imports
@@ skipping 22 matching lines @@
 
   /**
    * The set of exported elements that need to be propageted to dependent
    * libraries as part of the work-list computation performed in
    * [LibraryDependencyHandler.computeExports]. Each export element is mapped
    * to a list of exports directives that export it.
    */
   Map<Element, Link<Export>> pendingExportMap =
       new Map<Element, Link<Export>>();
 
-  LibraryDependencyNode(LibraryElement this.library);
+  LibraryDependencyNode(this.library);
 
   /**
    * Registers that the library of this node imports [importLibrary] through the
    * [import] tag.
    */
   void registerImportDependency(Import import,
                                 LibraryElement importedLibrary) {
     imports = imports.prepend(new ImportLink(import, importedLibrary));
   }
 
@@ skipping 229 matching lines @@
 
     // Setup import scopes.
     nodeMap.forEach((LibraryElement library, LibraryDependencyNode node) {
       node.registerImports(compiler);
     });
   }
 
   /**
    * Registers that [library] depends on [loadedLibrary] through [tag].
    */
-  void registerDependency(LibraryElement library,
+  void registerDependency(LibraryElementX library,
                           LibraryDependency tag,
                           LibraryElement loadedLibrary) {
     if (tag != null) {
       library.recordResolvedTag(tag, loadedLibrary);
     }
     if (tag is Export) {
       // [loadedLibrary] is exported by [library].
       LibraryDependencyNode exportingNode = nodeMap[library];
       if (loadedLibrary.exportsHandled) {
         // Export scope already computed on [loadedLibrary].
@@ skipping 157 matching lines @@
         }
         suffixes.add(const Link<Uri>().prepend(canonicalUri));
       }
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 }