Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/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 '../helpers/helpers.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 26 matching lines @@
 abstract class ElementX implements Element {
   static int elementHashCode = 0;
 
   final String name;
   final ElementKind kind;
   final Element enclosingElement;
   final int hashCode = ++elementHashCode;
   Link<MetadataAnnotation> metadata = const Link<MetadataAnnotation>();
 
   ElementX(this.name, this.kind, this.enclosingElement) {
-    assert(isErroneous() || getImplementationLibrary() != null);
+    assert(isErroneous || implementationLibrary != null);
   }
 
   Modifiers get modifiers => Modifiers.EMPTY;
 
   Node parseNode(DiagnosticListener listener) {
     listener.internalError(this, 'Not implemented.');
     return null;
   }
 
   DartType computeType(Compiler compiler) {
     compiler.internalError(this, "$this.computeType.");
     return null;
   }
 
   void addMetadata(MetadataAnnotation annotation) {
     assert(annotation.annotatedElement == null);
     annotation.annotatedElement = this;
     addMetadataInternal(annotation);
   }
 
   void addMetadataInternal(MetadataAnnotation annotation) {
     metadata = metadata.prepend(annotation);
   }
 
 
-  bool isFunction() => identical(kind, ElementKind.FUNCTION);
-  bool isConstructor() => isFactoryConstructor() || isGenerativeConstructor();
-  bool isClosure() => false;
-  bool isMember() {
+  bool get isFunction => identical(kind, ElementKind.FUNCTION);
+  bool get isConstructor => isFactoryConstructor || isGenerativeConstructor;
+  bool get isClosure => false;
+  bool get isMember {
     // Check that this element is defined in the scope of a Class.
-    return enclosingElement != null && enclosingElement.isClass();
+    return enclosingElement != null && enclosingElement.isClass;
   }
-  bool isInstanceMember() => false;
-  bool isDeferredLoaderGetter() => false;
+  bool get isInstanceMember => false;
+  bool get isDeferredLoaderGetter => false;
 
-  bool isFactoryConstructor() => modifiers.isFactory();
-  bool isGenerativeConstructor() =>
+  bool get isFactoryConstructor => modifiers.isFactory;
+  bool get isGenerativeConstructor =>
       identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR);
-  bool isGenerativeConstructorBody() =>
+  bool get isGenerativeConstructorBody =>
       identical(kind, ElementKind.GENERATIVE_CONSTRUCTOR_BODY);
-  bool isCompilationUnit() => identical(kind, ElementKind.COMPILATION_UNIT);
-  bool isClass() => identical(kind, ElementKind.CLASS);
-  bool isPrefix() => identical(kind, ElementKind.PREFIX);
-  bool isVariable() => identical(kind, ElementKind.VARIABLE);
-  bool isParameter() => identical(kind, ElementKind.PARAMETER);
-  bool isStatement() => identical(kind, ElementKind.STATEMENT);
-  bool isTypedef() => identical(kind, ElementKind.TYPEDEF);
-  bool isTypeVariable() => identical(kind, ElementKind.TYPE_VARIABLE);
-  bool isField() => identical(kind, ElementKind.FIELD);
-  bool isFieldParameter() => identical(kind, ElementKind.FIELD_PARAMETER);
-  bool isAbstractField() => identical(kind, ElementKind.ABSTRACT_FIELD);
-  bool isGetter() => identical(kind, ElementKind.GETTER);
-  bool isSetter() => identical(kind, ElementKind.SETTER);
-  bool isAccessor() => isGetter() || isSetter();
-  bool isLibrary() => identical(kind, ElementKind.LIBRARY);
-  bool impliesType() => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
+  bool get isCompilationUnit => identical(kind, ElementKind.COMPILATION_UNIT);
+  bool get isClass => identical(kind, ElementKind.CLASS);
+  bool get isPrefix => identical(kind, ElementKind.PREFIX);
+  bool get isVariable => identical(kind, ElementKind.VARIABLE);
+  bool get isParameter => identical(kind, ElementKind.PARAMETER);
+  bool get isStatement => identical(kind, ElementKind.STATEMENT);
+  bool get isTypedef => identical(kind, ElementKind.TYPEDEF);
+  bool get isTypeVariable => identical(kind, ElementKind.TYPE_VARIABLE);
+  bool get isField => identical(kind, ElementKind.FIELD);
+  bool get isFieldParameter => identical(kind, ElementKind.FIELD_PARAMETER);
+  bool get isAbstractField => identical(kind, ElementKind.ABSTRACT_FIELD);
+  bool get isGetter => identical(kind, ElementKind.GETTER);
+  bool get isSetter => identical(kind, ElementKind.SETTER);
+  bool get isAccessor => isGetter || isSetter;
+  bool get isLibrary => identical(kind, ElementKind.LIBRARY);
+  bool get impliesType => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
 
   /** See [ErroneousElement] for documentation. */
-  bool isErroneous() => false;
+  bool get isErroneous => false;
 
   /** See [AmbiguousElement] for documentation. */
-  bool isAmbiguous() => false;
+  bool get isAmbiguous => false;
 
   /** See [WarnOnUseElement] for documentation. */
-  bool isWarnOnUse() => false;
+  bool get isWarnOnUse => false;
 
   bool get isPatched => false;
 
   bool get isPatch => false;
 
   bool get isImplementation => true;
 
   bool get isDeclaration => true;
 
   Element get implementation => this;
@@ skipping 11 matching lines @@
   bool get isSynthesized => false;
 
   bool get isForwardingConstructor => false;
 
   bool get isMixinApplication => false;
 
   // TODO(johnniwinther): This breaks for libraries (for which enclosing
   // elements are null) and is invalid for top level variable declarations for
   // which the enclosing element is a VariableDeclarations and not a compilation
   // unit.
-  bool isTopLevel() {
-    return enclosingElement != null && enclosingElement.isCompilationUnit();
+  bool get isTopLevel {
+    return enclosingElement != null && enclosingElement.isCompilationUnit;
   }
 
-  bool isAssignable() {
-    if (modifiers.isFinalOrConst()) return false;
-    if (isFunction() || isGenerativeConstructor()) return false;
+  bool get isAssignable {
+    if (modifiers.isFinalOrConst) return false;
+    if (isFunction || isGenerativeConstructor) return false;
     return true;
   }
 
-  Token position() => null;
+  Token get position => null;
 
   Token findMyName(Token token) {
-    return findNameToken(token, isConstructor(), name, enclosingElement.name);
+    return findNameToken(token, isConstructor, name, enclosingElement.name);
   }
 
   static Token findNameToken(Token token, bool isConstructor, String name,
                              String enclosingClassName) {
     // We search for the token that has the name of this element.
     // For constructors, that doesn't work because they may have
     // named formed out of multiple tokens (named constructors) so
     // for those we search for the class name instead.
     String needle = isConstructor ? enclosingClassName : name;
     // The unary '-' operator has a special element name (specified).
     if (needle == 'unary-') needle = '-';
     for (Token t = token; EOF_TOKEN != t.kind; t = t.next) {
       if (needle == t.value) return t;
     }
     return token;
   }
 
-  CompilationUnitElement getCompilationUnit() {
+  CompilationUnitElement get compilationUnit {
     Element element = this;
-    while (!element.isCompilationUnit()) {
+    while (!element.isCompilationUnit) {
       element = element.enclosingElement;
     }
     return element;
   }
 
-  LibraryElement getLibrary() => enclosingElement.getLibrary();
+  LibraryElement get library => enclosingElement.library;
 
-  LibraryElement getImplementationLibrary() {
+  LibraryElement get implementationLibrary {
     Element element = this;
     while (!identical(element.kind, ElementKind.LIBRARY)) {
       element = element.enclosingElement;
     }
     return element;
   }
 
-  ClassElement getEnclosingClass() {
+  ClassElement get enclosingClass {
     for (Element e = this; e != null; e = e.enclosingElement) {
-      if (e.isClass()) return e;
+      if (e.isClass) return e;
     }
     return null;
   }
 
-  Element getEnclosingClassOrCompilationUnit() {
+  Element get enclosingClassOrCompilationUnit {
    for (Element e = this; e != null; e = e.enclosingElement) {
-      if (e.isClass() || e.isCompilationUnit()) return e;
+      if (e.isClass || e.isCompilationUnit) return e;
     }
     return null;
   }
 
   /**
    * Returns the member enclosing this element or the element itself if it is a
    * member. If no enclosing element is found, [:null:] is returned.
    */
-  Element getEnclosingMember() {
+  Element get enclosingMember {
     for (Element e = this; e != null; e = e.enclosingElement) {
-      if (e.isMember()) return e;
+      if (e.isMember) return e;
     }
     return null;
   }
 
-  Element getOutermostEnclosingMemberOrTopLevel() {
+  Element get outermostEnclosingMemberOrTopLevel {
     // TODO(lrn): Why is this called "Outermost"?
     for (Element e = this; e != null; e = e.enclosingElement) {
-      if (e.isMember() || e.isTopLevel()) {
+      if (e.isMember || e.isTopLevel) {
         return e;
       }
     }
     return null;
   }
 
   /**
    * Creates the scope for this element.
    */
   Scope buildScope() => enclosingElement.buildScope();
 
   String toString() {
     // TODO(johnniwinther): Test for nullness of name, or make non-nullness an
     // invariant for all element types?
     var nameText = name != null ? name : '?';
-    if (enclosingElement != null && !isTopLevel()) {
+    if (enclosingElement != null && !isTopLevel) {
       String holderName = enclosingElement.name != null
           ? enclosingElement.name
           : '${enclosingElement.kind}?';
       return '$kind($holderName#${nameText})';
     } else {
       return '$kind(${nameText})';
     }
   }
 
   String _fixedBackendName = null;
   bool _isNative = false;
-  bool isNative() => _isNative;
-  bool hasFixedBackendName() => _fixedBackendName != null;
-  String fixedBackendName() => _fixedBackendName;
+  bool get isNative => _isNative;
+  bool get hasFixedBackendName => _fixedBackendName != null;
+  String get fixedBackendName => _fixedBackendName;
   // Marks this element as a native element.
   void setNative(String name) {
     _isNative = true;
     _fixedBackendName = name;
   }
   void setFixedBackendName(String name) {
     _fixedBackendName = name;
   }
 
   FunctionElement asFunctionElement() => null;
 
-  bool get isAbstract => modifiers.isAbstract();
-  bool isForeign(Compiler compiler) => getLibrary() == compiler.foreignLibrary;
+  bool get isAbstract => modifiers.isAbstract;
+  bool isForeign(Compiler compiler) => library == compiler.foreignLibrary;
 
   FunctionElement get targetConstructor => null;
 
   void diagnose(Element context, DiagnosticListener listener) {}
 
   TreeElements get treeElements => enclosingElement.treeElements;
 }
 
 /**
  * Represents an unresolvable or duplicated element.
@@ skipping 13 matching lines @@
  *   [: element == null :].
  */
 class ErroneousElementX extends ElementX implements ErroneousElement {
   final MessageKind messageKind;
   final Map messageArguments;
 
   ErroneousElementX(this.messageKind, this.messageArguments,
                     String name, Element enclosing)
       : super(name, ElementKind.ERROR, enclosing);
 
-  isErroneous() => true;
+  bool get isErroneous => true;
 
   AbstractFieldElement abstractField;
 
   unsupported() {
     throw 'unsupported operation on erroneous element';
   }
 
   Link<MetadataAnnotation> get metadata => unsupported();
   get node => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get patch => null;
   get origin => this;
   get defaultImplementation => unsupported();
   get nestedClosures => unsupported();
 
   bool get isRedirectingFactory => unsupported();
 
   computeSignature(compiler) => unsupported();
 
   // TODO(kasperl): These seem unnecessary.
   set defaultImplementation(value) => unsupported();
 
   get redirectionTarget => this;
 
-  getLibrary() => enclosingElement.getLibrary();
-
   computeTargetType(InterfaceType newType) => unsupported();
 
   String get message => '${messageKind.message(messageArguments)}';
 
   String toString() => '<$name: $message>';
 
   accept(ElementVisitor visitor) => visitor.visitErroneousElement(this);
 }
 
 /// A message attached to a [WarnOnUseElementX].
@@ skipping 26 matching lines @@
   final WrappedMessage info;
 
   /// The element whose usage cause a warning.
   final Element wrappedElement;
 
   WarnOnUseElementX(WrappedMessage this.warning, WrappedMessage this.info,
                     Element enclosingElement, Element wrappedElement)
       : this.wrappedElement = wrappedElement,
         super(wrappedElement.name, ElementKind.WARN_ON_USE, enclosingElement);
 
-  bool isWarnOnUse() => true;
+  bool get isWarnOnUse => true;
 
   Element unwrap(DiagnosticListener listener, Spannable usageSpannable) {
     var unwrapped = wrappedElement;
     if (warning != null) {
       Spannable spannable = warning.spannable;
       if (spannable == null) spannable = usageSpannable;
       listener.reportWarning(
           spannable, warning.messageKind, warning.messageArguments);
     }
     if (info != null) {
       Spannable spannable = info.spannable;
       if (spannable == null) spannable = usageSpannable;
       listener.reportInfo(
           spannable, info.messageKind, info.messageArguments);
     }
-    if (unwrapped.isWarnOnUse()) {
+    if (unwrapped.isWarnOnUse) {
       unwrapped = unwrapped.unwrap(listener, usageSpannable);
     }
     return unwrapped;
   }
 
   accept(ElementVisitor visitor) => visitor.visitWarnOnUseElement(this);
 }
 
 /**
  * An ambiguous element represents multiple elements accessible by the same name.
@@ skipping 22 matching lines @@
    * The second element that this ambiguous element might refer to.
    */
   final Element newElement;
 
   AmbiguousElementX(this.messageKind, this.messageArguments,
       Element enclosingElement, Element existingElement, Element newElement)
       : this.existingElement = existingElement,
         this.newElement = newElement,
         super(existingElement.name, ElementKind.AMBIGUOUS, enclosingElement);
 
-  bool isAmbiguous() => true;
+  bool get isAmbiguous => true;
 
   Setlet flatten() {
     Element element = this;
     var set = new Setlet();
-    while (element.isAmbiguous()) {
+    while (element.isAmbiguous) {
       AmbiguousElement ambiguous = element;
       set.add(ambiguous.newElement);
       element = ambiguous.existingElement;
     }
     set.add(element);
     return set;
   }
 
   void diagnose(Element context, DiagnosticListener listener) {
     Setlet ambiguousElements = flatten();
     MessageKind code = (ambiguousElements.length == 1)
         ? MessageKind.AMBIGUOUS_REEXPORT : MessageKind.AMBIGUOUS_LOCATION;
-    LibraryElementX importer = context.getLibrary();
+    LibraryElementX importer = context.library;
     for (Element element in ambiguousElements) {
       var arguments = {'name': element.name};
       listener.reportInfo(element, code, arguments);
       Link<Import> importers = importer.importers.getImports(element);
       listener.withCurrentElement(importer, () {
         for (; !importers.isEmpty; importers = importers.tail) {
           listener.reportInfo(
               importers.head, MessageKind.IMPORTED_HERE, arguments);
         }
       });
     }
   }
 
   accept(ElementVisitor visitor) => visitor.visitAmbiguousElement(this);
 }
 
 class ScopeX {
   final Map<String, Element> contents = new Map<String, Element>();
 
   bool get isEmpty => contents.isEmpty;
   Iterable<Element> get values => contents.values;
 
   Element lookup(String name) {
     return contents[name];
   }
 
   void add(Element element, DiagnosticListener listener) {
     String name = element.name;
-    if (element.isAccessor()) {
+    if (element.isAccessor) {
       addAccessor(element, contents[name], listener);
     } else {
       Element existing = contents.putIfAbsent(name, () => element);
       if (!identical(existing, element)) {
         listener.reportError(
             element, MessageKind.DUPLICATE_DEFINITION, {'name': name});
         listener.reportInfo(existing,
             MessageKind.EXISTING_DEFINITION, {'name': name});
       }
     }
@@ skipping 24 matching lines @@
                                 MessageKind.EXISTING_DEFINITION,
                                 {'name': accessor.name});
     }
 
     if (existing != null) {
       if (!identical(existing.kind, ElementKind.ABSTRACT_FIELD)) {
         reportError(existing);
       } else {
         AbstractFieldElementX field = existing;
         accessor.abstractField = field;
-        if (accessor.isGetter()) {
+        if (accessor.isGetter) {
           if (field.getter != null && field.getter != accessor) {
             reportError(field.getter);
           }
           field.getter = accessor;
         } else {
-          assert(accessor.isSetter());
+          assert(accessor.isSetter);
           if (field.setter != null && field.setter != accessor) {
             reportError(field.setter);
           }
           field.setter = accessor;
         }
       }
     } else {
-      Element container = accessor.getEnclosingClassOrCompilationUnit();
+      Element container = accessor.enclosingClassOrCompilationUnit;
       AbstractFieldElementX field =
           new AbstractFieldElementX(accessor.name, container);
       accessor.abstractField = field;
-      if (accessor.isGetter()) {
+      if (accessor.isGetter) {
         field.getter = accessor;
       } else {
         field.setter = accessor;
       }
       add(field, listener);
     }
   }
 }
 
 class CompilationUnitElementX extends ElementX with AnalyzableElement
@@ skipping 12 matching lines @@
 
   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) {
-      getImplementationLibrary().addMember(element, listener);
+      implementationLibrary.addMember(element, listener);
     } else {
-      getLibrary().addMember(element, listener);
+      library.addMember(element, listener);
     }
   }
 
   void setPartOf(PartOf tag, DiagnosticListener listener) {
     LibraryElementX library = enclosingElement;
     if (library.entryCompilationUnit == this) {
       listener.reportError(tag, MessageKind.ILLEGAL_DIRECTIVE);
       return;
     }
     if (!localMembers.isEmpty) {
       listener.reportError(tag, MessageKind.BEFORE_TOP_LEVEL);
       return;
     }
     if (partTag != null) {
       listener.reportWarning(tag, MessageKind.DUPLICATED_PART_OF);
       return;
     }
     partTag = tag;
-    LibraryName libraryTag = getLibrary().libraryTag;
+    LibraryName libraryTag = library.libraryTag;
     String actualName = tag.name.toString();
     if (libraryTag != null) {
       String expectedName = libraryTag.name.toString();
       if (expectedName != actualName) {
         listener.reportWarning(tag.name,
             MessageKind.LIBRARY_NAME_MISMATCH,
             {'libraryName': expectedName});
       }
     } else {
-      listener.reportWarning(getLibrary(),
+      listener.reportWarning(library,
           MessageKind.MISSING_LIBRARY_NAME,
           {'libraryName': actualName});
       listener.reportInfo(tag.name,
           MessageKind.THIS_IS_THE_PART_OF_TAG);
     }
   }
 
   bool get hasMembers => !localMembers.isEmpty;
 
   int compareTo(CompilationUnitElement other) {
@@ skipping 37 matching lines @@
    * Adds [element] to the import scope of this library.
    *
    * If an element by the same name is already in the imported scope, an
    * [ErroneousElement] will be put in the imported scope, allowing for
    * detection of ambiguous uses of imported names.
    */
   void addImport(Element enclosingElement,
                  Element element,
                  Import import,
                  DiagnosticListener listener) {
-    LibraryElementX library = enclosingElement.getLibrary();
+    LibraryElementX library = enclosingElement.library;
     Importers importers = library.importers;
 
     String name = element.name;
 
     // The loadLibrary function always shadows existing bindings to that name.
-    if (element.isDeferredLoaderGetter()) {
+    if (element.isDeferredLoaderGetter) {
       importScope.remove(name);
       // TODO(sigurdm): Print a hint.
     }
     Element existing = importScope.putIfAbsent(name, () => element);
     importers.registerImport(element, import);
 
     void registerWarnOnUseElement(Import import,
                                   MessageKind messageKind,
                                   Element hidingElement,
                                   Element hiddenElement) {
-      Uri hiddenUri = hiddenElement.getLibrary().canonicalUri;
-      Uri hidingUri = hidingElement.getLibrary().canonicalUri;
+      Uri hiddenUri = hiddenElement.library.canonicalUri;
+      Uri hidingUri = hidingElement.library.canonicalUri;
       Element element = new WarnOnUseElementX(
           new WrappedMessage(
               null, // Report on reference to [hidingElement].
               messageKind,
               {'name': name, 'hiddenUri': hiddenUri, 'hidingUri': hidingUri}),
           new WrappedMessage(
               listener.spanFromSpannable(import),
               MessageKind.IMPORTED_HERE,
               {'name': name}),
           enclosingElement, hidingElement);
       importScope[name] = element;
       importers.registerImport(element, import);
     }
 
     if (existing != element) {
       Import existingImport = importers.getImport(existing);
       Element newElement;
-      if (existing.getLibrary().isPlatformLibrary &&
-          !element.getLibrary().isPlatformLibrary) {
+      if (existing.library.isPlatformLibrary &&
+          !element.library.isPlatformLibrary) {
         // [existing] is implicitly hidden.
         registerWarnOnUseElement(
             import, MessageKind.HIDDEN_IMPORT, element, existing);
-      } else if (!existing.getLibrary().isPlatformLibrary &&
-                 element.getLibrary().isPlatformLibrary) {
+      } else if (!existing.library.isPlatformLibrary &&
+                 element.library.isPlatformLibrary) {
         // [element] is implicitly hidden.
         if (import == null) {
           // [element] is imported implicitly (probably through dart:core).
           registerWarnOnUseElement(
               existingImport, MessageKind.HIDDEN_IMPLICIT_IMPORT,
               existing, element);
         } else {
           registerWarnOnUseElement(
               import, MessageKind.HIDDEN_IMPORT, existing, element);
         }
@@ skipping 54 matching lines @@
 
   Link<MetadataAnnotation> get metadata {
     return (libraryTag == null) ? super.metadata : libraryTag.metadata;
   }
 
   set metadata(value) {
     // The metadata is stored on [libraryTag].
     throw new SpannableAssertionFailure(this, 'Cannot set metadata on Library');
   }
 
-  CompilationUnitElement getCompilationUnit() => entryCompilationUnit;
+  CompilationUnitElement get compilationUnit => entryCompilationUnit;
 
   void addCompilationUnit(CompilationUnitElement element) {
     compilationUnits = compilationUnits.prepend(element);
   }
 
   void addTag(LibraryTag tag, DiagnosticListener listener) {
     tags = tags.prepend(tag);
   }
 
   void recordResolvedTag(LibraryDependency tag, LibraryElement library) {
@@ skipping 50 matching lines @@
     assert(invariant(this, !exportsHandled,
         message: 'Exports already set to $slotForExports on $this'));
     assert(invariant(this, exportedElements != null));
     var builder = new LinkBuilder<Element>();
     for (Element export in exportedElements) {
       builder.addLast(export);
     }
     slotForExports = builder.toLink();
   }
 
-  LibraryElement getLibrary() => isPatch ? origin : this;
+  LibraryElement get library => isPatch ? origin : this;
 
   /**
    * Look up a top-level element in this library. The element could
    * potentially have been imported from another library. Returns
    * null if no such element exist and an [ErroneousElement] if multiple
    * elements have been imported.
    */
   Element find(String elementName) {
     Element result = localScope.lookup(elementName);
     if (result != null) return result;
     if (origin != null) {
       result = origin.localScope.lookup(elementName);
       if (result != null) return result;
     }
     result = importScope[elementName];
     if (result != null) return result;
     if (origin != null) {
       result = origin.importScope[elementName];
       if (result != null) return result;
     }
     return null;
   }
 
   /** Look up a top-level element in this library, but only look for
     * non-imported elements. Returns null if no such element exist. */
   Element findLocal(String elementName) {
     // TODO(johnniwinther): How to handle injected elements in the patch
     // library?
     Element result = localScope.lookup(elementName);
-    if (result == null || result.getLibrary() != this) return null;
+    if (result == null || result.library != this) return null;
     return result;
   }
 
   Element findExported(String elementName) {
     for (Link link = exports; !link.isEmpty; link = link.tail) {
       Element element = link.head;
       if (element.name == elementName) return element;
     }
     return null;
   }
@@ skipping 100 matching lines @@
   Import _deferredImport;
   Import get deferredImport => _deferredImport;
 
   PrefixElementX(String prefix, Element enclosing, this.firstPosition)
       : super(prefix, ElementKind.PREFIX, enclosing);
 
   Element lookupLocalMember(String memberName) => importScope[memberName];
 
   DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
-  Token position() => firstPosition;
+  Token get position => firstPosition;
 
   void addImport(Element element, Import import, DiagnosticListener listener) {
     importScope.addImport(this, element, import, listener);
   }
 
   accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
 
   void markAsDeferred(Import deferredImport) {
     _deferredImport = deferredImport;
   }
@@ skipping 163 matching lines @@
     });
     return variables.computeType(this, compiler);
   }
 
   DartType get type {
     assert(invariant(this, variables.type != null,
         message: "Type has not been computed for $this."));
     return variables.type;
   }
 
-  bool isInstanceMember() => isMember() && !modifiers.isStatic();
+  bool get isInstanceMember => isMember && !modifiers.isStatic;
 
-  // Note: cachedNode.getBeginToken() will not be correct in all
+  // Note: cachedNode.beginToken will not be correct in all
   // cases, for example, for function typed parameters.
-  Token position() => token;
+  Token get position => token;
 
   accept(ElementVisitor visitor) => visitor.visitVariableElement(this);
 }
 
 class FieldElementX extends VariableElementX implements FieldElement {
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
   FieldElementX(Identifier name,
                 Element enclosingElement,
                 VariableList variables)
@@ skipping 45 matching lines @@
   ParameterElementX(ElementKind elementKind,
                     Element enclosingElement,
                     this.definitions,
                     Identifier identifier,
                     this.initializer)
       : this.identifier = identifier,
         super(identifier.source, elementKind, enclosingElement);
 
   Modifiers get modifiers => definitions.modifiers;
 
-  Token position() => identifier.getBeginToken();
+  Token get position => identifier.getBeginToken();
 
   Node parseNode(DiagnosticListener listener) => definitions;
 
   DartType computeType(Compiler compiler) {
     assert(invariant(this, type != null,
         message: "Parameter type has not been set for $this."));
     return type;
   }
 
   DartType get type {
@@ skipping 23 matching lines @@
       : 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";
   }
 
-  Token position() {
+  Token get position {
     // The getter and setter may be defined in two different
     // compilation units.  However, we know that one of them is
     // non-null and defined in the same compilation unit as the
     // abstract element.
     // TODO(lrn): No we don't know that if the element from the same
     // compilation unit is patched.
     //
     // We need to make sure that the position returned is relative to
     // the compilation unit of the abstract element.
     if (getter != null
-        && identical(getter.getCompilationUnit(), getCompilationUnit())) {
-      return getter.position();
+        && identical(getter.compilationUnit, compilationUnit)) {
+      return getter.position;
     } else {
-      return setter.position();
+      return setter.position;
     }
   }
 
   Modifiers get modifiers {
     // The resolver ensures that the flags match (ignoring abstract).
     if (getter != null) {
       return new Modifiers.withFlags(
           getter.modifiers.nodes,
           getter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     } else {
       return new Modifiers.withFlags(
           setter.modifiers.nodes,
           setter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
     }
   }
 
-  bool isInstanceMember() {
-    return isMember() && !modifiers.isStatic();
+  bool get isInstanceMember {
+    return isMember && !modifiers.isStatic;
   }
 
   accept(ElementVisitor visitor) => visitor.visitAbstractFieldElement(this);
 
   bool get isAbstract {
     return getter != null && getter.isAbstract
         || setter != null && setter.isAbstract;
   }
 }
 
@@ skipping 155 matching lines @@
   }
 
   InterfaceType computeTargetType(InterfaceType newType) {
     if (!isRedirectingFactory) return newType;
     assert(invariant(this, redirectionTargetType != null,
         message: 'Redirection target type has not yet been computed for '
                  '$this.'));
     return redirectionTargetType.substByContext(newType);
   }
 
-  bool isInstanceMember() {
-    return isMember()
-           && !isConstructor()
-           && !modifiers.isStatic();
+  bool get isInstanceMember {
+    return isMember
+           && !isConstructor
+           && !modifiers.isStatic;
   }
 
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignatureCache != null) return functionSignatureCache;
     compiler.withCurrentElement(this, () {
       functionSignatureCache = compiler.resolveSignature(this);
     });
     return functionSignatureCache;
   }
 
@@ skipping 10 matching lines @@
   }
 
   FunctionType get type {
     assert(invariant(this, typeCache != null,
         message: "Type has not been computed for $this."));
     return typeCache;
   }
 
   FunctionExpression parseNode(DiagnosticListener listener) {
     if (patch == null) {
-      if (modifiers.isExternal()) {
+      if (modifiers.isExternal) {
         listener.internalError(this,
             "Compiling external function with no implementation.");
       }
     }
     return cachedNode;
   }
 
   FunctionExpression get node {
     assert(invariant(this, cachedNode != null,
         message: "Node has not been computed for $this."));
     return cachedNode;
   }
 
-  Token position() {
+  Token get position {
     // Use the name as position if this is not an unnamed closure.
     if (cachedNode.name != null) {
       return cachedNode.name.getBeginToken();
     } else {
       return cachedNode.getBeginToken();
     }
   }
 
   FunctionElement asFunctionElement() => this;
 
   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()) &&
+    return !modifiers.isExternal &&
+           (isFunction || isAccessor) &&
            _hasNoBody;
   }
 
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 }
 
 class SynthesizedCallMethodElementX extends FunctionElementX {
   final FunctionElement expression;
 
   SynthesizedCallMethodElementX(String name,
@@ skipping 20 matching lines @@
   FunctionSignature computeSignature(Compiler compiler) {
     if (functionSignatureCache != null) return functionSignature;
     compiler.withCurrentElement(this, () {
       DartType inner = new FunctionType(this, compiler.types.dynamicType);
       functionSignatureCache = new FunctionSignatureX(const Link(),
           const Link(), 0, 0, false, [], inner);
     });
     return functionSignatureCache;
   }
 
-  bool isMember() => false;
+  bool get isMember => false;
 
   bool isForeign(Compiler compiler) => true;
 
   bool get isSynthesized => true;
 
-  bool isFunction() => false;
+  bool get isFunction => false;
 
-  bool isDeferredLoaderGetter() => true;
+  bool get isDeferredLoaderGetter => true;
 
-  bool isGetter() => true;
+  bool get isGetter => true;
 
   // By having position null, the enclosing elements location is printed in
   // error messages.
-  Token position() => null;
+  Token get position => null;
 }
 
 class ConstructorBodyElementX extends FunctionElementX
     implements ConstructorBodyElement {
   FunctionElement constructor;
 
   ConstructorBodyElementX(FunctionElement constructor)
       : this.constructor = constructor,
         super(constructor.name,
               ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
               Modifiers.EMPTY,
               constructor.enclosingElement, false) {
     functionSignatureCache = constructor.functionSignature;
   }
 
-  bool isInstanceMember() => true;
+  bool get isInstanceMember => true;
 
   FunctionType computeType(Compiler compiler) {
     compiler.internalError(this, '$this.computeType.');
     return null;
   }
 
   Node parseNode(DiagnosticListener listener) {
     if (cachedNode != null) return cachedNode;
     cachedNode = constructor.parseNode(listener);
     assert(cachedNode != null);
     return cachedNode;
   }
 
-  Token position() => constructor.position();
+  Token get position => constructor.position;
 
-  Element getOutermostEnclosingMemberOrTopLevel() => constructor;
+  Element get outermostEnclosingMemberOrTopLevel => constructor;
 
   accept(ElementVisitor visitor) => visitor.visitConstructorBodyElement(this);
 }
 
 /**
  * A constructor that is not defined in the source code but rather implied by
  * the language semantics.
  *
  * This class is used to represent default constructors and forwarding
  * constructors for mixin applications.
  */
 class SynthesizedConstructorElementX extends FunctionElementX {
   final FunctionElement superMember;
   final bool isDefaultConstructor;
 
   SynthesizedConstructorElementX(String name,
                                  this.superMember,
                                  Element enclosing,
                                  this.isDefaultConstructor)
       : super(name,
               ElementKind.GENERATIVE_CONSTRUCTOR,
               Modifiers.EMPTY,
               enclosing, false);
 
   SynthesizedConstructorElementX.forDefault(superMember, Element enclosing)
       : this('', superMember, enclosing, true);
 
-  Token position() => enclosingElement.position();
+  Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
   FunctionElement get targetConstructor => superMember;
 
   FunctionSignature computeSignature(compiler) {
     if (functionSignatureCache != null) return functionSignatureCache;
     if (isDefaultConstructor) {
       return functionSignatureCache = new FunctionSignatureX(
           const Link<Element>(), const Link<Element>(), 0, 0, false,
           const <Element>[],
-          new FunctionType(this, getEnclosingClass().thisType));
+          new FunctionType(this, enclosingClass.thisType));
     }
-    if (superMember.isErroneous()) {
+    if (superMember.isErroneous) {
       return functionSignatureCache =
           compiler.objectClass.localLookup('').computeSignature(compiler);
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
     return functionSignatureCache = superMember.computeSignature(compiler);
   }
 
   get declaration => this;
   get implementation => this;
   get defaultImplementation => this;
 
   accept(ElementVisitor visitor) {
     return visitor.visitFunctionElement(this);
   }
 }
 
 class VoidElementX extends ElementX implements VoidElement {
   VoidElementX(Element enclosing) : super('void', ElementKind.VOID, enclosing);
   DartType computeType(compiler) => compiler.types.voidType;
   Node parseNode(_) {
     throw 'internal error: parseNode on void';
   }
-  bool impliesType() => true;
+  bool get impliesType => true;
 
   accept(ElementVisitor visitor) => visitor.visitVoidElement(this);
 }
 
 abstract class TypeDeclarationElementX<T extends GenericType>
     implements TypeDeclarationElement {
   /**
    * The `this type` for this type declaration.
    *
    * The type of [:this:] is the generic type based on this element in which
@@ skipping 157 matching lines @@
   void ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveClass(this);
     }
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler);
 
   void addBackendMember(Element member) {
     // TODO(ngeoffray): Deprecate this method.
-    assert(member.isGenerativeConstructorBody());
+    assert(member.isGenerativeConstructorBody);
     backendMembers = backendMembers.prepend(member);
   }
 
   void reverseBackendMembers() {
     backendMembers = backendMembers.reverse();
   }
 
   /**
    * Lookup local members in the class. This will ignore constructors.
    */
   Element lookupLocalMember(String memberName) {
     var result = localLookup(memberName);
-    if (result != null && result.isConstructor()) return null;
+    if (result != null && result.isConstructor) return null;
     return result;
   }
 
   /// Lookup a synthetic element created by the backend.
   Element lookupBackendMember(String memberName) {
     for (Element element in backendMembers) {
       if (element.name == memberName) {
         return element;
       }
     }
     return null;
   }
   /**
    * Lookup super members for the class. This will ignore constructors.
    */
   Element lookupSuperMember(String memberName) {
-    return lookupSuperMemberInLibrary(memberName, getLibrary());
+    return lookupSuperMemberInLibrary(memberName, library);
   }
 
   /**
    * Lookup super members for the class that is accessible in [library].
    * This will ignore constructors.
    */
   Element lookupSuperMemberInLibrary(String memberName,
                                      LibraryElement library) {
     bool isPrivate = isPrivateName(memberName);
     for (ClassElement s = superclass; s != null; s = s.superclass) {
       // Private members from a different library are not visible.
-      if (isPrivate && !identical(library, s.getLibrary())) continue;
+      if (isPrivate && !identical(library, s.library)) continue;
       Element e = s.lookupLocalMember(memberName);
       if (e == null) continue;
       // Static members are not inherited.
-      if (e.modifiers.isStatic()) continue;
+      if (e.modifiers.isStatic) continue;
       return e;
     }
     return null;
   }
 
   /**
    * Find the first member in the class chain with the given [selector].
    *
    * This method is NOT to be used for resolving
    * unqualified sends because it does not implement the scoping
@@ skipping 20 matching lines @@
          current != null;
          current = current.superclass) {
       Element member = current.lookupLocalMember(name);
       if (member == null && current.isPatched) {
         // Doing lookups on selectors is done after resolution, so it
         // is safe to look in the patch class.
         member = current.patch.lookupLocalMember(name);
       }
       if (member == null) continue;
       // Private members from a different library are not visible.
-      if (isPrivate && !identical(library, member.getLibrary())) continue;
+      if (isPrivate && !identical(library, member.library)) continue;
       // Static members are not inherited.
-      if (member.modifiers.isStatic() && !identical(this, current)) continue;
+      if (member.modifiers.isStatic && !identical(this, current)) continue;
       // If we find an abstract field we have to make sure that it has
       // the getter or setter part we're actually looking
       // for. Otherwise, we continue up the superclass chain.
-      if (member.isAbstractField()) {
+      if (member.isAbstractField) {
         AbstractFieldElement field = member;
         FunctionElement getter = field.getter;
         FunctionElement setter = field.setter;
-        if (selector.isSetter()) {
+        if (selector.isSetter) {
           // Abstract members can be defined in a super class.
           if (setter != null && !setter.isAbstract) return setter;
         } else {
-          assert(selector.isGetter() || selector.isCall());
+          assert(selector.isGetter || selector.isCall);
           if (getter != null && !getter.isAbstract) return getter;
         }
       // Abstract members can be defined in a super class.
       } else if (!member.isAbstract) {
         return member;
       }
     }
     return null;
   }
 
   /**
    * Find the first member in the class chain with the given
    * [memberName]. This method is NOT to be used for resolving
    * unqualified sends because it does not implement the scoping
    * rules, where library scope comes before superclass scope.
    */
   Element lookupMember(String memberName) {
     Element localMember = lookupLocalMember(memberName);
     return localMember == null ? lookupSuperMember(memberName) : localMember;
   }
 
   /**
    * Returns true if the [fieldMember] shadows another field.  The given
    * [fieldMember] must be a member of this class, i.e. if there is a field of
    * the same name in the superclass chain.
    *
    * This method also works if the [fieldMember] is private.
    */
   bool hasFieldShadowedBy(Element fieldMember) {
-    assert(fieldMember.isField());
+    assert(fieldMember.isField);
     String fieldName = fieldMember.name;
     bool isPrivate = isPrivateName(fieldName);
-    LibraryElement memberLibrary = fieldMember.getLibrary();
+    LibraryElement memberLibrary = fieldMember.library;
     ClassElement lookupClass = this.superclass;
     while (lookupClass != null) {
       Element foundMember = lookupClass.lookupLocalMember(fieldName);
       if (foundMember != null) {
-        if (foundMember.isField()) {
-          if (!isPrivate || memberLibrary == foundMember.getLibrary()) {
+        if (foundMember.isField) {
+          if (!isPrivate || memberLibrary == foundMember.library) {
             // Private fields can only be shadowed by a field declared in the
             // same library.
             return true;
           }
         }
       }
       lookupClass = lookupClass.superclass;
     }
     return false;
   }
 
   Element validateConstructorLookupResults(Selector selector,
                                            Element result,
                                            Element noMatch(Element)) {
     if (result == null
-        || !result.isConstructor()
+        || !result.isConstructor
         || (isPrivateName(selector.name)
-            && result.getLibrary() != selector.library)) {
+            && result.library != selector.library)) {
       result = noMatch != null ? noMatch(result) : null;
     }
     return result;
   }
 
   // TODO(aprelev@gmail.com): Peter believes that it would be great to
   // make noMatch a required argument. Peter's suspicion is that most
   // callers of this method would benefit from using the noMatch method.
   Element lookupConstructor(Selector selector, [Element noMatch(Element)]) {
     Element result = localLookup(selector.name);
     return validateConstructorLookupResults(selector, result, noMatch);
   }
 
   Link<Element> get constructors {
     // TODO(ajohnsen): See if we can avoid this method at some point.
     Link<Element> result = const Link<Element>();
     // TODO(johnniwinther): Should we include injected constructors?
     forEachMember((_, Element member) {
-      if (member.isConstructor()) result = result.prepend(member);
+      if (member.isConstructor) result = result.prepend(member);
     });
     return result;
   }
 
   /**
    * Returns the super class, if any.
    *
    * The returned element may not be resolved yet.
    */
   ClassElement get superclass {
@@ skipping 45 matching lines @@
    * [includeSuperAndInjectedMembers] is [:true:].
    *
    * When called on the implementation element both the fields declared in the
    * origin and in the patch are included.
    */
   void forEachInstanceField(void f(ClassElement enclosingClass,
                                    FieldElement field),
                             {bool includeSuperAndInjectedMembers: false}) {
     // Filters so that [f] is only invoked with instance fields.
     void fieldFilter(ClassElement enclosingClass, Element member) {
-      if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
+      if (member.isInstanceMember && member.kind == ElementKind.FIELD) {
         f(enclosingClass, member);
       }
     }
 
     forEachMember(fieldFilter,
         includeSuperAndInjectedMembers: includeSuperAndInjectedMembers);
   }
 
   /// Similar to [forEachInstanceField] but visits static fields.
   void forEachStaticField(void f(ClassElement enclosingClass, Element field)) {
     // Filters so that [f] is only invoked with static fields.
     void fieldFilter(ClassElement enclosingClass, Element member) {
-      if (!member.isInstanceMember() && member.kind == ElementKind.FIELD) {
+      if (!member.isInstanceMember && member.kind == ElementKind.FIELD) {
         f(enclosingClass, member);
       }
     }
 
     forEachMember(fieldFilter);
   }
 
   void forEachBackendMember(void f(Element member)) {
     backendMembers.forEach(f);
   }
@@ skipping 18 matching lines @@
   bool isSubclassOf(ClassElement cls) {
     // Use [declaration] for both [this] and [cls], because
     // declaration classes hold the superclass hierarchy.
     cls = cls.declaration;
     for (ClassElement s = declaration; s != null; s = s.superclass) {
       if (identical(s, cls)) return true;
     }
     return false;
   }
 
-  bool isNative() => nativeTagInfo != null;
+  bool get isNative => nativeTagInfo != null;
   void setNative(String name) {
     nativeTagInfo = name;
   }
 
   FunctionType get callType {
     MemberSignature member =
         lookupInterfaceMember(const PublicName(Compiler.CALL_OPERATOR_NAME));
     return member != null && member.isMethod ? member.type : null;
   }
 
@@ skipping 13 matching lines @@
 
   bool get isMixinApplication => false;
   bool get hasLocalScopeMembers => !localScope.isEmpty;
 
   void addMember(Element element, DiagnosticListener listener) {
     localMembers = localMembers.prepend(element);
     addToScope(element, listener);
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
-    if (element.isField() && element.name == name) {
+    if (element.isField && element.name == name) {
       listener.reportError(element, MessageKind.MEMBER_USES_CLASS_NAME);
     }
     localScope.add(element, listener);
   }
 
   Element localLookup(String elementName) {
     Element result = localScope.lookup(elementName);
     if (result == null && isPatch) {
       result = origin.localLookup(elementName);
     }
     return result;
   }
 
   void forEachLocalMember(void f(Element member)) {
     localMembers.reverse().forEach(f);
   }
 
   bool get hasConstructor {
     // Search in scope to be sure we search patched constructors.
     for (var element in localScope.values) {
-      if (element.isConstructor()) return true;
+      if (element.isConstructor) return true;
     }
     return false;
   }
 
   void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
     addToScope(constructor, compiler);
     // The default constructor, although synthetic, is part of a class' API.
     localMembers = localMembers.prepend(constructor);
   }
 
@@ skipping 31 matching lines @@
   ClassElement get mixin => mixinType != null ? mixinType.element : null;
 
   bool get isMixinApplication => true;
   bool get isUnnamedMixinApplication => node is! NamedMixinApplication;
   bool get hasConstructor => !constructors.isEmpty;
   bool get hasLocalScopeMembers => !constructors.isEmpty;
 
   get patch => null;
   get origin => null;
 
-  Token position() => node.getBeginToken();
+  Token get position => node.getBeginToken();
 
   Node parseNode(DiagnosticListener listener) => node;
 
   FunctionElement lookupLocalConstructor(String name) {
     for (Link<Element> link = constructors;
          !link.isEmpty;
          link = link.tail) {
       if (link.head.name == name) return link.head;
     }
     return null;
   }
 
   Element localLookup(String name) {
     Element constructor = lookupLocalConstructor(name);
     if (constructor != null) return constructor;
     if (mixin == null) return null;
     Element mixedInElement = mixin.localLookup(name);
     if (mixedInElement == null) return null;
-    return mixedInElement.isInstanceMember() ? mixedInElement : null;
+    return mixedInElement.isInstanceMember ? mixedInElement : null;
   }
 
   void forEachLocalMember(void f(Element member)) {
     constructors.forEach(f);
     if (mixin != null) mixin.forEachLocalMember((Element mixedInElement) {
-      if (mixedInElement.isInstanceMember()) f(mixedInElement);
+      if (mixedInElement.isInstanceMember) f(mixedInElement);
     });
   }
 
   void addMember(Element element, DiagnosticListener listener) {
     throw new UnsupportedError("Cannot add member to $this.");
   }
 
   void addToScope(Element element, DiagnosticListener listener) {
     listener.internalError(this, 'Cannot add to scope of $this.');
   }
@@ skipping 45 matching lines @@
     target.isBreakTarget = true;
   }
   void setContinueTarget() {
     isContinueTarget = true;
     target.isContinueTarget = true;
   }
 
   bool get isTarget => isBreakTarget || isContinueTarget;
   Node parseNode(DiagnosticListener l) => label;
 
-  Token position() => label.getBeginToken();
+  Token get position => label.getBeginToken();
   String toString() => "${labelName}:";
 
   accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
 }
 
 // Represents a reference to a statement or switch-case, either by label or the
 // default target of a break or continue.
 class TargetElementX extends ElementX implements TargetElement {
   final Node statement;
   final int nestingLevel;
   Link<LabelElement> labels = const Link<LabelElement>();
   bool isBreakTarget = false;
   bool isContinueTarget = false;
 
   TargetElementX(this.statement, this.nestingLevel, Element enclosingElement)
       : super("target", ElementKind.STATEMENT, enclosingElement);
   bool get isTarget => isBreakTarget || isContinueTarget;
 
   LabelElement addLabel(Label label, String labelName) {
     LabelElement result = new LabelElementX(label, labelName, this,
                                             enclosingElement);
     labels = labels.prepend(result);
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 
   bool get isSwitch => statement is SwitchStatement;
 
-  Token position() => statement.getBeginToken();
+  Token get position => statement.getBeginToken();
   String toString() => statement.toString();
 
   accept(ElementVisitor visitor) => visitor.visitTargetElement(this);
 }
 
 class TypeVariableElementX extends ElementX implements TypeVariableElement {
   final Node cachedNode;
   TypeVariableType typeCache;
   DartType boundCache;
 
@@ skipping 11 matching lines @@
   DartType get bound {
     assert(invariant(this, boundCache != null,
         message: "Bound has not been set on $this."));
     return boundCache;
   }
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name}";
 
-  Token position() => cachedNode.getBeginToken();
+  Token get position => cachedNode.getBeginToken();
 
   accept(ElementVisitor visitor) => visitor.visitTypeVariableElement(this);
 }
 
 /**
  * A single metadata annotation.
  *
  * For example, consider:
  *
  *     class Data {
@@ skipping 80 matching lines @@
     assert(invariant(this, this.origin == null,
                      message: "Origin element is a patch."));
     assert(invariant(patch, patch.origin == null,
                      message: "Element is patched twice."));
     assert(invariant(patch, patch.patch == null,
                      message: "Patch element is patched."));
     this.patch = patch;
     patch.origin = this;
   }
 }