Convert generic method errors to hints

pkg/analyzer/lib/src/dart/error/hint_codes.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.dart.error.hint_codes;
 
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 
 /**
@@ skipping 77 matching lines @@
    *
    * Parameters:
    * 0: the name of the member
    */
   static const HintCode DEPRECATED_MEMBER_USE = const HintCode(
       'DEPRECATED_MEMBER_USE',
       "'{0}' is deprecated and shouldn't be used.",
       "Try replacing the use of the deprecated member with the replacement.");
 
   /**
-   * Duplicate imports.
-   */
-  static const HintCode DUPLICATE_IMPORT = const HintCode('DUPLICATE_IMPORT',
-      "Duplicate import.", "Try removing all but one import of the library.");
-
-  /**
    * Hint to use the ~/ operator.
    */
   static const HintCode DIVISION_OPTIMIZATION = const HintCode(
       'DIVISION_OPTIMIZATION',
       "The operator x ~/ y is more efficient than (x / y).toInt().",
       "Try re-writing the expression to use the '~/' operator.");
 
   /**
-   * Hint for the `x is double` type checks.
+   * Duplicate imports.
    */
-  static const HintCode IS_DOUBLE = const HintCode(
-      'IS_DOUBLE',
-      "When compiled to JS, this test might return true when the left hand "
-      "side is an int.",
-      "Try testing for 'num' instead.");
+  static const HintCode DUPLICATE_IMPORT = const HintCode('DUPLICATE_IMPORT',
+      "Duplicate import.", "Try removing all but one import of the library.");
 
   /**
-   * Hint for the `x is int` type checks.
+   * It is a bad practice for a source file in a package "lib" directory
+   * hierarchy to traverse outside that directory hierarchy. For example, a
+   * source file in the "lib" directory should not contain a directive such as
+   * `import '../web/some.dart'` which references a file outside the lib
+   * directory.
    */
-  static const HintCode IS_INT = const HintCode(
-      'IS_INT',
-      "When compiled to JS, this test might return true when the left hand "
-      "side is a double.",
-      "Try testing for 'num' instead.");
+  static const HintCode FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE =
+  const HintCode(
+      'FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE',
+      "A file in the 'lib' directory shouldn't import a file outside the "
+          "'lib' directory.",
+      "Try removing the import, or "
+          "moving the imported file inside the 'lib' directory.");
 
   /**
-   * Hint for the `x is! double` type checks.
+   * It is a bad practice for a source file ouside a package "lib" directory
+   * hierarchy to traverse into that directory hierarchy. For example, a source
+   * file in the "web" directory should not contain a directive such as
+   * `import '../lib/some.dart'` which references a file inside the lib
+   * directory.
    */
-  static const HintCode IS_NOT_DOUBLE = const HintCode(
-      'IS_NOT_DOUBLE',
-      "When compiled to JS, this test might return false when the left hand "
-      "side is an int.",
-      "Try testing for 'num' instead.");
-
-  /**
-   * Hint for the `x is! int` type checks.
-   */
-  static const HintCode IS_NOT_INT = const HintCode(
-      'IS_NOT_INT',
-      "When compiled to JS, this test might return false when the left hand "
-      "side is a double.",
-      "Try testing for 'num' instead.");
+  static const HintCode FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE =
+  const HintCode(
+      'FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE',
+      "A file outside the 'lib' directory shouldn't reference a file "
+          "inside the 'lib' directory using a relative path.",
+      "Try using a package: URI instead.");
 
   /**
    * Deferred libraries shouldn't define a top level function 'loadLibrary'.
    */
   static const HintCode IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION =
       const HintCode(
           'IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION',
           "The library '{0}' defines a top-level function named 'loadLibrary' "
           "which is hidden by deferring this library.",
           "Try changing the import to not be deferred, or "
@@ skipping 36 matching lines @@
    * object.
    *
    * Parameters:
    * 0: the name of the method
    */
   static const HintCode INVALID_FACTORY_METHOD_IMPL = const HintCode(
       'INVALID_FACTORY_METHOD_IMPL',
       "Factory method '{0}' doesn't return a newly allocated object.");
 
   /**
+   * Generic Method DEP: number of type parameters must match.
+   * <https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md#function-subtyping>
+   *
+   * Parameters:
+   * 0: the number of type parameters in the method
+   * 1: the number of type parameters in the overridden method
+   * 2: the name of the class where the overridden method is declared
+   */
+  static const HintCode INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS =
+  const HintCode(
+      'INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS',
+      "The method has {0} type parameters, but it is overriding a method "
+          "with {1} type parameters from '{2}'.",
+      "Try changing the number of type parameters so that they are the same.");
+
+  /**
+   * Generic Method DEP: bounds of type parameters must be compatible.
+   * <https://github.com/leafpetersen/dep-generic-methods/blob/master/proposal.md#function-subtyping>
+   *
+   * Parameters:
+   * 0: the type parameter name
+   * 1: the type parameter bound
+   * 2: the overridden type parameter name
+   * 3: the overridden type parameter bound
+   * 4: the name of the class where the overridden method is declared
+   */
+  static const HintCode INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND =
+  const HintCode(
+      'INVALID_METHOD_OVERRIDE_TYPE_PARAMETER_BOUND',
+      "The type parameter '{0}' extends '{1}', but that is stricter than "
+          "'{2}' extends '{3}' in the overridden method from '{4}'.",
+      "Try changing the bounds on the type parameters so that they are compatible.");
+
+  /**
    * This hint is generated anywhere where a member annotated with `@protected`
    * is used outside an instance member of a subclass.
    *
    * Parameters:
    * 0: the name of the member
    * 1: the name of the defining class
    */
   static const HintCode INVALID_USE_OF_PROTECTED_MEMBER = const HintCode(
       'INVALID_USE_OF_PROTECTED_MEMBER',
       "The member '{0}' can only be used within instance members of subclasses "
       "of '{1}'.");
 
   /**
+   * Hint for the `x is double` type checks.
+   */
+  static const HintCode IS_DOUBLE = const HintCode(
+      'IS_DOUBLE',
+      "When compiled to JS, this test might return true when the left hand "
+          "side is an int.",
+      "Try testing for 'num' instead.");
+
+  /**
+   * Hint for the `x is int` type checks.
+   */
+  static const HintCode IS_INT = const HintCode(
+      'IS_INT',
+      "When compiled to JS, this test might return true when the left hand "
+          "side is a double.",
+      "Try testing for 'num' instead.");
+
+  /**
+   * Hint for the `x is! double` type checks.
+   */
+  static const HintCode IS_NOT_DOUBLE = const HintCode(
+      'IS_NOT_DOUBLE',
+      "When compiled to JS, this test might return false when the left hand "
+          "side is an int.",
+      "Try testing for 'num' instead.");
+
+  /**
+   * Hint for the `x is! int` type checks.
+   */
+  static const HintCode IS_NOT_INT = const HintCode(
+      'IS_NOT_INT',
+      "When compiled to JS, this test might return false when the left hand "
+          "side is a double.",
+      "Try testing for 'num' instead.");
+
+  /**
+   * Generate a hint for an element that is annotated with `@JS(...)` whose
+   * library declaration is not similarly annotated.
+   */
+  static const HintCode MISSING_JS_LIB_ANNOTATION = const HintCode(
+      'MISSING_JS_LIB_ANNOTATION',
+      "The @JS() annotation can only be used if it is also declared on the "
+          "library directive.",
+      "Try adding the annotation to the library directive.");
+
+  /**
    * Generate a hint for a constructor, function or method invocation where a
    * required parameter is missing.
    *
    * Parameters:
    * 0: the name of the parameter
    */
   static const HintCode MISSING_REQUIRED_PARAM = const HintCode(
       'MISSING_REQUIRED_PARAM', "The parameter '{0}' is required.");
 
   /**
    * Generate a hint for a constructor, function or method invocation where a
    * required parameter is missing.
    *
    * Parameters:
    * 0: the name of the parameter
    * 1: message details
    */
   static const HintCode MISSING_REQUIRED_PARAM_WITH_DETAILS = const HintCode(
       'MISSING_REQUIRED_PARAM_WITH_DETAILS',
       "The parameter '{0}' is required. {1}.");
 
   /**
-   * Generate a hint for an element that is annotated with `@JS(...)` whose
-   * library declaration is not similarly annotated.
-   */
-  static const HintCode MISSING_JS_LIB_ANNOTATION = const HintCode(
-      'MISSING_JS_LIB_ANNOTATION',
-      "The @JS() annotation can only be used if it is also declared on the "
-      "library directive.",
-      "Try adding the annotation to the library directive.");
-
-  /**
    * Generate a hint for methods or functions that have a return type, but do
    * not have a non-void return statement on all branches. At the end of methods
    * or functions with no return, Dart implicitly returns `null`, avoiding these
    * implicit returns is considered a best practice.
    *
    * Parameters:
    * 0: the name of the declared return type
    */
   static const HintCode MISSING_RETURN = const HintCode(
       'MISSING_RETURN',
@@ skipping 18 matching lines @@
    * 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 isn't appropriate "
       "in a condition.",
       "Try replacing the '?.' with a '.', testing the left-hand side for null if "
       "necessary.");
 
   /**
+   * Hint for classes that override equals, but not hashCode.
+   *
+   * Parameters:
+   * 0: the name of the current class
+   */
+  static const HintCode OVERRIDE_EQUALS_BUT_NOT_HASH_CODE = const HintCode(
+      'OVERRIDE_EQUALS_BUT_NOT_HASH_CODE',
+      "The class '{0}' overrides 'operator==', but not 'get hashCode'.",
+      "Try implementing 'hashCode'.");
+
+  /**
    * A getter with the override annotation does not override an existing getter.
    */
   static const HintCode OVERRIDE_ON_NON_OVERRIDING_GETTER = const HintCode(
       'OVERRIDE_ON_NON_OVERRIDING_GETTER',
       "Getter doesn't override an inherited getter.",
       "Try updating this class to match the superclass, or "
       "removing the override annotation.");
 
   /**
    * A field with the override annotation does not override a getter or setter.
@@ skipping 16 matching lines @@
   /**
    * A setter with the override annotation does not override an existing setter.
    */
   static const HintCode OVERRIDE_ON_NON_OVERRIDING_SETTER = const HintCode(
       'OVERRIDE_ON_NON_OVERRIDING_SETTER',
       "Setter doesn't override an inherited setter.",
       "Try updating this class to match the superclass, or "
       "removing the override annotation.");
 
   /**
-   * Hint for classes that override equals, but not hashCode.
-   *
-   * Parameters:
-   * 0: the name of the current class
+   * It is a bad practice for a package import to reference anything outside the
+   * given package, or more generally, it is bad practice for a package import
+   * to contain a "..". For example, a source file should not contain a
+   * directive such as `import 'package:foo/../some.dart'`.
    */
-  static const HintCode OVERRIDE_EQUALS_BUT_NOT_HASH_CODE = const HintCode(
-      'OVERRIDE_EQUALS_BUT_NOT_HASH_CODE',
-      "The class '{0}' overrides 'operator==', but not 'get hashCode'.",
-      "Try implementing 'hashCode'.");
+  static const HintCode PACKAGE_IMPORT_CONTAINS_DOT_DOT = const HintCode(
+      'PACKAGE_IMPORT_CONTAINS_DOT_DOT',
+      "A package import shouldn't contain '..'.");
 
   /**
    * Type checks of the type `x is! Null` should be done with `x != null`.
    */
   static const HintCode TYPE_CHECK_IS_NOT_NULL = const HintCode(
       'TYPE_CHECK_IS_NOT_NULL',
       "Tests for non-null should be done with '!= null'.",
       "Try replacing the 'is! Null' check with '!= null'.");
 
   /**
@@ skipping 103 matching lines @@
 
   /**
    * Unnecessary type checks, the result is always true.
    */
   static const HintCode UNNECESSARY_TYPE_CHECK_TRUE = const HintCode(
       'UNNECESSARY_TYPE_CHECK_TRUE',
       "Unnecessary type check, the result is always true.",
       "Try correcting the type check, or removing the type check.");
 
   /**
+   * Unused catch exception variables.
+   */
+  static const HintCode UNUSED_CATCH_CLAUSE = const HintCode(
+      'UNUSED_CATCH_CLAUSE',
+      "The exception variable '{0}' isn't used, so the 'catch' clause can be removed.",
+  // TODO(brianwilkerson) Split this error code so that we can differentiate
+  // between removing the catch clause and replacing the catch clause with
+  // an on clause.
+      "Try removing the catch clause.");
+
+  /**
+   * Unused catch stack trace variables.
+   */
+  static const HintCode UNUSED_CATCH_STACK = const HintCode(
+      'UNUSED_CATCH_STACK',
+      "The stack trace variable '{0}' isn't used and can be removed.",
+      "Try removing the stack trace variable, or using it.");
+
+  /**
    * See [Modifier.IS_USED_IN_LIBRARY].
    */
   static const HintCode UNUSED_ELEMENT = const HintCode('UNUSED_ELEMENT',
       "The {0} '{1}' isn't used.", "Try removing the declaration of '{1}'.");
 
   /**
    * Unused fields are fields which are never read.
    */
   static const HintCode UNUSED_FIELD = const HintCode(
       'UNUSED_FIELD',
       "The value of the field '{0}' isn't used.",
       "Try removing the field, or using it.");
 
   /**
    * Unused imports are imports which are never used.
    */
   static const HintCode UNUSED_IMPORT = const HintCode(
       'UNUSED_IMPORT', "Unused import.", "Try removing the import directive.");
 
   /**
-   * Unused catch exception variables.
-   */
-  static const HintCode UNUSED_CATCH_CLAUSE = const HintCode(
-      'UNUSED_CATCH_CLAUSE',
-      "The exception variable '{0}' isn't used, so the 'catch' clause can be removed.",
-      // TODO(brianwilkerson) Split this error code so that we can differentiate
-      // between removing the catch clause and replacing the catch clause with
-      // an on clause.
-      "Try removing the catch clause.");
-
-  /**
-   * Unused catch stack trace variables.
-   */
-  static const HintCode UNUSED_CATCH_STACK = const HintCode(
-      'UNUSED_CATCH_STACK',
-      "The stack trace variable '{0}' isn't used and can be removed.",
-      "Try removing the stack trace variable, or using it.");
-
-  /**
    * Unused local variables are local variables which are never read.
    */
   static const HintCode UNUSED_LOCAL_VARIABLE = const HintCode(
       'UNUSED_LOCAL_VARIABLE',
       "The value of the local variable '{0}' isn't used.",
       "Try removing the variable, or using it.");
 
   /**
    * Unused shown names are names shown on imports which are never used.
    */
   static const HintCode UNUSED_SHOWN_NAME = const HintCode(
       'UNUSED_SHOWN_NAME',
       "The name {0} is shown, but not used.",
       "Try removing the name from the list of shown members.");
 
   /**
    * Hint for cases where the source expects a method or function to return a
    * non-void result, but the method or function signature returns void.
    *
    * Parameters:
    * 0: the name of the method or function that returns void
    */
   static const HintCode USE_OF_VOID_RESULT = const HintCode(
       'USE_OF_VOID_RESULT',
       "The result of '{0}' is being used, even though it is declared to be 'void'.");
 
   /**
-   * It is a bad practice for a source file in a package "lib" directory
-   * hierarchy to traverse outside that directory hierarchy. For example, a
-   * source file in the "lib" directory should not contain a directive such as
-   * `import '../web/some.dart'` which references a file outside the lib
-   * directory.
+   * It will be a static type warning if <i>m</i> is not a generic method with
+   * exactly <i>n</i> type parameters.
+   *
+   * Parameters:
+   * 0: the name of the method being referenced (<i>G</i>)
+   * 1: the number of type parameters that were declared
+   * 2: the number of type arguments provided
    */
-  static const HintCode FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE =
-      const HintCode(
-          'FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE',
-          "A file in the 'lib' directory shouldn't import a file outside the "
-          "'lib' directory.",
-          "Try removing the import, or "
-          "moving the imported file inside the 'lib' directory.");
-
-  /**
-   * It is a bad practice for a source file ouside a package "lib" directory
-   * hierarchy to traverse into that directory hierarchy. For example, a source
-   * file in the "web" directory should not contain a directive such as
-   * `import '../lib/some.dart'` which references a file inside the lib
-   * directory.
-   */
-  static const HintCode FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE =
-      const HintCode(
-          'FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE',
-          "A file outside the 'lib' directory shouldn't reference a file "
-          "inside the 'lib' directory using a relative path.",
-          "Try using a package: URI instead.");
-
-  /**
-   * It is a bad practice for a package import to reference anything outside the
-   * given package, or more generally, it is bad practice for a package import
-   * to contain a "..". For example, a source file should not contain a
-   * directive such as `import 'package:foo/../some.dart'`.
-   */
-  static const HintCode PACKAGE_IMPORT_CONTAINS_DOT_DOT = const HintCode(
-      'PACKAGE_IMPORT_CONTAINS_DOT_DOT',
-      "A package import shouldn't contain '..'.");
+  static const HintCode WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD =
+  const HintCode(
+      'WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD',
+      "The method '{0}' is declared with {1} type parameters, "
+          "but {2} type arguments were given.",
+      "Try adjusting the number of type arguments.");
 
   /**
    * Initialize a newly created error code to have the given [name]. The message
    * associated with the error will be created from the given [message]
    * template. The correction associated with the error will be created from the
    * given [correction] template.
    */
   const HintCode(String name, String message, [String correction])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorType.HINT.severity;
 
   @override
   ErrorType get type => ErrorType.HINT;
 }