Make isEmpty a getter.

lib/compiler/implementation/resolution/members.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.
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
   bool isParameterChecked(Element element);
 }
@@ skipping 96 matching lines @@
     if (constructor.isPatched) {
       checkMatchingPatchSignatures(constructor, constructor.patch);
       constructor = constructor.patch;
     }
     FunctionExpression node = constructor.parseNode(compiler);
 
     // A synthetic constructor does not have a node.
     if (node == null) return null;
     if (node.initializers == null) return null;
     Link<Node> initializers = node.initializers.nodes;
-    if (!initializers.isEmpty() &&
+    if (!initializers.isEmpty &&
         Initializers.isConstructorRedirect(initializers.head)) {
       final ClassElement classElement = constructor.getEnclosingClass();
       Selector selector;
       if (isNamedConstructor(initializers.head)) {
         SourceString constructorName = getConstructorName(initializers.head);
         selector = new Selector.callConstructor(
             constructorName,
             resolver.visitor.enclosingElement.getLibrary());
       } else {
         selector = new Selector.callDefaultConstructor(
@@ skipping 16 matching lines @@
         return;
       }
       seen.add(redirection);
       redirection = resolveConstructorRedirection(resolver, redirection);
     }
   }
 
   void checkMatchingPatchParameters(FunctionElement origin,
                                     Link<Element> originParameters,
                                     Link<Element> patchParameters) {
-    while (!originParameters.isEmpty()) {
+    while (!originParameters.isEmpty) {
       Element originParameter = originParameters.head;
       Element patchParameter = patchParameters.head;
       // Hack: Use unparser to test parameter equality. This only works because
       // we are restricting patch uses and the approach cannot be used
       // elsewhere.
       String originParameterText =
           originParameter.parseNode(compiler).toString();
       String patchParameterText =
           patchParameter.parseNode(compiler).toString();
       if (originParameterText != patchParameterText) {
@@ skipping 452 matching lines @@
         element.isBeingResolved = false;
         element.isResolved = true;
       });
     });
   }
 
   FunctionType computeFunctionType(Element element,
                                    FunctionSignature signature) {
     LinkBuilder<DartType> parameterTypes = new LinkBuilder<DartType>();
     for (Link<Element> link = signature.requiredParameters;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
        parameterTypes.addLast(link.head.computeType(compiler));
        // TODO(karlklose): optional parameters.
     }
     return new FunctionType(signature.returnType,
                             parameterTypes.toLink(),
                             element);
   }
 
   void resolveMetadataAnnotation(PartialMetadataAnnotation annotation) {
@@ skipping 194 matching lines @@
                            : MessageKind.NO_MATCHING_CONSTRUCTOR;
         error(diagnosticNode, kind);
       }
     }
   }
 
   FunctionElement resolveRedirection(FunctionElement constructor,
                                      FunctionExpression functionNode) {
     if (functionNode.initializers == null) return null;
     Link<Node> link = functionNode.initializers.nodes;
-    if (!link.isEmpty() && Initializers.isConstructorRedirect(link.head)) {
+    if (!link.isEmpty && Initializers.isConstructorRedirect(link.head)) {
       return resolveSuperOrThisForSend(constructor, functionNode, link.head);
     }
     return null;
   }
 
   /**
    * Resolve all initializers of this constructor. In the case of a redirecting
    * constructor, the resolved constructor's function element is returned.
    */
   FunctionElement resolveInitializers(FunctionElement constructor,
@@ skipping 10 matching lines @@
     });
 
     if (functionNode.initializers == null) {
       initializers = const Link<Node>();
     } else {
       initializers = functionNode.initializers.nodes;
     }
     FunctionElement result;
     bool resolvedSuper = false;
     for (Link<Node> link = initializers;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       if (link.head.asSendSet() != null) {
         final SendSet init = link.head.asSendSet();
         resolveFieldInitializer(constructor, init);
       } else if (link.head.asSend() != null) {
         final Send call = link.head.asSend();
         if (Initializers.isSuperConstructorCall(call)) {
           if (resolvedSuper) {
             error(call, MessageKind.DUPLICATE_SUPER_INITIALIZER);
           }
           resolveSuperOrThisForSend(constructor, functionNode, call);
           resolvedSuper = true;
         } else if (Initializers.isConstructorRedirect(call)) {
           // Check that there is no body (Language specification 7.5.1).
           if (functionNode.hasBody()) {
             error(functionNode, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_BODY);
           }
           // Check that there are no other initializers.
-          if (!initializers.tail.isEmpty()) {
+          if (!initializers.tail.isEmpty) {
             error(call, MessageKind.REDIRECTING_CONSTRUCTOR_HAS_INITIALIZER);
           }
           return resolveSuperOrThisForSend(constructor, functionNode, call);
         } else {
           visitor.error(call, MessageKind.CONSTRUCTOR_CALL_EXPECTED);
           return null;
         }
       } else {
         error(link.head, MessageKind.INVALID_INITIALIZER);
       }
@@ skipping 91 matching lines @@
   StatementScope()
       : labels = const EmptyLabelScope(),
         breakTargetStack = const Link<TargetElement>(),
         continueTargetStack = const Link<TargetElement>();
 
   LabelElement lookupLabel(String label) {
     return labels.lookup(label);
   }
 
   TargetElement currentBreakTarget() =>
-    breakTargetStack.isEmpty() ? null : breakTargetStack.head;
+    breakTargetStack.isEmpty ? null : breakTargetStack.head;
 
   TargetElement currentContinueTarget() =>
-    continueTargetStack.isEmpty() ? null : continueTargetStack.head;
+    continueTargetStack.isEmpty ? null : continueTargetStack.head;
 
   void enterLabelScope(Map<String, LabelElement> elements) {
     labels = new LabeledStatementLabelScope(labels, elements);
     nestingLevel++;
   }
 
   void exitLabelScope() {
     nestingLevel--;
     labels = labels.outer;
   }
@@ skipping 101 matching lines @@
     } else {
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.types.dynamicType.element)) {
         type = element.computeType(compiler);
       } else if (element.isClass()) {
         ClassElement cls = element;
         cls.ensureResolved(compiler);
         Link<DartType> arguments =
             resolveTypeArguments(node, cls.typeVariables, scope,
                                  onFailure, whenResolved);
-        if (cls.typeVariables.isEmpty() && arguments.isEmpty()) {
+        if (cls.typeVariables.isEmpty && arguments.isEmpty) {
           // Use the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
           type = new InterfaceType(cls, arguments);
         }
       } else if (element.isTypedef()) {
         TypedefElement typdef = element;
         // TODO(ahe): Should be [ensureResolved].
         compiler.resolveTypedef(typdef);
         typdef.computeType(compiler);
         Link<DartType> arguments = resolveTypeArguments(
             node, typdef.typeVariables,
             scope, onFailure, whenResolved);
-        if (typdef.typeVariables.isEmpty() && arguments.isEmpty()) {
+        if (typdef.typeVariables.isEmpty && arguments.isEmpty) {
           // Return the canonical type if it has no type parameters.
           type = typdef.computeType(compiler);
         } else {
           type = new TypedefType(typdef, arguments);
         }
       } else if (element.isTypeVariable()) {
         type = element.computeType(compiler);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     whenResolved(node, type);
     return type;
   }
 
   Link<DartType> resolveTypeArguments(TypeAnnotation node,
                                       Link<DartType> typeVariables,
                                       Scope scope, onFailure, whenResolved) {
     if (node.typeArguments == null) {
       return const Link<DartType>();
     }
     var arguments = new LinkBuilder<DartType>();
     for (Link<Node> typeArguments = node.typeArguments.nodes;
-         !typeArguments.isEmpty();
+         !typeArguments.isEmpty;
          typeArguments = typeArguments.tail) {
-      if (typeVariables.isEmpty()) {
+      if (typeVariables.isEmpty) {
         onFailure(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
       }
       DartType argType = resolveTypeAnnotationInContext(scope,
                                                     typeArguments.head,
                                                     onFailure,
                                                     whenResolved);
       arguments.addLast(argType);
-      if (!typeVariables.isEmpty()) {
+      if (!typeVariables.isEmpty) {
         typeVariables = typeVariables.tail;
       }
     }
-    if (!typeVariables.isEmpty()) {
+    if (!typeVariables.isEmpty) {
       onFailure(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
     }
     return arguments.toLink();
   }
 }
 
 class ResolverVisitor extends CommonResolverVisitor<Element> {
   final TreeElementMapping mapping;
   Element enclosingElement;
   final TypeResolver typeResolver;
@@ skipping 390 matching lines @@
 
     if (node.isOperator) {
       SourceString source = node.selector.asOperator().source;
       String string = source.stringValue;
       if (identical(string, '!')   || identical(string, '&&')  || string == '||' ||
           identical(string, 'is')  || identical(string, 'as')  ||
           identical(string, '===') || identical(string, '!==') ||
           identical(string, '>>>')) {
         return null;
       }
-      return node.arguments.isEmpty()
+      return node.arguments.isEmpty
           ? new Selector.unaryOperator(source)
           : new Selector.binaryOperator(source);
     }
 
     Identifier identifier = node.selector.asIdentifier();
     if (node.isPropertyAccess) {
       assert(!isSet);
       return new Selector.getter(identifier.source, library);
     } else if (isSet) {
       return new Selector.setter(identifier.source, library);
     }
 
     // Compute the arity and the list of named arguments.
     int arity = 0;
     List<SourceString> named = <SourceString>[];
     for (Link<Node> link = node.argumentsNode.nodes;
-        !link.isEmpty();
+        !link.isEmpty;
         link = link.tail) {
       Expression argument = link.head;
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         named.add(namedArgument.name.source);
       }
       arity++;
     }
 
     // If we're invoking a closure, we do not have an identifier.
     return (identifier == null)
         ? new Selector.callClosure(arity, named)
         : new Selector.call(identifier.source, library, arity, named);
   }
 
   Selector resolveSelector(Send node) {
     LibraryElement library = enclosingElement.getLibrary();
     Selector selector = computeSendSelector(node, library);
     if (selector != null) mapping.setSelector(node, selector);
     return selector;
   }
 
   void resolveArguments(NodeList list) {
     if (list == null) return;
     bool seenNamedArgument = false;
-    for (Link<Node> link = list.nodes; !link.isEmpty(); link = link.tail) {
+    for (Link<Node> link = list.nodes; !link.isEmpty; link = link.tail) {
       Expression argument = link.head;
       visit(argument);
       if (argument.asNamedArgument() != null) {
         seenNamedArgument = true;
       } else if (seenNamedArgument) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
     }
   }
 
   visitSend(Send node) {
     Element target = resolveSend(node);
     if (!Elements.isUnresolved(target)
         && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       target = field.getter;
       if (target == null && !inInstanceContext) {
         target =
             warnAndCreateErroneousElement(node.selector, field.name,
                                           MessageKind.CANNOT_RESOLVE_GETTER,
                                           [node.selector]);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (identical(operatorString, 'is') || identical(operatorString, 'as')) {
-        assert(node.arguments.tail.isEmpty());
+        assert(node.arguments.tail.isEmpty);
         DartType type = resolveTypeTest(node.arguments.head);
         if (type != null) {
           compiler.enqueuer.resolution.registerIsCheck(type);
         }
         resolvedArguments = true;
       } else if (identical(operatorString, '?')) {
         Element parameter = mapping[node.receiver];
         if (parameter == null
             || !identical(parameter.kind, ElementKind.PARAMETER)) {
           error(node.receiver, MessageKind.PARAMETER_NAME_EXPECTED);
@@ skipping 139 matching lines @@
   }
 
   visitLiteralNull(LiteralNull node) {
   }
 
   visitStringJuxtaposition(StringJuxtaposition node) {
     node.visitChildren(this);
   }
 
   visitNodeList(NodeList node) {
-    for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
+    for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       visit(link.head);
     }
   }
 
   visitOperator(Operator node) {
     unimplemented(node, 'operator');
   }
 
   visitReturn(Return node) {
     if (node.isRedirectingFactoryBody) {
@@ skipping 148 matching lines @@
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
     NodeList arguments = node.typeArguments;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
-      if (nodes.isEmpty()) {
+      if (nodes.isEmpty) {
         error(arguments, MessageKind.MISSING_TYPE_ARGUMENT, []);
       } else {
         resolveTypeRequired(nodes.head);
-        for (nodes = nodes.tail; !nodes.isEmpty(); nodes = nodes.tail) {
+        for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
           error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT, []);
           resolveTypeRequired(nodes.head);
         }
       }
     }
     visit(node.elements);
   }
 
   visitConditional(Conditional node) {
     node.visitChildren(this);
@@ skipping 85 matching lines @@
     visit(node.expression);
     Scope blockScope = new BlockScope(scope);
     Node declaration = node.declaredIdentifier;
     visitIn(declaration, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
 
     // TODO(lrn): Also allow a single identifier.
     if ((declaration is !Send || declaration.asSend().selector is !Identifier
         || declaration.asSend().receiver != null)
         && (declaration is !VariableDefinitions ||
-        !declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty()))
+        !declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty))
     {
       // The variable declaration is either not an identifier, not a
       // declaration, or it's declaring more than one variable.
       error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN, []);
     }
   }
 
   visitLabel(Label node) {
     // Labels are handled by their containing statements/cases.
   }
@@ skipping 36 matching lines @@
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     node.expression.accept(this);
 
     TargetElement breakElement = getOrCreateTargetElement(node);
     Map<String, LabelElement> continueLabels = <String, LabelElement>{};
     Link<Node> cases = node.cases.nodes;
-    while (!cases.isEmpty()) {
+    while (!cases.isEmpty) {
       SwitchCase switchCase = cases.head;
       for (Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is! Label) continue;
         Label label = labelOrCase;
         String labelName = label.slowToString();
 
         LabelElement existingElement = continueLabels[labelName];
         if (existingElement != null) {
           // It's an error if the same label occurs twice in the same switch.
           warning(label, MessageKind.DUPLICATE_LABEL, [labelName]);
@@ skipping 15 matching lines @@
         mapping[switchCase] = targetElement;
 
         LabelElement labelElement =
             new LabelElement(label, labelName,
                              targetElement, enclosingElement);
         mapping[label] = labelElement;
         continueLabels[labelName] = labelElement;
       }
       cases = cases.tail;
       // Test that only the last case, if any, is a default case.
-      if (switchCase.defaultKeyword != null && !cases.isEmpty()) {
+      if (switchCase.defaultKeyword != null && !cases.isEmpty) {
         error(switchCase, MessageKind.INVALID_CASE_DEFAULT);
       }
     }
 
     statementScope.enterSwitch(breakElement, continueLabels);
     node.cases.accept(this);
     statementScope.exitSwitch();
 
     // Clean-up unused labels.
     continueLabels.forEach((String key, LabelElement label) {
@@ skipping 10 matching lines @@
     node.labelsAndCases.accept(this);
     visitIn(node.statements, new BlockScope(scope));
   }
 
   visitCaseMatch(CaseMatch node) {
     visit(node.expression);
   }
 
   visitTryStatement(TryStatement node) {
     visit(node.tryBlock);
-    if (node.catchBlocks.isEmpty() && node.finallyBlock == null) {
+    if (node.catchBlocks.isEmpty && node.finallyBlock == null) {
       // TODO(ngeoffray): The precise location is
       // node.getEndtoken.next. Adjust when issue #1581 is fixed.
       error(node, MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
   }
 
   visitCatchBlock(CatchBlock node) {
     // Check that if catch part is present, then
     // it has one or two formal parameters.
     if (node.formals != null) {
-      if (node.formals.isEmpty()) {
+      if (node.formals.isEmpty) {
         error(node, MessageKind.EMPTY_CATCH_DECLARATION);
       }
-      if (!node.formals.nodes.tail.isEmpty() &&
-          !node.formals.nodes.tail.tail.isEmpty()) {
+      if (!node.formals.nodes.tail.isEmpty &&
+          !node.formals.nodes.tail.tail.isEmpty) {
         for (Node extra in node.formals.nodes.tail.tail) {
           error(extra, MessageKind.EXTRA_CATCH_DECLARATION);
         }
       }
 
       // Check that the formals aren't optional and that they have no
       // modifiers or type.
       for (Link<Node> link = node.formals.nodes;
-           !link.isEmpty();
+           !link.isEmpty;
            link = link.tail) {
         // If the formal parameter is a node list, it means that it is a
         // sequence of optional parameters.
         NodeList nodeList = link.head.asNodeList();
         if (nodeList != null) {
           error(nodeList, MessageKind.OPTIONAL_PARAMETER_IN_CATCH);
         } else {
         VariableDefinitions declaration = link.head;
           for (Node modifier in declaration.modifiers.nodes) {
             error(modifier, MessageKind.PARAMETER_WITH_MODIFIER_IN_CATCH);
@@ skipping 34 matching lines @@
         typeResolver = new TypeResolver(compiler),
         super(compiler);
 
   void resolveTypeVariableBounds(NodeList node) {
     if (node == null) return;
 
     var nameSet = new Set<SourceString>();
     // Resolve the bounds of type variables.
     Link<DartType> typeLink = element.typeVariables;
     Link<Node> nodeLink = node.nodes;
-    while (!nodeLink.isEmpty()) {
+    while (!nodeLink.isEmpty) {
       TypeVariableType typeVariable = typeLink.head;
       SourceString typeName = typeVariable.name;
       TypeVariable typeNode = nodeLink.head;
       if (nameSet.contains(typeName)) {
         error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME, [typeName]);
       }
       nameSet.add(typeName);
 
       TypeVariableElement variableElement = typeVariable.element;
       if (typeNode.bound != null) {
         DartType boundType = typeResolver.resolveTypeAnnotation(
             typeNode.bound, inScope: scope, onFailure: warning);
         if (boundType != null && boundType.element == variableElement) {
           // TODO(johnniwinther): Check for more general cycles, like
           // [: <A extends B, B extends C, C extends B> :].
           warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
                   [variableElement.name]);
         } else if (boundType != null) {
           variableElement.bound = boundType;
         } else {
           // TODO(johnniwinther): Should be an erroneous type.
           variableElement.bound = compiler.objectClass.computeType(compiler);
         }
       } else {
         variableElement.bound = compiler.objectClass.computeType(compiler);
       }
       nodeLink = nodeLink.tail;
       typeLink = typeLink.tail;
     }
-    assert(typeLink.isEmpty());
+    assert(typeLink.isEmpty);
   }
 }
 
 class TypedefResolverVisitor extends TypeDefinitionVisitor {
   TypedefElement get element => super.element;
 
   TypedefResolverVisitor(Compiler compiler, TypedefElement typedefElement)
       : super(compiler, typedefElement);
 
   visitTypedef(Typedef node) {
@@ skipping 57 matching lines @@
                                node: node);
       } else {
         objectElement.ensureResolved(compiler);
       }
       // TODO(ahe): This should be objectElement.computeType(...).
       element.supertype = new InterfaceType(objectElement);
     }
     assert(element.interfaces == null);
     Link<DartType> interfaces = const Link<DartType>();
     for (Link<Node> link = node.interfaces.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       DartType interfaceType = visit(link.head);
       if (interfaceType != null && interfaceType.element.isExtendable()) {
         interfaces = interfaces.prepend(interfaceType);
         if (isBlackListed(interfaceType)) {
           error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
         }
       } else {
         error(link.head, MessageKind.TYPE_NAME_EXPECTED);
       }
@@ skipping 60 matching lines @@
     // TODO(karlklose): check if type arguments match, if a classelement occurs
     //                  more than once in the supertypes.
     if (cls.allSupertypes != null) return;
     final DartType supertype = cls.supertype;
     if (supertype != null) {
       ClassElement superElement = supertype.element;
       Link<DartType> superSupertypes = superElement.allSupertypes;
       assert(superSupertypes != null);
       Link<DartType> supertypes = superSupertypes.prepend(supertype);
       for (Link<DartType> interfaces = cls.interfaces;
-           !interfaces.isEmpty();
+           !interfaces.isEmpty;
            interfaces = interfaces.tail) {
         ClassElement element = interfaces.head.element;
         Link<DartType> interfaceSupertypes = element.allSupertypes;
         assert(interfaceSupertypes != null);
         supertypes = supertypes.reversePrependAll(interfaceSupertypes);
         supertypes = supertypes.prepend(interfaces.head);
       }
       cls.allSupertypes = supertypes;
     } else {
       assert(identical(cls, compiler.objectClass));
@@ skipping 53 matching lines @@
 
   void visitClassNode(ClassNode node) {
     if (node.superclass == null) {
       if (!identical(classElement, compiler.objectClass)) {
         loadSupertype(compiler.objectClass, node);
       }
     } else {
       node.superclass.accept(this);
     }
     for (Link<Node> link = node.interfaces.nodes;
-         !link.isEmpty();
+         !link.isEmpty;
          link = link.tail) {
       link.head.accept(this);
     }
   }
 
   void visitTypeAnnotation(TypeAnnotation node) {
     node.typeName.accept(this);
   }
 
   void visitIdentifier(Identifier node) {
@@ skipping 43 matching lines @@
   VariableListElement variables;
 
   VariableDefinitionsVisitor(Compiler compiler,
                              this.definitions, this.resolver, this.kind)
       : super(compiler) {
     variables = new VariableListElement.node(
         definitions, ElementKind.VARIABLE_LIST, resolver.enclosingElement);
   }
 
   SourceString visitSendSet(SendSet node) {
-    assert(node.arguments.tail.isEmpty()); // Sanity check
+    assert(node.arguments.tail.isEmpty); // Sanity check
     resolver.visit(node.arguments.head);
     return visit(node.selector);
   }
 
   SourceString visitIdentifier(Identifier node) => node.source;
 
   visitNodeList(NodeList node) {
-    for (Link<Node> link = node.nodes; !link.isEmpty(); link = link.tail) {
+    for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       SourceString name = visit(link.head);
       VariableElement element =
           new VariableElement(name, variables, kind, link.head);
       resolver.defineElement(link.head, element);
     }
   }
 }
 
 /**
  * [SignatureResolver] resolves function signatures.
@@ skipping 15 matching lines @@
     }
     optionalParametersAreNamed = (identical(value, '{'));
     LinkBuilder<Element> elements = analyzeNodes(node.nodes);
     optionalParameterCount = elements.length;
     optionalParameters = elements.toLink();
     return null;
   }
 
   Element visitVariableDefinitions(VariableDefinitions node) {
     Link<Node> definitions = node.definitions.nodes;
-    if (definitions.isEmpty()) {
+    if (definitions.isEmpty) {
       cancel(node, 'internal error: no parameter definition');
       return null;
     }
-    if (!definitions.tail.isEmpty()) {
+    if (!definitions.tail.isEmpty) {
       cancel(definitions.tail.head, 'internal error: extra definition');
       return null;
     }
     Node definition = definitions.head;
     if (definition is NodeList) {
       cancel(node, 'optional parameters are not implemented');
     }
 
     if (currentDefinitions != null) {
       cancel(node, 'function type parameters not supported');
@@ skipping 72 matching lines @@
   }
 
   Element visitFunctionExpression(FunctionExpression node) {
     // This is a function typed parameter.
     // TODO(ahe): Resolve the function type.
     return visit(node.name);
   }
 
   LinkBuilder<Element> analyzeNodes(Link<Node> link) {
     LinkBuilder<Element> elements = new LinkBuilder<Element>();
-    for (; !link.isEmpty(); link = link.tail) {
+    for (; !link.isEmpty; link = link.tail) {
       Element element = link.head.accept(this);
       if (element != null) {
         elements.addLast(element);
       } else {
         // If parameter is null, the current node should be the last,
         // and a list of optional named parameters.
-        if (!link.tail.isEmpty() || (link.head is !NodeList)) {
+        if (!link.tail.isEmpty || (link.head is !NodeList)) {
           internalError(link.head, "expected optional parameters");
         }
       }
     }
     return elements;
   }
 
   /**
    * Resolves formal parameters and return type to a [FunctionSignature].
    */
@@ skipping 169 matching lines @@
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);
     } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
       error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE, [name]);
     } else if (!identical(e.kind, ElementKind.CLASS)
         && !identical(e.kind, ElementKind.PREFIX)) {
       error(node, MessageKind.NOT_A_TYPE, [name]);
     }
     return e;
   }
 }