Clean up references in comments

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 'java_core.dart';
 import 'source.dart';
 import 'scanner.dart' show Token;
 import 'ast.dart' show AstNode;
 import 'element.dart';
 
 /**
  * Instances of the class `AnalysisError` represent an error discovered during the analysis of
  * some Dart code.
  *
- * @see AnalysisErrorListener
+ * See [AnalysisErrorListener].
  */
 class AnalysisError {
   /**
    * An empty array of errors used when no errors are expected.
    */
   static List<AnalysisError> NO_ERRORS = new List<AnalysisError>(0);
 
   /**
    * A [Comparator] that sorts by the name of the file that the [AnalysisError] was
    * found.
@@ skipping 767 matching lines @@
   static const CompileTimeErrorCode CONST_EVAL_THROWS_IDBZE = const CompileTimeErrorCode('CONST_EVAL_THROWS_IDBZE', "Evaluation of this constant expression throws IntegerDivisionByZeroException");
 
   /**
    * 12.11.2 Const: If <i>T</i> is a parameterized type <i>S&lt;U<sub>1</sub>,
    * &hellip;, U<sub>m</sub>&gt;</i>, let <i>R = S</i>; It is a compile time
    * error if <i>S</i> is not a generic type with <i>m</i> type parameters.
    *
    * @param typeName the name of the type being referenced (<i>S</i>)
    * @param parameterCount the number of type parameters that were declared
    * @param argumentCount the number of type arguments provided
-   * @see CompileTimeErrorCode#NEW_WITH_INVALID_TYPE_PARAMETERS
-   * @see StaticTypeWarningCode#WRONG_NUMBER_OF_TYPE_ARGUMENTS
+   * See [CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS], and
+   * [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS].
    */
   static const CompileTimeErrorCode CONST_WITH_INVALID_TYPE_PARAMETERS = const CompileTimeErrorCode('CONST_WITH_INVALID_TYPE_PARAMETERS', "The type '{0}' is declared with {1} type parameters, but {2} type arguments were given");
 
   /**
    * 12.11.2 Const: If <i>e</i> is of the form <i>const T(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 compile-time error if the
    * type <i>T</i> does not declare a constant constructor with the same name as
    * the declaration of <i>T</i>.
    */
@@ skipping 94 matching lines @@
   /**
    * 7. Classes: It is a compile-time error if a class has an instance member
    * and a static member with the same name.
    *
    * This covers the additional duplicate definition cases where inheritance has
    * to be considered.
    *
    * @param className the name of the class that has conflicting instance/static
    *        members
    * @param name the name of the conflicting members
-   * @see [DUPLICATE_DEFINITION]
+   * See [DUPLICATE_DEFINITION].
    */
   static const CompileTimeErrorCode DUPLICATE_DEFINITION_INHERITANCE = const CompileTimeErrorCode('DUPLICATE_DEFINITION_INHERITANCE', "The name '{0}' is already defined in '{1}'");
 
   /**
    * 12.14.2 Binding Actuals to Formals: It is a compile-time error if
    * <i>q<sub>i</sub> = q<sub>j</sub></i> for any <i>i != j</i> [where
    * <i>q<sub>i</sub></i> is the label for a named argument].
    */
   static const CompileTimeErrorCode DUPLICATE_NAMED_ARGUMENT = const CompileTimeErrorCode('DUPLICATE_NAMED_ARGUMENT', "The argument for the named parameter '{0}' was already specified");
 
@@ skipping 41 matching lines @@
    * int and double to
    * attempt to extend or implement num.
    *
    * 12.4 Booleans: It is a compile-time error for a class to attempt to extend
    * or implement bool.
    *
    * 12.5 Strings: It is a compile-time error for a class to attempt to extend
    * or implement String.
    *
    * @param typeName the name of the type that cannot be extended
-   * @see [IMPLEMENTS_DISALLOWED_CLASS]
+   * See [IMPLEMENTS_DISALLOWED_CLASS].
    */
   static const CompileTimeErrorCode EXTENDS_DISALLOWED_CLASS = const CompileTimeErrorCode('EXTENDS_DISALLOWED_CLASS', "Classes cannot extend '{0}'");
 
   /**
    * 7.9 Superclasses: It is a compile-time error if the extends clause of a
    * class <i>C</i> includes a deferred type expression.
    *
    * @param typeName the name of the type that cannot be extended
-   * @see [IMPLEMENTS_DEFERRED_CLASS]
-   * @see [MIXIN_DEFERRED_CLASS]
+   * See [IMPLEMENTS_DEFERRED_CLASS], and [MIXIN_DEFERRED_CLASS].
    */
   static const CompileTimeErrorCode EXTENDS_DEFERRED_CLASS = const CompileTimeErrorCode('EXTENDS_DEFERRED_CLASS', "This class cannot extend the deferred class '{0}'");
 
   /**
    * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m &lt;
    * h</i> or if <i>m &gt; n</i>.
    *
    * 12.11.2 Const: It is a compile-time error if evaluation of a constant
    * object results in an uncaught exception being thrown.
    *
@@ skipping 57 matching lines @@
    * @param name the conflicting name of the getter and method
    */
   static const CompileTimeErrorCode GETTER_AND_METHOD_WITH_SAME_NAME = const CompileTimeErrorCode('GETTER_AND_METHOD_WITH_SAME_NAME', "'{0}' cannot be used to name a getter, there is already a method with the same name");
 
   /**
    * 7.10 Superinterfaces: It is a compile-time error if the implements clause
    * of a class <i>C</i> specifies a malformed type or deferred type as a
    * superinterface.
    *
    * @param typeName the name of the type that cannot be extended
-   * @see [EXTENDS_DEFERRED_CLASS]
-   * @see [MIXIN_DEFERRED_CLASS]
+   * See [EXTENDS_DEFERRED_CLASS], and [MIXIN_DEFERRED_CLASS].
    */
   static const CompileTimeErrorCode IMPLEMENTS_DEFERRED_CLASS = const CompileTimeErrorCode('IMPLEMENTS_DEFERRED_CLASS', "This class cannot implement the deferred class '{0}'");
 
   /**
    * 12.2 Null: It is a compile-time error for a class to attempt to extend or
    * implement Null.
    *
    * 12.3 Numbers: It is a compile-time error for a class to attempt to extend
    * or implement int.
    *
    * 12.3 Numbers: It is a compile-time error for a class to attempt to extend
    * or implement double.
    *
    * 12.3 Numbers: It is a compile-time error for any type other than the types
    * int and double to
    * attempt to extend or implement num.
    *
    * 12.4 Booleans: It is a compile-time error for a class to attempt to extend
    * or implement bool.
    *
    * 12.5 Strings: It is a compile-time error for a class to attempt to extend
    * or implement String.
    *
    * @param typeName the name of the type that cannot be implemented
-   * @see [EXTENDS_DISALLOWED_CLASS]
+   * See [EXTENDS_DISALLOWED_CLASS].
    */
   static const CompileTimeErrorCode IMPLEMENTS_DISALLOWED_CLASS = const CompileTimeErrorCode('IMPLEMENTS_DISALLOWED_CLASS', "Classes cannot implement '{0}'");
 
   /**
    * 7.10 Superinterfaces: It is a compile-time error if the implements clause
    * of a class includes type dynamic.
    */
   static const CompileTimeErrorCode IMPLEMENTS_DYNAMIC = const CompileTimeErrorCode('IMPLEMENTS_DYNAMIC', "Classes cannot implement 'dynamic'");
 
   /**
@@ skipping 46 matching lines @@
    *
    * @param uri the uri pointing to a library
    */
   static const CompileTimeErrorCode IMPORT_INTERNAL_LIBRARY = const CompileTimeErrorCode('IMPORT_INTERNAL_LIBRARY', "The library '{0}' is internal and cannot be imported");
 
   /**
    * 14.1 Imports: It is a compile-time error if the specified URI of an
    * immediate import does not refer to a library declaration.
    *
    * @param uri the uri pointing to a non-library declaration
-   * @see [StaticWarningCode.IMPORT_OF_NON_LIBRARY]
+   * See [StaticWarningCode.IMPORT_OF_NON_LIBRARY].
    */
   static const CompileTimeErrorCode IMPORT_OF_NON_LIBRARY = const CompileTimeErrorCode('IMPORT_OF_NON_LIBRARY', "The imported library '{0}' must not have a part-of directive");
 
   /**
    * 13.9 Switch: It is a compile-time error if values of the expressions
    * <i>e<sub>k</sub></i> are not instances of the same class <i>C</i>, for all
    * <i>1 &lt;= k &lt;= n</i>.
    *
    * @param expressionSource the expression source code that is the unexpected
    *        type
    * @param expectedType the name of the expected type
    */
   static const CompileTimeErrorCode INCONSISTENT_CASE_EXPRESSION_TYPES = const CompileTimeErrorCode('INCONSISTENT_CASE_EXPRESSION_TYPES', "Case expressions must have the same types, '{0}' is not a '{1}'");
 
   /**
    * 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. It
    * is a compile-time error if <i>k</i>'s initializer list contains an
    * initializer for a variable that is not an instance variable declared in the
    * immediately surrounding class.
    *
    * @param id the name of the initializing formal that is not an instance
    *        variable in the immediately enclosing class
-   * @see [INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]
+   * See [INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD].
    */
   static const CompileTimeErrorCode INITIALIZER_FOR_NON_EXISTENT_FIELD = const CompileTimeErrorCode('INITIALIZER_FOR_NON_EXISTENT_FIELD', "'{0}' is not a variable in the enclosing class");
 
   /**
    * 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. It
    * is a compile-time error if <i>k</i>'s initializer list contains an
    * initializer for a variable that is not an instance variable declared in the
    * immediately surrounding class.
    *
    * @param id the name of the initializing formal that is a static variable in
    *        the immediately enclosing class
-   * @see #INITIALIZING_FORMAL_FOR_STATIC_FIELD
+   * See [INITIALIZING_FORMAL_FOR_STATIC_FIELD].
    */
   static const CompileTimeErrorCode INITIALIZER_FOR_STATIC_FIELD = const CompileTimeErrorCode('INITIALIZER_FOR_STATIC_FIELD', "'{0}' is a static variable in the enclosing class, variables initialized in a constructor cannot be static");
 
   /**
    * 7.6.1 Generative Constructors: An initializing formal has the form
    * <i>this.id</i>. It is a compile-time error if <i>id</i> is not the name of
    * an instance variable of the immediately enclosing class.
    *
    * @param id the name of the initializing formal that is not an instance
    *        variable in the immediately enclosing class
-   * @see [INITIALIZING_FORMAL_FOR_STATIC_FIELD]
-   * @see [INITIALIZER_FOR_NON_EXISTENT_FIELD]
+   * See [INITIALIZING_FORMAL_FOR_STATIC_FIELD], and
+   * [INITIALIZER_FOR_NON_EXISTENT_FIELD].
    */
   static const CompileTimeErrorCode INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD = const CompileTimeErrorCode('INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD', "'{0}' is not a variable in the enclosing class");
 
   /**
    * 7.6.1 Generative Constructors: An initializing formal has the form
    * <i>this.id</i>. It is a compile-time error if <i>id</i> is not the name of
    * an instance variable of the immediately enclosing class.
    *
    * @param id the name of the initializing formal that is a static variable in
    *        the immediately enclosing class
-   * @see [INITIALIZER_FOR_STATIC_FIELD]
+   * See [INITIALIZER_FOR_STATIC_FIELD].
    */
   static const CompileTimeErrorCode INITIALIZING_FORMAL_FOR_STATIC_FIELD = const CompileTimeErrorCode('INITIALIZING_FORMAL_FOR_STATIC_FIELD', "'{0}' is a static field in the enclosing class, fields initialized in a constructor cannot be static");
 
   /**
    * 12.30 Identifier Reference: Otherwise, e is equivalent to the property
    * extraction <b>this</b>.<i>id</i>.
    */
   static const CompileTimeErrorCode INSTANCE_MEMBER_ACCESS_FROM_FACTORY = const CompileTimeErrorCode('INSTANCE_MEMBER_ACCESS_FROM_FACTORY', "Instance members cannot be accessed from a factory constructor");
 
   /**
@@ skipping 95 matching lines @@
    * 14.2 Exports: It is a compile-time error if the compilation unit found at
    * the specified URI is not a library declaration.
    *
    * 14.1 Imports: It is a compile-time error if the compilation unit found at
    * the specified URI is not a library declaration.
    *
    * 14.3 Parts: It is a compile time error if the contents of the URI are not a
    * valid part declaration.
    *
    * @param uri the URI that is invalid
-   * @see [URI_DOES_NOT_EXIST]
+   * See [URI_DOES_NOT_EXIST].
    */
   static const CompileTimeErrorCode INVALID_URI = const CompileTimeErrorCode('INVALID_URI', "Invalid URI syntax: '{0}'");
 
   /**
    * 13.13 Break: It is a compile-time error if no such statement
    * <i>s<sub>E</sub></i> exists within the innermost function in which
    * <i>s<sub>b</sub></i> occurs.
    *
    * 13.14 Continue: It is a compile-time error if no such statement or case
    * clause <i>s<sub>E</sub></i> exists within the innermost function in which
@@ skipping 59 matching lines @@
    *
    * @param typeName the name of the mixin that is invalid
    */
   static const CompileTimeErrorCode MIXIN_DECLARES_CONSTRUCTOR = const CompileTimeErrorCode('MIXIN_DECLARES_CONSTRUCTOR', "The class '{0}' cannot be used as a mixin because it declares a constructor");
 
   /**
    * 9.1 Mixin Application: It is a compile-time error if the with clause of a
    * mixin application <i>C</i> includes a deferred type expression.
    *
    * @param typeName the name of the type that cannot be extended
-   * @see #EXTENDS_DEFERRED_CLASS
-   * @see #IMPLEMENTS_DEFERRED_CLASS
+   * See [EXTENDS_DEFERRED_CLASS], and [IMPLEMENTS_DEFERRED_CLASS].
    */
   static const CompileTimeErrorCode MIXIN_DEFERRED_CLASS = const CompileTimeErrorCode('MIXIN_DEFERRED_CLASS', "This class cannot mixin the deferred class '{0}'");
 
   /**
    * 9 Mixins: It is a compile-time error if a mixin is derived from a class
    * whose superclass is not Object.
    *
    * @param typeName the name of the mixin that is invalid
    */
   static const CompileTimeErrorCode MIXIN_INHERITS_FROM_NOT_OBJECT = const CompileTimeErrorCode('MIXIN_INHERITS_FROM_NOT_OBJECT', "The class '{0}' cannot be used as a mixin because it extends a class other than Object");
@@ skipping 11 matching lines @@
    * 12.3 Numbers: It is a compile-time error for any type other than the types
    * int and double to attempt to extend or implement num.
    *
    * 12.4 Booleans: It is a compile-time error for a class to attempt to extend
    * or implement bool.
    *
    * 12.5 Strings: It is a compile-time error for a class to attempt to extend
    * or implement String.
    *
    * @param typeName the name of the type that cannot be extended
-   * @see [IMPLEMENTS_DISALLOWED_CLASS]
+   * See [IMPLEMENTS_DISALLOWED_CLASS].
    */
   static const CompileTimeErrorCode MIXIN_OF_DISALLOWED_CLASS = const CompileTimeErrorCode('MIXIN_OF_DISALLOWED_CLASS', "Classes cannot mixin '{0}'");
 
   /**
    * Enum proposal: It is a compile-time error to subclass, mix-in or implement
    * an enum.
    */
   static const CompileTimeErrorCode MIXIN_OF_ENUM = const CompileTimeErrorCode('MIXIN_OF_ENUM', "Classes cannot mixin an enum");
 
   /**
@@ skipping 154 matching lines @@
    */
   static const CompileTimeErrorCode NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY = const CompileTimeErrorCode('NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY', "Constant values from a deferred library cannot be used as values in a 'const' map");
 
   /**
    * 11 Metadata: Metadata consists of a series of annotations, each of which
    * begin with the character @, followed by a constant expression that must be
    * either a reference to a compile-time constant variable, or a call to a
    * constant constructor.
    *
    * "From deferred library" case is covered by
-   * [CompileTimeErrorCode#INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY].
+   * [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY].
    */
   static const CompileTimeErrorCode NON_CONSTANT_ANNOTATION_CONSTRUCTOR = const CompileTimeErrorCode('NON_CONSTANT_ANNOTATION_CONSTRUCTOR', "Annotation creation can use only 'const' constructor");
 
   /**
    * 7.6.3 Constant Constructors: Any expression that appears within the
    * initializer list of a constant constructor must be a potentially constant
    * expression, or a compile-time error occurs.
    */
   static const CompileTimeErrorCode NON_CONSTANT_VALUE_IN_INITIALIZER = const CompileTimeErrorCode('NON_CONSTANT_VALUE_IN_INITIALIZER', "Initializer expressions in constant constructors must be constants");
 
@@ skipping 238 matching lines @@
    * 12.11.1 New: If T is malformed a dynamic error occurs. In checked mode, if
    * T is mal-bounded a dynamic error occurs.
    *
    * 12.1 Constants: It is a compile-time error if evaluation of a compile-time
    * constant would raise an exception.
    *
    * @param boundedTypeName the name of the type used in the instance creation
    *        that should be limited by the bound as specified in the class
    *        declaration
    * @param boundingTypeName the name of the bounding type
-   * @see [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]
+   * See [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS].
    */
   static const CompileTimeErrorCode TYPE_ARGUMENT_NOT_MATCHING_BOUNDS = const CompileTimeErrorCode('TYPE_ARGUMENT_NOT_MATCHING_BOUNDS', "'{0}' does not extend '{1}'");
 
   /**
    * 15.3.1 Typedef: Any self reference, either directly, or recursively via
    * another typedef, is a compile time error.
    */
   static const CompileTimeErrorCode TYPE_ALIAS_CANNOT_REFERENCE_ITSELF = const CompileTimeErrorCode('TYPE_ALIAS_CANNOT_REFERENCE_ITSELF', "Type alias cannot reference itself directly or recursively via another typedef");
 
   /**
@@ skipping 37 matching lines @@
    * 14.2 Exports: It is a compile-time error if the compilation unit found at
    * the specified URI is not a library declaration.
    *
    * 14.1 Imports: It is a compile-time error if the compilation unit found at
    * the specified URI is not a library declaration.
    *
    * 14.3 Parts: It is a compile time error if the contents of the URI are not a
    * valid part declaration.
    *
    * @param uri the URI pointing to a non-existent file
-   * @see [INVALID_URI]
+   * See [INVALID_URI].
    */
   static const CompileTimeErrorCode URI_DOES_NOT_EXIST = const CompileTimeErrorCode('URI_DOES_NOT_EXIST', "Target of URI does not exist: '{0}'");
 
   /**
    * 14.1 Imports: It is a compile-time error if <i>x</i> is not a compile-time
    * constant, or if <i>x</i> involves string interpolation.
    *
    * 14.3 Parts: It is a compile-time error if <i>s</i> is not a compile-time
    * constant, or if <i>s</i> involves string interpolation.
    *
@@ skipping 531 matching lines @@
    */
   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");
 
   /**
    * 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]
+   * 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.
    *
    * @param returnType the name of the declared return type
@@ skipping 34 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]
-   * @see [StaticWarningCode.UNDEFINED_GETTER]
+   * 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}'");
 
   /**
    * 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]
+   * 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]
+   * See [StaticTypeWarningCode.UNDEFINED_OPERATOR].
    */
   static const HintCode UNDEFINED_OPERATOR = const HintCode('UNDEFINED_OPERATOR', "There is no such operator '{0}' in '{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]
-   * @see [StaticWarningCode.UNDEFINED_SETTER]
+   * 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}'");
 
   /**
    * Unnecessary cast.
    */
   static const HintCode UNNECESSARY_CAST = const HintCode('UNNECESSARY_CAST', "Unnecessary cast");
 
   /**
    * Unnecessary type checks, the result is always true.
@@ skipping 158 matching lines @@
    *
    * @param numTypeArgument the number of provided type arguments
    */
   static const StaticTypeWarningCode EXPECTED_TWO_MAP_TYPE_ARGUMENTS = const StaticTypeWarningCode('EXPECTED_TWO_MAP_TYPE_ARGUMENTS', "Map literal requires exactly two type arguments or none, but {0} found");
 
   /**
    * 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>.
    *
-   * @see [UNDEFINED_SETTER]
+   * See [UNDEFINED_SETTER].
    */
   static const StaticTypeWarningCode INACCESSIBLE_SETTER = const StaticTypeWarningCode('INACCESSIBLE_SETTER', "");
 
   /**
    * 8.1.1 Inheritance and Overriding: However, if the above rules would cause
    * multiple members <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></i> with the
    * same name <i>n</i> that would be inherited (because identically named
    * members existed in several superinterfaces) then at most one member is
    * inherited.
    *
@@ skipping 18 matching lines @@
    * * Otherwise none of the members <i>m<sub>1</sub>, &hellip;,
    *   m<sub>k</sub></i> is inherited.
    */
   static const StaticTypeWarningCode INCONSISTENT_METHOD_INHERITANCE = const StaticTypeWarningCode('INCONSISTENT_METHOD_INHERITANCE', "'{0}' is inherited by at least two interfaces inconsistently, from {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>.
    *
    * @param memberName the name of the static member
-   * @see [UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER]
+   * See [UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER].
    */
   static const StaticTypeWarningCode INSTANCE_ACCESS_TO_STATIC_MEMBER = const StaticTypeWarningCode('INSTANCE_ACCESS_TO_STATIC_MEMBER', "Static member '{0}' cannot be accessed using instance access");
 
   /**
    * 12.18 Assignment: It is a static type warning if the static type of
    * <i>e</i> may not be assigned to the static type of <i>v</i>. The static
    * type of the expression <i>v = e</i> is the static type of <i>e</i>.
    *
    * 12.18 Assignment: It is a static type warning if the static type of
    * <i>e</i> may not be assigned to the static type of <i>C.v</i>. The static
@@ skipping 119 matching lines @@
    * i &lt;= n</i>.
    *
    * 7.6.2 Factories: It is a static type warning if any of the type arguments
    * to <i>k'</i> are not subtypes of the bounds of the corresponding formal
    * type parameters of type.
    *
    * @param boundedTypeName the name of the type used in the instance creation
    *        that should be limited by the bound as specified in the class
    *        declaration
    * @param boundingTypeName the name of the bounding type
-   * @see [TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND]
+   * See [TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND].
    */
   static const StaticTypeWarningCode TYPE_ARGUMENT_NOT_MATCHING_BOUNDS = const StaticTypeWarningCode('TYPE_ARGUMENT_NOT_MATCHING_BOUNDS', "'{0}' does not extend '{1}'");
 
   /**
    * 10 Generics: It is a static type warning if a type parameter is a supertype
    * of its upper bound.
    *
    * @param typeParameterName the name of the type parameter
-   * @see [TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]
+   * See [TYPE_ARGUMENT_NOT_MATCHING_BOUNDS].
    */
   static const StaticTypeWarningCode TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND = const StaticTypeWarningCode('TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND', "'{0}' cannot be a supertype of its upper bound");
 
   /**
    * 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 constantName the name of the enumeration constant that is not
    *        defined
@@ skipping 58 matching lines @@
   static const StaticTypeWarningCode UNDEFINED_OPERATOR = const StaticTypeWarningCode('UNDEFINED_OPERATOR', "There is no such operator '{0}' in '{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]
+   * See [INACCESSIBLE_SETTER].
    */
   static const StaticTypeWarningCode UNDEFINED_SETTER = const StaticTypeWarningCode('UNDEFINED_SETTER', "There is no such setter '{0}' in '{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>.
    *
@@ skipping 13 matching lines @@
    */
   static const StaticTypeWarningCode UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER = const StaticTypeWarningCode('UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER', "Static members from supertypes must be qualified by the name of the defining type");
 
   /**
    * 15.8 Parameterized Types: It is a static type warning if <i>G</i> is not a
    * generic type with exactly <i>n</i> type parameters.
    *
    * @param typeName the name of the type being referenced (<i>G</i>)
    * @param parameterCount the number of type parameters that were declared
    * @param argumentCount the number of type arguments provided
-   * @see [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]
-   * @see [CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS]
+   * See [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS], and
+   * [CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS].
    */
   static const StaticTypeWarningCode WRONG_NUMBER_OF_TYPE_ARGUMENTS = const StaticTypeWarningCode('WRONG_NUMBER_OF_TYPE_ARGUMENTS', "The type '{0}' is declared with {1} type parameters, but {2} type arguments were given");
 
   /**
    * 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 StaticTypeWarningCode(String name, String message, [String correction]) : super(name, message, correction);
@@ skipping 214 matching lines @@
       = const StaticWarningCode(
           'EXPORT_DUPLICATED_LIBRARY_UNNAMED',
           "The exported libraries '{0}' and '{1}' cannot both be unnamed");
 
   /**
    * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m &lt;
    * h</i> or if <i>m &gt; n</i>.
    *
    * @param requiredCount the maximum number of positional arguments
    * @param argumentCount the actual number of positional arguments given
-   * @see [NOT_ENOUGH_REQUIRED_ARGUMENTS]
+   * See [NOT_ENOUGH_REQUIRED_ARGUMENTS].
    */
   static const StaticWarningCode EXTRA_POSITIONAL_ARGUMENTS = const StaticWarningCode('EXTRA_POSITIONAL_ARGUMENTS', "{0} positional arguments expected, but {1} found");
 
   /**
    * 5. Variables: It is a static warning if a final instance variable that has
    * been initialized at its point of declaration is also initialized in a
    * constructor.
    */
   static const StaticWarningCode FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION = const StaticWarningCode('FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION', "Values cannot be set in the constructor if they are final, and have already been set");
 
@@ skipping 80 matching lines @@
   static const StaticWarningCode IMPORT_DUPLICATED_LIBRARY_UNNAMED
       = const StaticWarningCode(
           'IMPORT_DUPLICATED_LIBRARY_UNNAMED',
           "The imported libraries '{0}' and '{1}' cannot both be unnamed");
 
   /**
    * 14.1 Imports: It is a static warning if the specified URI of a deferred
    * import does not refer to a library declaration.
    *
    * @param uri the uri pointing to a non-library declaration
-   * @see [CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]
+   * See [CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY].
    */
   static const StaticWarningCode IMPORT_OF_NON_LIBRARY = const StaticWarningCode('IMPORT_OF_NON_LIBRARY', "The imported library '{0}' must not have a part-of directive");
 
   /**
    * 8.1.1 Inheritance and Overriding: However, if the above rules would cause
    * multiple members <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></i> with the
    * same name <i>n</i> that would be inherited (because identically named
    * members existed in several superinterfaces) then at most one member is
    * inherited.
    *
@@ skipping 17 matching lines @@
   /**
    * 7.2 Getters: It is a static warning if a getter <i>m1</i> overrides a
    * getter <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of
    * <i>m2</i>.
    *
    * @param actualReturnTypeName the name of the expected return type
    * @param expectedReturnType the name of the actual return type, not
    *        assignable to the actualReturnTypeName
    * @param className the name of the class where the overridden getter is
    *        declared
-   * @see [INVALID_METHOD_OVERRIDE_RETURN_TYPE]
+   * See [INVALID_METHOD_OVERRIDE_RETURN_TYPE].
    */
   static const StaticWarningCode INVALID_GETTER_OVERRIDE_RETURN_TYPE = const StaticWarningCode('INVALID_GETTER_OVERRIDE_RETURN_TYPE', "The return type '{0}' is not assignable to '{1}' as required by the getter it is overriding from '{2}'");
 
   /**
    * 7.1 Instance Methods: It is a static warning if an instance method
    * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
    * is not a subtype of the type of <i>m2</i>.
    *
    * @param actualParamTypeName the name of the expected parameter type
    * @param expectedParamType the name of the actual parameter type, not
    *        assignable to the actualParamTypeName
    * @param className the name of the class where the overridden method is
    *        declared
    */
   static const StaticWarningCode INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE = const StaticWarningCode('INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE', "The parameter type '{0}' is not assignable to '{1}' as required by the method it is overriding from '{2}'");
 
   /**
    * 7.1 Instance Methods: It is a static warning if an instance method
    * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
    * is not a subtype of the type of <i>m2</i>.
    *
    * @param actualParamTypeName the name of the expected parameter type
    * @param expectedParamType the name of the actual parameter type, not
    *        assignable to the actualParamTypeName
    * @param className the name of the class where the overridden method is
    *        declared
-   * @see [INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE]
+   * See [INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE].
    */
   static const StaticWarningCode INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE = const StaticWarningCode('INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE', "The parameter type '{0}' is not assignable to '{1}' as required by the method it is overriding from '{2}'");
 
   /**
    * 7.1 Instance Methods: It is a static warning if an instance method
    * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
    * is not a subtype of the type of <i>m2</i>.
    *
    * @param actualParamTypeName the name of the expected parameter type
    * @param expectedParamType the name of the actual parameter type, not
    *        assignable to the actualParamTypeName
    * @param className the name of the class where the overridden method is
    *        declared
    */
   static const StaticWarningCode INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE = const StaticWarningCode('INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE', "The parameter type '{0}' is not assignable to '{1}' as required by the method it is overriding from '{2}'");
 
   /**
    * 7.1 Instance Methods: It is a static warning if an instance method
    * <i>m1</i> overrides an instance method <i>m2</i> and the type of <i>m1</i>
    * is not a subtype of the type of <i>m2</i>.
    *
    * @param actualReturnTypeName the name of the expected return type
    * @param expectedReturnType the name of the actual return type, not
    *        assignable to the actualReturnTypeName
    * @param className the name of the class where the overridden method is
    *        declared
-   * @see [INVALID_GETTER_OVERRIDE_RETURN_TYPE]
+   * See [INVALID_GETTER_OVERRIDE_RETURN_TYPE].
    */
   static const StaticWarningCode INVALID_METHOD_OVERRIDE_RETURN_TYPE = const StaticWarningCode('INVALID_METHOD_OVERRIDE_RETURN_TYPE', "The return type '{0}' is not assignable to '{1}' as required by the method it is overriding from '{2}'");
 
   /**
    * 7.1 Instance Methods: It is a static warning if an instance method
    * <i>m1</i> overrides an instance member <i>m2</i>, the signature of
    * <i>m2</i> explicitly specifies a default value for a formal parameter
    * <i>p</i> and the signature of <i>m1</i> specifies a different default value
    * for <i>p</i>.
    */
@@ skipping 43 matching lines @@
   /**
    * 7.3 Setters: It is a static warning if a setter <i>m1</i> overrides a
    * setter <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of
    * <i>m2</i>.
    *
    * @param actualParamTypeName the name of the expected parameter type
    * @param expectedParamType the name of the actual parameter type, not
    *        assignable to the actualParamTypeName
    * @param className the name of the class where the overridden setter is
    *        declared
-   * @see [INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE]
+   * See [INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE].
    */
   static const StaticWarningCode INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE = const StaticWarningCode('INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE', "The parameter type '{0}' is not assignable to '{1}' as required by the setter it is overriding from '{2}'");
 
   /**
    * 12.6 Lists: A run-time list literal &lt;<i>E</i>&gt; [<i>e<sub>1</sub></i>
    * &hellip; <i>e<sub>n</sub></i>] is evaluated as follows:
    * * The operator []= is invoked on <i>a</i> with first argument <i>i</i> and
    *   second argument <i>o<sub>i+1</sub></i><i>, 1 &lt;= i &lt;= n</i>
    *
    * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static
@@ skipping 66 matching lines @@
    */
   static const StaticWarningCode NEW_WITH_ABSTRACT_CLASS = const StaticWarningCode('NEW_WITH_ABSTRACT_CLASS', "Abstract classes cannot be created with a 'new' expression");
 
   /**
    * 15.8 Parameterized Types: Any use of a malbounded type gives rise to a
    * static warning.
    *
    * @param typeName the name of the type being referenced (<i>S</i>)
    * @param parameterCount the number of type parameters that were declared
    * @param argumentCount the number of type arguments provided
-   * @see [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]
-   * @see [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]
+   * See [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS], and
+   * [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS].
    */
   static const StaticWarningCode NEW_WITH_INVALID_TYPE_PARAMETERS = const StaticWarningCode('NEW_WITH_INVALID_TYPE_PARAMETERS', "The type '{0}' is declared with {1} type parameters, but {2} type arguments were given");
 
   /**
    * 12.11.1 New: It is a static warning if <i>T</i> is not a class accessible
    * in the current scope, optionally followed by type arguments.
    *
    * @param name the name of the non-type element
    */
   static const StaticWarningCode NEW_WITH_NON_TYPE = const StaticWarningCode('NEW_WITH_NON_TYPE', "The name '{0}' is not a class");
@@ skipping 166 matching lines @@
    * @param nonTypeName the name that is not a type
    */
   static const StaticWarningCode NOT_A_TYPE = const StaticWarningCode('NOT_A_TYPE', "{0} is not a type");
 
   /**
    * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m &lt;
    * h</i> or if <i>m &gt; n</i>.
    *
    * @param requiredCount the expected number of required arguments
    * @param argumentCount the actual number of positional arguments given
-   * @see [EXTRA_POSITIONAL_ARGUMENTS]
+   * See [EXTRA_POSITIONAL_ARGUMENTS].
    */
   static const StaticWarningCode NOT_ENOUGH_REQUIRED_ARGUMENTS = const StaticWarningCode('NOT_ENOUGH_REQUIRED_ARGUMENTS', "{0} required argument(s) expected, but {1} found");
 
   /**
    * 14.3 Parts: It is a static warning if the referenced part declaration
    * <i>p</i> names a library other than the current library as the library to
    * which <i>p</i> belongs.
    *
    * @param expectedLibraryName the name of expected library name
    * @param actualLibraryName the non-matching actual library name from the
@@ skipping 205 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;
 }