| # Copyright (c) 2021, 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. |
| |
| # This file is organized as a two level map, where the outer key corresponds to |
| # the name of an analyzer error class (e.g. CompileTimeErrorCode), and the inner |
| # key corresponds to the name of a static variable in that class, describing a |
| # single diagnostic message. Ideally, each entry contains three parts: |
| # |
| # 1. A message template (problemMessage). |
| # |
| # 2. A suggestion for how to correct the problem (correctionMessage). |
| # |
| # 3. User-facing documentation for the problem (documentation). |
| # |
| # A message shouldn't indicate which kind of diagnostic it is, for example, |
| # warning or error. This is implied by the analyzer error class. For example, |
| # all entries in `StaticWarningCode` are warnings. |
| # |
| # See the file [lib/src/fasta/diagnostics.md] for more details on how to write |
| # good diagnostic messages. |
| # |
| # A message used for internal errors should have key that starts with |
| # "InternalProblem". This way, UX review can prioritize it accordingly. |
| # |
| # Eventually, we'd like to have all diagnostics in one shared location. However, |
| # for now, we have analyzer error codes and CFE error codes in separate files. |
| # See `pkg/front_end/messages.yaml` for the CFE error codes. |
| # |
| # ## Parameter Substitution in problemMessage and correctionMessage |
| # |
| # The fields `problemMessage` and `correctionMessage` are subject to parameter |
| # substitution. When the compiler reports a problem, it may also specify a list |
| # of values to be substituted into the message. Parameters are declared using |
| # placeholders of the form `{INTEGER}`, e.g. `{0}` is the zeroth parameter. |
| |
| AnalysisOptionsErrorCode: |
| INCLUDED_FILE_PARSE_ERROR: |
| problemMessage: "{3} in {0}({1}..{2})" |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that there is a syntactic error in the included |
| file. |
| |
| Parameters: |
| 0: the path of the file containing the error |
| 1: the starting offset of the text in the file that contains the error |
| 2: the ending offset of the text in the file that contains the error |
| 3: the error message |
| PARSE_ERROR: |
| problemMessage: "{0}" |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that there is a syntactic error in the file. |
| |
| Parameters: |
| 0: the error message from the parse error |
| AnalysisOptionsHintCode: |
| DEPRECATED_LINT: |
| problemMessage: "'{0}' is a deprecated lint rule and should not be used." |
| correctionMessage: Try removing '{0}'. |
| hasPublishedDocs: false |
| comment: |- |
| A hint code indicating reference to a deprecated lint. |
| |
| Parameters: |
| 0: the rule name |
| DEPRECATED_LINT_WITH_REPLACEMENT: |
| problemMessage: "'{0}' is deprecated and should be replaced by '{1}'." |
| correctionMessage: "Try replacing '{0}' with '{1}'." |
| hasPublishedDocs: false |
| comment: |- |
| A hint code indicating reference to a deprecated lint. |
| |
| Parameters: |
| 0: the deprecated lint name |
| 1: the replacing rule name |
| DUPLICATE_RULE: |
| problemMessage: "The rule {0} is already specified and doesn't need to be specified again." |
| correctionMessage: "Try removing all but one specification of the rule." |
| hasPublishedDocs: false |
| comment: |- |
| Duplicate rules. |
| |
| Parameters: |
| 0: the rule name |
| AnalysisOptionsWarningCode: |
| ANALYSIS_OPTION_DEPRECATED: |
| problemMessage: "The option '{0}' is no longer supported." |
| hasPublishedDocs: false |
| comment: | |
| An error code indicating that the given option is deprecated. |
| |
| Parameters: |
| 0: the option name |
| ANALYSIS_OPTION_DEPRECATED_WITH_REPLACEMENT: |
| sharedName: ANALYSIS_OPTION_DEPRECATED |
| problemMessage: "The option '{0}' is no longer supported." |
| correctionMessage: "Try using the new '{1}' option." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that the given option is deprecated. |
| |
| Parameters: |
| 0: the option name |
| 1: the replacement option name |
| INCLUDED_FILE_WARNING: |
| problemMessage: "Warning in the included options file {0}({1}..{2}): {3}" |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating a specified include file has a warning. |
| |
| Parameters: |
| 0: the path of the file containing the warnings |
| 1: the starting offset of the text in the file that contains the warning |
| 2: the ending offset of the text in the file that contains the warning |
| 3: the warning message |
| INCLUDE_FILE_NOT_FOUND: |
| problemMessage: "The include file '{0}' in '{1}' can't be found when analyzing '{2}'." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating a specified include file could not be found. |
| |
| Parameters: |
| 0: the URI of the file to be included |
| 1: the path of the file containing the include directive |
| 2: the path of the context being analyzed |
| INCOMPATIBLE_LINT: |
| problemMessage: "The rule '{0}' is incompatible with the rule '{1}'." |
| correctionMessage: "Try removing one of the incompatible rules." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating an incompatible rule. |
| |
| Parameters: |
| 0: the rule name |
| 1: the incompatible rule |
| INVALID_OPTION: |
| problemMessage: "Invalid option specified for '{0}': {1}" |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that a plugin is being configured with an invalid |
| value for an option and a detail message is provided. |
| |
| Parameters: |
| 0: the option name |
| 1: the detail message |
| INVALID_SECTION_FORMAT: |
| problemMessage: "Invalid format for the '{0}' section." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating an invalid format for an options file section. |
| |
| Parameters: |
| 0: the section name |
| MULTIPLE_PLUGINS: |
| problemMessage: "Multiple plugins can't be enabled." |
| correctionMessage: "Remove all plugins following the first, '{0}'." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating multiple plugins have been specified as enabled. |
| |
| Parameters: |
| 0: the name of the first plugin |
| RECURSIVE_INCLUDE_FILE: |
| problemMessage: "The include file '{0}' in '{1}' includes itself recursively." |
| correctionMessage: "Try changing the chain of 'include's to not re-include this file." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating a specified include file includes itself recursively. |
| |
| Parameters: |
| 0: the URI of the file to be included |
| 1: the path of the file containing the include directive |
| REMOVED_LINT: |
| problemMessage: "'{0}' was removed in Dart '{1}'" |
| correctionMessage: "Remove the reference to '{0}'." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating a removed lint rule. |
| |
| Parameters: |
| 0: the rule name |
| 1: the SDK version in which the lint was removed |
| REPLACED_LINT: |
| problemMessage: "'{0}' was replaced by '{2}' in Dart '{1}'." |
| correctionMessage: "Replace '{0}' with '{1}'." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating a removed lint rule. |
| |
| Parameters: |
| 0: the rule name |
| 1: the SDK version in which the lint was removed |
| 2: the name of a replacing lint |
| UNDEFINED_LINT: |
| problemMessage: "'{0}' is not a recognized lint rule." |
| correctionMessage: "Try using the name of a recognized lint rule." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating an undefined lint rule. |
| |
| Parameters: |
| 0: the rule name |
| UNRECOGNIZED_ERROR_CODE: |
| problemMessage: "'{0}' isn't a recognized error code." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that an unrecognized error code is being used to |
| specify an error filter. |
| |
| Parameters: |
| 0: the unrecognized error code |
| UNSUPPORTED_OPTION_WITHOUT_VALUES: |
| problemMessage: "The option '{1}' isn't supported by '{0}'." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that a plugin is being configured with an |
| unsupported option and legal options are provided. |
| |
| Parameters: |
| 0: the plugin name |
| 1: the unsupported option key |
| UNSUPPORTED_OPTION_WITH_LEGAL_VALUE: |
| problemMessage: "The option '{1}' isn't supported by '{0}'. Try using the only supported option: '{2}'." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that a plugin is being configured with an |
| unsupported option where there is just one legal value. |
| |
| Parameters: |
| 0: the plugin name |
| 1: the unsupported option key |
| 2: the legal value |
| UNSUPPORTED_OPTION_WITH_LEGAL_VALUES: |
| problemMessage: "The option '{1}' isn't supported by '{0}'." |
| correctionMessage: "Try using one of the supported options: {2}." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that a plugin is being configured with an |
| unsupported option and legal options are provided. |
| |
| Parameters: |
| 0: the plugin name |
| 1: the unsupported option key |
| 2: legal values |
| UNSUPPORTED_VALUE: |
| problemMessage: "The value '{1}' isn't supported by '{0}'." |
| correctionMessage: "Try using one of the supported options: {2}." |
| hasPublishedDocs: false |
| comment: |- |
| An error code indicating that an option entry is being configured with an |
| unsupported value. |
| |
| Parameters: |
| 0: the option name |
| 1: the unsupported value |
| 2: legal values |
| CompileTimeErrorCode: |
| ABSTRACT_FIELD_CONSTRUCTOR_INITIALIZER: |
| sharedName: ABSTRACT_FIELD_INITIALIZER |
| problemMessage: "Abstract fields can't have initializers." |
| correctionMessage: "Try removing the field initializer or the 'abstract' keyword from the field declaration." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a field that has the `abstract` |
| modifier also has an initializer. |
| |
| #### Examples |
| |
| The following code produces this diagnostic because `f` is marked as |
| `abstract` and has an initializer: |
| |
| ```dart |
| abstract class C { |
| abstract int [!f!] = 0; |
| } |
| ``` |
| |
| The following code produces this diagnostic because `f` is marked as |
| `abstract` and there's an initializer in the constructor: |
| |
| ```dart |
| abstract class C { |
| abstract int f; |
| |
| C() : [!f!] = 0; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the field must be abstract, then remove the initializer: |
| |
| ```dart |
| abstract class C { |
| abstract int f; |
| } |
| ``` |
| |
| If the field isn't required to be abstract, then remove the keyword: |
| |
| ```dart |
| abstract class C { |
| int f = 0; |
| } |
| ``` |
| ABSTRACT_FIELD_INITIALIZER: |
| problemMessage: "Abstract fields can't have initializers." |
| correctionMessage: "Try removing the initializer or the 'abstract' keyword." |
| hasPublishedDocs: true |
| comment: No parameters. |
| ABSTRACT_SUPER_MEMBER_REFERENCE: |
| problemMessage: "The {0} '{1}' is always abstract in the supertype." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the display name for the kind of the found abstract member |
| 1: the name of the member |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when an inherited member is |
| referenced using `super`, but there is no concrete implementation of the |
| member in the superclass chain. Abstract members can't be invoked. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `B` doesn't inherit a |
| concrete implementation of `a`: |
| |
| ```dart |
| abstract class A { |
| int get a; |
| } |
| class B extends A { |
| int get a => super.[!a!]; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Remove the invocation of the abstract member, possibly replacing it with an |
| invocation of a concrete member. |
| TODO(brianwilkerson): This either needs to be generalized (use 'member' |
| rather than '{0}') or split into multiple codes. |
| AMBIGUOUS_EXPORT: |
| problemMessage: "The name '{0}' is defined in the libraries '{1}' and '{2}'." |
| correctionMessage: Try removing the export of one of the libraries, or explicitly hiding the name in one of the export directives. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the ambiguous element |
| 1: the name of the first library in which the type is found |
| 2: the name of the second library in which the type is found |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when two or more export directives |
| cause the same name to be exported from multiple libraries. |
| |
| #### Example |
| |
| Given a file `a.dart` containing |
| |
| ```dart |
| %uri="lib/a.dart" |
| class C {} |
| ``` |
| |
| And a file `b.dart` containing |
| |
| ```dart |
| %uri="lib/b.dart" |
| class C {} |
| ``` |
| |
| The following code produces this diagnostic because the name `C` is being |
| exported from both `a.dart` and `b.dart`: |
| |
| ```dart |
| export 'a.dart'; |
| export [!'b.dart'!]; |
| ``` |
| |
| #### Common fixes |
| |
| If none of the names in one of the libraries needs to be exported, then |
| remove the unnecessary export directives: |
| |
| ```dart |
| export 'a.dart'; |
| ``` |
| |
| If all of the export directives are needed, then hide the name in all |
| except one of the directives: |
| |
| ```dart |
| export 'a.dart'; |
| export 'b.dart' hide C; |
| ``` |
| AMBIGUOUS_EXTENSION_MEMBER_ACCESS: |
| problemMessage: "A member named '{0}' is defined in {1}, and none are more specific." |
| correctionMessage: Try using an extension override to specify the extension you want to be chosen. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the member |
| 1: the names of the declaring extensions |
| documentation: |- |
| #### Description |
| |
| When code refers to a member of an object (for example, `o.m()` or `o.m` or |
| `o[i]`) where the static type of `o` doesn't declare the member (`m` or |
| `[]`, for example), then the analyzer tries to find the member in an |
| extension. For example, if the member is `m`, then the analyzer looks for |
| extensions that declare a member named `m` and have an extended type that |
| the static type of `o` can be assigned to. When there's more than one such |
| extension in scope, the extension whose extended type is most specific is |
| selected. |
| |
| The analyzer produces this diagnostic when none of the extensions has an |
| extended type that's more specific than the extended types of all of the |
| other extensions, making the reference to the member ambiguous. |
| |
| #### Example |
| |
| The following code produces this diagnostic because there's no way to |
| choose between the member in `E1` and the member in `E2`: |
| |
| ```dart |
| extension E1 on String { |
| int get charCount => 1; |
| } |
| |
| extension E2 on String { |
| int get charCount => 2; |
| } |
| |
| void f(String s) { |
| print(s.[!charCount!]); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If you don't need both extensions, then you can delete or hide one of them. |
| |
| If you need both, then explicitly select the one you want to use by using |
| an extension override: |
| |
| ```dart |
| extension E1 on String { |
| int get charCount => length; |
| } |
| |
| extension E2 on String { |
| int get charCount => length; |
| } |
| |
| void f(String s) { |
| print(E2(s).charCount); |
| } |
| ``` |
| AMBIGUOUS_IMPORT: |
| problemMessage: "The name '{0}' is defined in the libraries {1}." |
| correctionMessage: "Try using 'as prefix' for one of the import directives, or hiding the name from all but one of the imports." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the ambiguous type |
| 1: the names of the libraries that the type is found |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a name is referenced that is |
| declared in two or more imported libraries. |
| |
| #### Example |
| |
| Given a library (`a.dart`) that defines a class (`C` in this example): |
| |
| ```dart |
| %uri="lib/a.dart" |
| class A {} |
| class C {} |
| ``` |
| |
| And a library (`b.dart`) that defines a different class with the same name: |
| |
| ```dart |
| %uri="lib/b.dart" |
| class B {} |
| class C {} |
| ``` |
| |
| The following code produces this diagnostic: |
| |
| ```dart |
| import 'a.dart'; |
| import 'b.dart'; |
| |
| void f([!C!] c1, [!C!] c2) {} |
| ``` |
| |
| #### Common fixes |
| |
| If any of the libraries aren't needed, then remove the import directives |
| for them: |
| |
| ```dart |
| import 'a.dart'; |
| |
| void f(C c1, C c2) {} |
| ``` |
| |
| If the name is still defined by more than one library, then add a `hide` |
| clause to the import directives for all except one library: |
| |
| ```dart |
| import 'a.dart' hide C; |
| import 'b.dart'; |
| |
| void f(C c1, C c2) {} |
| ``` |
| |
| If you must be able to reference more than one of these types, then add a |
| prefix to each of the import directives, and qualify the references with |
| the appropriate prefix: |
| |
| ```dart |
| import 'a.dart' as a; |
| import 'b.dart' as b; |
| |
| void f(a.C c1, b.C c2) {} |
| ``` |
| AMBIGUOUS_SET_OR_MAP_LITERAL_BOTH: |
| problemMessage: "The literal can't be either a map or a set because it contains at least one literal map entry or a spread operator spreading a 'Map', and at least one element which is neither of these." |
| correctionMessage: Try removing or changing some of the elements so that all of the elements are consistent. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| Because map and set literals use the same delimiters (`{` and `}`), the |
| analyzer looks at the type arguments and the elements to determine which |
| kind of literal you meant. When there are no type arguments, then the |
| analyzer uses the types of the elements. If all of the elements are literal |
| map entries and all of the spread operators are spreading a `Map` then it's |
| a `Map`. If none of the elements are literal map entries and all of the |
| spread operators are spreading an `Iterable`, then it's a `Set`. If neither |
| of those is true then it's ambiguous. |
| |
| The analyzer produces this diagnostic when at least one element is a |
| literal map entry or a spread operator spreading a `Map`, and at least one |
| element is neither of these, making it impossible for the analyzer to |
| determine whether you are writing a map literal or a set literal. |
| |
| #### Example |
| |
| The following code produces this diagnostic: |
| |
| ```dart |
| union(Map<String, String> a, List<String> b, Map<String, String> c) => |
| [!{...a, ...b, ...c}!]; |
| ``` |
| |
| The list `b` can only be spread into a set, and the maps `a` and `c` can |
| only be spread into a map, and the literal can't be both. |
| |
| #### Common fixes |
| |
| There are two common ways to fix this problem. The first is to remove all |
| of the spread elements of one kind or another, so that the elements are |
| consistent. In this case, that likely means removing the list and deciding |
| what to do about the now unused parameter: |
| |
| ```dart |
| union(Map<String, String> a, List<String> b, Map<String, String> c) => |
| {...a, ...c}; |
| ``` |
| |
| The second fix is to change the elements of one kind into elements that are |
| consistent with the other elements. For example, you can add the elements |
| of the list as keys that map to themselves: |
| |
| ```dart |
| union(Map<String, String> a, List<String> b, Map<String, String> c) => |
| {...a, for (String s in b) s: s, ...c}; |
| ``` |
| AMBIGUOUS_SET_OR_MAP_LITERAL_EITHER: |
| problemMessage: "This literal must be either a map or a set, but the elements don't have enough information for type inference to work." |
| correctionMessage: Try adding type arguments to the literal (one for sets, two for maps). |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| Because map and set literals use the same delimiters (`{` and `}`), the |
| analyzer looks at the type arguments and the elements to determine which |
| kind of literal you meant. When there are no type arguments and all of the |
| elements are spread elements (which are allowed in both kinds of literals) |
| then the analyzer uses the types of the expressions that are being spread. |
| If all of the expressions have the type `Iterable`, then it's a set |
| literal; if they all have the type `Map`, then it's a map literal. |
| |
| This diagnostic is produced when none of the expressions being spread have |
| a type that allows the analyzer to decide whether you were writing a map |
| literal or a set literal. |
| |
| #### Example |
| |
| The following code produces this diagnostic: |
| |
| ```dart |
| union(a, b) => [!{...a, ...b}!]; |
| ``` |
| |
| The problem occurs because there are no type arguments, and there is no |
| information about the type of either `a` or `b`. |
| |
| #### Common fixes |
| |
| There are three common ways to fix this problem. The first is to add type |
| arguments to the literal. For example, if the literal is intended to be a |
| map literal, you might write something like this: |
| |
| ```dart |
| union(a, b) => <String, String>{...a, ...b}; |
| ``` |
| |
| The second fix is to add type information so that the expressions have |
| either the type `Iterable` or the type `Map`. You can add an explicit cast |
| or, in this case, add types to the declarations of the two parameters: |
| |
| ```dart |
| union(List<int> a, List<int> b) => {...a, ...b}; |
| ``` |
| |
| The third fix is to add context information. In this case, that means |
| adding a return type to the function: |
| |
| ```dart |
| Set<String> union(a, b) => {...a, ...b}; |
| ``` |
| |
| In other cases, you might add a type somewhere else. For example, say the |
| original code looks like this: |
| |
| ```dart |
| union(a, b) { |
| var x = [!{...a, ...b}!]; |
| return x; |
| } |
| ``` |
| |
| You might add a type annotation on `x`, like this: |
| |
| ```dart |
| union(a, b) { |
| Map<String, String> x = {...a, ...b}; |
| return x; |
| } |
| ``` |
| ARGUMENT_TYPE_NOT_ASSIGNABLE: |
| problemMessage: "The argument type '{0}' can't be assigned to the parameter type '{1}'. {2}" |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the actual argument type |
| 1: the name of the expected type |
| 2: additional information, if any, when problem is associated with records |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the static type of an argument |
| can't be assigned to the static type of the corresponding parameter. |
| |
| #### Example |
| |
| The following code produces this diagnostic because a `num` can't be |
| assigned to a `String`: |
| |
| ```dart |
| String f(String x) => x; |
| String g(num y) => f([!y!]); |
| ``` |
| |
| #### Common fixes |
| |
| If possible, rewrite the code so that the static type is assignable. In the |
| example above you might be able to change the type of the parameter `y`: |
| |
| ```dart |
| String f(String x) => x; |
| String g(String y) => f(y); |
| ``` |
| |
| If that fix isn't possible, then add code to handle the case where the |
| argument value isn't the required type. One approach is to coerce other |
| types to the required type: |
| |
| ```dart |
| String f(String x) => x; |
| String g(num y) => f(y.toString()); |
| ``` |
| |
| Another approach is to add explicit type tests and fallback code: |
| |
| ```dart |
| String f(String x) => x; |
| String g(Object y) => f(y is String ? y : ''); |
| ``` |
| |
| If you believe that the runtime type of the argument will always be the |
| same as the static type of the parameter, and you're willing to risk having |
| an exception thrown at runtime if you're wrong, then add an explicit cast: |
| |
| ```dart |
| String f(String x) => x; |
| String g(num y) => f(y as String); |
| ``` |
| ASSERT_IN_REDIRECTING_CONSTRUCTOR: |
| problemMessage: "A redirecting constructor can't have an 'assert' initializer." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a redirecting constructor (a |
| constructor that redirects to another constructor in the same class) has an |
| assert in the initializer list. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the unnamed constructor |
| is a redirecting constructor and also has an assert in the initializer |
| list: |
| |
| ```dart |
| class C { |
| C(int x) : [!assert(x > 0)!], this.name(); |
| C.name() {} |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the assert isn't needed, then remove it: |
| |
| ```dart |
| class C { |
| C(int x) : this.name(); |
| C.name() {} |
| } |
| ``` |
| |
| If the assert is needed, then convert the constructor into a factory |
| constructor: |
| |
| ```dart |
| class C { |
| factory C(int x) { |
| assert(x > 0); |
| return C.name(); |
| } |
| C.name() {} |
| } |
| ``` |
| ASSIGNMENT_TO_CONST: |
| problemMessage: "Constant variables can't be assigned a value." |
| correctionMessage: "Try removing the assignment, or remove the modifier 'const' from the variable." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when it finds an assignment to a |
| top-level variable, a static field, or a local variable that has the |
| `const` modifier. The value of a compile-time constant can't be changed at |
| runtime. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `c` is being assigned a |
| value even though it has the `const` modifier: |
| |
| ```dart |
| const c = 0; |
| |
| void f() { |
| [!c!] = 1; |
| print(c); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the variable must be assignable, then remove the `const` modifier: |
| |
| ```dart |
| var c = 0; |
| |
| void f() { |
| c = 1; |
| print(c); |
| } |
| ``` |
| |
| If the constant shouldn't be changed, then either remove the assignment or |
| use a local variable in place of references to the constant: |
| |
| ```dart |
| const c = 0; |
| |
| void f() { |
| var v = 1; |
| print(v); |
| } |
| ``` |
| ASSIGNMENT_TO_FINAL: |
| problemMessage: "'{0}' can't be used as a setter because it's final." |
| correctionMessage: "Try finding a different setter, or making '{0}' non-final." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the final variable |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when it finds an invocation of a |
| setter, but there's no setter because the field with the same name was |
| declared to be `final` or `const`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `v` is final: |
| |
| ```dart |
| class C { |
| final v = 0; |
| } |
| |
| f(C c) { |
| c.[!v!] = 1; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If you need to be able to set the value of the field, then remove the |
| modifier `final` from the field: |
| |
| ```dart |
| class C { |
| int v = 0; |
| } |
| |
| f(C c) { |
| c.v = 1; |
| } |
| ``` |
| ASSIGNMENT_TO_FINAL_LOCAL: |
| problemMessage: "The final variable '{0}' can only be set once." |
| correctionMessage: "Try making '{0}' non-final." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the variable |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a local variable that was |
| declared to be final is assigned after it was initialized. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `x` is final, so it |
| can't have a value assigned to it after it was initialized: |
| |
| ```dart |
| void f() { |
| final x = 0; |
| [!x!] = 3; |
| print(x); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Remove the keyword `final`, and replace it with `var` if there's no type |
| annotation: |
| |
| ```dart |
| void f() { |
| var x = 0; |
| x = 3; |
| print(x); |
| } |
| ``` |
| ASSIGNMENT_TO_FINAL_NO_SETTER: |
| problemMessage: "There isn't a setter named '{0}' in class '{1}'." |
| correctionMessage: Try correcting the name to reference an existing setter, or declare the setter. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the reference |
| 1: the name of the class |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a reference to a setter is |
| found; there is no setter defined for the type; but there is a getter |
| defined with the same name. |
| |
| #### Example |
| |
| The following code produces this diagnostic because there is no setter |
| named `x` in `C`, but there is a getter named `x`: |
| |
| ```dart |
| class C { |
| int get x => 0; |
| set y(int p) {} |
| } |
| |
| void f(C c) { |
| c.[!x!] = 1; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If you want to invoke an existing setter, then correct the name: |
| |
| ```dart |
| class C { |
| int get x => 0; |
| set y(int p) {} |
| } |
| |
| void f(C c) { |
| c.y = 1; |
| } |
| ``` |
| |
| If you want to invoke the setter but it just doesn't exist yet, then |
| declare it: |
| |
| ```dart |
| class C { |
| int get x => 0; |
| set x(int p) {} |
| set y(int p) {} |
| } |
| |
| void f(C c) { |
| c.x = 1; |
| } |
| ``` |
| ASSIGNMENT_TO_FUNCTION: |
| problemMessage: "Functions can't be assigned a value." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the name of a function appears |
| on the left-hand side of an assignment expression. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the assignment to the |
| function `f` is invalid: |
| |
| ```dart |
| void f() {} |
| |
| void g() { |
| [!f!] = () {}; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the right-hand side should be assigned to something else, such as a |
| local variable, then change the left-hand side: |
| |
| ```dart |
| void f() {} |
| |
| void g() { |
| var x = () {}; |
| print(x); |
| } |
| ``` |
| |
| If the intent is to change the implementation of the function, then define |
| a function-valued variable instead of a function: |
| |
| ```dart |
| void Function() f = () {}; |
| |
| void g() { |
| f = () {}; |
| } |
| ``` |
| ASSIGNMENT_TO_METHOD: |
| problemMessage: "Methods can't be assigned a value." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the target of an assignment is a |
| method. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `f` can't be assigned a |
| value because it's a method: |
| |
| ```dart |
| class C { |
| void f() {} |
| |
| void g() { |
| [!f!] = null; |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Rewrite the code so that there isn't an assignment to a method. |
| ASSIGNMENT_TO_TYPE: |
| problemMessage: "Types can't be assigned a value." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the name of a type name appears |
| on the left-hand side of an assignment expression. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the assignment to the |
| class `C` is invalid: |
| |
| ```dart |
| class C {} |
| |
| void f() { |
| [!C!] = null; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the right-hand side should be assigned to something else, such as a |
| local variable, then change the left-hand side: |
| |
| ```dart |
| void f() {} |
| |
| void g() { |
| var c = null; |
| print(c); |
| } |
| ``` |
| ASYNC_FOR_IN_WRONG_CONTEXT: |
| problemMessage: The async for-in loop can only be used in an async function. |
| correctionMessage: Try marking the function body with either 'async' or 'async*', or removing the 'await' before the for-in loop. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when an async for-in loop is found in |
| a function or method whose body isn't marked as being either `async` or |
| `async*`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the body of `f` isn't |
| marked as being either `async` or `async*`, but `f` contains an async |
| for-in loop: |
| |
| ```dart |
| void f(list) { |
| [!await!] for (var e in list) { |
| print(e); |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the function should return a `Future`, then mark the body with `async`: |
| |
| ```dart |
| Future<void> f(list) async { |
| await for (var e in list) { |
| print(e); |
| } |
| } |
| ``` |
| |
| If the function should return a `Stream` of values, then mark the body with |
| `async*`: |
| |
| ```dart |
| Stream<void> f(list) async* { |
| await for (var e in list) { |
| print(e); |
| } |
| } |
| ``` |
| |
| If the function should be synchronous, then remove the `await` before the |
| loop: |
| |
| ```dart |
| void f(list) { |
| for (var e in list) { |
| print(e); |
| } |
| } |
| ``` |
| AUGMENTATION_EXTENDS_CLAUSE_ALREADY_PRESENT: |
| problemMessage: The augmentation has an 'extends' clause, but an augmentation target already includes an 'extends' clause and it isn't allowed to be repeated or changed. |
| correctionMessage: Try removing the 'extends' clause, either here or in the augmentation target. |
| AUGMENTATION_MODIFIER_EXTRA: |
| problemMessage: The augmentation has the '{0}' modifier that the declaration doesn't have. |
| correctionMessage: Try removing the '{0}' modifier, or adding it to the declaration. |
| comment: |- |
| Parameters: |
| 0: the lexeme of the modifier. |
| AUGMENTATION_MODIFIER_MISSING: |
| problemMessage: The augmentation is missing the '{0}' modifier that the declaration has. |
| correctionMessage: Try adding the '{0}' modifier, or removing it from the declaration. |
| comment: |- |
| Parameters: |
| 0: the lexeme of the modifier. |
| AUGMENTATION_OF_DIFFERENT_DECLARATION_KIND: |
| problemMessage: Can't augment a {0} with a {1}. |
| correctionMessage: Try changing the augmentation to match the declaration kind. |
| hasPublishedDocs: false |
| comment: |- |
| Parameters: |
| 0: the name of the declaration kind. |
| 1: the name of the augmentation kind. |
| AUGMENTATION_TYPE_PARAMETER_BOUND: |
| problemMessage: The augmentation type parameter must have the same bound as the corresponding type parameter of the declaration. |
| correctionMessage: Try changing the augmentation to match the declaration type parameters. |
| hasPublishedDocs: false |
| AUGMENTATION_TYPE_PARAMETER_COUNT: |
| problemMessage: The augmentation must have the same number of type parameters as the declaration. |
| correctionMessage: Try changing the augmentation to match the declaration type parameters. |
| hasPublishedDocs: false |
| AUGMENTATION_TYPE_PARAMETER_NAME: |
| problemMessage: The augmentation type parameter must have the same name as the corresponding type parameter of the declaration. |
| correctionMessage: Try changing the augmentation to match the declaration type parameters. |
| hasPublishedDocs: false |
| AUGMENTATION_WITHOUT_DECLARATION: |
| problemMessage: The declaration being augmented doesn't exist. |
| correctionMessage: Try changing the augmentation to match an existing declaration. |
| hasPublishedDocs: false |
| AUGMENTED_EXPRESSION_IS_NOT_SETTER: |
| problemMessage: The augmented declaration is not a setter, it can't be used to write a value. |
| correctionMessage: Try assigning a value to a setter. |
| hasPublishedDocs: false |
| AUGMENTED_EXPRESSION_IS_SETTER: |
| problemMessage: The augmented declaration is a setter, it can't be used to read a value. |
| correctionMessage: Try assigning a value to the augmented setter. |
| hasPublishedDocs: false |
| AUGMENTED_EXPRESSION_NOT_OPERATOR: |
| problemMessage: The enclosing augmentation doesn't augment the operator '{0}'. |
| correctionMessage: Try augmenting or invoking the correct operator. |
| hasPublishedDocs: false |
| comment: |- |
| Parameters: |
| 0: the lexeme of the operator. |
| AWAIT_IN_LATE_LOCAL_VARIABLE_INITIALIZER: |
| problemMessage: "The 'await' expression can't be used in a 'late' local variable's initializer." |
| correctionMessage: "Try removing the 'late' modifier, or rewriting the initializer without using the 'await' expression." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a local variable that has the |
| `late` modifier uses an `await` expression in the initializer. |
| |
| #### Example |
| |
| The following code produces this diagnostic because an `await` expression |
| is used in the initializer for `v`, a local variable that is marked `late`: |
| |
| ```dart |
| Future<int> f() async { |
| late var v = [!await!] 42; |
| return v; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the initializer can be rewritten to not use `await`, then rewrite it: |
| |
| ```dart |
| Future<int> f() async { |
| late var v = 42; |
| return v; |
| } |
| ``` |
| |
| If the initializer can't be rewritten, then remove the `late` modifier: |
| |
| ```dart |
| Future<int> f() async { |
| var v = await 42; |
| return v; |
| } |
| ``` |
| AWAIT_IN_WRONG_CONTEXT: |
| problemMessage: The await expression can only be used in an async function. |
| correctionMessage: Try marking the function body with either 'async' or 'async*'. |
| hasPublishedDocs: false |
| comment: |- |
| 16.30 Await Expressions: It is a compile-time error if the function |
| immediately enclosing _a_ is not declared asynchronous. (Where _a_ is the |
| await expression.) |
| AWAIT_OF_INCOMPATIBLE_TYPE: |
| problemMessage: "The 'await' expression can't be used for an expression with an extension type that is not a subtype of 'Future'." |
| correctionMessage: Try removing the `await`, or updating the extension type to implement 'Future'. |
| hasPublishedDocs: true |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the type of the expression in |
| an `await` expression is an extension type, and the extension type isn't a |
| subclass of `Future`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the extension type `E` |
| isn't a subclass of `Future`: |
| |
| ```dart |
| extension type E(int i) {} |
| |
| void f(E e) async { |
| [!await!] e; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the extension type is correctly defined, then remove the `await`: |
| |
| ```dart |
| extension type E(int i) {} |
| |
| void f(E e) { |
| e; |
| } |
| ``` |
| |
| If the extension type is intended to be awaitable, then add `Future` (or a |
| subtype of `Future`) to the `implements` clause (adding an `implements` |
| clause if there isn't one already), and make the representation type |
| match: |
| |
| ```dart |
| extension type E(Future<int> i) implements Future<int> {} |
| |
| void f(E e) async { |
| await e; |
| } |
| ``` |
| BASE_CLASS_IMPLEMENTED_OUTSIDE_OF_LIBRARY: |
| sharedName: INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY |
| problemMessage: "The class '{0}' can't be implemented outside of its library because it's a base class." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the base class being implemented |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when an `extends`, `implements`, |
| `with`, or `on` clause uses a class or mixin in a way that isn't allowed |
| given the modifiers on that class or mixin's declaration. |
| |
| The message specifies how the declaration is being used and why it isn't |
| allowed. |
| |
| #### Example |
| |
| Given a file `a.dart` that defines a base class `A`: |
| |
| ```dart |
| %uri="lib/a.dart" |
| base class A {} |
| ``` |
| |
| The following code produces this diagnostic because the class `B` |
| implements the class `A`, but the `base` modifier prevents `A` from being |
| implemented outside of the library where it's defined: |
| |
| ```dart |
| import 'a.dart'; |
| |
| final class B implements [!A!] {} |
| ``` |
| |
| #### Common fixes |
| |
| Use of this type is restricted outside of its declaring library. If a |
| different, unrestricted type is available that can provide similar |
| functionality, then replace the type: |
| |
| ```dart |
| class B implements C {} |
| class C {} |
| ``` |
| |
| If there isn't a different type that would be appropriate, then remove the |
| type, and possibly the whole clause: |
| |
| ```dart |
| class B {} |
| ``` |
| BASE_MIXIN_IMPLEMENTED_OUTSIDE_OF_LIBRARY: |
| sharedName: INVALID_USE_OF_TYPE_OUTSIDE_LIBRARY |
| problemMessage: "The mixin '{0}' can't be implemented outside of its library because it's a base mixin." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the base mixin being implemented |
| BODY_MIGHT_COMPLETE_NORMALLY: |
| problemMessage: The body might complete normally, causing 'null' to be returned, but the return type, '{0}', is a potentially non-nullable type. |
| correctionMessage: Try adding either a return or a throw statement at the end. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the return type |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a method or function has a |
| return type that's [potentially non-nullable][] but would implicitly return |
| `null` if control reached the end of the function. |
| |
| #### Examples |
| |
| The following code produces this diagnostic because the method `m` has an |
| implicit return of `null` inserted at the end of the method, but the method |
| is declared to not return `null`: |
| |
| ```dart |
| class C { |
| int [!m!](int t) { |
| print(t); |
| } |
| } |
| ``` |
| |
| The following code produces this diagnostic because the method `m` has an |
| implicit return of `null` inserted at the end of the method, but because |
| the class `C` can be instantiated with a non-nullable type argument, the |
| method is effectively declared to not return `null`: |
| |
| ```dart |
| class C<T> { |
| T [!m!](T t) { |
| print(t); |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If there's a reasonable value that can be returned, then add a `return` |
| statement at the end of the method: |
| |
| ```dart |
| class C<T> { |
| T m(T t) { |
| print(t); |
| return t; |
| } |
| } |
| ``` |
| |
| If the method won't reach the implicit return, then add a `throw` at the |
| end of the method: |
| |
| ```dart |
| class C<T> { |
| T m(T t) { |
| print(t); |
| throw ''; |
| } |
| } |
| ``` |
| |
| If the method intentionally returns `null` at the end, then add an |
| explicit return of `null` at the end of the method and change the |
| return type so that it's valid to return `null`: |
| |
| ```dart |
| class C<T> { |
| T? m(T t) { |
| print(t); |
| return null; |
| } |
| } |
| ``` |
| BREAK_LABEL_ON_SWITCH_MEMBER: |
| problemMessage: A break label resolves to the 'case' or 'default' statement. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a break in a case clause inside |
| a switch statement has a label that is associated with another case clause. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the label `l` is |
| associated with the case clause for `0`: |
| |
| ```dart |
| %language=2.18 |
| void f(int i) { |
| switch (i) { |
| l: case 0: |
| break; |
| case 1: |
| break [!l!]; |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the intent is to transfer control to the statement after the switch, |
| then remove the label from the break statement: |
| |
| ```dart |
| void f(int i) { |
| switch (i) { |
| case 0: |
| break; |
| case 1: |
| break; |
| } |
| } |
| ``` |
| |
| If the intent is to transfer control to a different case block, then use |
| `continue` rather than `break`: |
| |
| ```dart |
| %language=2.18 |
| void f(int i) { |
| switch (i) { |
| l: case 0: |
| break; |
| case 1: |
| continue l; |
| } |
| } |
| ``` |
| BUILT_IN_IDENTIFIER_AS_TYPE: |
| problemMessage: The built-in identifier '{0}' can't be used as a type. |
| correctionMessage: Try correcting the name to match an existing type. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the built-in identifier that is being used |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a built-in identifier is used |
| where a type name is expected. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `import` can't be used |
| as a type because it's a built-in identifier: |
| |
| ```dart |
| [!import!]<int> x; |
| ``` |
| |
| #### Common fixes |
| |
| Replace the built-in identifier with the name of a valid type: |
| |
| ```dart |
| List<int> x; |
| ``` |
| BUILT_IN_IDENTIFIER_AS_EXTENSION_NAME: |
| sharedName: BUILT_IN_IDENTIFIER_IN_DECLARATION |
| problemMessage: "The built-in identifier '{0}' can't be used as an extension name." |
| correctionMessage: Try choosing a different name for the extension. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the built-in identifier that is being used |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the name used in the declaration |
| of a class, extension, mixin, typedef, type parameter, or import prefix is |
| a built-in identifier. Built-in identifiers can't be used to name any of |
| these kinds of declarations. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `mixin` is a built-in |
| identifier: |
| |
| ```dart |
| extension [!mixin!] on int {} |
| ``` |
| |
| #### Common fixes |
| |
| Choose a different name for the declaration. |
| BUILT_IN_IDENTIFIER_AS_EXTENSION_TYPE_NAME: |
| sharedName: BUILT_IN_IDENTIFIER_IN_DECLARATION |
| problemMessage: "The built-in identifier '{0}' can't be used as an extension type name." |
| correctionMessage: Try choosing a different name for the extension type. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the built-in identifier that is being used |
| BUILT_IN_IDENTIFIER_AS_PREFIX_NAME: |
| sharedName: BUILT_IN_IDENTIFIER_IN_DECLARATION |
| problemMessage: "The built-in identifier '{0}' can't be used as a prefix name." |
| correctionMessage: Try choosing a different name for the prefix. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the built-in identifier that is being used |
| BUILT_IN_IDENTIFIER_AS_TYPE_NAME: |
| sharedName: BUILT_IN_IDENTIFIER_IN_DECLARATION |
| problemMessage: "The built-in identifier '{0}' can't be used as a type name." |
| correctionMessage: Try choosing a different name for the type. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the built-in identifier that is being used |
| BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME: |
| sharedName: BUILT_IN_IDENTIFIER_IN_DECLARATION |
| problemMessage: "The built-in identifier '{0}' can't be used as a type parameter name." |
| correctionMessage: Try choosing a different name for the type parameter. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the built-in identifier that is being used |
| BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME: |
| sharedName: BUILT_IN_IDENTIFIER_IN_DECLARATION |
| problemMessage: "The built-in identifier '{0}' can't be used as a typedef name." |
| correctionMessage: Try choosing a different name for the typedef. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the built-in identifier that is being used |
| CASE_BLOCK_NOT_TERMINATED: |
| removedIn: "3.0" |
| problemMessage: "The last statement of the 'case' should be 'break', 'continue', 'rethrow', 'return', or 'throw'." |
| correctionMessage: Try adding one of the required statements. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the last statement in a `case` |
| block isn't one of the required terminators: `break`, `continue`, |
| `rethrow`, `return`, or `throw`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the `case` block ends |
| with an assignment: |
| |
| ```dart |
| %language=2.9 |
| void f(int x) { |
| switch (x) { |
| [!case!] 0: |
| x += 2; |
| default: |
| x += 1; |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Add one of the required terminators: |
| |
| ```dart |
| %language=2.9 |
| void f(int x) { |
| switch (x) { |
| case 0: |
| x += 2; |
| break; |
| default: |
| x += 1; |
| } |
| } |
| ``` |
| CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS: |
| problemMessage: "The switch case expression type '{0}' can't override the '==' operator." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the this of the switch case expression |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the type of the expression |
| following the keyword `case` has an implementation of the `==` operator |
| other than the one in `Object`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the expression |
| following the keyword `case` (`C(0)`) has the type `C`, and the class `C` |
| overrides the `==` operator: |
| |
| ```dart |
| %language=2.18 |
| class C { |
| final int value; |
| |
| const C(this.value); |
| |
| bool operator ==(Object other) { |
| return false; |
| } |
| } |
| |
| void f(C c) { |
| switch (c) { |
| case [!C(0)!]: |
| break; |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If there isn't a strong reason not to do so, then rewrite the code to use |
| an if-else structure: |
| |
| ```dart |
| class C { |
| final int value; |
| |
| const C(this.value); |
| |
| bool operator ==(Object other) { |
| return false; |
| } |
| } |
| |
| void f(C c) { |
| if (c == C(0)) { |
| // ... |
| } |
| } |
| ``` |
| |
| If you can't rewrite the switch statement and the implementation of `==` |
| isn't necessary, then remove it: |
| |
| ```dart |
| %language=2.18 |
| class C { |
| final int value; |
| |
| const C(this.value); |
| } |
| |
| void f(C c) { |
| switch (c) { |
| case C(0): |
| break; |
| } |
| } |
| ``` |
| |
| If you can't rewrite the switch statement and you can't remove the |
| definition of `==`, then find some other value that can be used to control |
| the switch: |
| |
| ```dart |
| class C { |
| final int value; |
| |
| const C(this.value); |
| |
| bool operator ==(Object other) { |
| return false; |
| } |
| } |
| |
| void f(C c) { |
| switch (c.value) { |
| case 0: |
| break; |
| } |
| } |
| ``` |
| CASE_EXPRESSION_TYPE_IS_NOT_SWITCH_EXPRESSION_SUBTYPE: |
| problemMessage: "The switch case expression type '{0}' must be a subtype of the switch expression type '{1}'." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the type of the case expression |
| 1: the type of the switch expression |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the expression following `case` |
| in a `switch` statement has a static type that isn't a subtype of the |
| static type of the expression following `switch`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `1` is an `int`, which |
| isn't a subtype of `String` (the type of `s`): |
| |
| ```dart |
| %language=2.18 |
| void f(String s) { |
| switch (s) { |
| case [!1!]: |
| break; |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the value of the `case` expression is wrong, then change the `case` |
| expression so that it has the required type: |
| |
| ```dart |
| void f(String s) { |
| switch (s) { |
| case '1': |
| break; |
| } |
| } |
| ``` |
| |
| If the value of the `case` expression is correct, then change the `switch` |
| expression to have the required type: |
| |
| ```dart |
| void f(int s) { |
| switch (s) { |
| case 1: |
| break; |
| } |
| } |
| ``` |
| CAST_TO_NON_TYPE: |
| problemMessage: "The name '{0}' isn't a type, so it can't be used in an 'as' expression." |
| correctionMessage: "Try changing the name to the name of an existing type, or creating a type with the name '{0}'." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the name following the `as` in a |
| cast expression is defined to be something other than a type. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `x` is a variable, not |
| a type: |
| |
| ```dart |
| num x = 0; |
| int y = x as [!x!]; |
| ``` |
| |
| #### Common fixes |
| |
| Replace the name with the name of a type: |
| |
| ```dart |
| num x = 0; |
| int y = x as int; |
| ``` |
| CLASS_USED_AS_MIXIN: |
| problemMessage: "The class '{0}' can't be used as a mixin because it's neither a mixin class nor a mixin." |
| comment: |- |
| Parameters: |
| 0: the name of the class being used as a mixin |
| hasPublishedDocs: true |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a class that is neither a |
| `mixin class` nor a `mixin` is used in a `with` clause. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the class `M` is being |
| used as a mixin, but it isn't defined as a `mixin class`: |
| |
| ```dart |
| class M {} |
| class C with [!M!] {} |
| ``` |
| |
| #### Common fixes |
| |
| If the class can be a pure mixin, then change `class` to `mixin`: |
| |
| ```dart |
| mixin M {} |
| class C with M {} |
| ``` |
| |
| If the class needs to be both a class and a mixin, then add `mixin`: |
| |
| ```dart |
| mixin class M {} |
| class C with M {} |
| ``` |
| CLASS_INSTANTIATION_ACCESS_TO_INSTANCE_MEMBER: |
| sharedName: CLASS_INSTANTIATION_ACCESS_TO_MEMBER |
| problemMessage: "The instance member '{0}' can't be accessed on a class instantiation." |
| correctionMessage: Try changing the member name to the name of a constructor. |
| hasPublishedDocs: false |
| comment: |- |
| Parameters: |
| 0: the name of the member |
| CLASS_INSTANTIATION_ACCESS_TO_UNKNOWN_MEMBER: |
| sharedName: CLASS_INSTANTIATION_ACCESS_TO_MEMBER |
| problemMessage: "The class '{0}' doesn't have a constructor named '{1}'." |
| correctionMessage: "Try invoking a different constructor, or defining a constructor named '{1}'." |
| hasPublishedDocs: false |
| comment: |- |
| Parameters: |
| 0: the name of the class |
| 1: the name of the member |
| CLASS_INSTANTIATION_ACCESS_TO_STATIC_MEMBER: |
| sharedName: CLASS_INSTANTIATION_ACCESS_TO_MEMBER |
| problemMessage: "The static member '{0}' can't be accessed on a class instantiation." |
| correctionMessage: Try removing the type arguments from the class name, or changing the member name to the name of a constructor. |
| hasPublishedDocs: false |
| comment: |- |
| Parameters: |
| 0: the name of the member |
| NON_CONST_GENERATIVE_ENUM_CONSTRUCTOR: |
| problemMessage: Generative enum constructors must be 'const'. |
| correctionMessage: Try adding the keyword 'const'. |
| hasPublishedDocs: true |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when an enum declaration contains a |
| generative constructor that isn't marked as `const`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the constructor in `E` |
| isn't marked as being `const`: |
| |
| ```dart |
| enum E { |
| e; |
| |
| [!E!](); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Add the `const` keyword before the constructor: |
| |
| ```dart |
| enum E { |
| e; |
| |
| const E(); |
| } |
| ``` |
| NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY: |
| sharedName: COLLECTION_ELEMENT_FROM_DEFERRED_LIBRARY |
| problemMessage: "Constant values from a deferred library can't be used as values in a 'const' list literal." |
| correctionMessage: "Try removing the keyword 'const' from the list literal or removing the keyword 'deferred' from the import." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a collection literal that is |
| either explicitly (because it's prefixed by the `const` keyword) or |
| implicitly (because it appears in a [constant context][]) a constant |
| contains a value that is declared in a library that is imported using a |
| deferred import. Constants are evaluated at compile time, and values from |
| deferred libraries aren't available at compile time. |
| |
| For more information, check out |
| [Lazily loading a library](https://dart.dev/language/libraries#lazily-loading-a-library). |
| |
| #### Example |
| |
| Given a file `a.dart` that defines the constant `zero`: |
| |
| ```dart |
| %uri="lib/a.dart" |
| const zero = 0; |
| ``` |
| |
| The following code produces this diagnostic because the constant list |
| literal contains `a.zero`, which is imported using a `deferred` import: |
| |
| ```dart |
| import 'a.dart' deferred as a; |
| |
| var l = const [a.[!zero!]]; |
| ``` |
| |
| #### Common fixes |
| |
| If the collection literal isn't required to be constant, then remove the |
| `const` keyword: |
| |
| ```dart |
| import 'a.dart' deferred as a; |
| |
| var l = [a.zero]; |
| ``` |
| |
| If the collection is required to be constant and the imported constant must |
| be referenced, then remove the keyword `deferred` from the import: |
| |
| ```dart |
| import 'a.dart' as a; |
| |
| var l = const [a.zero]; |
| ``` |
| |
| If you don't need to reference the constant, then replace it with a |
| suitable value: |
| |
| ```dart |
| var l = const [0]; |
| ``` |
| NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY: |
| sharedName: COLLECTION_ELEMENT_FROM_DEFERRED_LIBRARY |
| problemMessage: "Constant values from a deferred library can't be used as keys in a 'const' map literal." |
| correctionMessage: "Try removing the keyword 'const' from the map literal or removing the keyword 'deferred' from the import." |
| hasPublishedDocs: true |
| comment: No parameters. |
| NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY: |
| sharedName: COLLECTION_ELEMENT_FROM_DEFERRED_LIBRARY |
| problemMessage: "Constant values from a deferred library can't be used as values in a 'const' map literal." |
| correctionMessage: "Try removing the keyword 'const' from the map literal or removing the keyword 'deferred' from the import." |
| hasPublishedDocs: true |
| comment: No parameters. |
| NON_CONSTANT_RECORD_FIELD_FROM_DEFERRED_LIBRARY: |
| problemMessage: "Constant values from a deferred library can't be used as fields in a 'const' record literal." |
| correctionMessage: "Try removing the keyword 'const' from the record literal or removing the keyword 'deferred' from the import." |
| hasPublishedDocs: false |
| comment: No parameters. |
| PATTERN_CONSTANT_FROM_DEFERRED_LIBRARY: |
| problemMessage: Constant values from a deferred library can't be used in patterns. |
| correctionMessage: Try removing the keyword 'deferred' from the import. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a pattern contains a value |
| declared in a different library, and that library is imported using a |
| deferred import. Constants are evaluated at compile time, but values from |
| deferred libraries aren't available at compile time. |
| |
| For more information, check out |
| [Lazily loading a library](https://dart.dev/language/libraries#lazily-loading-a-library). |
| |
| #### Example |
| |
| Given a file `a.dart` that defines the constant `zero`: |
| |
| ```dart |
| %uri="lib/a.dart" |
| const zero = 0; |
| ``` |
| |
| The following code produces this diagnostic because the constant pattern |
| `a.zero` is imported using a deferred import: |
| |
| ```dart |
| import 'a.dart' deferred as a; |
| |
| void f(int x) { |
| switch (x) { |
| case a.[!zero!]: |
| // ... |
| break; |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If you need to reference the constant from the imported library, then |
| remove the `deferred` keyword: |
| |
| ```dart |
| import 'a.dart' as a; |
| |
| void f(int x) { |
| switch (x) { |
| case a.zero: |
| // ... |
| break; |
| } |
| } |
| ``` |
| |
| If you need to reference the constant from the imported library and also |
| need the imported library to be deferred, then rewrite the switch |
| statement as a sequence of `if` statements: |
| |
| ```dart |
| import 'a.dart' deferred as a; |
| |
| void f(int x) { |
| if (x == a.zero) { |
| // ... |
| } |
| } |
| ``` |
| |
| If you don't need to reference the constant, then replace the case |
| expression: |
| |
| ```dart |
| void f(int x) { |
| switch (x) { |
| case 0: |
| // ... |
| break; |
| } |
| } |
| ``` |
| RECORD_LITERAL_ONE_POSITIONAL_NO_TRAILING_COMMA: |
| problemMessage: "A record literal with exactly one positional field requires a trailing comma." |
| correctionMessage: Try adding a trailing comma. |
| hasPublishedDocs: true |
| SET_ELEMENT_FROM_DEFERRED_LIBRARY: |
| sharedName: COLLECTION_ELEMENT_FROM_DEFERRED_LIBRARY |
| problemMessage: "Constant values from a deferred library can't be used as values in a 'const' set literal." |
| correctionMessage: "Try removing the keyword 'const' from the set literal or removing the keyword 'deferred' from the import." |
| hasPublishedDocs: true |
| comment: No parameters. |
| CONCRETE_CLASS_HAS_ENUM_SUPERINTERFACE: |
| problemMessage: "Concrete classes can't have 'Enum' as a superinterface." |
| correctionMessage: Try specifying a different interface, or remove it from the list. |
| hasPublishedDocs: true |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a concrete class indirectly has |
| the class `Enum` as a superinterface. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the concrete class `B` |
| has `Enum` as a superinterface as a result of implementing `A`: |
| |
| ```dart |
| abstract class A implements Enum {} |
| |
| class [!B!] implements A {} |
| ``` |
| |
| #### Common fixes |
| |
| If the implemented class isn't the class you intend to implement, then |
| change it: |
| |
| ```dart |
| abstract class A implements Enum {} |
| |
| class B implements C {} |
| |
| class C {} |
| ``` |
| |
| If the implemented class can be changed to not implement `Enum`, then do |
| so: |
| |
| ```dart |
| abstract class A {} |
| |
| class B implements A {} |
| ``` |
| |
| If the implemented class can't be changed to not implement `Enum`, then |
| remove it from the `implements` clause: |
| |
| ```dart |
| abstract class A implements Enum {} |
| |
| class B {} |
| ``` |
| CONCRETE_CLASS_WITH_ABSTRACT_MEMBER: |
| problemMessage: "'{0}' must have a method body because '{1}' isn't abstract." |
| correctionMessage: "Try making '{1}' abstract, or adding a body to '{0}'." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the abstract method |
| 1: the name of the enclosing class |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a member of a concrete class is |
| found that doesn't have a concrete implementation. Concrete classes aren't |
| allowed to contain abstract members. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `m` is an abstract |
| method but `C` isn't an abstract class: |
| |
| ```dart |
| class C { |
| [!void m();!] |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If it's valid to create instances of the class, provide an implementation |
| for the member: |
| |
| ```dart |
| class C { |
| void m() {} |
| } |
| ``` |
| |
| If it isn't valid to create instances of the class, mark the class as being |
| abstract: |
| |
| ```dart |
| abstract class C { |
| void m(); |
| } |
| ``` |
| CONFLICTING_CONSTRUCTOR_AND_STATIC_FIELD: |
| sharedName: CONFLICTING_CONSTRUCTOR_AND_STATIC_MEMBER |
| problemMessage: "'{0}' can't be used to name both a constructor and a static field in this class." |
| correctionMessage: Try renaming either the constructor or the field. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the constructor and field |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a named constructor and either a |
| static method or static field have the same name. Both are accessed using |
| the name of the class, so having the same name makes the reference |
| ambiguous. |
| |
| #### Examples |
| |
| The following code produces this diagnostic because the static field `foo` |
| and the named constructor `foo` have the same name: |
| |
| ```dart |
| class C { |
| C.[!foo!](); |
| static int foo = 0; |
| } |
| ``` |
| |
| The following code produces this diagnostic because the static method `foo` |
| and the named constructor `foo` have the same name: |
| |
| ```dart |
| class C { |
| C.[!foo!](); |
| static void foo() {} |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Rename either the member or the constructor. |
| CONFLICTING_CONSTRUCTOR_AND_STATIC_GETTER: |
| sharedName: CONFLICTING_CONSTRUCTOR_AND_STATIC_MEMBER |
| problemMessage: "'{0}' can't be used to name both a constructor and a static getter in this class." |
| correctionMessage: Try renaming either the constructor or the getter. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the constructor and getter |
| CONFLICTING_CONSTRUCTOR_AND_STATIC_METHOD: |
| sharedName: CONFLICTING_CONSTRUCTOR_AND_STATIC_MEMBER |
| problemMessage: "'{0}' can't be used to name both a constructor and a static method in this class." |
| correctionMessage: Try renaming either the constructor or the method. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the constructor |
| CONFLICTING_CONSTRUCTOR_AND_STATIC_SETTER: |
| sharedName: CONFLICTING_CONSTRUCTOR_AND_STATIC_MEMBER |
| problemMessage: "'{0}' can't be used to name both a constructor and a static setter in this class." |
| correctionMessage: Try renaming either the constructor or the setter. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the constructor and setter |
| CONFLICTING_FIELD_AND_METHOD: |
| problemMessage: "Class '{0}' can't define field '{1}' and have method '{2}.{1}' with the same name." |
| correctionMessage: "Try converting the getter to a method, or renaming the field to a name that doesn't conflict." |
| hasPublishedDocs: false |
| comment: |- |
| 10.11 Class Member Conflicts: Let `C` be a class. It is a compile-time |
| error if `C` declares a getter or a setter with basename `n`, and has a |
| method named `n`. |
| |
| Parameters: |
| 0: the name of the class defining the conflicting field |
| 1: the name of the conflicting field |
| 2: the name of the class defining the method with which the field conflicts |
| CONFLICTING_GENERIC_INTERFACES: |
| problemMessage: "The {0} '{1}' can't implement both '{2}' and '{3}' because the type arguments are different." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the kind of the element implementing the conflicting interface |
| 1: the name of the element implementing the conflicting interface |
| 2: the first conflicting type |
| 3: the second conflicting type |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a class attempts to implement a |
| generic interface multiple times, and the values of the type arguments |
| aren't the same. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `C` is defined to |
| implement both `I<int>` (because it extends `A`) and `I<String>` (because |
| it implements`B`), but `int` and `String` aren't the same type: |
| |
| ```dart |
| class I<T> {} |
| class A implements I<int> {} |
| class B implements I<String> {} |
| class [!C!] extends A implements B {} |
| ``` |
| |
| #### Common fixes |
| |
| Rework the type hierarchy to avoid this situation. For example, you might |
| make one or both of the inherited types generic so that `C` can specify the |
| same type for both type arguments: |
| |
| ```dart |
| class I<T> {} |
| class A<S> implements I<S> {} |
| class B implements I<String> {} |
| class C extends A<String> implements B {} |
| ``` |
| CONFLICTING_INHERITED_METHOD_AND_SETTER: |
| problemMessage: "The {0} '{1}' can't inherit both a method and a setter named '{2}'." |
| hasPublishedDocs: false |
| comment: |- |
| 10.11 Class Member Conflicts: Let `C` be a class. It is a compile-time |
| error if the interface of `C` has an instance method named `n` and an |
| instance setter with basename `n`. |
| |
| Parameters: |
| 0: the name of the enclosing element kind - class, extension type, etc |
| 1: the name of the enclosing element |
| 2: the name of the conflicting method / setter |
| CONFLICTING_METHOD_AND_FIELD: |
| problemMessage: "Class '{0}' can't define method '{1}' and have field '{2}.{1}' with the same name." |
| correctionMessage: "Try converting the method to a getter, or renaming the method to a name that doesn't conflict." |
| hasPublishedDocs: false |
| comment: |- |
| 10.11 Class Member Conflicts: Let `C` be a class. It is a compile-time |
| error if `C` declares a method named `n`, and has a getter or a setter |
| with basename `n`. |
| |
| Parameters: |
| 0: the name of the class defining the conflicting method |
| 1: the name of the conflicting method |
| 2: the name of the class defining the field with which the method conflicts |
| CONFLICTING_STATIC_AND_INSTANCE: |
| problemMessage: "Class '{0}' can't define static member '{1}' and have instance member '{2}.{1}' with the same name." |
| correctionMessage: "Try renaming the member to a name that doesn't conflict." |
| hasPublishedDocs: false |
| comment: |- |
| 10.11 Class Member Conflicts: Let `C` be a class. It is a compile-time |
| error if `C` declares a static member with basename `n`, and has an |
| instance member with basename `n`. |
| |
| Parameters: |
| 0: the name of the class defining the conflicting member |
| 1: the name of the conflicting static member |
| 2: the name of the class defining the field with which the method conflicts |
| CONFLICTING_TYPE_VARIABLE_AND_CLASS: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_CONTAINER |
| problemMessage: "'{0}' can't be used to name both a type variable and the class in which the type variable is defined." |
| correctionMessage: Try renaming either the type variable or the class. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a class, mixin, or extension |
| declaration declares a type parameter with the same name as the class, |
| mixin, or extension that declares it. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the type parameter `C` |
| has the same name as the class `C` of which it's a part: |
| |
| ```dart |
| class C<[!C!]> {} |
| ``` |
| |
| #### Common fixes |
| |
| Rename either the type parameter, or the class, mixin, or extension: |
| |
| ```dart |
| class C<T> {} |
| ``` |
| CONFLICTING_TYPE_VARIABLE_AND_ENUM: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_CONTAINER |
| problemMessage: "'{0}' can't be used to name both a type variable and the enum in which the type variable is defined." |
| correctionMessage: Try renaming either the type variable or the enum. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| CONFLICTING_TYPE_VARIABLE_AND_EXTENSION: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_CONTAINER |
| problemMessage: "'{0}' can't be used to name both a type variable and the extension in which the type variable is defined." |
| correctionMessage: Try renaming either the type variable or the extension. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| CONFLICTING_TYPE_VARIABLE_AND_EXTENSION_TYPE: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_CONTAINER |
| problemMessage: "'{0}' can't be used to name both a type variable and the extension type in which the type variable is defined." |
| correctionMessage: Try renaming either the type variable or the extension. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| CONFLICTING_TYPE_VARIABLE_AND_MIXIN: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_CONTAINER |
| problemMessage: "'{0}' can't be used to name both a type variable and the mixin in which the type variable is defined." |
| correctionMessage: Try renaming either the type variable or the mixin. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| CONFLICTING_TYPE_VARIABLE_AND_MEMBER_CLASS: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_MEMBER |
| problemMessage: "'{0}' can't be used to name both a type variable and a member in this class." |
| correctionMessage: Try renaming either the type variable or the member. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a class, mixin, or extension |
| declaration declares a type parameter with the same name as one of the |
| members of the class, mixin, or extension that declares it. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the type parameter `T` |
| has the same name as the field `T`: |
| |
| ```dart |
| class C<[!T!]> { |
| int T = 0; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Rename either the type parameter or the member with which it conflicts: |
| |
| ```dart |
| class C<T> { |
| int total = 0; |
| } |
| ``` |
| CONFLICTING_TYPE_VARIABLE_AND_MEMBER_MIXIN: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_MEMBER |
| problemMessage: "'{0}' can't be used to name both a type variable and a member in this mixin." |
| correctionMessage: Try renaming either the type variable or the member. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| CONFLICTING_TYPE_VARIABLE_AND_MEMBER_ENUM: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_MEMBER |
| problemMessage: "'{0}' can't be used to name both a type variable and a member in this enum." |
| correctionMessage: Try renaming either the type variable or the member. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| CONFLICTING_TYPE_VARIABLE_AND_MEMBER_EXTENSION: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_MEMBER |
| problemMessage: "'{0}' can't be used to name both a type variable and a member in this extension." |
| correctionMessage: Try renaming either the type variable or the member. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| CONFLICTING_TYPE_VARIABLE_AND_MEMBER_EXTENSION_TYPE: |
| sharedName: CONFLICTING_TYPE_VARIABLE_AND_MEMBER |
| problemMessage: "'{0}' can't be used to name both a type variable and a member in this extension type." |
| correctionMessage: Try renaming either the type variable or the member. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the type variable |
| CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH: |
| problemMessage: "In a const constructor, a value of type '{0}' can't be assigned to the field '{1}', which has type '{2}'." |
| correctionMessage: "Try using a subtype, or removing the keyword 'const'." |
| hasPublishedDocs: false |
| comment: |- |
| 16.12.2 Const: It is a compile-time error if evaluation of a constant |
| object results in an uncaught exception being thrown. |
| |
| Parameters: |
| 0: the type of the runtime value of the argument |
| 1: the name of the field |
| 2: the type of the field |
| CONST_CONSTRUCTOR_CONSTANT_FROM_DEFERRED_LIBRARY: |
| sharedName: COLLECTION_ELEMENT_FROM_DEFERRED_LIBRARY |
| problemMessage: "Constant values from a deferred library can't be used as values in a 'const' constructor." |
| correctionMessage: "Try removing the keyword 'const' from the constructor or removing the keyword 'deferred' from the import." |
| hasPublishedDocs: true |
| comment: No parameters. |
| CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH: |
| problemMessage: "A value of type '{0}' can't be assigned to a parameter of type '{1}' in a const constructor." |
| correctionMessage: "Try using a subtype, or removing the keyword 'const'." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the type of the runtime value of the argument |
| 1: the static type of the parameter |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the runtime type of a constant |
| value can't be assigned to the static type of a constant constructor's |
| parameter. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the runtime type of `i` |
| is `int`, which can't be assigned to the static type of `s`: |
| |
| ```dart |
| class C { |
| final String s; |
| |
| const C(this.s); |
| } |
| |
| const dynamic i = 0; |
| |
| void f() { |
| const C([!i!]); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Pass a value of the correct type to the constructor: |
| |
| ```dart |
| class C { |
| final String s; |
| |
| const C(this.s); |
| } |
| |
| const dynamic i = 0; |
| |
| void f() { |
| const C('$i'); |
| } |
| ``` |
| CONST_CONSTRUCTOR_THROWS_EXCEPTION: |
| problemMessage: "Const constructors can't throw exceptions." |
| correctionMessage: "Try removing the throw statement, or removing the keyword 'const'." |
| hasPublishedDocs: false |
| comment: |- |
| 16.12.2 Const: It is a compile-time error if evaluation of a constant |
| object results in an uncaught exception being thrown. |
| CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST: |
| problemMessage: "Can't define the 'const' constructor because the field '{0}' is initialized with a non-constant value." |
| correctionMessage: "Try initializing the field to a constant value, or removing the keyword 'const' from the constructor." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the field |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a constructor has the keyword |
| `const`, but a field in the class is initialized to a non-constant value. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the field `s` is |
| initialized to a non-constant value: |
| |
| ```dart |
| String x = '3'; |
| class C { |
| final String s = x; |
| [!const!] C(); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the field can be initialized to a constant value, then change the |
| initializer to a constant expression: |
| |
| ```dart |
| class C { |
| final String s = '3'; |
| const C(); |
| } |
| ``` |
| |
| If the field can't be initialized to a constant value, then remove the |
| keyword `const` from the constructor: |
| |
| ```dart |
| String x = '3'; |
| class C { |
| final String s = x; |
| C(); |
| } |
| ``` |
| CONST_CONSTRUCTOR_WITH_MIXIN_WITH_FIELD: |
| problemMessage: "This constructor can't be declared 'const' because a mixin adds the instance field: {0}." |
| correctionMessage: "Try removing the 'const' keyword or removing the 'with' clause from the class declaration, or removing the field from the mixin class." |
| hasPublishedDocs: false |
| comment: |- |
| 7.6.3 Constant Constructors: The superinitializer that appears, explicitly |
| or implicitly, in the initializer list of a constant constructor must |
| specify a constant constructor of the superclass of the immediately |
| enclosing class or a compile-time error occurs. |
| |
| 12.1 Mixin Application: For each generative constructor named ... an |
| implicitly declared constructor named ... is declared. If Sq is a |
| generative const constructor, and M does not declare any fields, Cq is |
| also a const constructor. |
| |
| Parameters: |
| 0: the name of the instance field. |
| CONST_CONSTRUCTOR_WITH_MIXIN_WITH_FIELDS: |
| sharedName: CONST_CONSTRUCTOR_WITH_MIXIN_WITH_FIELD |
| problemMessage: "This constructor can't be declared 'const' because the mixins add the instance fields: {0}." |
| correctionMessage: "Try removing the 'const' keyword or removing the 'with' clause from the class declaration, or removing the fields from the mixin classes." |
| hasPublishedDocs: false |
| comment: |- |
| 7.6.3 Constant Constructors: The superinitializer that appears, explicitly |
| or implicitly, in the initializer list of a constant constructor must |
| specify a constant constructor of the superclass of the immediately |
| enclosing class or a compile-time error occurs. |
| |
| 12.1 Mixin Application: For each generative constructor named ... an |
| implicitly declared constructor named ... is declared. If Sq is a |
| generative const constructor, and M does not declare any fields, Cq is |
| also a const constructor. |
| |
| Parameters: |
| 0: the names of the instance fields. |
| CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER: |
| problemMessage: "A constant constructor can't call a non-constant super constructor of '{0}'." |
| correctionMessage: "Try calling a constant constructor in the superclass, or removing the keyword 'const' from the constructor." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the superclass |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a constructor that is marked as |
| `const` invokes a constructor from its superclass that isn't marked as |
| `const`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the `const` constructor |
| in `B` invokes the constructor `nonConst` from the class `A`, and the |
| superclass constructor isn't a `const` constructor: |
| |
| ```dart |
| class A { |
| const A(); |
| A.nonConst(); |
| } |
| |
| class B extends A { |
| const B() : [!super.nonConst()!]; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If it isn't essential to invoke the superclass constructor that is |
| currently being invoked, then invoke a constant constructor from the |
| superclass: |
| |
| ```dart |
| class A { |
| const A(); |
| A.nonConst(); |
| } |
| |
| class B extends A { |
| const B() : super(); |
| } |
| ``` |
| |
| If it's essential that the current constructor be invoked and if you can |
| modify it, then add `const` to the constructor in the superclass: |
| |
| ```dart |
| class A { |
| const A(); |
| const A.nonConst(); |
| } |
| |
| class B extends A { |
| const B() : super.nonConst(); |
| } |
| ``` |
| |
| If it's essential that the current constructor be invoked and you can't |
| modify it, then remove `const` from the constructor in the subclass: |
| |
| ```dart |
| class A { |
| const A(); |
| A.nonConst(); |
| } |
| |
| class B extends A { |
| B() : super.nonConst(); |
| } |
| ``` |
| CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD: |
| problemMessage: "Can't define a const constructor for a class with non-final fields." |
| correctionMessage: "Try making all of the fields final, or removing the keyword 'const' from the constructor." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a constructor is marked as a |
| const constructor, but the constructor is defined in a class that has at |
| least one non-final instance field (either directly or by inheritance). |
| |
| #### Example |
| |
| The following code produces this diagnostic because the field `x` isn't |
| final: |
| |
| ```dart |
| class C { |
| int x; |
| |
| const [!C!](this.x); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If it's possible to mark all of the fields as final, then do so: |
| |
| ```dart |
| class C { |
| final int x; |
| |
| const C(this.x); |
| } |
| ``` |
| |
| If it isn't possible to mark all of the fields as final, then remove the |
| keyword `const` from the constructor: |
| |
| ```dart |
| class C { |
| int x; |
| |
| C(this.x); |
| } |
| ``` |
| CONST_DEFERRED_CLASS: |
| problemMessage: "Deferred classes can't be created with 'const'." |
| correctionMessage: "Try using 'new' to create the instance, or changing the import to not be deferred." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a class from a library that is |
| imported using a deferred import is used to create a `const` object. |
| Constants are evaluated at compile time, and classes from deferred |
| libraries aren't available at compile time. |
| |
| For more information, check out |
| [Lazily loading a library](https://dart.dev/language/libraries#lazily-loading-a-library). |
| |
| #### Example |
| |
| The following code produces this diagnostic because it attempts to create a |
| `const` instance of a class from a deferred library: |
| |
| ```dart |
| import 'dart:convert' deferred as convert; |
| |
| const json2 = [!convert.JsonCodec()!]; |
| ``` |
| |
| #### Common fixes |
| |
| If the object isn't required to be a constant, then change the code so that |
| a non-constant instance is created: |
| |
| ```dart |
| import 'dart:convert' deferred as convert; |
| |
| final json2 = convert.JsonCodec(); |
| ``` |
| |
| If the object must be a constant, then remove `deferred` from the import |
| directive: |
| |
| ```dart |
| import 'dart:convert' as convert; |
| |
| const json2 = convert.JsonCodec(); |
| ``` |
| CONST_EVAL_ASSERTION_FAILURE: |
| problemMessage: "The assertion in this constant expression failed." |
| hasPublishedDocs: false |
| CONST_EVAL_ASSERTION_FAILURE_WITH_MESSAGE: |
| problemMessage: "An assertion failed with message '{0}'." |
| hasPublishedDocs: false |
| comment: |- |
| Parameters: |
| 0: the message of the assertion |
| CONST_EVAL_EXTENSION_METHOD: |
| problemMessage: "Extension methods can't be used in constant expressions." |
| hasPublishedDocs: false |
| CONST_EVAL_EXTENSION_TYPE_METHOD: |
| problemMessage: "Extension type methods can't be used in constant expressions." |
| hasPublishedDocs: false |
| CONST_EVAL_FOR_ELEMENT: |
| problemMessage: "Constant expressions don't support 'for' elements." |
| correctionMessage: "Try replacing the 'for' element with a spread, or removing 'const'." |
| hasPublishedDocs: false |
| CONST_EVAL_PROPERTY_ACCESS: |
| problemMessage: "The property '{0}' can't be accessed on the type '{1}' in a constant expression." |
| hasPublishedDocs: false |
| comment: |- |
| Parameters: |
| 0: the name of the property being accessed |
| 1: the type with the property being accessed |
| CONST_EVAL_METHOD_INVOCATION: |
| problemMessage: "Methods can't be invoked in constant expressions." |
| hasPublishedDocs: false |
| CONST_EVAL_THROWS_EXCEPTION: |
| problemMessage: Evaluation of this constant expression throws an exception. |
| hasPublishedDocs: false |
| comment: |- |
| 16.12.2 Const: It is a compile-time error if evaluation of a constant |
| object results in an uncaught exception being thrown. |
| CONST_EVAL_THROWS_IDBZE: |
| problemMessage: Evaluation of this constant expression throws an IntegerDivisionByZeroException. |
| hasPublishedDocs: false |
| comment: |- |
| 16.12.2 Const: It is a compile-time error if evaluation of a constant |
| object results in an uncaught exception being thrown. |
| CONST_EVAL_TYPE_BOOL: |
| problemMessage: "In constant expressions, operands of this operator must be of type 'bool'." |
| hasPublishedDocs: false |
| comment: |- |
| See https://spec.dart.dev/DartLangSpecDraft.pdf#constants, "Constants", |
| for text about "An expression of the form !e1", "An expression of the form |
| e1 && e2", and "An expression of the form e1 || e2". |
| CONST_EVAL_TYPE_BOOL_INT: |
| problemMessage: "In constant expressions, operands of this operator must be of type 'bool' or 'int'." |
| hasPublishedDocs: false |
| comment: |- |
| See https://spec.dart.dev/DartLangSpecDraft.pdf#constants, "Constants", |
| for text about "An expression of the form e1 & e2". |
| CONST_EVAL_TYPE_BOOL_NUM_STRING: |
| problemMessage: "In constant expressions, operands of this operator must be of type 'bool', 'num', 'String' or 'null'." |
| hasPublishedDocs: false |
| comment: |- |
| See https://spec.dart.dev/DartLangSpecDraft.pdf#constants, "Constants", |
| for text about "A literal string". |
| CONST_EVAL_TYPE_INT: |
| problemMessage: "In constant expressions, operands of this operator must be of type 'int'." |
| hasPublishedDocs: false |
| comment: |- |
| See https://spec.dart.dev/DartLangSpecDraft.pdf#constants, "Constants", |
| for text about "An expression of the form ~e1", "An expression of one of |
| the forms e1 >> e2". |
| CONST_EVAL_TYPE_NUM: |
| problemMessage: "In constant expressions, operands of this operator must be of type 'num'." |
| hasPublishedDocs: false |
| comment: |- |
| See https://spec.dart.dev/DartLangSpecDraft.pdf#constants, "Constants", |
| for text about "An expression of the form e1 - e2". |
| CONST_EVAL_TYPE_NUM_STRING: |
| problemMessage: "In constant expressions, operands of this operator must be of type 'num' or 'String'." |
| hasPublishedDocs: false |
| comment: |- |
| See https://spec.dart.dev/DartLangSpecDraft.pdf#constants, "Constants", |
| for text about "An expression of the form e1 + e2". |
| CONST_EVAL_TYPE_STRING: |
| problemMessage: "In constant expressions, operands of this operator must be of type 'String'." |
| hasPublishedDocs: false |
| comment: No parameters. |
| CONST_EVAL_TYPE_TYPE: |
| problemMessage: "In constant expressions, operands of this operator must be of type 'Type'." |
| hasPublishedDocs: false |
| CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE: |
| problemMessage: Const variables must be initialized with a constant value. |
| correctionMessage: Try changing the initializer to be a constant expression. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a value that isn't statically |
| known to be a constant is assigned to a variable that's declared to be a |
| `const` variable. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `x` isn't declared to |
| be `const`: |
| |
| ```dart |
| var x = 0; |
| const y = [!x!]; |
| ``` |
| |
| #### Common fixes |
| |
| If the value being assigned can be declared to be `const`, then change the |
| declaration: |
| |
| ```dart |
| const x = 0; |
| const y = x; |
| ``` |
| |
| If the value can't be declared to be `const`, then remove the `const` |
| modifier from the variable, possibly using `final` in its place: |
| |
| ```dart |
| var x = 0; |
| final y = x; |
| ``` |
| CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY: |
| problemMessage: "Constant values from a deferred library can't be used to initialize a 'const' variable." |
| correctionMessage: Try initializing the variable without referencing members of the deferred library, or changing the import to not be deferred. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a `const` variable is |
| initialized using a `const` variable from a library that is imported using |
| a deferred import. Constants are evaluated at compile time, and values from |
| deferred libraries aren't available at compile time. |
| |
| For more information, check out |
| [Lazily loading a library](https://dart.dev/language/libraries#lazily-loading-a-library). |
| |
| #### Example |
| |
| The following code produces this diagnostic because the variable `pi` is |
| being initialized using the constant `math.pi` from the library |
| `dart:math`, and `dart:math` is imported as a deferred library: |
| |
| ```dart |
| import 'dart:math' deferred as math; |
| |
| const pi = math.[!pi!]; |
| ``` |
| |
| #### Common fixes |
| |
| If you need to reference the value of the constant from the imported |
| library, then remove the keyword `deferred`: |
| |
| ```dart |
| import 'dart:math' as math; |
| |
| const pi = math.pi; |
| ``` |
| |
| If you don't need to reference the imported constant, then remove the |
| reference: |
| |
| ```dart |
| const pi = 3.14; |
| ``` |
| CONST_INSTANCE_FIELD: |
| problemMessage: Only static fields can be declared as const. |
| correctionMessage: "Try declaring the field as final, or adding the keyword 'static'." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when an instance field is marked as |
| being const. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `f` is an instance |
| field: |
| |
| ```dart |
| class C { |
| [!const!] int f = 3; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the field needs to be an instance field, then remove the keyword |
| `const`, or replace it with `final`: |
| |
| ```dart |
| class C { |
| final int f = 3; |
| } |
| ``` |
| |
| If the field really should be a const field, then make it a static field: |
| |
| ```dart |
| class C { |
| static const int f = 3; |
| } |
| ``` |
| CONST_MAP_KEY_NOT_PRIMITIVE_EQUALITY: |
| problemMessage: "The type of a key in a constant map can't override the '==' operator, or 'hashCode', but the class '{0}' does." |
| correctionMessage: "Try using a different value for the key, or removing the keyword 'const' from the map." |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the type of the entry's key |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the class of object used as a |
| key in a constant map literal implements either the `==` operator, the |
| getter `hashCode`, or both. The implementation of constant maps uses both |
| the `==` operator and the `hashCode` getter, so any implementation other |
| than the ones inherited from `Object` requires executing arbitrary code at |
| compile time, which isn't supported. |
| |
| #### Examples |
| |
| The following code produces this diagnostic because the constant map |
| contains a key whose type is `C`, and the class `C` overrides the |
| implementation of `==`: |
| |
| ```dart |
| class C { |
| const C(); |
| |
| bool operator ==(Object other) => true; |
| } |
| |
| const map = {[!C()!] : 0}; |
| ``` |
| |
| The following code produces this diagnostic because the constant map |
| contains a key whose type is `C`, and the class `C` overrides the |
| implementation of `hashCode`: |
| |
| ```dart |
| class C { |
| const C(); |
| |
| int get hashCode => 3; |
| } |
| |
| const map = {[!C()!] : 0}; |
| ``` |
| |
| #### Common fixes |
| |
| If you can remove the implementation of `==` and `hashCode` from the |
| class, then do so: |
| |
| ```dart |
| class C { |
| const C(); |
| } |
| |
| const map = {C() : 0}; |
| ``` |
| |
| If you can't remove the implementation of `==` and `hashCode` from the |
| class, then make the map non-constant: |
| |
| ```dart |
| class C { |
| const C(); |
| |
| bool operator ==(Object other) => true; |
| } |
| |
| final map = {C() : 0}; |
| ``` |
| CONST_NOT_INITIALIZED: |
| problemMessage: "The constant '{0}' must be initialized." |
| correctionMessage: Try adding an initialization to the declaration. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the uninitialized final variable |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a variable that is declared to |
| be a constant doesn't have an initializer. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `c` isn't initialized: |
| |
| ```dart |
| const [!c!]; |
| ``` |
| |
| #### Common fixes |
| |
| Add an initializer: |
| |
| ```dart |
| const c = 'c'; |
| ``` |
| CONST_SET_ELEMENT_NOT_PRIMITIVE_EQUALITY: |
| problemMessage: "An element in a constant set can't override the '==' operator, or 'hashCode', but the type '{0}' does." |
| correctionMessage: "Try using a different value for the element, or removing the keyword 'const' from the set." |
| previousName: CONST_SET_ELEMENT_TYPE_IMPLEMENTS_EQUALS |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the type of the element |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the class of object used as an |
| element in a constant set literal implements either the `==` operator, the |
| getter `hashCode`, or both. The implementation of constant sets uses both |
| the `==` operator and the `hashCode` getter, so any implementation other |
| than the ones inherited from `Object` requires executing arbitrary code at |
| compile time, which isn't supported. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the constant set |
| contains an element whose type is `C`, and the class `C` overrides the |
| implementation of `==`: |
| |
| ```dart |
| class C { |
| const C(); |
| |
| bool operator ==(Object other) => true; |
| } |
| |
| const set = {[!C()!]}; |
| ``` |
| |
| The following code produces this diagnostic because the constant set |
| contains an element whose type is `C`, and the class `C` overrides the |
| implementation of `hashCode`: |
| |
| ```dart |
| class C { |
| const C(); |
| |
| int get hashCode => 3; |
| } |
| |
| const map = {[!C()!]}; |
| ``` |
| |
| #### Common fixes |
| |
| If you can remove the implementation of `==` and `hashCode` from the |
| class, then do so: |
| |
| ```dart |
| class C { |
| const C(); |
| } |
| |
| const set = {C()}; |
| ``` |
| |
| If you can't remove the implementation of `==` and `hashCode` from the |
| class, then make the set non-constant: |
| |
| ```dart |
| class C { |
| const C(); |
| |
| bool operator ==(Object other) => true; |
| } |
| |
| final set = {C()}; |
| ``` |
| CONST_SPREAD_EXPECTED_LIST_OR_SET: |
| problemMessage: A list or a set is expected in this spread. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the expression of a spread |
| operator in a constant list or set evaluates to something other than a list |
| or a set. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the value of `list1` is |
| `null`, which is neither a list nor a set: |
| |
| ```dart |
| const dynamic list1 = 42; |
| const List<int> list2 = [...[!list1!]]; |
| ``` |
| |
| #### Common fixes |
| |
| Change the expression to something that evaluates to either a constant list |
| or a constant set: |
| |
| ```dart |
| const dynamic list1 = [42]; |
| const List<int> list2 = [...list1]; |
| ``` |
| CONST_SPREAD_EXPECTED_MAP: |
| problemMessage: A map is expected in this spread. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the expression of a spread |
| operator in a constant map evaluates to something other than a map. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the value of `map1` is |
| `null`, which isn't a map: |
| |
| ```dart |
| const dynamic map1 = 42; |
| const Map<String, int> map2 = {...[!map1!]}; |
| ``` |
| |
| #### Common fixes |
| |
| Change the expression to something that evaluates to a constant map: |
| |
| ```dart |
| const dynamic map1 = {'answer': 42}; |
| const Map<String, int> map2 = {...map1}; |
| ``` |
| CONST_TYPE_PARAMETER: |
| problemMessage: "Type parameters can't be used in a constant expression." |
| correctionMessage: Try replacing the type parameter with a different type. |
| hasPublishedDocs: false |
| comment: No parameters. |
| CONST_WITH_NON_CONST: |
| problemMessage: "The constructor being called isn't a const constructor." |
| correctionMessage: "Try removing 'const' from the constructor invocation." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the keyword `const` is used to |
| invoke a constructor that isn't marked with `const`. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the constructor in `A` |
| isn't a const constructor: |
| |
| ```dart |
| class A { |
| A(); |
| } |
| |
| A f() => [!const!] A(); |
| ``` |
| |
| #### Common fixes |
| |
| If it's desirable and possible to make the class a constant class (by |
| making all of the fields of the class, including inherited fields, final), |
| then add the keyword `const` to the constructor: |
| |
| ```dart |
| class A { |
| const A(); |
| } |
| |
| A f() => const A(); |
| ``` |
| |
| Otherwise, remove the keyword `const`: |
| |
| ```dart |
| class A { |
| A(); |
| } |
| |
| A f() => A(); |
| ``` |
| CONST_WITH_NON_CONSTANT_ARGUMENT: |
| problemMessage: Arguments of a constant creation must be constant expressions. |
| correctionMessage: "Try making the argument a valid constant, or use 'new' to call the constructor." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a const constructor is invoked |
| with an argument that isn't a constant expression. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `i` isn't a constant: |
| |
| ```dart |
| class C { |
| final int i; |
| const C(this.i); |
| } |
| C f(int i) => const C([!i!]); |
| ``` |
| |
| #### Common fixes |
| |
| Either make all of the arguments constant expressions, or remove the |
| `const` keyword to use the non-constant form of the constructor: |
| |
| ```dart |
| class C { |
| final int i; |
| const C(this.i); |
| } |
| C f(int i) => C(i); |
| ``` |
| CONST_WITH_TYPE_PARAMETERS: |
| problemMessage: "A constant creation can't use a type parameter as a type argument." |
| correctionMessage: Try replacing the type parameter with a different type. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a type parameter is used as a |
| type argument in a `const` invocation of a constructor. This isn't allowed |
| because the value of the type parameter (the actual type that will be used |
| at runtime) can't be known at compile time. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the type parameter `T` |
| is being used as a type argument when creating a constant: |
| |
| ```dart |
| class C<T> { |
| const C(); |
| } |
| |
| C<T> newC<T>() => const C<[!T!]>(); |
| ``` |
| |
| #### Common fixes |
| |
| If the type that will be used for the type parameter can be known at |
| compile time, then remove the use of the type parameter: |
| |
| ```dart |
| class C<T> { |
| const C(); |
| } |
| |
| C<int> newC() => const C<int>(); |
| ``` |
| |
| If the type that will be used for the type parameter can't be known until |
| runtime, then remove the keyword `const`: |
| |
| ```dart |
| class C<T> { |
| const C(); |
| } |
| |
| C<T> newC<T>() => C<T>(); |
| ``` |
| CONST_WITH_TYPE_PARAMETERS_CONSTRUCTOR_TEAROFF: |
| sharedName: CONST_WITH_TYPE_PARAMETERS |
| problemMessage: "A constant constructor tearoff can't use a type parameter as a type argument." |
| correctionMessage: Try replacing the type parameter with a different type. |
| hasPublishedDocs: true |
| comment: No parameters. |
| CONST_WITH_TYPE_PARAMETERS_FUNCTION_TEAROFF: |
| sharedName: CONST_WITH_TYPE_PARAMETERS |
| problemMessage: "A constant function tearoff can't use a type parameter as a type argument." |
| correctionMessage: Try replacing the type parameter with a different type. |
| hasPublishedDocs: true |
| comment: No parameters. |
| CONST_WITH_UNDEFINED_CONSTRUCTOR: |
| problemMessage: "The class '{0}' doesn't have a constant constructor '{1}'." |
| correctionMessage: Try calling a different constructor. |
| hasPublishedDocs: false |
| comment: |- |
| 16.12.2 Const: It is a compile-time error if <i>T.id</i> is not the name of |
| a constant constructor declared by the type <i>T</i>. |
| |
| Parameters: |
| 0: the name of the type |
| 1: the name of the requested constant constructor |
| CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT: |
| problemMessage: "The class '{0}' doesn't have an unnamed constant constructor." |
| correctionMessage: Try calling a different constructor. |
| hasPublishedDocs: false |
| comment: |- |
| 16.12.2 Const: It is a compile-time error if <i>T.id</i> is not the name of |
| a constant constructor declared by the type <i>T</i>. |
| |
| Parameters: |
| 0: the name of the type |
| CONSTANT_PATTERN_WITH_NON_CONSTANT_EXPRESSION: |
| problemMessage: The expression of a constant pattern must be a valid constant. |
| correctionMessage: Try making the expression a valid constant. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a constant pattern has an |
| expression that isn't a valid constant. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the constant pattern |
| `i` isn't a constant: |
| |
| ```dart |
| void f(int e, int i) { |
| switch (e) { |
| case [!i!]: |
| break; |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the value that should be matched is known, then replace the expression |
| with a constant: |
| |
| ```dart |
| void f(int e, int i) { |
| switch (e) { |
| case 0: |
| break; |
| } |
| } |
| ``` |
| |
| If the value that should be matched isn't known, then rewrite the code to |
| not use a pattern: |
| |
| ```dart |
| void f(int e, int i) { |
| if (e == i) {} |
| } |
| ``` |
| CONTINUE_LABEL_INVALID: |
| previousName: CONTINUE_LABEL_ON_SWITCH |
| hasPublishedDocs: true |
| problemMessage: The label used in a 'continue' statement must be defined on either a loop or a switch member. |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when the label in a `continue` |
| statement resolves to a label on a `switch` statement. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the label `l`, used to |
| label a `switch` statement, is used in the `continue` statement: |
| |
| ```dart |
| void f(int i) { |
| l: switch (i) { |
| case 0: |
| [!continue l;!] |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Find a different way to achieve the control flow you need; for example, by |
| introducing a loop that re-executes the `switch` statement. |
| COULD_NOT_INFER: |
| problemMessage: "Couldn't infer type parameter '{0}'.{1}" |
| hasPublishedDocs: false |
| comment: |- |
| Parameters: |
| 0: the name of the type parameter |
| 1: detail text explaining why the type could not be inferred |
| NEW_WITH_NON_TYPE: |
| sharedName: CREATION_WITH_NON_TYPE |
| problemMessage: "The name '{0}' isn't a class." |
| correctionMessage: Try correcting the name to match an existing class. |
| isUnresolvedIdentifier: true |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the non-type element |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when an instance creation using |
| either `new` or `const` specifies a name that isn't defined as a class. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `f` is a function |
| rather than a class: |
| |
| ```dart |
| int f() => 0; |
| |
| void g() { |
| new [!f!](); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If a class should be created, then replace the invalid name with the name |
| of a valid class: |
| |
| ```dart |
| int f() => 0; |
| |
| void g() { |
| new Object(); |
| } |
| ``` |
| |
| If the name is the name of a function and you want that function to be |
| invoked, then remove the `new` or `const` keyword: |
| |
| ```dart |
| int f() => 0; |
| |
| void g() { |
| f(); |
| } |
| ``` |
| CONST_WITH_NON_TYPE: |
| sharedName: CREATION_WITH_NON_TYPE |
| problemMessage: "The name '{0}' isn't a class." |
| correctionMessage: Try correcting the name to match an existing class. |
| isUnresolvedIdentifier: true |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the non-type element |
| DEFAULT_LIST_CONSTRUCTOR: |
| removedIn: "3.2" |
| problemMessage: "The default 'List' constructor isn't available when null safety is enabled." |
| correctionMessage: "Try using a list literal, 'List.filled' or 'List.generate'." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when it finds a use of the default |
| constructor for the class `List` in code that has opted in to null safety. |
| |
| #### Example |
| |
| Assuming the following code is opted in to null safety, it produces this |
| diagnostic because it uses the default `List` constructor: |
| |
| ```dart |
| var l = [!List<int>!](); |
| ``` |
| |
| #### Common fixes |
| |
| If no initial size is provided, then convert the code to use a list |
| literal: |
| |
| ```dart |
| var l = <int>[]; |
| ``` |
| |
| If an initial size needs to be provided and there is a single reasonable |
| initial value for the elements, then use `List.filled`: |
| |
| ```dart |
| var l = List.filled(3, 0); |
| ``` |
| |
| If an initial size needs to be provided but each element needs to be |
| computed, then use `List.generate`: |
| |
| ```dart |
| var l = List.generate(3, (i) => i); |
| ``` |
| DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR: |
| problemMessage: "Default values aren't allowed in factory constructors that redirect to another constructor." |
| correctionMessage: Try removing the default value. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a factory constructor that |
| redirects to another constructor specifies a default value for an optional |
| parameter. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the factory constructor |
| in `A` has a default value for the optional parameter `x`: |
| |
| ```dart |
| class A { |
| factory A([int [!x!] = 0]) = B; |
| } |
| |
| class B implements A { |
| B([int x = 1]) {} |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Remove the default value from the factory constructor: |
| |
| ```dart |
| class A { |
| factory A([int x]) = B; |
| } |
| |
| class B implements A { |
| B([int x = 1]) {} |
| } |
| ``` |
| |
| Note that this fix might change the value used when the optional parameter |
| is omitted. If that happens, and if that change is a problem, then consider |
| making the optional parameter a required parameter in the factory method: |
| |
| ```dart |
| class A { |
| factory A(int x) = B; |
| } |
| |
| class B implements A { |
| B([int x = 1]) {} |
| } |
| ``` |
| DEFAULT_VALUE_ON_REQUIRED_PARAMETER: |
| problemMessage: "Required named parameters can't have a default value." |
| correctionMessage: "Try removing either the default value or the 'required' modifier." |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a named parameter has both the |
| `required` modifier and a default value. If the parameter is required, then |
| a value for the parameter is always provided at the call sites, so the |
| default value can never be used. |
| |
| #### Example |
| |
| The following code generates this diagnostic: |
| |
| ```dart |
| void log({required String [!message!] = 'no message'}) {} |
| ``` |
| |
| #### Common fixes |
| |
| If the parameter is really required, then remove the default value: |
| |
| ```dart |
| void log({required String message}) {} |
| ``` |
| |
| If the parameter isn't always required, then remove the `required` |
| modifier: |
| |
| ```dart |
| void log({String message = 'no message'}) {} |
| ``` |
| DEFERRED_IMPORT_OF_EXTENSION: |
| problemMessage: Imports of deferred libraries must hide all extensions. |
| correctionMessage: Try adding either a show combinator listing the names you need to reference or a hide combinator listing all of the extensions. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a library that is imported using |
| a deferred import declares an extension that is visible in the importing |
| library. Extension methods are resolved at compile time, and extensions |
| from deferred libraries aren't available at compile time. |
| |
| For more information, check out |
| [Lazily loading a library](https://dart.dev/language/libraries#lazily-loading-a-library). |
| |
| #### Example |
| |
| Given a file `a.dart` that defines a named extension: |
| |
| ```dart |
| %uri="lib/a.dart" |
| class C {} |
| |
| extension E on String { |
| int get size => length; |
| } |
| ``` |
| |
| The following code produces this diagnostic because the named extension is |
| visible to the library: |
| |
| ```dart |
| import [!'a.dart'!] deferred as a; |
| |
| void f() { |
| a.C(); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the library must be imported as `deferred`, then either add a `show` |
| clause listing the names being referenced or add a `hide` clause listing |
| all of the named extensions. Adding a `show` clause would look like this: |
| |
| ```dart |
| import 'a.dart' deferred as a show C; |
| |
| void f() { |
| a.C(); |
| } |
| ``` |
| |
| Adding a `hide` clause would look like this: |
| |
| ```dart |
| import 'a.dart' deferred as a hide E; |
| |
| void f() { |
| a.C(); |
| } |
| ``` |
| |
| With the first fix, the benefit is that if new extensions are added to the |
| imported library, then the extensions won't cause a diagnostic to be |
| generated. |
| |
| If the library doesn't need to be imported as `deferred`, or if you need to |
| make use of the extension method declared in it, then remove the keyword |
| `deferred`: |
| |
| ```dart |
| import 'a.dart' as a; |
| |
| void f() { |
| a.C(); |
| } |
| ``` |
| DEFINITELY_UNASSIGNED_LATE_LOCAL_VARIABLE: |
| problemMessage: "The late local variable '{0}' is definitely unassigned at this point." |
| correctionMessage: Ensure that it is assigned on necessary execution paths. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the variable that is invalid |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when [definite assignment][] analysis |
| shows that a local variable that's marked as `late` is read before being |
| assigned. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `x` wasn't assigned a |
| value before being read: |
| |
| ```dart |
| void f(bool b) { |
| late int x; |
| print([!x!]); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Assign a value to the variable before reading from it: |
| |
| ```dart |
| void f(bool b) { |
| late int x; |
| x = b ? 1 : 0; |
| print(x); |
| } |
| ``` |
| DISALLOWED_TYPE_INSTANTIATION_EXPRESSION: |
| problemMessage: Only a generic type, generic function, generic instance method, or generic constructor can have type arguments. |
| correctionMessage: Try removing the type arguments, or instantiating the type(s) of a generic type, generic function, generic instance method, or generic constructor. |
| comment: No parameters. |
| hasPublishedDocs: true |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when an expression with a value that |
| is anything other than one of the allowed kinds of values is followed by |
| type arguments. The allowed kinds of values are: |
| - generic types, |
| - generic constructors, and |
| - generic functions, including top-level functions, static and instance |
| members, and local functions. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `i` is a top-level |
| variable, which isn't one of the allowed cases: |
| |
| ```dart |
| int i = 1; |
| |
| void f() { |
| print([!i!]<int>); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the referenced value is correct, then remove the type arguments: |
| |
| ```dart |
| int i = 1; |
| |
| void f() { |
| print(i); |
| } |
| ``` |
| DUPLICATE_CONSTRUCTOR_NAME: |
| sharedName: DUPLICATE_CONSTRUCTOR |
| problemMessage: "The constructor with name '{0}' is already defined." |
| correctionMessage: Try renaming one of the constructors. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the duplicate entity |
| DUPLICATE_CONSTRUCTOR_DEFAULT: |
| sharedName: DUPLICATE_CONSTRUCTOR |
| problemMessage: The unnamed constructor is already defined. |
| correctionMessage: Try giving one of the constructors a name. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a class declares more than one |
| unnamed constructor or when it declares more than one constructor with the |
| same name. |
| |
| #### Examples |
| |
| The following code produces this diagnostic because there are two |
| declarations for the unnamed constructor: |
| |
| ```dart |
| class C { |
| C(); |
| |
| [!C!](); |
| } |
| ``` |
| |
| The following code produces this diagnostic because there are two |
| declarations for the constructor named `m`: |
| |
| ```dart |
| class C { |
| C.m(); |
| |
| [!C.m!](); |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If there are multiple unnamed constructors and all of the constructors are |
| needed, then give all of them, or all except one of them, a name: |
| |
| ```dart |
| class C { |
| C(); |
| |
| C.n(); |
| } |
| ``` |
| |
| If there are multiple unnamed constructors and all except one of them are |
| unneeded, then remove the constructors that aren't needed: |
| |
| ```dart |
| class C { |
| C(); |
| } |
| ``` |
| |
| If there are multiple named constructors and all of the constructors are |
| needed, then rename all except one of them: |
| |
| ```dart |
| class C { |
| C.m(); |
| |
| C.n(); |
| } |
| ``` |
| |
| If there are multiple named constructors and all except one of them are |
| unneeded, then remove the constructors that aren't needed: |
| |
| ```dart |
| class C { |
| C.m(); |
| } |
| ``` |
| DUPLICATE_DEFINITION: |
| problemMessage: "The name '{0}' is already defined." |
| correctionMessage: Try renaming one of the declarations. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the duplicate entity |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a name is declared, and there is |
| a previous declaration with the same name in the same scope. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the name `x` is |
| declared twice: |
| |
| ```dart |
| int x = 0; |
| int [!x!] = 1; |
| ``` |
| |
| #### Common fixes |
| |
| Choose a different name for one of the declarations. |
| |
| ```dart |
| int x = 0; |
| int y = 1; |
| ``` |
| DUPLICATE_FIELD_NAME: |
| problemMessage: The field name '{0}' is already used in this record. |
| correctionMessage: Try renaming the field. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the duplicated name |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when either a record literal or a |
| record type annotation contains a field whose name is the same as a |
| previously declared field in the same literal or type. |
| |
| #### Examples |
| |
| The following code produces this diagnostic because the record literal has |
| two fields named `a`: |
| |
| ```dart |
| var r = (a: 1, [!a!]: 2); |
| ``` |
| |
| The following code produces this diagnostic because the record type |
| annotation has two fields named `a`, one a positional field and the other |
| a named field: |
| |
| ```dart |
| void f((int a, {int [!a!]}) r) {} |
| ``` |
| |
| #### Common fixes |
| |
| Rename one or both of the fields: |
| |
| ```dart |
| var r = (a: 1, b: 2); |
| ``` |
| DUPLICATE_FIELD_FORMAL_PARAMETER: |
| problemMessage: "The field '{0}' can't be initialized by multiple parameters in the same constructor." |
| correctionMessage: Try removing one of the parameters, or using different fields. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the field |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when there's more than one |
| initializing formal parameter for the same field in a constructor's |
| parameter list. It isn't useful to assign a value that will immediately be |
| overwritten. |
| |
| #### Example |
| |
| The following code produces this diagnostic because `this.f` appears twice |
| in the parameter list: |
| |
| ```dart |
| class C { |
| int f; |
| |
| C(this.f, this.[!f!]) {} |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Remove one of the initializing formal parameters: |
| |
| ```dart |
| class C { |
| int f; |
| |
| C(this.f) {} |
| } |
| ``` |
| DUPLICATE_NAMED_ARGUMENT: |
| problemMessage: "The argument for the named parameter '{0}' was already specified." |
| correctionMessage: Try removing one of the named arguments, or correcting one of the names to reference a different named parameter. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the parameter that was duplicated |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when an invocation has two or more |
| named arguments that have the same name. |
| |
| #### Example |
| |
| The following code produces this diagnostic because there are two arguments |
| with the name `a`: |
| |
| ```dart |
| void f(C c) { |
| c.m(a: 0, [!a!]: 1); |
| } |
| |
| class C { |
| void m({int? a, int? b}) {} |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If one of the arguments should have a different name, then change the name: |
| |
| ```dart |
| void f(C c) { |
| c.m(a: 0, b: 1); |
| } |
| |
| class C { |
| void m({int? a, int? b}) {} |
| } |
| ``` |
| |
| If one of the arguments is wrong, then remove it: |
| |
| ```dart |
| void f(C c) { |
| c.m(a: 1); |
| } |
| |
| class C { |
| void m({int? a, int? b}) {} |
| } |
| ``` |
| DUPLICATE_PART: |
| problemMessage: "The library already contains a part with the URI '{0}'." |
| correctionMessage: Try removing all except one of the duplicated part directives. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the URI of the duplicate part |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a single file is referenced in |
| multiple part directives. |
| |
| #### Example |
| |
| Given a file `part.dart` containing |
| |
| ```dart |
| %uri="lib/part.dart" |
| part of lib; |
| ``` |
| |
| The following code produces this diagnostic because the file `part.dart` is |
| included multiple times: |
| |
| ```dart |
| library lib; |
| |
| part 'part.dart'; |
| part [!'part.dart'!]; |
| ``` |
| |
| #### Common fixes |
| |
| Remove all except the first of the duplicated part directives: |
| |
| ```dart |
| library lib; |
| |
| part 'part.dart'; |
| ``` |
| DUPLICATE_PATTERN_ASSIGNMENT_VARIABLE: |
| problemMessage: The variable '{0}' is already assigned in this pattern. |
| correctionMessage: Try renaming the variable. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the variable |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a single pattern variable is |
| assigned a value more than once in the same pattern assignment. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the variable `a` is |
| assigned twice in the pattern `(a, a)`: |
| |
| ```dart |
| int f((int, int) r) { |
| int a; |
| (a, [!a!]) = r; |
| return a; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If you need to capture all of the values, then use a unique variable for |
| each of the subpatterns being matched: |
| |
| ```dart |
| int f((int, int) r) { |
| int a, b; |
| (a, b) = r; |
| return a + b; |
| } |
| ``` |
| |
| If some of the values don't need to be captured, then use a wildcard |
| pattern `_` to avoid having to bind the value to a variable: |
| |
| ```dart |
| int f((int, int) r) { |
| int a; |
| (_, a) = r; |
| return a; |
| } |
| ``` |
| DUPLICATE_PATTERN_FIELD: |
| problemMessage: The field '{0}' is already matched in this pattern. |
| correctionMessage: Try removing the duplicate field. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the field |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a record pattern matches the |
| same field more than once, or when an object pattern matches the same |
| getter more than once. |
| |
| #### Examples |
| |
| The following code produces this diagnostic because the record field `a` |
| is matched twice in the same record pattern: |
| |
| ```dart |
| void f(({int a, int b}) r) { |
| switch (r) { |
| case (a: 1, [!a!]: 2): |
| return; |
| } |
| } |
| ``` |
| |
| The following code produces this diagnostic because the getter `f` is |
| matched twice in the same object pattern: |
| |
| ```dart |
| void f(Object o) { |
| switch (o) { |
| case C(f: 1, [!f!]: 2): |
| return; |
| } |
| } |
| class C { |
| int? f; |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the pattern should match for more than one value of the duplicated |
| field, then use a logical-or pattern: |
| |
| ```dart |
| void f(({int a, int b}) r) { |
| switch (r) { |
| case (a: 1, b: _) || (a: 2, b: _): |
| break; |
| } |
| } |
| ``` |
| |
| If the pattern should match against multiple fields, then change the name |
| of one of the fields: |
| |
| ```dart |
| void f(({int a, int b}) r) { |
| switch (r) { |
| case (a: 1, b: 2): |
| return; |
| } |
| } |
| ``` |
| DUPLICATE_REST_ELEMENT_IN_PATTERN: |
| problemMessage: At most one rest element is allowed in a list or map pattern. |
| correctionMessage: Try removing the duplicate rest element. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when there's more than one rest |
| pattern in either a list or map pattern. A rest pattern will capture any |
| values unmatched by other subpatterns, making subsequent rest patterns |
| unnecessary because there's nothing left to capture. |
| |
| #### Example |
| |
| The following code produces this diagnostic because there are two rest |
| patterns in the list pattern: |
| |
| ```dart |
| void f(List<int> x) { |
| if (x case [0, ..., [!...!]]) {} |
| } |
| ``` |
| |
| #### Common fixes |
| |
| Remove all but one of the rest patterns: |
| |
| ```dart |
| void f(List<int> x) { |
| if (x case [0, ...]) {} |
| } |
| ``` |
| DUPLICATE_VARIABLE_PATTERN: |
| problemMessage: The variable '{0}' is already defined in this pattern. |
| correctionMessage: Try renaming the variable. |
| hasPublishedDocs: true |
| comment: |- |
| Parameters: |
| 0: the name of the variable |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a branch of a logical-and |
| pattern declares a variable that is already declared in an earlier branch |
| of the same pattern. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the variable `a` is |
| declared in both branches of the logical-and pattern: |
| |
| ```dart |
| void f((int, int) r) { |
| if (r case (var a, 0) && (0, var [!a!])) { |
| print(a); |
| } |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If you need to capture the matched value in multiple branches, then change |
| the names of the variables so that they are unique: |
| |
| ```dart |
| void f((int, int) r) { |
| if (r case (var a, 0) && (0, var b)) { |
| print(a + b); |
| } |
| } |
| ``` |
| |
| If you only need to capture the matched value on one branch, then remove |
| the variable pattern from all but one branch: |
| |
| ```dart |
| void f((int, int) r) { |
| if (r case (var a, 0) && (0, _)) { |
| print(a); |
| } |
| } |
| ``` |
| EMPTY_MAP_PATTERN: |
| problemMessage: A map pattern must have at least one entry. |
| correctionMessage: Try replacing it with an object pattern 'Map()'. |
| hasPublishedDocs: true |
| comment: No parameters. |
| documentation: |- |
| #### Description |
| |
| The analyzer produces this diagnostic when a map pattern is empty. |
| |
| #### Example |
| |
| The following code produces this diagnostic because the map pattern |
| is empty: |
| |
| ```dart |
| void f(Map<int, String> x) { |
| if (x case [!{}!]) {} |
| } |
| ``` |
| |
| #### Common fixes |
| |
| If the pattern should match any map, then replace it with an object |
| pattern: |
| |
| ```dart |
| void f(Map<int, String> x) { |
| if (x case Map()) {} |
| } |
| ``` |
| |
| If the pattern should only match an empty map, then check the length |
| in the pattern: |
| |
| ```dart |
| void f(Map<int, String> x) { |
| if (x case Map(isEmpty: true)) {} |
| } |
| ``` |
| ENUM_CONSTANT_INVOKES_FACTORY_CONSTRUCTOR: |
| problemMessage: "An enum value can't invoke a factory constructor." |
| correctionMessage: Try using a generative constructor. |
| hasPublishedDocs: false |
| ENUM_CONSTANT_SAME_NAME_AS_ENCLOSING: |
| problemMessage: "The name of the enum value can't be the same as the enum's name." |
<