Add Accessor, Getter, and Setter elements.

pkg/compiler/lib/src/elements/elements.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 elements;
 
 
 import '../constants/expressions.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 393 matching lines @@
 
   bool get isSynthesized;
   bool get isMixinApplication;
 
   bool get hasFixedBackendName;
   String get fixedBackendName;
 
   bool get isAbstract;
   bool isForeign(Backend backend);
 
-  void addMetadata(MetadataAnnotation annotation);
-  void setNative(String name);
-
   Scope buildScope();
 
   void diagnose(Element context, DiagnosticListener listener);
 
   // TODO(johnniwinther): Move this to [AstElement].
   /// Returns the [Element] that holds the [TreeElements] for this element.
   AnalyzableElement get analyzableElement;
 
   accept(ElementVisitor visitor, arg);
 }
@@ skipping 406 matching lines @@
 
 // TODO(kasperl): This probably shouldn't be called an element. It's
 // just an interface shared by classes and libraries.
 abstract class ScopeContainerElement implements Element {
   Element localLookup(String elementName);
 
   void forEachLocalMember(f(Element element));
 }
 
 abstract class CompilationUnitElement extends Element {
+  /// Use [library] instead.
+  @deprecated
+  get enclosingElement;
+
   Script get script;
   PartOf get partTag;
 
   void forEachLocalMember(f(Element element));
-  void addMember(Element element, DiagnosticListener listener);
-  void setPartOf(PartOf tag, DiagnosticListener listener);
   bool get hasMembers;
 
   int compareTo(CompilationUnitElement other);
 }
 
 abstract class LibraryElement extends Element
     implements ScopeContainerElement, AnalyzableElement {
   /**
    * The canonical uri for this library.
    *
@@ skipping 21 matching lines @@
    * [:true:] if this library is from a package, that is, its canonical uri has
    * the scheme 'package'.
    */
   bool get isPackageLibrary;
 
   /**
    * [:true:] if this library is a platform library whose path starts with
    * an underscore.
    */
   bool get isInternalLibrary;
+
   bool get canUseNative;
   bool get exportsHandled;
 
-  // TODO(kasperl): We should try to get rid of these.
-  void set libraryTag(LibraryName value);
-
   LibraryElement get implementation;
 
-  void addCompilationUnit(CompilationUnitElement element);
-  void addTag(LibraryTag tag, DiagnosticListener listener);
-  void addImport(Element element, Import import, DiagnosticListener listener);
-
-  /// Record which element an import or export tag resolved to.
-  /// (Belongs on builder object).
-  void recordResolvedTag(LibraryDependency tag, LibraryElement library);
-
   /// Return the library element corresponding to an import or export.
   LibraryElement getLibraryFromTag(LibraryDependency tag);
 
-  void addMember(Element element, DiagnosticListener listener);
-  void addToScope(Element element, DiagnosticListener listener);
-
-  // TODO(kasperl): Get rid of this method.
-  Iterable<Element> getNonPrivateElementsInScope();
-
-  void setExports(Iterable<Element> exportedElements);
-
   Element find(String elementName);
   Element findLocal(String elementName);
   Element findExported(String elementName);
   void forEachExport(f(Element element));
 
   /// Returns the imports that import element into this library.
   Link<Import> getImportsFor(Element element);
 
   bool hasLibraryName();
   String getLibraryName();
@@ skipping 205 matching lines @@
 abstract class FunctionElement extends Element
     implements AstElement,
                TypedElement,
                FunctionTypedElement,
                ExecutableElement {
   FunctionExpression get node;
 
   FunctionElement get patch;
   FunctionElement get origin;
 
-  /// Used to retrieve a link to the abstract field element representing this
-  /// element.
-  AbstractFieldElement get abstractField;
-
   /// Do not use [computeSignature] outside of the resolver; instead retrieve
   /// the signature through the [functionSignature] field.
   /// Trying to access a function signature that has not been computed in
   /// resolution is an error and calling [computeSignature] covers that error.
   /// This method will go away!
   // TODO(johnniwinther): Rename to `ensureFunctionSignature`.
   @deprecated FunctionSignature computeSignature(Compiler compiler);
 
   bool get hasFunctionSignature;
 
   /// The parameters of this functions.
   List<ParameterElement> get parameters;
 
   /// The type of this function.
   FunctionType get type;
 
   /// The synchronous/asynchronous marker on this function.
   AsyncMarker get asyncMarker;
 
   /// `true` if this function is external.
   bool get isExternal;
 }
 
+/// A getter or setter.
+abstract class AccessorElement extends MethodElement {
+  /// Used to retrieve a link to the abstract field element representing this
+  /// element.
+  AbstractFieldElement get abstractField;
+}
+
+/// A getter.
+abstract class GetterElement extends AccessorElement {
+  /// The setter corresponding to this getter, if any.
+  SetterElement get setter;
+}
+
+/// A setter.
+abstract class SetterElement extends AccessorElement {
+  /// The getter corresponding to this setter, if any.
+  GetterElement get getter;
+}
+
 /// Enum for the synchronous/asynchronous function body modifiers.
 class AsyncMarker {
   /// The default function body marker.
   static const AsyncMarker SYNC = const AsyncMarker._();
 
   /// The `sync*` function body marker.
   static const AsyncMarker SYNC_STAR = const AsyncMarker._(isYielding: true);
 
   /// The `async` function body marker.
   static const AsyncMarker ASYNC = const AsyncMarker._(isAsync: true);
@@ skipping 464 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }