Add Accessor, Getter, and Setter elements.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.modelx;
 
 import 'elements.dart';
 import '../constants/expressions.dart';
 import '../constants/constructors.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
@@ skipping 153 matching lines @@
     while (!element.isCompilationUnit) {
       element = element.enclosingElement;
     }
     return element;
   }
 
   LibraryElement get library => enclosingElement.library;
 
   Name get memberName => new Name(name, library);
 
-  LibraryElement get implementationLibrary {
+  LibraryElementX get implementationLibrary {
     Element element = this;
     while (!identical(element.kind, ElementKind.LIBRARY)) {
       element = element.enclosingElement;
     }
     return element;
   }
 
   ClassElement get enclosingClass {
     for (Element e = this; e != null; e = e.enclosingElement) {
       if (e.isClass) return e;
@@ skipping 237 matching lines @@
   }
 
   set nestedClosures(_) {
     throw new UnsupportedError("nestedClosures=");
   }
 
   set redirectionDeferredPrefix(_) {
     throw new UnsupportedError("redirectionDeferredPrefix=");
   }
 
-  bool get hasNoBody => false;
-
-  bool get _hasNoBody => false;
-
   void set effectiveTarget(_) {
     throw new UnsupportedError("effectiveTarget=");
   }
 }
 
 /// A message attached to a [WarnOnUseElementX].
 class WrappedMessage {
   /// The message position. If [:null:] the position of the reference to the
   /// [WarnOnUseElementX] is used.
   final Spannable spannable;
@@ skipping 170 matching lines @@
    * and a setter.
    *
    * The abstract field is added once, for the first getter or setter, and
    * reused if the other one is also added.
    * The abstract field should not be treated as a proper member of the
    * container, it's simply a way to return two results for one lookup.
    * That is, the getter or setter does not have the abstract field as enclosing
    * element, they are enclosed by the class or compilation unit, as is the
    * abstract field.
    */
-  void addAccessor(FunctionElementX accessor,
+  void addAccessor(AccessorElementX accessor,
                    Element existing,
                    DiagnosticListener listener) {
     void reportError(Element other) {
       listener.reportError(accessor,
                            MessageKind.DUPLICATE_DEFINITION,
                            {'name': accessor.name});
       listener.reportInfo(
           other, MessageKind.EXISTING_DEFINITION, {'name': accessor.name});
 
       contents[accessor.name] = new DuplicatedElementX(
@@ skipping 37 matching lines @@
     }
   }
 }
 
 class CompilationUnitElementX extends ElementX
     implements CompilationUnitElement {
   final Script script;
   PartOf partTag;
   Link<Element> localMembers = const Link<Element>();
 
-  CompilationUnitElementX(Script script, LibraryElement library)
+  CompilationUnitElementX(Script script, LibraryElementX library)
     : this.script = script,
       super(script.name,
             ElementKind.COMPILATION_UNIT,
             library) {
     library.addCompilationUnit(this);
   }
 
+  @override
+  LibraryElementX get library => enclosingElement.declaration;
+
   void forEachLocalMember(f(Element element)) {
     localMembers.forEach(f);
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     // Keep a list of top level members.
     localMembers = localMembers.prepend(element);
     // Provide the member to the library to build scope.
     if (enclosingElement.isPatch) {
       implementationLibrary.addMember(element, listener);
@@ skipping 231 matching lines @@
   }
 
   Iterable<LibraryTag> get tags {
     if (tagsCache == null) {
       tagsCache = tagsBuilder.toList();
       tagsBuilder = null;
     }
     return tagsCache;
   }
 
+  /// Record which element an import or export tag resolved to.
   void recordResolvedTag(LibraryDependency tag, LibraryElement library) {
     assert(tagMapping[tag] == null);
     tagMapping[tag] = library;
   }
 
   LibraryElement getLibraryFromTag(LibraryDependency tag) => tagMapping[tag];
 
   /**
    * Adds [element] to the import scope of this library.
    *
@@ skipping 726 matching lines @@
   MemberElement get memberContext => enclosingElement;
 
   bool get isLocal => false;
 
   bool get isErroneous => true;
 
   DynamicType get type => const DynamicType();
 }
 
 class AbstractFieldElementX extends ElementX implements AbstractFieldElement {
-  FunctionElementX getter;
-  FunctionElementX setter;
+  GetterElementX getter;
+  SetterElementX setter;
 
   AbstractFieldElementX(String name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
   DartType computeType(Compiler compiler) {
     throw "internal error: AbstractFieldElement has no type";
   }
 
   Node parseNode(DiagnosticListener listener) {
     throw "internal error: AbstractFieldElement has no node";
@@ skipping 137 matching lines @@
 abstract class BaseFunctionElementX
     extends ElementX with PatchMixin<FunctionElement>, AstElementMixin
     implements FunctionElement {
   DartType typeCache;
   final Modifiers modifiers;
 
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
   FunctionSignature functionSignatureCache;
 
-  final bool _hasNoBody;
-
-  AbstractFieldElement abstractField;
-
   AsyncMarker asyncMarker = AsyncMarker.SYNC;
 
   BaseFunctionElementX(String name,
                        ElementKind kind,
                        Modifiers this.modifiers,
-                       Element enclosing,
-                       bool hasNoBody)
-      : super(name, kind, enclosing),
-        _hasNoBody = hasNoBody {
+                       Element enclosing)
+      : super(name, kind, enclosing) {
     assert(modifiers != null);
   }
 
   bool get isExternal => modifiers.isExternal;
 
-  bool get hasNoBody => _hasNoBody;
-
   bool get isInstanceMember {
     return isClassMember
            && !isConstructor
            && !isStatic;
   }
 
   bool get hasFunctionSignature => functionSignatureCache != null;
 
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignatureCache != null) return functionSignatureCache;
@@ skipping 34 matching lines @@
   String toString() {
     if (isPatch) {
       return 'patch ${super.toString()}';
     } else if (isPatched) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 
-  bool get isAbstract {
-    return !modifiers.isExternal &&
-           (isFunction || isAccessor) &&
-           _hasNoBody;
-  }
+  bool get isAbstract => false;
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitFunctionElement(this, arg);
   }
 
   // A function is defined by the implementation element.
   AstElement get definingElement => implementation;
 }
 
 abstract class FunctionElementX extends BaseFunctionElementX
     with AnalyzableElementX implements MethodElement {
+
   FunctionElementX(String name,
                    ElementKind kind,
                    Modifiers modifiers,
-                   Element enclosing,
-                   bool hasNoBody)
-      : super(name, kind, modifiers, enclosing, hasNoBody);
+                   Element enclosing)
+      : super(name, kind, modifiers, enclosing);
 
   MemberElement get memberContext => this;
 
   void reuseElement() {
     super.reuseElement();
     nestedClosures.clear();
     functionSignatureCache = null;
     typeCache = null;
   }
 }
 
+abstract class MethodElementX extends FunctionElementX {
+  final bool hasBody;
+
+  MethodElementX(String name,
+                 ElementKind kind,
+                 Modifiers modifiers,
+                 Element enclosing,
+                 // TODO(15101): Make this a named parameter.
+                 this.hasBody)
+      : super(name, kind, modifiers, enclosing);
+
+  @override
+  bool get isAbstract {
+    return !modifiers.isExternal && !hasBody;
+  }
+}
+
+abstract class AccessorElementX extends MethodElementX
+    implements AccessorElement {
+  AbstractFieldElement abstractField;
+
+  AccessorElementX(String name,
+                   ElementKind kind,
+                   Modifiers modifiers,
+                   Element enclosing,
+                   bool hasBody)
+      : super(name, kind, modifiers, enclosing, hasBody);
+}
+
+abstract class GetterElementX extends AccessorElementX
+    implements GetterElement {
+
+  GetterElementX(String name,
+                 Modifiers modifiers,
+                 Element enclosing,
+                 bool hasBody)
+      : super(name, ElementKind.GETTER, modifiers, enclosing, hasBody);
+}
+
+abstract class SetterElementX extends AccessorElementX
+    implements SetterElement {
+
+  SetterElementX(String name,
+                 Modifiers modifiers,
+                 Element enclosing,
+                 bool hasBody)
+      : super(name, ElementKind.SETTER, modifiers, enclosing, hasBody);
+}
+
 class LocalFunctionElementX extends BaseFunctionElementX
     implements LocalFunctionElement {
   final FunctionExpression node;
 
   LocalFunctionElementX(String name,
                         FunctionExpression this.node,
                         ElementKind kind,
                         Modifiers modifiers,
                         ExecutableElement enclosing)
-      : super(name, kind, modifiers, enclosing, false);
+      : super(name, kind, modifiers, enclosing);
 
   ExecutableElement get executableContext => enclosingElement;
 
   MemberElement get memberContext => executableContext.memberContext;
 
   bool get hasNode => true;
 
   FunctionExpression parseNode(DiagnosticListener listener) => node;
 
   Token get position {
@@ skipping 33 matching lines @@
 }
 
 abstract class ConstructorElementX extends FunctionElementX
     with ConstantConstructorMixin implements ConstructorElement {
   bool isRedirectingGenerative = false;
 
   ConstructorElementX(String name,
                       ElementKind kind,
                       Modifiers modifiers,
                       Element enclosing)
-        : super(name, kind, modifiers, enclosing, false);
+        : super(name, kind, modifiers, enclosing);
 
   FunctionElement immediateRedirectionTarget;
   PrefixElement redirectionDeferredPrefix;
 
   bool get isRedirectingFactory => immediateRedirectionTarget != null;
 
   // TODO(johnniwinther): This should also return true for cyclic redirecting
   // generative constructors.
   bool get isCyclicRedirection => effectiveTarget.isRedirectingFactory;
 
@@ skipping 15 matching lines @@
   }
 
   InterfaceType computeEffectiveTargetType(InterfaceType newType) {
     if (!isRedirectingFactory) return newType;
     assert(invariant(this, effectiveTargetType != null,
         message: 'Redirection target type has not yet been computed for '
                  '$this.'));
     return effectiveTargetType.substByContext(newType);
   }
 
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitConstructorElement(this, arg);
+  }
+
   ConstructorElement get definingConstructor => null;
 
   ClassElement get enclosingClass => enclosingElement;
 }
 
-class DeferredLoaderGetterElementX extends FunctionElementX {
+class DeferredLoaderGetterElementX extends GetterElementX
+    implements GetterElement {
   final PrefixElement prefix;
 
   DeferredLoaderGetterElementX(PrefixElement prefix)
       : this.prefix = prefix,
         super("loadLibrary",
-              ElementKind.FUNCTION,
               Modifiers.EMPTY,
-              prefix, true);
+              prefix,
+              false);
 
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignatureCache != null) return functionSignature;
     compiler.withCurrentElement(this, () {
       DartType inner = new FunctionType(this);
       functionSignatureCache = new FunctionSignatureX(type: inner);
     });
     return functionSignatureCache;
   }
 
   bool get isClassMember => false;
 
   bool isForeign(Backend backend) => true;
 
   bool get isSynthesized => true;
 
-  bool get isFunction => false;
-
   bool get isDeferredLoaderGetter => true;
 
-  bool get isGetter => true;
-
   bool get isTopLevel => true;
   // By having position null, the enclosing elements location is printed in
   // error messages.
   Token get position => null;
 
   FunctionExpression parseNode(DiagnosticListener listener) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
+
+  @override
+  SetterElement get setter => null;
 }
 
 class ConstructorBodyElementX extends BaseFunctionElementX
     implements ConstructorBodyElement {
-  ConstructorElement constructor;
+  ConstructorElementX constructor;
 
-  ConstructorBodyElementX(FunctionElement constructor)
+  ConstructorBodyElementX(ConstructorElementX constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               Modifiers.EMPTY,
-              constructor.enclosingElement, false) {
+              constructor.enclosingElement) {
     functionSignatureCache = constructor.functionSignature;
   }
 
   bool get hasNode => constructor.hasNode;
 
   FunctionExpression get node => constructor.node;
 
   Link<MetadataAnnotation> get metadata => constructor.metadata;
 
   bool get isInstanceMember => true;
@@ skipping 717 matching lines @@
               modifiers,
               enumClass);
 
   @override
   bool get hasNode => true;
 
   @override
   FunctionExpression parseNode(Compiler compiler) => node;
 }
 
-class EnumMethodElementX extends FunctionElementX {
+class EnumMethodElementX extends MethodElementX {
   final FunctionExpression node;
 
   EnumMethodElementX(String name,
                      EnumClassElementX enumClass,
                      Modifiers modifiers,
                      this.node)
-      : super(name,
-              ElementKind.FUNCTION,
-              modifiers,
-              enumClass,
-              false);
+      : super(name, ElementKind.FUNCTION, modifiers, enumClass, true);
 
   @override
   bool get hasNode => true;
 
   @override
   FunctionExpression parseNode(Compiler compiler) => node;
 }
 
 class EnumFormalElementX extends InitializingFormalElementX {
   EnumFormalElementX(ConstructorElement constructor,
@@ skipping 317 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }