Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/native_handler.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 native;
 
 import 'dart:collection' show Queue;
 import 'dart2jslib.dart';
 import 'dart_types.dart';
 import 'elements/elements.dart';
@@ skipping 119 matching lines @@
     processSubclassesOfNativeClasses(libraries);
     if (!enableLiveTypeAnalysis) {
       nativeClasses.forEach((c) => enqueueClass(c, 'forced'));
       flushQueue();
     }
   }
 
   void processNativeClassesInLibrary(LibraryElement library) {
     // Use implementation to ensure the inclusion of injected members.
     library.implementation.forEachLocalMember((Element element) {
-      if (element.isClass() && element.isNative()) {
+      if (element.isClass && element.isNative) {
         processNativeClass(element);
       }
     });
   }
 
   void processNativeClass(ClassElement classElement) {
     nativeClasses.add(classElement);
     unusedClasses.add(classElement);
     // Resolve class to ensure the class has valid inheritance info.
     classElement.ensureResolved(compiler);
   }
 
   void processSubclassesOfNativeClasses(Iterable<LibraryElement> libraries) {
     // Collect potential subclasses, e.g.
     //
     //     class B extends foo.A {}
     //
     // String "A" has a potential subclass B.
 
     var potentialExtends = new Map<String, Set<ClassElement>>();
 
     libraries.forEach((library) {
       library.implementation.forEachLocalMember((element) {
-        if (element.isClass()) {
+        if (element.isClass) {
           String name = element.name;
           String extendsName = findExtendsNameOfClass(element);
           if (extendsName != null) {
             Set<ClassElement> potentialSubclasses =
                 potentialExtends.putIfAbsent(
                     extendsName,
                     () => new Set<ClassElement>());
             potentialSubclasses.add(element);
           }
         }
       });
     });
 
     // Resolve all the native classes and any classes that might extend them in
     // [potentialExtends], and then check that the properly resolved class is in
     // fact a subclass of a native class.
 
     ClassElement nativeSuperclassOf(ClassElement classElement) {
-      if (classElement.isNative()) return classElement;
+      if (classElement.isNative) return classElement;
       if (classElement.superclass == null) return null;
       return nativeSuperclassOf(classElement.superclass);
     }
 
     void walkPotentialSubclasses(ClassElement element) {
       if (nativeClassesAndSubclasses.contains(element)) return;
       element.ensureResolved(compiler);
       ClassElement nativeSuperclass = nativeSuperclassOf(element);
       if (nativeSuperclass != null) {
         nativeClassesAndSubclasses.add(element);
-        if (!element.isNative()) {
+        if (!element.isNative) {
           nonNativeSubclasses.putIfAbsent(nativeSuperclass,
               () => new Set<ClassElement>())
             .add(element);
         }
         Set<ClassElement> potentialSubclasses = potentialExtends[element.name];
         if (potentialSubclasses != null) {
           potentialSubclasses.forEach(walkPotentialSubclasses);
         }
       }
     }
@@ skipping 52 matching lines @@
         if (token.stringValue != '.') break;
         token = token.next;
         if (!token.isIdentifier()) return null;
         id = token;
       }
       // Should be at '{', 'with', 'implements', '<' or 'native'.
       return id.value;
     }
 
     return compiler.withCurrentElement(classElement, () {
-      return scanForExtendsName(classElement.position());
+      return scanForExtendsName(classElement.position);
     });
   }
 
   ClassElement get annotationCreatesClass {
     findAnnotationClasses();
     return _annotationCreatesClass;
   }
 
   ClassElement get annotationReturnsClass {
     findAnnotationClasses();
@@ skipping 83 matching lines @@
     // only be parsed if there is a call to one of its constructors.
     classElement.parseNode(compiler);
 
     if (firstTime) {
       queue.add(onFirstNativeClass);
     }
   }
 
   registerElement(Element element) {
     compiler.withCurrentElement(element, () {
-      if (element.isFunction() || element.isGetter() || element.isSetter()) {
+      if (element.isFunction || element.isGetter || element.isSetter) {
         handleMethodAnnotations(element);
-        if (element.isNative()) {
+        if (element.isNative) {
           registerMethodUsed(element);
         }
-      } else if (element.isField()) {
+      } else if (element.isField) {
         handleFieldAnnotations(element);
-        if (element.isNative()) {
+        if (element.isNative) {
           registerFieldLoad(element);
           registerFieldStore(element);
         }
       }
     });
   }
 
   handleFieldAnnotations(Element element) {
-    if (element.enclosingElement.isNative()) {
+    if (element.enclosingElement.isNative) {
       // Exclude non-instance (static) fields - they not really native and are
       // compiled as isolate globals.  Access of a property of a constructor
       // function or a non-method property in the prototype chain, must be coded
       // using a JS-call.
-      if (element.isInstanceMember()) {
+      if (element.isInstanceMember) {
         setNativeName(element);
       }
     }
   }
 
   handleMethodAnnotations(Element method) {
     if (isNativeMethod(method)) {
       setNativeName(method);
     }
   }
 
   /// Sets the native name of [element], either from an annotation, or
   /// defaulting to the Dart name.
   void setNativeName(Element element) {
     String name = findJsNameFromAnnotation(element);
     if (name == null) name = element.name;
     element.setNative(name);
   }
 
   bool isNativeMethod(Element element) {
-    if (!element.getLibrary().canUseNative) return false;
+    if (!element.library.canUseNative) return false;
     // Native method?
     return compiler.withCurrentElement(element, () {
       Node node = element.parseNode(compiler);
       if (node is! FunctionExpression) return false;
       FunctionExpression functionExpression = node;
       node = functionExpression.body;
       Token token = node.getBeginToken();
       if (identical(token.stringValue, 'native')) return true;
       return false;
     });
@@ skipping 165 matching lines @@
   }
 
   processClass(ClassElement classElement, cause) {
     super.processClass(classElement, cause);
     // Add the information that this class is a subtype of its supertypes.  The
     // code emitter and the ssa builder use that information.
     addSubtypes(classElement, emitter.nativeEmitter);
   }
 
   void addSubtypes(ClassElement cls, NativeEmitter emitter) {
-    if (!cls.isNative()) return;
+    if (!cls.isNative) return;
     if (doneAddSubtypes.contains(cls)) return;
     doneAddSubtypes.add(cls);
 
     // Walk the superclass chain since classes on the superclass chain might not
     // be instantiated (abstract or simply unused).
     addSubtypes(cls.superclass, emitter);
 
     for (DartType type in cls.allSupertypes) {
       List<Element> subtypes = emitter.subtypes.putIfAbsent(
           type.element,
           () => <ClassElement>[]);
       subtypes.add(cls);
     }
 
     // Skip through all the mixin applications in the super class
     // chain. That way, the direct subtypes set only contain the
     // natives classes.
     ClassElement superclass = cls.superclass;
     while (superclass != null && superclass.isMixinApplication) {
-      assert(!superclass.isNative());
+      assert(!superclass.isNative);
       superclass = superclass.superclass;
     }
 
     List<Element> directSubtypes = emitter.directSubtypes.putIfAbsent(
         superclass,
         () => <ClassElement>[]);
     directSubtypes.add(cls);
   }
 
   void logSummary(log(message)) {
@@ skipping 354 matching lines @@
         "Type '$typeString' not found.");
   }
 
   static _errorNode(locationNodeOrElement, compiler) {
     if (locationNodeOrElement is Node) return locationNodeOrElement;
     return locationNodeOrElement.parseNode(compiler);
   }
 }
 
 void checkAllowedLibrary(ElementListener listener, Token token) {
-  LibraryElement currentLibrary = listener.compilationUnitElement.getLibrary();
+  LibraryElement currentLibrary = listener.compilationUnitElement.library;
   if (!currentLibrary.canUseNative) {
     listener.recoverableError(token, "Unexpected token");
   }
 }
 
 Token handleNativeBlockToSkip(Listener listener, Token token) {
   checkAllowedLibrary(listener, token);
   token = token.next;
   if (identical(token.kind, STRING_TOKEN)) {
     token = token.next;
@@ skipping 100 matching lines @@
   }
 
   // Check which pattern this native method follows:
   // 1) foo() native;
   //      hasBody = false
   // 2) foo() native "bar";
   //      No longer supported, this is now done with @JSName('foo') and case 1.
   // 3) foo() native "return 42";
   //      hasBody = true
   bool hasBody = false;
-  assert(element.isNative());
-  String nativeMethodName = element.fixedBackendName();
+  assert(element.isNative);
+  String nativeMethodName = element.fixedBackendName;
   if (nativeBody != null) {
     LiteralString jsCode = nativeBody.asLiteralString();
     String str = jsCode.dartString.slowToString();
     if (nativeRedirectionRegExp.hasMatch(str)) {
       compiler.internalError(
           nativeBody, "Deprecated syntax, use @JSName('name') instead.");
     }
     hasBody = true;
   }
 
   if (!hasBody) {
     nativeEmitter.nativeMethods.add(element);
   }
 
   FunctionSignature parameters = element.functionSignature;
   if (!hasBody) {
     List<String> arguments = <String>[];
     List<HInstruction> inputs = <HInstruction>[];
     String receiver = '';
-    if (element.isInstanceMember()) {
+    if (element.isInstanceMember) {
       receiver = '#.';
       inputs.add(builder.localsHandler.readThis());
     }
     parameters.forEachParameter((ParameterElement parameter) {
       DartType type = parameter.type.unalias(compiler);
       HInstruction input = builder.localsHandler.readLocal(parameter);
       if (type is FunctionType) {
         // The parameter type is a function type either directly or through
         // typedef(s).
         input = convertDartClosure(parameter, type);
@@ skipping 33 matching lines @@
     LiteralString jsCode = nativeBody.asLiteralString();
     builder.push(new HForeign.statement(
         js.js.statementTemplateYielding(
             new js.LiteralStatement(jsCode.dartString.slowToString())),
         <HInstruction>[],
         new SideEffects(),
         null,
         backend.dynamicType));
   }
 }