Make isEmpty a getter.

lib/compiler/implementation/js_backend/native_emitter.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.
 
 class NativeEmitter {
 
   CodeEmitterTask emitter;
   CodeBuffer nativeBuffer;
 
   // Classes that participate in dynamic dispatch. These are the
@@ skipping 135 matching lines @@
       // Global object, just be like the other types for now.
       return quotedName.substring(3, quotedName.length - 1);
     } else {
       return quotedName.substring(2, quotedName.length - 1);
     }
   }
 
   void generateNativeClass(ClassElement classElement) {
     nativeClasses.add(classElement);
 
-    assert(classElement.backendMembers.isEmpty());
+    assert(classElement.backendMembers.isEmpty);
     String quotedName = classElement.nativeName.slowToString();
     if (isNativeLiteral(quotedName)) {
       generateNativeLiteral(classElement);
       // The native literal kind needs to be dealt with specially when
       // generating code for it.
       return;
     }
 
     CodeBuffer fieldBuffer = new CodeBuffer();
     CodeBuffer getterSetterBuffer = new CodeBuffer();
 
     emitter.emitClassFields(classElement, fieldBuffer);
     emitter.emitClassGettersSetters(classElement, getterSetterBuffer,
                                     omitLeadingComma: true);
 
     CodeBuffer methodBuffer = new CodeBuffer();
     emitter.emitInstanceMembers(classElement, methodBuffer, false);
 
-    if (methodBuffer.isEmpty()
-        && fieldBuffer.isEmpty()
-        && getterSetterBuffer.isEmpty()) {
+    if (methodBuffer.isEmpty
+        && fieldBuffer.isEmpty
+        && getterSetterBuffer.isEmpty) {
       return;
     }
 
     String nativeName = toNativeName(classElement);
     nativeBuffer.add("$defineNativeClassName('$nativeName', ");
     nativeBuffer.add('{');
     bool firstInMap = true;
-    if (!fieldBuffer.isEmpty()) {
+    if (!fieldBuffer.isEmpty) {
       firstInMap = false;
       nativeBuffer.add(fieldBuffer);
     }
-    if (!getterSetterBuffer.isEmpty()) {
+    if (!getterSetterBuffer.isEmpty) {
       if (!firstInMap) nativeBuffer.add(",");
       firstInMap = false;
       nativeBuffer.add("\n ");
       nativeBuffer.add(getterSetterBuffer);
     }
-    if (!methodBuffer.isEmpty()) {
+    if (!methodBuffer.isEmpty) {
       if (!firstInMap) nativeBuffer.add(",");
       nativeBuffer.add(methodBuffer);
     }
     nativeBuffer.add('\n});\n\n');
 
     classesWithDynamicDispatch.add(classElement);
   }
 
   List<ClassElement> getDirectSubclasses(ClassElement cls) {
     List<ClassElement> result = directSubtypes[cls];
@@ skipping 62 matching lines @@
     if (isNativeLiteral(nativeName) || !overriddenMethods.contains(member)) {
       // Call the method directly.
       buffer.add(code.toString());
     } else {
       native.generateMethodWithPrototypeCheck(
           compiler, buffer, invocationName, code.toString(), stubParameters);
     }
   }
 
   void emitDynamicDispatchMetadata() {
-    if (classesWithDynamicDispatch.isEmpty()) return;
+    if (classesWithDynamicDispatch.isEmpty) return;
     int length = classesWithDynamicDispatch.length;
     nativeBuffer.add('// $length dynamic classes.\n');
 
     // Build a pre-order traversal over all the classes and their subclasses.
     Set<ClassElement> seen = new Set<ClassElement>();
     List<ClassElement> classes = <ClassElement>[];
     void visit(ClassElement cls) {
       if (seen.contains(cls)) return;
       seen.add(cls);
       for (final ClassElement subclass in getDirectSubclasses(cls)) {
         visit(subclass);
       }
       classes.add(cls);
     }
     for (final ClassElement classElement in classesWithDynamicDispatch) {
       visit(classElement);
     }
 
     Collection<ClassElement> dispatchClasses = classes.filter(
-        (cls) => !getDirectSubclasses(cls).isEmpty() &&
+        (cls) => !getDirectSubclasses(cls).isEmpty &&
                   classesWithDynamicDispatch.contains(cls));
 
     nativeBuffer.add('// ${classes.length} classes\n');
     Collection<ClassElement> classesThatHaveSubclasses = classes.filter(
-        (ClassElement t) => !getDirectSubclasses(t).isEmpty());
+        (ClassElement t) => !getDirectSubclasses(t).isEmpty);
     nativeBuffer.add('// ${classesThatHaveSubclasses.length} !leaf\n');
 
     // Generate code that builds the map from cls tags used in dynamic dispatch
     // to the set of cls tags of classes that extend (TODO: or implement) those
     // classes.  The set is represented as a string of tags joined with '|'.
     // This is easily split into an array of tags, or converted into a regexp.
     //
     // To reduce the size of the sets, subsets are CSE-ed out into variables.
     // The sets could be much smaller if we could make assumptions about the
     // cls tags of other classes (which are constructor names or part of the
@@ skipping 44 matching lines @@
         expression = "[${Strings.join(expressions, ',')}].join('|')";
       }
       return expression;
     }
 
     for (final ClassElement classElement in dispatchClasses) {
       tagDefns[classElement] = makeExpression(classElement);
     }
 
     // Write out a thunk that builds the metadata.
-    if (!tagDefns.isEmpty()) {
+    if (!tagDefns.isEmpty) {
       nativeBuffer.add('(function(){\n');
 
       for (final String varName in varNames) {
         nativeBuffer.add('  var ${varName} = ${varDefns[varName]};\n');
       }
 
       nativeBuffer.add('  var table = [\n');
       nativeBuffer.add(
           '    // [dynamic-dispatch-tag, '
           'tags of classes implementing dynamic-dispatch-tag]');
@@ skipping 40 matching lines @@
   void emitIsChecks(Map<String, String> objectProperties) {
     for (Element element in emitter.checkedClasses) {
       if (!requiresNativeIsCheck(element)) continue;
       if (element.isObject(compiler)) continue;
       String name = backend.namer.operatorIs(element);
       objectProperties[name] = 'function() { return false; }';
     }
   }
 
   void assembleCode(CodeBuffer targetBuffer) {
-    if (nativeClasses.isEmpty()) return;
+    if (nativeClasses.isEmpty) return;
     emitDynamicDispatchMetadata();
     targetBuffer.add('$defineNativeClassName = '
                      '$defineNativeClassFunction;\n\n');
 
     // Because of native classes, we have to generate some is checks
     // by calling a method, instead of accessing a property. So we
     // attach to the JS Object prototype these methods that return
     // false, and will be overridden by subclasses when they have to
     // return true.
     Map<String, String> objectProperties = new Map<String, String>();
@@ skipping 15 matching lines @@
     // If the native emitter has been asked to take care of the
     // noSuchMethod handlers, we do that now.
     if (handleNoSuchMethod) {
       emitter.emitNoSuchMethodHandlers((String name, CodeBuffer buffer) {
         objectProperties[name] = buffer.toString();
       });
     }
 
     // If we have any properties to add to Object.prototype, we run
     // through them and add them using defineProperty.
-    if (!objectProperties.isEmpty()) {
+    if (!objectProperties.isEmpty) {
       targetBuffer.add("(function(table) {\n"
                        "  for (var key in table) {\n"
                        "    $defPropName(Object.prototype, key, table[key]);\n"
                        "  }\n"
                        "})({\n");
       bool first = true;
       objectProperties.forEach((String name, String function) {
         if (!first) targetBuffer.add(",\n");
         targetBuffer.add(" $name: $function");
         first = false;
       });
       targetBuffer.add("\n});\n\n");
     }
     targetBuffer.add(nativeBuffer);
     targetBuffer.add('\n');
   }
 }