Fix issue 21426

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 engine.error;
 
 import 'dart:collection';
 
 import 'ast.dart' show AstNode;
 import 'element.dart';
@@ skipping 3035 matching lines @@
           'IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION',
           "The library '{0}' defines a top-level function named 'loadLibrary' which is hidden by deferring this library");
 
   /**
    * This hint is generated anywhere where the
    * [StaticTypeWarningCode.INVALID_ASSIGNMENT] would have been generated, if we
    * used propagated information for the warnings.
    *
    * @param rhsTypeName the name of the right hand side type
    * @param lhsTypeName the name of the left hand side type
-   * See [StaticTypeWarningCode.INVALID_ASSIGNMENT].
    */
   static const HintCode INVALID_ASSIGNMENT = const HintCode(
       'INVALID_ASSIGNMENT',
       "A value of type '{0}' cannot be assigned to a variable of type '{1}'");
 
   /**
    * 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.
@@ skipping 51 matching lines @@
 
   /**
    * This hint is generated anywhere where the
    * [StaticTypeWarningCode.UNDEFINED_GETTER] or
    * [StaticWarningCode.UNDEFINED_GETTER] would have been generated, if we used
    * propagated information for the warnings.
    *
    * @param getterName the name of the getter
    * @param enclosingType the name of the enclosing type where the getter is
    *        being looked for
-   * See [StaticTypeWarningCode.UNDEFINED_GETTER], and
-   * [StaticWarningCode.UNDEFINED_GETTER].
    */
   static const HintCode UNDEFINED_GETTER =
-      const HintCode('UNDEFINED_GETTER', "There is no such getter '{0}' in '{1}'");
+      const HintCode(
+          'UNDEFINED_GETTER',
+          "The getter '{0}' is not defined for the class '{1}'");
 
   /**
    * This hint is generated anywhere where the
    * [StaticTypeWarningCode.UNDEFINED_METHOD] would have been generated, if we
    * used propagated information for the warnings.
    *
    * @param methodName the name of the method that is undefined
    * @param typeName the resolved type name that the method lookup is happening
    *        on
-   * See [StaticTypeWarningCode.UNDEFINED_METHOD].
    */
   static const HintCode UNDEFINED_METHOD = const HintCode(
       'UNDEFINED_METHOD',
       "The method '{0}' is not defined for the class '{1}'");
 
   /**
    * This hint is generated anywhere where the
    * [StaticTypeWarningCode.UNDEFINED_OPERATOR] would have been generated, if we
    * used propagated information for the warnings.
    *
    * @param operator the name of the operator
    * @param enclosingType the name of the enclosing type where the operator is
    *        being looked for
-   * See [StaticTypeWarningCode.UNDEFINED_OPERATOR].
    */
   static const HintCode UNDEFINED_OPERATOR = const HintCode(
       'UNDEFINED_OPERATOR',
-      "There is no such operator '{0}' in '{1}'");
+      "The operator '{0}' is not defined for the class '{1}'");
 
   /**
    * This hint is generated anywhere where the
    * [StaticTypeWarningCode.UNDEFINED_SETTER] or
    * [StaticWarningCode.UNDEFINED_SETTER] would have been generated, if we used
    * propagated information for the warnings.
    *
    * @param setterName the name of the setter
    * @param enclosingType the name of the enclosing type where the setter is
    *        being looked for
-   * See [StaticTypeWarningCode.UNDEFINED_SETTER], and
-   * [StaticWarningCode.UNDEFINED_SETTER].
    */
   static const HintCode UNDEFINED_SETTER =
-      const HintCode('UNDEFINED_SETTER', "There is no such setter '{0}' in '{1}'");
+      const HintCode(
+          'UNDEFINED_SETTER',
+          "The setter '{0}' is not defined for the class '{1}'");
 
   /**
    * Unnecessary cast.
    */
   static const HintCode UNNECESSARY_CAST =
       const HintCode('UNNECESSARY_CAST', "Unnecessary cast");
 
   /**
    * Unnecessary type checks, the result is always true.
    */
@@ skipping 485 matching lines @@
    * 12.17 Getter Invocation: Let <i>T</i> be the static type of <i>e</i>. It is
    * a static type warning if <i>T</i> does not have a getter named <i>m</i>.
    *
    * @param getterName the name of the getter
    * @param enclosingType the name of the enclosing type where the getter is
    *        being looked for
    */
   static const StaticTypeWarningCode UNDEFINED_GETTER =
       const StaticTypeWarningCode(
           'UNDEFINED_GETTER',
-          "There is no such getter '{0}' in '{1}'");
+          "The getter '{0}' is not defined for the class '{1}'");
 
   /**
    * 12.15.1 Ordinary Invocation: Let <i>T</i> be the static type of <i>o</i>.
    * It is a static type warning if <i>T</i> does not have an accessible
    * instance member named <i>m</i>.
    *
    * @param methodName the name of the method that is undefined
    * @param typeName the resolved type name that the method lookup is happening
    *        on
    */
@@ skipping 18 matching lines @@
    * It is a static type warning if <i>T</i> does not have an accessible
    * instance member named <i>m</i>.
    *
    * @param operator the name of the operator
    * @param enclosingType the name of the enclosing type where the operator is
    *        being looked for
    */
   static const StaticTypeWarningCode UNDEFINED_OPERATOR =
       const StaticTypeWarningCode(
           'UNDEFINED_OPERATOR',
-          "There is no such operator '{0}' in '{1}'");
+          "The operator '{0}' is not defined for the class '{1}'");
 
   /**
    * 12.18 Assignment: Let <i>T</i> be the static type of <i>e<sub>1</sub></i>.
    * It is a static type warning if <i>T</i> does not have an accessible
    * instance setter named <i>v=</i>.
    *
    * @param setterName the name of the setter
    * @param enclosingType the name of the enclosing type where the setter is
    *        being looked for
    * See [INACCESSIBLE_SETTER].
    */
   static const StaticTypeWarningCode UNDEFINED_SETTER =
       const StaticTypeWarningCode(
           'UNDEFINED_SETTER',
-          "There is no such setter '{0}' in '{1}'");
+          "The setter '{0}' is not defined for the class '{1}'");
+
+  /**
+   * 12.17 Getter Invocation: Let <i>T</i> be the static type of <i>e</i>. It is
+   * a static type warning if <i>T</i> does not have a getter named <i>m</i>.
+   *
+   * @param getterName the name of the getter
+   * @param enclosingType the name of the enclosing type where the getter is
+   *        being looked for
+   */
+  static const StaticTypeWarningCode UNDEFINED_SUPER_GETTER =
+      const StaticTypeWarningCode(
+          'UNDEFINED_SUPER_GETTER',
+          "The getter '{0}' is not defined in a superclass of '{1}'");
 
   /**
    * 12.15.4 Super Invocation: A super method invocation <i>i</i> has the form
    * <i>super.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>:
    * a<sub>n+1</sub>, &hellip; x<sub>n+k</sub>: a<sub>n+k</sub>)</i>. It is a
    * static type warning if <i>S</i> does not have an accessible instance member
    * named <i>m</i>.
    *
    * @param methodName the name of the method that is undefined
    * @param typeName the resolved type name that the method lookup is happening
    *        on
    */
   static const StaticTypeWarningCode UNDEFINED_SUPER_METHOD =
       const StaticTypeWarningCode(
           'UNDEFINED_SUPER_METHOD',
-          "There is no such method '{0}' in '{1}'");
+          "The method '{0}' is not defined in a superclass of '{1}'");
+
+  /**
+   * 12.18 Assignment: Evaluation of an assignment of the form
+   * <i>e<sub>1</sub></i>[<i>e<sub>2</sub></i>] = <i>e<sub>3</sub></i> is
+   * equivalent to the evaluation of the expression (a, i, e){a.[]=(i, e);
+   * return e;} (<i>e<sub>1</sub></i>, <i>e<sub>2</sub></i>,
+   * <i>e<sub>2</sub></i>).
+   *
+   * 12.29 Assignable Expressions: An assignable expression of the form
+   * <i>e<sub>1</sub></i>[<i>e<sub>2</sub></i>] is evaluated as a method
+   * invocation of the operator method [] on <i>e<sub>1</sub></i> with argument
+   * <i>e<sub>2</sub></i>.
+   *
+   * 12.15.1 Ordinary Invocation: Let <i>T</i> be the static type of <i>o</i>.
+   * It is a static type warning if <i>T</i> does not have an accessible
+   * instance member named <i>m</i>.
+   *
+   * @param operator the name of the operator
+   * @param enclosingType the name of the enclosing type where the operator is
+   *        being looked for
+   */
+  static const StaticTypeWarningCode UNDEFINED_SUPER_OPERATOR =
+      const StaticTypeWarningCode(
+          'UNDEFINED_SUPER_OPERATOR',
+          "The operator '{0}' is not defined in a superclass of '{1}'");
+
+  /**
+   * 12.18 Assignment: Let <i>T</i> be the static type of <i>e<sub>1</sub></i>.
+   * It is a static type warning if <i>T</i> does not have an accessible
+   * instance setter named <i>v=</i>.
+   *
+   * @param setterName the name of the setter
+   * @param enclosingType the name of the enclosing type where the setter is
+   *        being looked for
+   * See [INACCESSIBLE_SETTER].
+   */
+  static const StaticTypeWarningCode UNDEFINED_SUPER_SETTER =
+      const StaticTypeWarningCode(
+          'UNDEFINED_SUPER_SETTER',
+          "The setter '{0}' is not defined in a superclass of '{1}'");
 
   /**
    * 12.15.1 Ordinary Invocation: It is a static type warning if <i>T</i> does
    * not have an accessible (3.2) instance member named <i>m</i>.
    *
    * This is a specialization of [INSTANCE_ACCESS_TO_STATIC_MEMBER] that is used
    * when we are able to find the name defined in a supertype. It exists to
    * provide a more informative error message.
    */
   static const StaticTypeWarningCode
@@ skipping 1125 matching lines @@
    * 12.17 Getter Invocation: It is a static warning if there is no class
    * <i>C</i> in the enclosing lexical scope of <i>i</i>, or if <i>C</i> does
    * not declare, implicitly or explicitly, a getter named <i>m</i>.
    *
    * @param getterName the name of the getter
    * @param enclosingType the name of the enclosing type where the getter is
    *        being looked for
    */
   static const StaticWarningCode UNDEFINED_GETTER = const StaticWarningCode(
       'UNDEFINED_GETTER',
-      "There is no such getter '{0}' in '{1}'");
+      "The getter '{0}' is not defined for the class '{1}'");
 
   /**
    * 12.30 Identifier Reference: It is as static warning if an identifier
    * expression of the form <i>id</i> occurs inside a top level or static
    * function (be it function, method, getter, or setter) or variable
    * initializer and there is no declaration <i>d</i> with name <i>id</i> in the
    * lexical scope enclosing the expression.
    *
    * @param name the name of the identifier
    */
@@ skipping 23 matching lines @@
    * 12.18 Assignment: It is a static warning if there is no class <i>C</i> in
    * the enclosing lexical scope of the assignment, or if <i>C</i> does not
    * declare, implicitly or explicitly, a setter <i>v=</i>.
    *
    * @param setterName the name of the getter
    * @param enclosingType the name of the enclosing type where the setter is
    *        being looked for
    */
   static const StaticWarningCode UNDEFINED_SETTER = const StaticWarningCode(
       'UNDEFINED_SETTER',
-      "There is no such setter '{0}' in '{1}'");
+      "The setter '{0}' is not defined for the class '{1}'");
 
   /**
    * 12.16.3 Static Invocation: It is a static warning if <i>C</i> does not
    * declare a static method or getter <i>m</i>.
    *
    * @param methodName the name of the method
    * @param enclosingType the name of the enclosing type where the method is
    *        being looked for
    */
   static const StaticWarningCode UNDEFINED_STATIC_METHOD_OR_GETTER =
       const StaticWarningCode(
           'UNDEFINED_STATIC_METHOD_OR_GETTER',
-          "There is no such static method, getter or setter '{0}' in '{1}'");
+          "The static method, getter or setter '{0}' is not defined for the class '{1}'");
+
+  /**
+   * 12.17 Getter Invocation: It is a static warning if there is no class
+   * <i>C</i> in the enclosing lexical scope of <i>i</i>, or if <i>C</i> does
+   * not declare, implicitly or explicitly, a getter named <i>m</i>.
+   *
+   * @param getterName the name of the getter
+   * @param enclosingType the name of the enclosing type where the getter is
+   *        being looked for
+   */
+  static const StaticWarningCode UNDEFINED_SUPER_GETTER = const StaticWarningCode(
+      'UNDEFINED_SUPER_GETTER',
+      "The getter '{0}' is not defined in a superclass of '{1}'");
+
+  /**
+   * 12.18 Assignment: It is as static warning if an assignment of the form
+   * <i>v = e</i> occurs inside a top level or static function (be it function,
+   * method, getter, or setter) or variable initializer and there is no
+   * declaration <i>d</i> with name <i>v=</i> in the lexical scope enclosing the
+   * assignment.
+   *
+   * 12.18 Assignment: It is a static warning if there is no class <i>C</i> in
+   * the enclosing lexical scope of the assignment, or if <i>C</i> does not
+   * declare, implicitly or explicitly, a setter <i>v=</i>.
+   *
+   * @param setterName the name of the getter
+   * @param enclosingType the name of the enclosing type where the setter is
+   *        being looked for
+   */
+  static const StaticWarningCode UNDEFINED_SUPER_SETTER = const StaticWarningCode(
+      'UNDEFINED_SUPER_SETTER',
+      "The setter '{0}' is not defined in a superclass of '{1}'");
 
   /**
    * 7.2 Getters: It is a static warning if the return type of a getter is void.
    */
   static const StaticWarningCode VOID_RETURN_FOR_GETTER =
       const StaticWarningCode(
           'VOID_RETURN_FOR_GETTER',
           "The return type of the getter must not be 'void'");
 
   /**
@@ skipping 41 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;
 }