Convert property methods into getters.

sdk/lib/_internal/compiler/implementation/js_emitter/code_emitter_task.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.
 
 part of dart2js.js_emitter;
 
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
@@ skipping 599 matching lines @@
     ];
   }
 
   void emitFinishIsolateConstructorInvocation(CodeBuffer buffer) {
     String isolate = namer.isolateName;
     buffer.write("$isolate = $finishIsolateConstructorName($isolate)$N");
   }
 
   /// In minified mode we want to keep the name for the most common core types.
   bool _isNativeTypeNeedingReflectionName(Element element) {
-    if (!element.isClass()) return false;
+    if (!element.isClass) return false;
     return (element == compiler.intClass ||
             element == compiler.doubleClass ||
             element == compiler.numClass ||
             element == compiler.stringClass ||
             element == compiler.boolClass ||
             element == compiler.nullClass ||
             element == compiler.listClass);
   }
 
   /// Returns the "reflection name" of an [Element] or [Selector].
@@ skipping 20 matching lines @@
       // an instance method and a global.  They may have the same mangled name.
       // if (recordedMangledNames.contains(mangledName)) return null;
       recordedMangledNames.add(mangledName);
       return getReflectionNameInternal(elementOrSelector, mangledName);
     }
     return null;
   }
 
   String getReflectionNameInternal(elementOrSelector, String mangledName) {
     String name = elementOrSelector.name;
-    if (elementOrSelector.isGetter()) return name;
-    if (elementOrSelector.isSetter()) {
+    if (elementOrSelector.isGetter) return name;
+    if (elementOrSelector.isSetter) {
       if (!mangledName.startsWith(namer.setterPrefix)) return '$name=';
       String base = mangledName.substring(namer.setterPrefix.length);
       String getter = '${namer.getterPrefix}$base';
       mangledFieldNames[getter] = name;
       recordedMangledNames.add(getter);
       // TODO(karlklose,ahe): we do not actually need to store information
       // about the name of this setter in the output, but it is needed for
       // marking the function as invokable by reflection.
       return '$name=';
     }
-    if (elementOrSelector is Element && elementOrSelector.isClosure()) {
+    if (elementOrSelector is Element && elementOrSelector.isClosure) {
       // Closures are synthesized and their name might conflict with existing
       // globals. Assign an illegal name, and make sure they don't clash
       // with each other.
       return " $mangledName";
     }
     if (elementOrSelector is Selector
-        || elementOrSelector.isFunction()
-        || elementOrSelector.isConstructor()) {
+        || elementOrSelector.isFunction
+        || elementOrSelector.isConstructor) {
       int requiredParameterCount;
       int optionalParameterCount;
       String namedArguments = '';
       bool isConstructor = false;
       if (elementOrSelector is Selector) {
         Selector selector = elementOrSelector;
         requiredParameterCount = selector.argumentCount;
         optionalParameterCount = 0;
         namedArguments = namedParametersAsReflectionNames(selector);
       } else {
         FunctionElement function = elementOrSelector;
-        if (function.isConstructor()) {
+        if (function.isConstructor) {
           isConstructor = true;
           name = Elements.reconstructConstructorName(function);
         }
         FunctionSignature signature = function.functionSignature;
         requiredParameterCount = signature.requiredParameterCount;
         optionalParameterCount = signature.optionalParameterCount;
         if (signature.optionalParametersAreNamed) {
           var names = [];
           for (Element e in signature.optionalParameters) {
             names.add(e.name);
           }
           Selector selector = new Selector.call(
               function.name,
-              function.getLibrary(),
+              function.library,
               requiredParameterCount,
               names);
           namedArguments = namedParametersAsReflectionNames(selector);
         } else {
           // Named parameters are handled differently by mirrors.  For unnamed
           // parameters, they are actually required if invoked
           // reflectively. Also, if you have a method c(x) and c([x]) they both
           // get the same mangled name, so they must have the same reflection
           // name.
           requiredParameterCount += optionalParameterCount;
           optionalParameterCount = 0;
         }
       }
       String suffix =
           // TODO(ahe): We probably don't need optionalParameterCount in the
           // reflection name.
           '$name:$requiredParameterCount:$optionalParameterCount'
           '$namedArguments';
       return (isConstructor) ? 'new $suffix' : suffix;
     }
     Element element = elementOrSelector;
-    if (element.isGenerativeConstructorBody()) {
+    if (element.isGenerativeConstructorBody) {
       return null;
-    } else if (element.isClass()) {
+    } else if (element.isClass) {
       ClassElement cls = element;
       if (cls.isUnnamedMixinApplication) return null;
       return cls.name;
     }
     throw compiler.internalError(element,
         'Do not know how to reflect on this $element.');
   }
 
   String namedParametersAsReflectionNames(Selector selector) {
     if (selector.getOrderedNamedArguments().isEmpty) return '';
@@ skipping 70 matching lines @@
                    '$_$isolateProperties,'
                    '${_}null)$N');
 
       // Reset the map.
       buffer.write("$classesCollector$_=${_}null$N$n");
     }
   }
 
   void emitStaticFunctions() {
     bool isStaticFunction(Element element) =>
-        !element.isInstanceMember() && !element.isField();
+        !element.isInstanceMember && !element.isField;
 
     Iterable<Element> elements =
         backend.generatedCode.keys.where(isStaticFunction);
 
     for (Element element in Elements.sortedByPosition(elements)) {
       ClassBuilder builder = new ClassBuilder(namer);
       containerBuilder.addMember(element, builder);
       getElementDecriptor(element).properties.addAll(builder.properties);
     }
   }
@@ skipping 293 matching lines @@
         .toSet();
     neededClasses.addAll(mixinClasses);
 
     // 3. If we need noSuchMethod support, we run through all needed
     // classes to figure out if we need the support on any native
     // class. If so, we let the native emitter deal with it.
     if (compiler.enabledNoSuchMethod) {
       String noSuchMethodName = Compiler.NO_SUCH_METHOD;
       Selector noSuchMethodSelector = compiler.noSuchMethodSelector;
       for (ClassElement element in neededClasses) {
-        if (!element.isNative()) continue;
+        if (!element.isNative) continue;
         Element member = element.lookupLocalMember(noSuchMethodName);
         if (member == null) continue;
         if (noSuchMethodSelector.applies(member, compiler)) {
           nativeEmitter.handleNoSuchMethod = true;
           break;
         }
       }
     }
 
     // 4. Find all classes needed for rti.
@@ skipping 32 matching lines @@
     List<ClassElement> sortedClasses = Elements.sortedByPosition(neededClasses);
 
     for (ClassElement element in sortedClasses) {
       if (typeTestEmitter.rtiNeededClasses.contains(element)) {
         // TODO(sigurdm): We might be able to defer some of these.
         outputClassLists.putIfAbsent(compiler.deferredLoadTask.mainOutputUnit,
             () => new List<ClassElement>()).add(element);
       } else if (Elements.isNativeOrExtendsNative(element)) {
         // For now, native classes and related classes cannot be deferred.
         nativeClasses.add(element);
-        if (!element.isNative()) {
+        if (!element.isNative) {
           assert(invariant(element,
                            !compiler.deferredLoadTask.isDeferred(element)));
           outputClassLists.putIfAbsent(compiler.deferredLoadTask.mainOutputUnit,
               () => new List<ClassElement>()).add(element);
         }
       } else {
         outputClassLists.putIfAbsent(
             compiler.deferredLoadTask.outputUnitForElement(element),
             () => new List<ClassElement>())
             .add(element);
@@ skipping 168 matching lines @@
       if (!elementDescriptors.isEmpty) {
         var oldClassesCollector = classesCollector;
         classesCollector = r"$$";
         if (compiler.enableMinification) {
           mainBuffer.write(';');
         }
 
         for (Element element in elementDescriptors.keys) {
           // TODO(ahe): Should iterate over all libraries.  Otherwise, we will
           // not see libraries that only have fields.
-          if (element.isLibrary()) {
+          if (element.isLibrary) {
             LibraryElement library = element;
             ClassBuilder builder = new ClassBuilder(namer);
             if (classEmitter.emitFields(
                     library, builder, null, emitStatics: true)) {
               OutputUnit mainUnit = compiler.deferredLoadTask.mainOutputUnit;
               getElementDescriptorForOutputUnit(library, mainUnit)
                   .properties.addAll(builder.toObjectInitializer().properties);
             }
           }
         }
@@ skipping 37 matching lines @@
                 jsAst.prettyPrint(
                     getReflectionDataParser(classesCollector, backend),
                     compiler))
             ..write(')')
             ..write('([$n');
 
         List<Element> sortedElements =
             Elements.sortedByPosition(elementDescriptors.keys);
 
         Iterable<Element> pendingStatics = sortedElements.where((element) {
-            return !element.isLibrary() &&
+            return !element.isLibrary &&
                 elementDescriptors[element].values.any((descriptor) =>
                     descriptor != null);
         });
 
         pendingStatics.forEach((element) =>
             compiler.reportInfo(
                 element, MessageKind.GENERIC, {'text': 'Pending statics.'}));
 
         for (LibraryElement library in sortedElements.where((element) =>
-            element.isLibrary())) {
+            element.isLibrary)) {
           writeLibraryDescriptors(library);
           elementDescriptors[library] = const {};
         }
         if (!pendingStatics.isEmpty) {
           compiler.internalError(pendingStatics.first,
               'Pending statics (see above).');
         }
         mainBuffer.write('])$N');
 
         emitFinishClassesInvocationIfNecessary(mainBuffer);
@@ skipping 124 matching lines @@
       }
       compiler.outputProvider('', 'js')
           ..add(assembledCode)
           ..add(sourceMapTags)
           ..close();
       compiler.assembledCode = assembledCode;
 
       if (!compiler.useContentSecurityPolicy) {
         mainBuffer.write("""
 {
-  var message = 
+  var message =
       'Deprecation: Automatic generation of output for Content Security\\n' +
       'Policy is deprecated and will be removed with the next development\\n' +
       'release. Use the --csp option to generate CSP restricted output.';
   if (typeof dartPrint == "function") {
     dartPrint(message);
   } else if (typeof console == "object" && typeof console.log == "function") {
     console.log(message);
   } else if (typeof print == "function") {
     print(message);
   }
@@ skipping 36 matching lines @@
   ClassBuilder getElementDescriptorForOutputUnit(Element element,
                                                  OutputUnit outputUnit) {
     Map<OutputUnit, ClassBuilder> descriptors =
         elementDescriptors.putIfAbsent(
             element, () => new Map<OutputUnit, ClassBuilder>());
     return descriptors.putIfAbsent(outputUnit,
         () => new ClassBuilder(namer));
   }
 
   ClassBuilder getElementDecriptor(Element element) {
-    Element owner = element.getLibrary();
-    if (!element.isTopLevel() && !element.isNative()) {
+    Element owner = element.library;
+    if (!element.isTopLevel && !element.isNative) {
       // For static (not top level) elements, record their code in a buffer
       // specific to the class. For now, not supported for native classes and
       // native elements.
       ClassElement cls =
-          element.getEnclosingClassOrCompilationUnit().declaration;
+          element.enclosingClassOrCompilationUnit.declaration;
       if (compiler.codegenWorld.instantiatedClasses.contains(cls)
-          && !cls.isNative()) {
+          && !cls.isNative) {
         owner = cls;
       }
     }
     if (owner == null) {
       compiler.internalError(element, 'Owner is null.');
     }
     return getElementDescriptorForOutputUnit(owner,
         compiler.deferredLoadTask.outputUnitForElement(element));
   }
 
@@ skipping 72 matching lines @@
     String sourceMap = sourceMapBuilder.build();
     compiler.outputProvider(name, 'js.map')
         ..add(sourceMap)
         ..close();
   }
 
   void registerReadTypeVariable(TypeVariableElement element) {
     readTypeVariables.add(element);
   }
 }