Improve error messages containing named function types and clean up some duplicated code (issue 259…

pkg/analyzer/lib/src/generated/error.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.src.generated.error;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart' show AstNode;
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/source/error_processor.dart';
+import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart' show ScannerErrorCode;
 import 'package:analyzer/src/generated/generated/shared_messages.dart'
     as shared_messages;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/model.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:source_span/source_span.dart';
 
@@ skipping 3208 matching lines @@
   }
 
   /**
    * Given an array of [arguments] that is expected to contain two or more
    * types, convert the types into strings by using the display names of the
    * types, unless there are two or more types with the same names, in which
    * case the extended display names of the types will be used in order to
    * clarify the message.
    */
   void _convertTypeNames(List<Object> arguments) {
+    String displayName(DartType type) {
+      if (type is FunctionType) {
+        String name = type.name;
+        if (name != null && name.length > 0) {
+          StringBuffer buffer = new StringBuffer();
+          buffer.write(name);
+          (type as TypeImpl).appendTo(buffer);
+          return buffer.toString();
+        }
+      }
+      return type.displayName;
+    }
     if (_hasEqualTypeNames(arguments)) {
       int count = arguments.length;
       for (int i = 0; i < count; i++) {
         Object argument = arguments[i];
         if (argument is DartType) {
           DartType type = argument;
           Element element = type.element;
           if (element == null) {
-            arguments[i] = type.displayName;
+            arguments[i] = displayName(type);
           } else {
-            arguments[i] = element.getExtendedDisplayName(type.displayName);
+            arguments[i] = element.getExtendedDisplayName(displayName(type));
           }
         }
       }
     } else {
       int count = arguments.length;
       for (int i = 0; i < count; i++) {
         Object argument = arguments[i];
         if (argument is DartType) {
-          arguments[i] = argument.displayName;
+          arguments[i] = displayName(argument);
         }
       }
     }
   }
 
   /**
    * Return `true` if the given array of [arguments] contains two or more types
    * with the same display name.
    */
   bool _hasEqualTypeNames(List<Object> arguments) {
@@ skipping 299 matching lines @@
   /**
    * Generate a hint for methods that override methods annotated `@mustCallSuper`
    * that do not invoke the overridden super method.
    *
    * Parameters:
    * 0: the name of the class declaring the overriden method
    */
   static const HintCode MUST_CALL_SUPER = const HintCode(
       'MUST_CALL_SUPER',
       "This method overrides a method annotated as @mustCall super in '{0}', "
-          "but does invoke the overriden method");
+      "but does invoke the overriden method");
 
   /**
    * A condition in a control flow statement could evaluate to `null` because it
    * uses the null-aware '?.' operator.
    */
   static const HintCode NULL_AWARE_IN_CONDITION = const HintCode(
       'NULL_AWARE_IN_CONDITION',
       "The value of the '?.' operator can be 'null', which is not appropriate in a condition",
       "Replace the '?.' with a '.', testing the left-hand side for null if necessary");
 
@@ skipping 807 matching lines @@
 
   /**
    * 17.6.2 For-in. If the iterable expression does not implement Iterable,
    * this warning is reported.
    *
    * Parameters:
    * 0: The type of the iterable expression.
    * 1: The sequence type -- Iterable for `for` or Stream for `await for`.
    */
   static const StaticTypeWarningCode FOR_IN_OF_INVALID_TYPE =
-  const StaticTypeWarningCode('FOR_IN_OF_INVALID_TYPE',
-      "The type '{0}' used in the 'for' loop must implement {1}");
+      const StaticTypeWarningCode('FOR_IN_OF_INVALID_TYPE',
+          "The type '{0}' used in the 'for' loop must implement {1}");
 
   /**
    * 17.6.2 For-in. It the iterable expression does not implement Iterable with
    * a type argument that can be assigned to the for-in variable's type, this
    * warning is reported.
    *
    * Parameters:
    * 0: The type of the iterable expression.
    * 1: The sequence type -- Iterable for `for` or Stream for `await for`.
    * 2: The loop variable type.
@@ skipping 1310 matching lines @@
    * Initialize a newly created error code to have the given [name].
    */
   const TodoCode(String name) : super(name, "{0}");
 
   @override
   ErrorSeverity get errorSeverity => ErrorSeverity.INFO;
 
   @override
   ErrorType get type => ErrorType.TODO;
 }