// 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.

// It is hard to visually separate each code's _doc comment_ from its published
// _documentation comment_ when each is written as an end-of-line comment.
// ignore_for_file: slash_for_doc_comments

/**
 * The errors produced during syntactic analysis (scanning and parsing).
 */
import 'package:analyzer/error/error.dart';

export 'package:_fe_analyzer_shared/src/scanner/errors.dart'
    show ScannerErrorCode;

part 'syntactic_errors.g.dart';

/**
 * The error codes used for errors detected by the parser. The convention for
 * this class is for the name of the error code to indicate the problem that
 * caused the error to be generated and for the error message to explain what
 * is wrong and, when appropriate, how the problem can be corrected.
 */
class ParserErrorCode extends ErrorCode {
  static const ParserErrorCode ABSTRACT_CLASS_MEMBER = _ABSTRACT_CLASS_MEMBER;

  static const ParserErrorCode ABSTRACT_ENUM = ParserErrorCode(
      'ABSTRACT_ENUM', "Enums can't be declared to be 'abstract'.",
      correction: "Try removing the keyword 'abstract'.");

  static const ParserErrorCode ABSTRACT_EXTERNAL_FIELD =
      _ABSTRACT_EXTERNAL_FIELD;

  static const ParserErrorCode ABSTRACT_LATE_FIELD = _ABSTRACT_LATE_FIELD;

  static const ParserErrorCode ABSTRACT_STATIC_FIELD = _ABSTRACT_STATIC_FIELD;

  static const ParserErrorCode ABSTRACT_STATIC_METHOD = ParserErrorCode(
      'ABSTRACT_STATIC_METHOD',
      "Static methods can't be declared to be 'abstract'.",
      correction: "Try removing the keyword 'abstract'.");

  static const ParserErrorCode ABSTRACT_TOP_LEVEL_FUNCTION = ParserErrorCode(
      'ABSTRACT_TOP_LEVEL_FUNCTION',
      "Top-level functions can't be declared to be 'abstract'.",
      correction: "Try removing the keyword 'abstract'.");

  static const ParserErrorCode ABSTRACT_TOP_LEVEL_VARIABLE = ParserErrorCode(
      'ABSTRACT_TOP_LEVEL_VARIABLE',
      "Top-level variables can't be declared to be 'abstract'.",
      correction: "Try removing the keyword 'abstract'.");

  static const ParserErrorCode ABSTRACT_TYPEDEF = ParserErrorCode(
      'ABSTRACT_TYPEDEF', "Typedefs can't be declared to be 'abstract'.",
      correction: "Try removing the keyword 'abstract'.");

  static const ParserErrorCode ANNOTATION_WITH_TYPE_ARGUMENTS =
      _ANNOTATION_WITH_TYPE_ARGUMENTS;

  /**
   * 16.32 Identifier Reference: It is a compile-time error if any of the
   * identifiers async, await, or yield is used as an identifier in a function
   * body marked with either async, async*, or sync*.
   */
  static const ParserErrorCode ASYNC_KEYWORD_USED_AS_IDENTIFIER =
      ParserErrorCode(
          'ASYNC_KEYWORD_USED_AS_IDENTIFIER',
          "The keywords 'await' and 'yield' can't be used as "
              "identifiers in an asynchronous or generator function.");

  static const ParserErrorCode BREAK_OUTSIDE_OF_LOOP = _BREAK_OUTSIDE_OF_LOOP;

  static const ParserErrorCode CATCH_SYNTAX = _CATCH_SYNTAX;

  static const ParserErrorCode CATCH_SYNTAX_EXTRA_PARAMETERS =
      _CATCH_SYNTAX_EXTRA_PARAMETERS;

  static const ParserErrorCode CLASS_IN_CLASS = _CLASS_IN_CLASS;

  static const ParserErrorCode COLON_IN_PLACE_OF_IN = _COLON_IN_PLACE_OF_IN;

  static const ParserErrorCode CONFLICTING_MODIFIERS = _CONFLICTING_MODIFIERS;

  static const ParserErrorCode CONST_AND_FINAL = _CONST_AND_FINAL;

  static const ParserErrorCode CONST_CLASS = _CONST_CLASS;

  static const ParserErrorCode CONST_CONSTRUCTOR_WITH_BODY = ParserErrorCode(
      'CONST_CONSTRUCTOR_WITH_BODY', "Const constructors can't have a body.",
      correction: "Try removing either the 'const' keyword or the body.");

  static const ParserErrorCode CONST_ENUM = ParserErrorCode(
      'CONST_ENUM', "Enums can't be declared to be 'const'.",
      correction: "Try removing the 'const' keyword.");

  static const ParserErrorCode CONST_FACTORY = _CONST_FACTORY;

  static const ParserErrorCode CONST_METHOD = _CONST_METHOD;

  static const ParserErrorCode CONST_TYPEDEF = ParserErrorCode(
      'CONST_TYPEDEF', "Type aliases can't be declared to be 'const'.",
      correction: "Try removing the 'const' keyword.");

  static const ParserErrorCode CONSTRUCTOR_WITH_RETURN_TYPE =
      _CONSTRUCTOR_WITH_RETURN_TYPE;

  static const ParserErrorCode CONTINUE_OUTSIDE_OF_LOOP =
      _CONTINUE_OUTSIDE_OF_LOOP;

  static const ParserErrorCode CONTINUE_WITHOUT_LABEL_IN_CASE =
      _CONTINUE_WITHOUT_LABEL_IN_CASE;

  static const ParserErrorCode COVARIANT_AND_STATIC = _COVARIANT_AND_STATIC;

  static const ParserErrorCode COVARIANT_CONSTRUCTOR = ParserErrorCode(
      'COVARIANT_CONSTRUCTOR',
      "A constructor can't be declared to be 'covariant'.",
      correction: "Try removing the keyword 'covariant'.");

  static const ParserErrorCode COVARIANT_MEMBER = _COVARIANT_MEMBER;

  static const ParserErrorCode COVARIANT_TOP_LEVEL_DECLARATION =
      ParserErrorCode('COVARIANT_TOP_LEVEL_DECLARATION',
          "Top-level declarations can't be declared to be covariant.",
          correction: "Try removing the keyword 'covariant'.");

  static const ParserErrorCode DEFAULT_VALUE_IN_FUNCTION_TYPE = ParserErrorCode(
      'DEFAULT_VALUE_IN_FUNCTION_TYPE',
      "Parameters in a function type cannot have default values",
      correction: "Try removing the default value.");

  static const ParserErrorCode DEFERRED_AFTER_PREFIX = _DEFERRED_AFTER_PREFIX;

  static const ParserErrorCode DIRECTIVE_AFTER_DECLARATION =
      _DIRECTIVE_AFTER_DECLARATION;

  static const ParserErrorCode DUPLICATE_DEFERRED = _DUPLICATE_DEFERRED;

  /**
   * Parameters:
   * 0: the label that was duplicated
   */
  static const ParserErrorCode DUPLICATE_LABEL_IN_SWITCH_STATEMENT =
      _DUPLICATE_LABEL_IN_SWITCH_STATEMENT;

  static const ParserErrorCode DUPLICATE_PREFIX = _DUPLICATE_PREFIX;

  /**
   * Parameters:
   * 0: the modifier that was duplicated
   */
  static const ParserErrorCode DUPLICATED_MODIFIER = _DUPLICATED_MODIFIER;

  static const ParserErrorCode EMPTY_ENUM_BODY = ParserErrorCode(
      'EMPTY_ENUM_BODY', "An enum must declare at least one constant name.",
      correction: "Try declaring a constant.");

  static const ParserErrorCode ENUM_IN_CLASS = _ENUM_IN_CLASS;

  static const ParserErrorCode EQUALITY_CANNOT_BE_EQUALITY_OPERAND =
      _EQUALITY_CANNOT_BE_EQUALITY_OPERAND;

  static const ParserErrorCode EXPECTED_BODY = _EXPECTED_BODY;

  static const ParserErrorCode EXPECTED_CASE_OR_DEFAULT = ParserErrorCode(
      'EXPECTED_CASE_OR_DEFAULT', "Expected 'case' or 'default'.",
      correction: "Try placing this code inside a case clause.");

  static const ParserErrorCode EXPECTED_CLASS_MEMBER = ParserErrorCode(
      'EXPECTED_CLASS_MEMBER', "Expected a class member.",
      correction: "Try placing this code inside a class member.");

  static const ParserErrorCode EXPECTED_ELSE_OR_COMMA = _EXPECTED_ELSE_OR_COMMA;

  static const ParserErrorCode EXPECTED_EXECUTABLE = ParserErrorCode(
      'EXPECTED_EXECUTABLE',
      "Expected a method, getter, setter or operator declaration.",
      correction:
          "This appears to be incomplete code. Try removing it or completing it.");

  static const ParserErrorCode EXPECTED_INSTEAD = _EXPECTED_INSTEAD;

  static const ParserErrorCode EXPECTED_LIST_OR_MAP_LITERAL = ParserErrorCode(
      'EXPECTED_LIST_OR_MAP_LITERAL', "Expected a list or map literal.",
      correction:
          "Try inserting a list or map literal, or remove the type arguments.");

  static const ParserErrorCode EXPECTED_STRING_LITERAL =
      ParserErrorCode('EXPECTED_STRING_LITERAL', "Expected a string literal.");

  /**
   * Parameters:
   * 0: the token that was expected but not found
   */
  static const ParserErrorCode EXPECTED_TOKEN =
      ParserErrorCode('EXPECTED_TOKEN', "Expected to find '{0}'.");

  static const ParserErrorCode EXPECTED_TYPE_NAME =
      ParserErrorCode('EXPECTED_TYPE_NAME', "Expected a type name.");

  static const ParserErrorCode EXPERIMENT_NOT_ENABLED = _EXPERIMENT_NOT_ENABLED;

  static const ParserErrorCode EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE =
      _EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE;

  /**
   * No parameters.
   */
  // #### Description
  //
  // The analyzer produces this diagnostic when an abstract declaration is
  // declared in an extension. Extensions can declare only concrete members.
  //
  // #### Examples
  //
  // The following code produces this diagnostic because the method `a` doesn't
  // have a body:
  //
  // ```dart
  // extension E on String {
  //   int [!a!]();
  // }
  // ```
  //
  // #### Common fixes
  //
  // Either provide an implementation for the member or remove it.
  static const ParserErrorCode EXTENSION_DECLARES_ABSTRACT_MEMBER =
      _EXTENSION_DECLARES_ABSTRACT_MEMBER;

  /**
   * No parameters.
   */
  // #### Description
  //
  // The analyzer produces this diagnostic when a constructor declaration is
  // found in an extension. It isn't valid to define a constructor because
  // extensions aren't classes, and it isn't possible to create an instance of
  // an extension.
  //
  // #### Examples
  //
  // The following code produces this diagnostic because there is a constructor
  // declaration in `E`:
  //
  // ```dart
  // extension E on String {
  //   [!E!]() : super();
  // }
  // ```
  //
  // #### Common fixes
  //
  // Remove the constructor or replace it with a static method.
  static const ParserErrorCode EXTENSION_DECLARES_CONSTRUCTOR =
      _EXTENSION_DECLARES_CONSTRUCTOR;

  /**
   * No parameters.
   */
  // #### Description
  //
  // The analyzer produces this diagnostic when an instance field declaration is
  // found in an extension. It isn't valid to define an instance field because
  // extensions can only add behavior, not state.
  //
  // #### Examples
  //
  // The following code produces this diagnostic because `s` is an instance
  // field:
  //
  // ```dart
  // extension E on String {
  //   String [!s!];
  // }
  // ```
  //
  // #### Common fixes
  //
  // Remove the field, make it a static field, or convert it to be a getter,
  // setter, or method.
  static const ParserErrorCode EXTENSION_DECLARES_INSTANCE_FIELD =
      _EXTENSION_DECLARES_INSTANCE_FIELD;

  static const ParserErrorCode EXTERNAL_CLASS = _EXTERNAL_CLASS;

  static const ParserErrorCode EXTERNAL_CONSTRUCTOR_WITH_BODY =
      _EXTERNAL_CONSTRUCTOR_WITH_BODY;

  static const ParserErrorCode EXTERNAL_CONSTRUCTOR_WITH_INITIALIZER =
      _EXTERNAL_CONSTRUCTOR_WITH_INITIALIZER;

  static const ParserErrorCode EXTERNAL_ENUM = _EXTERNAL_ENUM;

  static const ParserErrorCode EXTERNAL_FACTORY_REDIRECTION =
      _EXTERNAL_FACTORY_REDIRECTION;

  static const ParserErrorCode EXTERNAL_FACTORY_WITH_BODY =
      _EXTERNAL_FACTORY_WITH_BODY;

  static const ParserErrorCode EXTERNAL_FIELD = _EXTERNAL_FIELD;

  static const ParserErrorCode EXTERNAL_GETTER_WITH_BODY = ParserErrorCode(
      'EXTERNAL_GETTER_WITH_BODY', "External getters can't have a body.",
      correction: "Try removing the body of the getter, or "
          "removing the keyword 'external'.");

  static const ParserErrorCode EXTERNAL_LATE_FIELD = _EXTERNAL_LATE_FIELD;

  static const ParserErrorCode EXTERNAL_METHOD_WITH_BODY =
      _EXTERNAL_METHOD_WITH_BODY;

  static const ParserErrorCode EXTERNAL_OPERATOR_WITH_BODY = ParserErrorCode(
      'EXTERNAL_OPERATOR_WITH_BODY', "External operators can't have a body.",
      correction: "Try removing the body of the operator, or "
          "removing the keyword 'external'.");

  static const ParserErrorCode EXTERNAL_SETTER_WITH_BODY = ParserErrorCode(
      'EXTERNAL_SETTER_WITH_BODY', "External setters can't have a body.",
      correction: "Try removing the body of the setter, or "
          "removing the keyword 'external'.");

  static const ParserErrorCode EXTERNAL_TYPEDEF = _EXTERNAL_TYPEDEF;

  static const ParserErrorCode EXTRANEOUS_MODIFIER = _EXTRANEOUS_MODIFIER;

  static const ParserErrorCode FACTORY_TOP_LEVEL_DECLARATION =
      _FACTORY_TOP_LEVEL_DECLARATION;

  static const ParserErrorCode FACTORY_WITH_INITIALIZERS = ParserErrorCode(
      'FACTORY_WITH_INITIALIZERS',
      "A 'factory' constructor can't have initializers.",
      correction:
          "Try removing the 'factory' keyword to make this a generative constructor, or "
          "removing the initializers.");

  static const ParserErrorCode FACTORY_WITHOUT_BODY = ParserErrorCode(
      'FACTORY_WITHOUT_BODY',
      "A non-redirecting 'factory' constructor must have a body.",
      correction: "Try adding a body to the constructor.");

  static const ParserErrorCode FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS =
      _FIELD_INITIALIZED_OUTSIDE_DECLARING_CLASS;

  static const ParserErrorCode FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR =
      _FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR;

  static const ParserErrorCode FINAL_AND_COVARIANT = _FINAL_AND_COVARIANT;

  static const ParserErrorCode FINAL_AND_COVARIANT_LATE_WITH_INITIALIZER =
      _FINAL_AND_COVARIANT_LATE_WITH_INITIALIZER;

  static const ParserErrorCode FINAL_AND_VAR = _FINAL_AND_VAR;

  static const ParserErrorCode FINAL_CLASS = ParserErrorCode(
      'FINAL_CLASS', "Classes can't be declared to be 'final'.",
      correction: "Try removing the keyword 'final'.");

  static const ParserErrorCode FINAL_CONSTRUCTOR = ParserErrorCode(
      'FINAL_CONSTRUCTOR', "A constructor can't be declared to be 'final'.",
      correction: "Try removing the keyword 'final'.");

  static const ParserErrorCode FINAL_ENUM = ParserErrorCode(
      'FINAL_ENUM', "Enums can't be declared to be 'final'.",
      correction: "Try removing the keyword 'final'.");

  static const ParserErrorCode FINAL_METHOD = ParserErrorCode('FINAL_METHOD',
      "Getters, setters and methods can't be declared to be 'final'.",
      correction: "Try removing the keyword 'final'.");

  static const ParserErrorCode FINAL_TYPEDEF = ParserErrorCode(
      'FINAL_TYPEDEF', "Typedefs can't be declared to be 'final'.",
      correction: "Try removing the keyword 'final'.");

  static const ParserErrorCode FUNCTION_TYPED_PARAMETER_VAR = ParserErrorCode(
      'FUNCTION_TYPED_PARAMETER_VAR',
      "Function-typed parameters can't specify 'const', 'final' or 'var' in place of a return type.",
      correction: "Try replacing the keyword with a return type.");

  static const ParserErrorCode GETTER_CONSTRUCTOR = _GETTER_CONSTRUCTOR;

  static const ParserErrorCode GETTER_IN_FUNCTION = ParserErrorCode(
      'GETTER_IN_FUNCTION',
      "Getters can't be defined within methods or functions.",
      correction: "Try moving the getter outside the method or function, or "
          "converting the getter to a function.");

  static const ParserErrorCode GETTER_WITH_PARAMETERS = ParserErrorCode(
      'GETTER_WITH_PARAMETERS',
      "Getters must be declared without a parameter list.",
      correction: "Try removing the parameter list, or "
          "removing the keyword 'get' to define a method rather than a getter.");

  static const ParserErrorCode ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE =
      _ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE;

  static const ParserErrorCode IMPLEMENTS_BEFORE_EXTENDS =
      _IMPLEMENTS_BEFORE_EXTENDS;

  static const ParserErrorCode IMPLEMENTS_BEFORE_ON = _IMPLEMENTS_BEFORE_ON;

  static const ParserErrorCode IMPLEMENTS_BEFORE_WITH = _IMPLEMENTS_BEFORE_WITH;

  static const ParserErrorCode IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE =
      _IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE;

  static const ParserErrorCode INITIALIZED_VARIABLE_IN_FOR_EACH =
      _INITIALIZED_VARIABLE_IN_FOR_EACH;

  static const ParserErrorCode INVALID_AWAIT_IN_FOR = _INVALID_AWAIT_IN_FOR;

  /**
   * Parameters:
   * 0: the invalid escape sequence
   */
  static const ParserErrorCode INVALID_CODE_POINT = ParserErrorCode(
      'INVALID_CODE_POINT',
      "The escape sequence '{0}' isn't a valid code point.");

  static const ParserErrorCode INVALID_COMMENT_REFERENCE = ParserErrorCode(
      'INVALID_COMMENT_REFERENCE',
      "Comment references should contain a possibly prefixed identifier and "
          "can start with 'new', but shouldn't contain anything else.");

  static const ParserErrorCode INVALID_CONSTRUCTOR_NAME =
      _INVALID_CONSTRUCTOR_NAME;

  static const ParserErrorCode INVALID_GENERIC_FUNCTION_TYPE = ParserErrorCode(
      'INVALID_GENERIC_FUNCTION_TYPE', "Invalid generic function type.",
      correction:
          "Try using a generic function type (returnType 'Function(' parameters ')').");

  static const ParserErrorCode INVALID_HEX_ESCAPE = _INVALID_HEX_ESCAPE;

  static const ParserErrorCode INVALID_INITIALIZER = _INVALID_INITIALIZER;

  static const ParserErrorCode INVALID_LITERAL_IN_CONFIGURATION =
      ParserErrorCode('INVALID_LITERAL_IN_CONFIGURATION',
          "The literal in a configuration can't contain interpolation.",
          correction: "Try removing the interpolation expressions.");

  /**
   * Parameters:
   * 0: the operator that is invalid
   */
  static const ParserErrorCode INVALID_OPERATOR = _INVALID_OPERATOR;

  /**
   * Parameters:
   * 0: the operator being applied to 'super'
   *
   * Only generated by the old parser.
   * Replaced by INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER.
   */
  static const ParserErrorCode INVALID_OPERATOR_FOR_SUPER = ParserErrorCode(
      'INVALID_OPERATOR_FOR_SUPER',
      "The operator '{0}' can't be used with 'super'.");

  static const ParserErrorCode INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER =
      _INVALID_OPERATOR_QUESTIONMARK_PERIOD_FOR_SUPER;

  static const ParserErrorCode INVALID_STAR_AFTER_ASYNC = ParserErrorCode(
      'INVALID_STAR_AFTER_ASYNC',
      "The modifier 'async*' isn't allowed for an expression function body.",
      correction: "Try converting the body to a block.");

  static const ParserErrorCode INVALID_SUPER_IN_INITIALIZER =
      _INVALID_SUPER_IN_INITIALIZER;

  static const ParserErrorCode INVALID_SYNC = ParserErrorCode('INVALID_SYNC',
      "The modifier 'sync' isn't allowed for an expression function body.",
      correction: "Try converting the body to a block.");

  static const ParserErrorCode INVALID_THIS_IN_INITIALIZER =
      _INVALID_THIS_IN_INITIALIZER;

  static const ParserErrorCode INVALID_UNICODE_ESCAPE = _INVALID_UNICODE_ESCAPE;

  /**
   * No parameters.
   */
  // #### Description
  //
  // The analyzer produces this diagnostic when a member declared inside an
  // extension uses the keyword `covariant` in the declaration of a parameter.
  // Extensions aren't classes and don't have subclasses, so the keyword serves
  // no purpose.
  //
  // #### Examples
  //
  // The following code produces this diagnostic because `i` is marked as being
  // covariant:
  //
  // ```dart
  // extension E on String {
  //   void a([!covariant!] int i) {}
  // }
  // ```
  //
  // #### Common fixes
  //
  // Remove the 'covariant' keyword:
  //
  // ```dart
  // extension E on String {
  //   void a(int i) {}
  // }
  // ```
  static const ParserErrorCode INVALID_USE_OF_COVARIANT_IN_EXTENSION =
      _INVALID_USE_OF_COVARIANT_IN_EXTENSION;

  static const ParserErrorCode LIBRARY_DIRECTIVE_NOT_FIRST =
      _LIBRARY_DIRECTIVE_NOT_FIRST;

  static const ParserErrorCode LOCAL_FUNCTION_DECLARATION_MODIFIER =
      ParserErrorCode('LOCAL_FUNCTION_DECLARATION_MODIFIER',
          "Local function declarations can't specify any modifiers.",
          correction: "Try removing the modifier.");

  static const ParserErrorCode MEMBER_WITH_CLASS_NAME = _MEMBER_WITH_CLASS_NAME;

  static const ParserErrorCode MISSING_ASSIGNABLE_SELECTOR =
      _MISSING_ASSIGNABLE_SELECTOR;

  static const ParserErrorCode MISSING_ASSIGNMENT_IN_INITIALIZER =
      _MISSING_ASSIGNMENT_IN_INITIALIZER;

  static const ParserErrorCode MISSING_CATCH_OR_FINALLY =
      _MISSING_CATCH_OR_FINALLY;

  static const ParserErrorCode MISSING_CLOSING_PARENTHESIS = ParserErrorCode(
      'MISSING_CLOSING_PARENTHESIS', "The closing parenthesis is missing.",
      correction: "Try adding the closing parenthesis.");

  static const ParserErrorCode MISSING_CONST_FINAL_VAR_OR_TYPE =
      _MISSING_CONST_FINAL_VAR_OR_TYPE;

  static const ParserErrorCode MISSING_ENUM_BODY = ParserErrorCode(
      'MISSING_ENUM_BODY',
      "An enum definition must have a body with at least one constant name.",
      correction: "Try adding a body and defining at least one constant.");

  static const ParserErrorCode MISSING_EXPRESSION_IN_INITIALIZER =
      ParserErrorCode('MISSING_EXPRESSION_IN_INITIALIZER',
          "Expected an expression after the assignment operator.",
          correction: "Try adding the value to be assigned, or "
              "remove the assignment operator.");

  static const ParserErrorCode MISSING_EXPRESSION_IN_THROW =
      _MISSING_EXPRESSION_IN_THROW;

  static const ParserErrorCode MISSING_FUNCTION_BODY = ParserErrorCode(
      'MISSING_FUNCTION_BODY', "A function body must be provided.",
      correction: "Try adding a function body.");

  static const ParserErrorCode MISSING_FUNCTION_KEYWORD = ParserErrorCode(
      'MISSING_FUNCTION_KEYWORD',
      "Function types must have the keyword 'Function' before the parameter list.",
      correction: "Try adding the keyword 'Function'.");

  static const ParserErrorCode MISSING_FUNCTION_PARAMETERS = ParserErrorCode(
      'MISSING_FUNCTION_PARAMETERS',
      "Functions must have an explicit list of parameters.",
      correction: "Try adding a parameter list.");

  static const ParserErrorCode MISSING_GET = ParserErrorCode('MISSING_GET',
      "Getters must have the keyword 'get' before the getter name.",
      correction: "Try adding the keyword 'get'.");

  static const ParserErrorCode MISSING_IDENTIFIER =
      ParserErrorCode('MISSING_IDENTIFIER', "Expected an identifier.");

  static const ParserErrorCode MISSING_INITIALIZER = _MISSING_INITIALIZER;

  static const ParserErrorCode MISSING_KEYWORD_OPERATOR =
      _MISSING_KEYWORD_OPERATOR;

  static const ParserErrorCode MISSING_METHOD_PARAMETERS = ParserErrorCode(
      'MISSING_METHOD_PARAMETERS',
      "Methods must have an explicit list of parameters.",
      correction: "Try adding a parameter list.");

  static const ParserErrorCode MISSING_NAME_FOR_NAMED_PARAMETER = ParserErrorCode(
      'MISSING_NAME_FOR_NAMED_PARAMETER',
      "Named parameters in a function type must have a name",
      correction:
          "Try providing a name for the parameter or removing the curly braces.");

  static const ParserErrorCode MISSING_NAME_IN_LIBRARY_DIRECTIVE = ParserErrorCode(
      'MISSING_NAME_IN_LIBRARY_DIRECTIVE',
      "Library directives must include a library name.",
      correction: "Try adding a library name after the keyword 'library', or "
          "remove the library directive if the library doesn't have any parts.");

  static const ParserErrorCode MISSING_NAME_IN_PART_OF_DIRECTIVE =
      ParserErrorCode('MISSING_NAME_IN_PART_OF_DIRECTIVE',
          "Part-of directives must include a library name.",
          correction: "Try adding a library name after the 'of'.");

  static const ParserErrorCode MISSING_PREFIX_IN_DEFERRED_IMPORT =
      _MISSING_PREFIX_IN_DEFERRED_IMPORT;

  static const ParserErrorCode MISSING_STAR_AFTER_SYNC = ParserErrorCode(
      'MISSING_STAR_AFTER_SYNC',
      "The modifier 'sync' must be followed by a star ('*').",
      correction: "Try removing the modifier, or add a star.");

  static const ParserErrorCode MISSING_STATEMENT = _MISSING_STATEMENT;

  /**
   * Parameters:
   * 0: the terminator that is missing
   */
  static const ParserErrorCode MISSING_TERMINATOR_FOR_PARAMETER_GROUP =
      ParserErrorCode('MISSING_TERMINATOR_FOR_PARAMETER_GROUP',
          "There is no '{0}' to close the parameter group.",
          correction: "Try inserting a '{0}' at the end of the group.");

  static const ParserErrorCode MISSING_TYPEDEF_PARAMETERS = ParserErrorCode(
      'MISSING_TYPEDEF_PARAMETERS',
      "Typedefs must have an explicit list of parameters.",
      correction: "Try adding a parameter list.");

  static const ParserErrorCode MISSING_VARIABLE_IN_FOR_EACH = ParserErrorCode(
      'MISSING_VARIABLE_IN_FOR_EACH',
      "A loop variable must be declared in a for-each loop before the 'in', but none was found.",
      correction: "Try declaring a loop variable.");

  static const ParserErrorCode MIXED_PARAMETER_GROUPS = ParserErrorCode(
      'MIXED_PARAMETER_GROUPS',
      "Can't have both positional and named parameters in a single parameter list.",
      correction: "Try choosing a single style of optional parameters.");

  static const ParserErrorCode MIXIN_DECLARES_CONSTRUCTOR =
      _MIXIN_DECLARES_CONSTRUCTOR;

  static const ParserErrorCode MODIFIER_OUT_OF_ORDER = _MODIFIER_OUT_OF_ORDER;

  static const ParserErrorCode MULTIPLE_EXTENDS_CLAUSES =
      _MULTIPLE_EXTENDS_CLAUSES;

  static const ParserErrorCode MULTIPLE_IMPLEMENTS_CLAUSES = ParserErrorCode(
      'MULTIPLE_IMPLEMENTS_CLAUSES',
      "Each class or mixin definition can have at most one implements clause.",
      correction:
          "Try combining all of the implements clauses into a single clause.");

  static const ParserErrorCode MULTIPLE_LIBRARY_DIRECTIVES =
      _MULTIPLE_LIBRARY_DIRECTIVES;

  static const ParserErrorCode MULTIPLE_NAMED_PARAMETER_GROUPS = ParserErrorCode(
      'MULTIPLE_NAMED_PARAMETER_GROUPS',
      "Can't have multiple groups of named parameters in a single parameter list.",
      correction: "Try combining all of the groups into a single group.");

  static const ParserErrorCode MULTIPLE_ON_CLAUSES = _MULTIPLE_ON_CLAUSES;

  static const ParserErrorCode MULTIPLE_PART_OF_DIRECTIVES =
      _MULTIPLE_PART_OF_DIRECTIVES;

  static const ParserErrorCode MULTIPLE_POSITIONAL_PARAMETER_GROUPS =
      ParserErrorCode('MULTIPLE_POSITIONAL_PARAMETER_GROUPS',
          "Can't have multiple groups of positional parameters in a single parameter list.",
          correction: "Try combining all of the groups into a single group.");

  /**
   * Parameters:
   * 0: the number of variables being declared
   */
  static const ParserErrorCode MULTIPLE_VARIABLES_IN_FOR_EACH = ParserErrorCode(
      'MULTIPLE_VARIABLES_IN_FOR_EACH',
      "A single loop variable must be declared in a for-each loop before "
          "the 'in', but {0} were found.",
      correction:
          "Try moving all but one of the declarations inside the loop body.");

  static const ParserErrorCode MULTIPLE_VARIANCE_MODIFIERS =
      _MULTIPLE_VARIANCE_MODIFIERS;

  static const ParserErrorCode MULTIPLE_WITH_CLAUSES = _MULTIPLE_WITH_CLAUSES;

  static const ParserErrorCode NAMED_FUNCTION_EXPRESSION = ParserErrorCode(
      'NAMED_FUNCTION_EXPRESSION', "Function expressions can't be named.",
      correction: "Try removing the name, or "
          "moving the function expression to a function declaration statement.");

  static const ParserErrorCode NAMED_FUNCTION_TYPE = ParserErrorCode(
      'NAMED_FUNCTION_TYPE', "Function types can't be named.",
      correction: "Try replacing the name with the keyword 'Function'.");

  static const ParserErrorCode NAMED_PARAMETER_OUTSIDE_GROUP = ParserErrorCode(
      'NAMED_PARAMETER_OUTSIDE_GROUP',
      "Named parameters must be enclosed in curly braces ('{' and '}').",
      correction: "Try surrounding the named parameters in curly braces.");

  static const ParserErrorCode NATIVE_CLAUSE_IN_NON_SDK_CODE = ParserErrorCode(
      'NATIVE_CLAUSE_IN_NON_SDK_CODE',
      "Native clause can only be used in the SDK and code that is loaded "
          "through native extensions.",
      correction: "Try removing the native clause.");

  static const ParserErrorCode NATIVE_CLAUSE_SHOULD_BE_ANNOTATION =
      _NATIVE_CLAUSE_SHOULD_BE_ANNOTATION;

  static const ParserErrorCode NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE =
      ParserErrorCode(
          'NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE',
          "Native functions can only be declared in the SDK and code that is "
              "loaded through native extensions.",
          correction: "Try removing the word 'native'.");

  static const ParserErrorCode NON_CONSTRUCTOR_FACTORY = ParserErrorCode(
      'NON_CONSTRUCTOR_FACTORY',
      "Only a constructor can be declared to be a factory.",
      correction: "Try removing the keyword 'factory'.");

  static const ParserErrorCode NON_IDENTIFIER_LIBRARY_NAME = ParserErrorCode(
      'NON_IDENTIFIER_LIBRARY_NAME',
      "The name of a library must be an identifier.",
      correction: "Try using an identifier as the name of the library.");

  static const ParserErrorCode NON_PART_OF_DIRECTIVE_IN_PART = ParserErrorCode(
      'NON_PART_OF_DIRECTIVE_IN_PART',
      "The part-of directive must be the only directive in a part.",
      correction: "Try removing the other directives, or "
          "moving them to the library for which this is a part.");

  static const ParserErrorCode NON_STRING_LITERAL_AS_URI = ParserErrorCode(
      'NON_STRING_LITERAL_AS_URI', "The URI must be a string literal.",
      correction: "Try enclosing the URI in either single or double quotes.");

  /**
   * Parameters:
   * 0: the operator that the user is trying to define
   */
  static const ParserErrorCode NON_USER_DEFINABLE_OPERATOR = ParserErrorCode(
      'NON_USER_DEFINABLE_OPERATOR',
      "The operator '{0}' isn't user definable.");

  static const ParserErrorCode NORMAL_BEFORE_OPTIONAL_PARAMETERS = ParserErrorCode(
      'NORMAL_BEFORE_OPTIONAL_PARAMETERS',
      "Normal parameters must occur before optional parameters.",
      correction:
          "Try moving all of the normal parameters before the optional parameters.");

  static const ErrorCode NULL_AWARE_CASCADE_OUT_OF_ORDER =
      _NULL_AWARE_CASCADE_OUT_OF_ORDER;

  static const ParserErrorCode POSITIONAL_AFTER_NAMED_ARGUMENT = ParserErrorCode(
      'POSITIONAL_AFTER_NAMED_ARGUMENT',
      "Positional arguments must occur before named arguments.",
      correction:
          "Try moving all of the positional arguments before the named arguments.");

  static const ParserErrorCode POSITIONAL_PARAMETER_OUTSIDE_GROUP = ParserErrorCode(
      'POSITIONAL_PARAMETER_OUTSIDE_GROUP',
      "Positional parameters must be enclosed in square brackets ('[' and ']').",
      correction:
          "Try surrounding the positional parameters in square brackets.");

  static const ParserErrorCode PREFIX_AFTER_COMBINATOR =
      _PREFIX_AFTER_COMBINATOR;

  static const ParserErrorCode REDIRECTING_CONSTRUCTOR_WITH_BODY =
      _REDIRECTING_CONSTRUCTOR_WITH_BODY;

  static const ParserErrorCode REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR =
      _REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR;

  static const ParserErrorCode SETTER_CONSTRUCTOR = _SETTER_CONSTRUCTOR;

  static const ParserErrorCode SETTER_IN_FUNCTION = ParserErrorCode(
      'SETTER_IN_FUNCTION',
      "Setters can't be defined within methods or functions.",
      correction: "Try moving the setter outside the method or function.");

  static const ParserErrorCode STACK_OVERFLOW = _STACK_OVERFLOW;

  static const ParserErrorCode STATIC_CONSTRUCTOR = _STATIC_CONSTRUCTOR;

  static const ParserErrorCode STATIC_GETTER_WITHOUT_BODY = ParserErrorCode(
      'STATIC_GETTER_WITHOUT_BODY', "A 'static' getter must have a body.",
      correction:
          "Try adding a body to the getter, or removing the keyword 'static'.");

  static const ParserErrorCode STATIC_OPERATOR = _STATIC_OPERATOR;

  static const ParserErrorCode STATIC_SETTER_WITHOUT_BODY = ParserErrorCode(
      'STATIC_SETTER_WITHOUT_BODY', "A 'static' setter must have a body.",
      correction:
          "Try adding a body to the setter, or removing the keyword 'static'.");

  static const ParserErrorCode STATIC_TOP_LEVEL_DECLARATION = ParserErrorCode(
      'STATIC_TOP_LEVEL_DECLARATION',
      "Top-level declarations can't be declared to be static.",
      correction: "Try removing the keyword 'static'.");

  static const ParserErrorCode SWITCH_HAS_CASE_AFTER_DEFAULT_CASE =
      _SWITCH_HAS_CASE_AFTER_DEFAULT_CASE;

  static const ParserErrorCode SWITCH_HAS_MULTIPLE_DEFAULT_CASES =
      _SWITCH_HAS_MULTIPLE_DEFAULT_CASES;

  static const ParserErrorCode TOP_LEVEL_OPERATOR = _TOP_LEVEL_OPERATOR;

  static const ParserErrorCode TYPE_ARGUMENTS_ON_TYPE_VARIABLE =
      _TYPE_ARGUMENTS_ON_TYPE_VARIABLE;

  static const ParserErrorCode TYPE_BEFORE_FACTORY = _TYPE_BEFORE_FACTORY;

  static const ParserErrorCode TYPE_PARAMETER_ON_CONSTRUCTOR =
      _TYPE_PARAMETER_ON_CONSTRUCTOR;

  /**
   * 7.1.1 Operators: Type parameters are not syntactically supported on an
   * operator.
   */
  static const ParserErrorCode TYPE_PARAMETER_ON_OPERATOR = ParserErrorCode(
      'TYPE_PARAMETERS_ON_OPERATOR',
      "Types parameters aren't allowed when defining an operator.",
      correction: "Try removing the type parameters.");

  static const ParserErrorCode TYPEDEF_IN_CLASS = _TYPEDEF_IN_CLASS;

  /**
   * Parameters:
   * 0: the starting character that was missing
   */
  static const ParserErrorCode UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP =
      ParserErrorCode('UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP',
          "There is no '{0}' to open a parameter group.",
          correction: "Try inserting the '{0}' at the appropriate location.");

  /**
   * Parameters:
   * 0: the unexpected text that was found
   */
  static const ParserErrorCode UNEXPECTED_TOKEN = ParserErrorCode(
      'UNEXPECTED_TOKEN', "Unexpected text '{0}'.",
      correction: "Try removing the text.");

  static const ParserErrorCode VAR_AND_TYPE = _VAR_AND_TYPE;

  static const ParserErrorCode VAR_AS_TYPE_NAME = _VAR_AS_TYPE_NAME;

  static const ParserErrorCode VAR_CLASS = ParserErrorCode(
      'VAR_CLASS', "Classes can't be declared to be 'var'.",
      correction: "Try removing the keyword 'var'.");

  static const ParserErrorCode VAR_ENUM = ParserErrorCode(
      'VAR_ENUM', "Enums can't be declared to be 'var'.",
      correction: "Try removing the keyword 'var'.");

  static const ParserErrorCode VAR_RETURN_TYPE = _VAR_RETURN_TYPE;

  static const ParserErrorCode VAR_TYPEDEF =
      ParserErrorCode('VAR_TYPEDEF', "Typedefs can't be declared to be 'var'.",
          correction: "Try removing the keyword 'var', or "
              "replacing it with the name of the return type.");

  static const ParserErrorCode VOID_WITH_TYPE_ARGUMENTS =
      _VOID_WITH_TYPE_ARGUMENTS;

  static const ParserErrorCode WITH_BEFORE_EXTENDS = _WITH_BEFORE_EXTENDS;

  static const ParserErrorCode WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER =
      ParserErrorCode('WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER',
          "The default value of a positional parameter should be preceded by '='.",
          correction: "Try replacing the ':' with '='.");

  /**
   * Parameters:
   * 0: the terminator that was expected
   * 1: the terminator that was found
   */
  static const ParserErrorCode WRONG_TERMINATOR_FOR_PARAMETER_GROUP =
      ParserErrorCode('WRONG_TERMINATOR_FOR_PARAMETER_GROUP',
          "Expected '{0}' to close parameter group.",
          correction: "Try replacing '{0}' with '{1}'.");

  /**
   * 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 ParserErrorCode(String name, String message,
      {String correction, bool hasPublishedDocs})
      : super.temporary(name, message,
            correction: correction,
            hasPublishedDocs: hasPublishedDocs ?? false);

  @override
  ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;

  @override
  ErrorType get type => ErrorType.SYNTACTIC_ERROR;
}