anchor.diff:    void declaredMethod(MethodDeclaration declaration) {
       if (optype.includeReturnValueSuggestions ||
           optype.includeVoidReturnSuggestions) {
  -      protocol.ElementKind kind;
  -      String parameters;
  -      TypeName returnType = declaration.returnType;
  -      int defaultRelevance = DART_RELEVANCE_DEFAULT;
  +      protocol.ElementKind elemKind;
  +      FormalParameterList param;
  +      TypeName typeName = declaration.returnType;
  +      int relevance = DART_RELEVANCE_DEFAULT;
         if (declaration.isGetter) {
  -        kind = protocol.ElementKind.GETTER;
  -        parameters = null;
  -        defaultRelevance = DART_RELEVANCE_LOCAL_ACCESSOR;
  +        elemKind = protocol.ElementKind.GETTER;
  +        param = null;
  +        relevance = DART_RELEVANCE_LOCAL_ACCESSOR;
         } else if (declaration.isSetter) {
           if (!optype.includeVoidReturnSuggestions) {
             return;
           }
  -        kind = protocol.ElementKind.SETTER;
  -        returnType = NO_RETURN_TYPE;
  -        defaultRelevance = DART_RELEVANCE_LOCAL_ACCESSOR;
  +        elemKind = protocol.ElementKind.SETTER;
  +        typeName = NO_RETURN_TYPE;
  +        relevance = DART_RELEVANCE_LOCAL_ACCESSOR;
         } else {
  -        if (!optype.includeVoidReturnSuggestions && _isVoid(returnType)) {
  +        if (!optype.includeVoidReturnSuggestions && _isVoid(typeName)) {
             return;
           }
  -        kind = protocol.ElementKind.METHOD;
  -        parameters = declaration.parameters.toSource();
  -        defaultRelevance = DART_RELEVANCE_LOCAL_METHOD;
  -      }
  -      bool deprecated = isDeprecated(declaration);
  -      CompletionSuggestion suggestion = _addSuggestion(
  -          declaration.name, returnType, deprecated, defaultRelevance,
  -          classDecl: declaration.parent);
  -      if (suggestion != null) {
  -        suggestion.element = createElement(kind, declaration.name,
  -            parameters: parameters,
  -            returnType: returnType,
  -            isAbstract: declaration.isAbstract,
  -            isDeprecated: deprecated);
  -        if (kind == protocol.ElementKind.METHOD) {
  -          _addParameterInfo(suggestion, declaration.parameters);
  -        }
  -      }
  -    }
  -  }
  -
  -  @override
  -  void declaredParam(SimpleIdentifier name, TypeName type) {
  +        elemKind = protocol.ElementKind.METHOD;
  +        param = declaration.parameters;
  +        relevance = DART_RELEVANCE_LOCAL_METHOD;
  +      }
  +      _addSuggestion(declaration.name, typeName, elemKind,
  +          isAbstract: declaration.isAbstract,
  +          isDeprecated: isDeprecated(declaration),
  +          classDecl: declaration.parent,
  +          param: param,
  +          relevance: relevance);
  +    }
  +  }
  +
  +  @override
  +  void declaredParam(SimpleIdentifier id, TypeName typeName) {
       if (optype.includeReturnValueSuggestions) {
  -      CompletionSuggestion suggestion =
  -          _addSuggestion(name, type, false, DART_RELEVANCE_PARAMETER);
  -      if (suggestion != null) {
  -        suggestion.element = createElement(protocol.ElementKind.PARAMETER, name,
  -            returnType: type);
  -      }
  +      _addSuggestion(id, typeName, protocol.ElementKind.PARAMETER,
  +          relevance: DART_RELEVANCE_PARAMETER);
       }
     }
   
  
positive.code:   void declaredTopLevelVar(
        VariableDeclarationList varList, VariableDeclaration varDecl) {
      if (optype.includeReturnValueSuggestions) {
        bool deprecated = isDeprecated(varList) || isDeprecated(varDecl);
        CompletionSuggestion suggestion = _addSuggestion(varDecl.name,
            varList.type, deprecated, DART_RELEVANCE_LOCAL_TOP_LEVEL_VARIABLE);
        if (suggestion != null) {
          suggestion.element = createElement(
              protocol.ElementKind.TOP_LEVEL_VARIABLE, varDecl.name,
              returnType: varList.type, isDeprecated: deprecated);
        }
      }
    }
  
  
negative.code:         .any((FormalParameter param) => param.kind == ParameterKind.NAMED);
    }
  
    void _addSuggestion(
        SimpleIdentifier id, TypeName typeName, protocol.ElementKind elemKind,
        {bool isAbstract: false, bool isDeprecated: false,
        ClassDeclaration classDecl, FormalParameterList param,
        int relevance: DART_RELEVANCE_DEFAULT}) {
      CompletionSuggestion suggestion = createSuggestion(
          id, isDeprecated, relevance, typeName, classDecl: classDecl);
      if (suggestion != null) {
        request.addSuggestion(suggestion);
        suggestion.element = createElement(elemKind, id,
            isAbstract: isAbstract,
            isDeprecated: isDeprecated,
            parameters: param != null ? param.toSource() : null,
            returnType: typeName);
        if ((elemKind == protocol.ElementKind.METHOD ||
                elemKind == protocol.ElementKind.FUNCTION) &&
            param != null) {
          _addParameterInfo(suggestion, param);
        }
      }
    }
  
    bool _isVoid(TypeName returnType) {
  