Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/ir/ir_builder.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 dart2js.ir_builder;
 
 import 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 41 matching lines @@
         if (canBuild(element)) {
           element = element.implementation;
 
           SourceFile sourceFile = elementSourceFile(element);
           IrBuilder builder =
               new IrBuilder(elementsMapping, compiler, sourceFile);
           ir.FunctionDefinition function;
           ElementKind kind = element.kind;
           if (kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
             // TODO(lry): build ir for constructors.
-          } else if (element.isDeferredLoaderGetter()) {
+          } else if (element.isDeferredLoaderGetter) {
             // TODO(sigurdm): Build ir for deferred loader functions.
           } else if (kind == ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||
               kind == ElementKind.FUNCTION ||
               kind == ElementKind.GETTER ||
               kind == ElementKind.SETTER) {
             function = builder.buildFunction(element);
           } else if (kind == ElementKind.FIELD) {
             // TODO(lry): build ir for lazy initializers of static fields.
           } else {
             compiler.internalError(element, 'Unexpected element kind $kind.');
           }
 
           if (function != null) {
             assert(() {
               // In host-checked mode, serialize and de-serialize the IrNode.
-              LibraryElement library = element.declaration.getLibrary();
+              LibraryElement library = element.declaration.library;
               IrConstantPool constantPool = IrConstantPool.forLibrary(library);
               List<int> data = function.pickle(constantPool);
               function = new Unpickler(compiler, constantPool).unpickle(data);
               return true;
             });
             nodes[element] = function;
             compiler.tracer.traceCompilation(element.name, null, compiler);
             compiler.tracer.traceGraph("IR Builder", function);
           }
         }
@@ skipping 25 matching lines @@
     bool parameters_ok = true;
     signature.forEachParameter((parameter) {
       parameters_ok =
           parameters_ok && typeVerifier.visit(parameter.type, null);
     });
     if (!parameters_ok) return false;
 
     // TODO(kmillikin): support getters and setters and static class members.
     // With the current Dart Tree emitter they just require recognizing them
     // and generating the correct syntax.
-    if (element.isGetter() || element.isSetter()) return false;
-    if (element.enclosingElement.isClass()) return false;
+    if (element.isGetter || element.isSetter) return false;
+    if (element.enclosingElement.isClass) return false;
 
     // TODO(lry): support native functions (also in [visitReturn]).
-    if (function.isNative()) return false;
+    if (function.isNative) return false;
 
     return true;
   }
 
   bool get inCheckedMode {
     bool result = false;
     assert((result = true));
     return result;
   }
 
   SourceFile elementSourceFile(Element element) {
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       if (functionElement.patch != null) element = functionElement.patch;
     }
-    return element.getCompilationUnit().script.file;
+    return element.compilationUnit.script.file;
   }
 }
 
 /**
  * A tree visitor that builds [IrNodes]. The visit methods add statements using
  * to the [builder] and return the last added statement for trees that represent
  * an expression.
  */
 class IrBuilder extends ResolvedVisitor<ir.Primitive> {
   final SourceFile sourceFile;
@@ skipping 76 matching lines @@
    * returns `null`.
    */
   ir.FunctionDefinition buildFunction(FunctionElement functionElement) {
     return nullIfGiveup(() => buildFunctionInternal(functionElement));
   }
 
   ir.FunctionDefinition buildFunctionInternal(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression function = element.parseNode(compiler);
     assert(function != null);
-    assert(!function.modifiers.isExternal());
+    assert(!function.modifiers.isExternal);
     assert(elements[function] != null);
 
     root = current = null;
 
     FunctionSignature signature = element.functionSignature;
     signature.orderedForEachParameter((parameterElement) {
       ir.Parameter parameter = new ir.Parameter(parameterElement);
       parameters.add(parameter);
       variableIndex[parameterElement] = assignedVars.length;
       assignedVars.add(parameter);
@@ skipping 294 matching lines @@
     assert(isOpen);
     return giveup();
   }
 
   // Build(StaticSend(f, arguments), C) = C[C'[InvokeStatic(f, xs)]]
   //   where (C', xs) = arguments.fold(Build, C)
   ir.Primitive visitStaticSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     // TODO(lry): support static fields. (separate IR instruction?)
-    if (element.isField() || element.isGetter()) return giveup();
+    if (element.isField || element.isGetter) return giveup();
     // TODO(kmillikin): support static setters.
-    if (element.isSetter()) return giveup();
+    if (element.isSetter) return giveup();
     // TODO(lry): support constructors / factory calls.
-    if (element.isConstructor()) return giveup();
+    if (element.isConstructor) return giveup();
     // TODO(lry): support foreign functions.
     if (element.isForeign(compiler)) return giveup();
     // TODO(lry): for elements that could not be resolved emit code to throw a
     // [NoSuchMethodError].
-    if (element.isErroneous()) return giveup();
+    if (element.isErroneous) return giveup();
     // TODO(lry): generate IR for object identicality.
     if (element == compiler.identicalFunction) giveup();
 
     Selector selector = elements.getSelector(node);
     // TODO(lry): support named arguments
     if (selector.namedArgumentCount != 0) return giveup();
 
     // TODO(kmillikin): support a receiver: A.m().
     if (node.receiver != null) return giveup();
 
@@ skipping 60 matching lines @@
   bool visit(DartType type, Null _) => type.accept(this, null);
 
   bool visitType(DartType type, Null _) => false;
 
   bool visitVoidType(VoidType type, Null _) => true;
 
   // Currently, InterfaceType and TypedefType are supported so long as they
   // do not have type parameters.  They are subclasses of GenericType.
   bool visitGenericType(GenericType type, Null _) => !type.isGeneric;
 }