Make isEmpty a getter.

lib/compiler/implementation/typechecker.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 TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name => "Type checker";
 
   static const bool LOG_FAILURES = false;
 
@@ skipping 114 matching lines @@
   const InterfaceType(this.element,
                       [this.arguments = const Link<DartType>()]);
 
   SourceString get name => element.name;
 
   DartType unalias(Compiler compiler) => this;
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.add(name.slowToString());
-    if (!arguments.isEmpty()) {
+    if (!arguments.isEmpty) {
       sb.add('<');
       arguments.printOn(sb, ', ');
       sb.add('>');
     }
     return sb.toString();
   }
 
   int get hashCode {
     int hash = element.hashCode;
     for (Link<DartType> arguments = this.arguments;
-         !arguments.isEmpty();
+         !arguments.isEmpty;
          arguments = arguments.tail) {
       int argumentHash = arguments.head != null ? arguments.head.hashCode : 0;
       hash = 17 * hash + 3 * argumentHash;
     }
     return hash;
   }
 
   bool operator ==(other) {
     if (other is !InterfaceType) return false;
     if (!identical(element, other.element)) return false;
@@ skipping 33 matching lines @@
   void initializeFrom(FunctionType other) {
     assert(returnType == null);
     assert(parameterTypes == null);
     returnType = other.returnType;
     parameterTypes = other.parameterTypes;
   }
 
   int get hashCode {
     int hash = 17 * element.hashCode + 3 * returnType.hashCode;
     for (Link<DartType> parameters = parameterTypes;
-         !parameters.isEmpty();
+         !parameters.isEmpty;
         parameters = parameters.tail) {
       hash = 17 * hash + 3 * parameters.head.hashCode;
     }
     return hash;
   }
 
   bool operator ==(other) {
     if (other is !FunctionType) return false;
     return returnType == other.returnType
            && parameterTypes == other.parameterTypes;
@@ skipping 11 matching lines @@
 
   DartType unalias(Compiler compiler) {
     // TODO(ahe): This should be [ensureResolved].
     compiler.resolveTypedef(element);
     return element.alias.unalias(compiler);
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.add(name.slowToString());
-    if (!typeArguments.isEmpty()) {
+    if (!typeArguments.isEmpty) {
       sb.add('<');
       typeArguments.printOn(sb, ', ');
       sb.add('>');
     }
     return sb.toString();
   }
 
   int get hashCode => 17 * element.hashCode;
 
   bool operator ==(other) {
@@ skipping 31 matching lines @@
     t = t.unalias(compiler);
     s = s.unalias(compiler);
 
     if (t is VoidType) {
       return false;
     } else if (t is InterfaceType) {
       if (s is !InterfaceType) return false;
       ClassElement tc = t.element;
       if (identical(tc, s.element)) return true;
       for (Link<DartType> supertypes = tc.allSupertypes;
-           supertypes != null && !supertypes.isEmpty();
+           supertypes != null && !supertypes.isEmpty;
            supertypes = supertypes.tail) {
         DartType supertype = supertypes.head;
         if (identical(supertype.element, s.element)) return true;
       }
       return false;
     } else if (t is FunctionType) {
       if (identical(s.element, compiler.functionClass)) return true;
       if (s is !FunctionType) return false;
       FunctionType tf = t;
       FunctionType sf = s;
       Link<DartType> tps = tf.parameterTypes;
       Link<DartType> sps = sf.parameterTypes;
-      while (!tps.isEmpty() && !sps.isEmpty()) {
+      while (!tps.isEmpty && !sps.isEmpty) {
         if (!isAssignable(tps.head, sps.head)) return false;
         tps = tps.tail;
         sps = sps.tail;
       }
-      if (!tps.isEmpty() || !sps.isEmpty()) return false;
+      if (!tps.isEmpty || !sps.isEmpty) return false;
       if (!isAssignable(sf.returnType, tf.returnType)) return false;
       return true;
     } else if (t is TypeVariableType) {
       if (s is !TypeVariableType) return false;
       return (identical(t.element, s.element));
     } else {
       throw 'internal error: unknown type kind';
     }
   }
 
@@ skipping 204 matching lines @@
   DartType visitLoop(Loop node) {
     return unhandledStatement();
   }
 
   DartType lookupMethodType(Node node, ClassElement classElement,
                         SourceString name) {
     Element member = classElement.lookupLocalMember(name);
     if (member == null) {
       classElement.ensureResolved(compiler);
       for (Link<DartType> supertypes = classElement.allSupertypes;
-           !supertypes.isEmpty() && member == null;
+           !supertypes.isEmpty && member == null;
            supertypes = supertypes.tail) {
         ClassElement lookupTarget = supertypes.head.element;
         member = lookupTarget.lookupLocalMember(name);
       }
     }
     if (member != null && member.kind == ElementKind.FUNCTION) {
       return computeType(member);
     }
     reportTypeWarning(node, MessageKind.METHOD_NOT_FOUND,
                       [classElement.name, name]);
     return types.dynamicType;
   }
 
   void analyzeArguments(Send send, DartType type) {
     Link<Node> arguments = send.arguments;
     if (type == null || identical(type, types.dynamicType)) {
-      while(!arguments.isEmpty()) {
+      while(!arguments.isEmpty) {
         analyze(arguments.head);
         arguments = arguments.tail;
       }
     } else {
       FunctionType funType = type;
       Link<DartType> parameterTypes = funType.parameterTypes;
-      while (!arguments.isEmpty() && !parameterTypes.isEmpty()) {
+      while (!arguments.isEmpty && !parameterTypes.isEmpty) {
         checkAssignable(arguments.head, parameterTypes.head,
                         analyze(arguments.head));
         arguments = arguments.tail;
         parameterTypes = parameterTypes.tail;
       }
-      if (!arguments.isEmpty()) {
+      if (!arguments.isEmpty) {
         reportTypeWarning(arguments.head, MessageKind.ADDITIONAL_ARGUMENT);
-      } else if (!parameterTypes.isEmpty()) {
+      } else if (!parameterTypes.isEmpty) {
         reportTypeWarning(send, MessageKind.MISSING_ARGUMENT,
                           [parameterTypes.head]);
       }
     }
   }
 
   DartType visitSend(Send node) {
     Element element = elements[node];
 
     if (Elements.isClosureSend(node, element)) {
       // TODO(karlklose): Finish implementation.
       return types.dynamicType;
     }
 
     Identifier selector = node.selector.asIdentifier();
     String name = selector.source.stringValue;
 
     if (node.isOperator && identical(name, 'is')) {
       analyze(node.receiver);
       return boolType;
     } else if (node.isOperator) {
       final Node firstArgument = node.receiver;
       final DartType firstArgumentType = analyze(node.receiver);
       final arguments = node.arguments;
-      final Node secondArgument = arguments.isEmpty() ? null : arguments.head;
+      final Node secondArgument = arguments.isEmpty ? null : arguments.head;
       final DartType secondArgumentType =
           analyzeWithDefault(secondArgument, null);
 
       if (identical(name, '+') || identical(name, '=') || identical(name, '-')
           || identical(name, '*') || identical(name, '/') || identical(name, '%')
           || identical(name, '~/') || identical(name, '|') || identical(name, '&')
           || identical(name, '^') || identical(name, '~')|| identical(name, '<<')
           || identical(name, '>>') || identical(name, '[]')) {
         return types.dynamicType;
       } else if (identical(name, '<') || identical(name, '>') || identical(name, '<=')
                  || identical(name, '>=') || identical(name, '==') || identical(name, '!=')
                  || identical(name, '===') || identical(name, '!==')) {
         return boolType;
       } else if (identical(name, '||') || identical(name, '&&') || identical(name, '!')) {
         checkAssignable(firstArgument, boolType, firstArgumentType);
-        if (!arguments.isEmpty()) {
+        if (!arguments.isEmpty) {
           // TODO(karlklose): check number of arguments in validator.
           checkAssignable(secondArgument, boolType, secondArgumentType);
         }
         return boolType;
       }
       fail(selector, 'unexpected operator ${name}');
 
     } else if (node.isPropertyAccess) {
       if (node.receiver != null) {
         // TODO(karlklose): we cannot handle fields.
@@ skipping 105 matching lines @@
     return analyze(node.send.selector);
   }
 
   DartType visitLiteralList(LiteralList node) {
     return listType;
   }
 
   DartType visitNodeList(NodeList node) {
     DartType type = StatementType.NOT_RETURNING;
     bool reportedDeadCode = false;
-    for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
+    for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       DartType nextType = analyze(link.head);
       if (type == StatementType.RETURNING) {
         if (!reportedDeadCode) {
           reportTypeWarning(link.head, MessageKind.UNREACHABLE_CODE);
           reportedDeadCode = true;
         }
       } else if (type == StatementType.MAYBE_RETURNING){
         if (nextType == StatementType.RETURNING) {
           type = nextType;
         }
@@ skipping 64 matching lines @@
   visitTypeVariable(TypeVariable node) {
     return types.dynamicType;
   }
 
   DartType visitVariableDefinitions(VariableDefinitions node) {
     DartType type = analyzeWithDefault(node.type, types.dynamicType);
     if (type == types.voidType) {
       reportTypeWarning(node.type, MessageKind.VOID_VARIABLE);
       type = types.dynamicType;
     }
-    for (Link<Node> link = node.definitions.nodes; !link.isEmpty();
+    for (Link<Node> link = node.definitions.nodes; !link.isEmpty;
          link = link.tail) {
       Node initialization = link.head;
       compiler.ensure(initialization is Identifier
                       || initialization is Send);
       if (initialization is Send) {
         DartType initializer = analyzeNonVoid(link.head);
         checkAssignable(node, type, initializer);
       }
     }
     return StatementType.NOT_RETURNING;
@@ skipping 165 matching lines @@
   }
 
   DartType visitStringNode(StringNode node) {
     compiler.unimplemented('visitNode', node: node);
   }
 
   DartType visitLibraryDependency(LibraryDependency node) {
     compiler.unimplemented('visitNode', node: node);
   }
 }