anchor.diff:    }
   
     @override
  -  void handleRecoverMixinHeader() {
  -    ImplementsClause implementsClause = pop(NullValue.IdentifierList);
  -    OnClause onClause = pop(NullValue.IdentifierList);
  -
  -    if (onClause != null) {
  -      if (mixinDeclaration.onClause == null) {
  -        mixinDeclaration.onClause = onClause;
  -      } else {
  -        mixinDeclaration.onClause.superclassConstraints
  -            .addAll(onClause.superclassConstraints);
  -      }
  -    }
  -    if (implementsClause != null) {
  -      if (mixinDeclaration.implementsClause == null) {
  -        mixinDeclaration.implementsClause = implementsClause;
  -      } else {
  -        mixinDeclaration.implementsClause.interfaces
  -            .addAll(implementsClause.interfaces);
  -      }
  -    }
  -  }
  -
  -  @override
  -  void endMixinDeclaration(Token mixinKeyword, Token endToken) {
  -    debugEvent("MixinDeclaration");
  -    mixinDeclaration = null;
  -  }
  -
  -  @override
  -  void beginNamedMixinApplication(
  -      Token begin, Token abstractToken, Token name) {
  -    push(new _Modifiers()..abstractKeyword = abstractToken);
  +  void handleMixinOn(Token onKeyword, int typeCount) {
  +    assert(onKeyword == null || onKeyword.isKeywordOrIdentifier);
  +    debugEvent("MixinOn");
  +
  +    if (onKeyword != null) {
  +      List<TypeName> types = popTypedList(typeCount);
  +      push(ast.onClause(onKeyword, types));
  +    } else {
  +      push(NullValue.IdentifierList);
  +    }
  +  }
  +
  +  void handleNamedArgument(Token colon) {
  +    assert(optional(':', colon));
  +    debugEvent("NamedArgument");
  +
  +    Expression expression = pop();
  +    SimpleIdentifier name = pop();
  +    push(ast.namedExpression(ast.label(name, colon), expression));
     }
   
     @override
  
positive.code:         semicolon));
    }
  
    void handleAssignmentExpression(Token token) {
      assert(token.type.isAssignmentOperator);
      debugEvent("AssignmentExpression");
  
negative.code:     push(popTypedList(count, new List<TypeParameter>(count)));
    }
  
    void handleUnaryPostfixAssignmentExpression(Token operator) {
      assert(operator.type.isUnaryPostfixOperator);
      debugEvent("UnaryPostfixAssignmentExpression");
  
      Expression expression = pop();
      if (!expression.isAssignable) {
        // This error is also reported by the body builder.
        handleRecoverableError(
            messageIllegalAssignmentToNonAssignable, operator, operator);
      }
      push(ast.postfixExpression(expression, operator));
    }
  
    void handleUnaryPrefixAssignmentExpression(Token operator) {
      assert(operator.type.isUnaryPrefixOperator);
      debugEvent("UnaryPrefixAssignmentExpression");
  
      Expression expression = pop();
      if (!expression.isAssignable) {
        // This error is also reported by the body builder.
        handleRecoverableError(messageMissingAssignableSelector,
            expression.endToken, expression.endToken);
      }
      push(ast.prefixExpression(operator, expression));
    }
  
    void handleUnaryPrefixExpression(Token operator) {
      assert(operator.type.isUnaryPrefixOperator);
      debugEvent("UnaryPrefixExpression");
  
      push(ast.prefixExpression(operator, pop()));
    }
  
    void handleValuedFormalParameter(Token equals, Token token) {
      assert(optional('=', equals) || optional(':', equals));
      debugEvent("ValuedFormalParameter");
  
      Expression value = pop();
      push(new _ParameterDefaultValue(equals, value));
    }
  
    @override
  