Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(746)

Side by Side Diff: pkg/analyzer_experimental/lib/src/generated/error.dart

Issue 45573002: Rename analyzer_experimental to analyzer. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Tweaks before publishing. Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // This code was auto-generated, is not intended to be edited, and is subject to
2 // significant change. Please see the README file for more information.
3 library engine.error;
4 import 'java_core.dart';
5 import 'source.dart';
6 import 'ast.dart' show ASTNode;
7 import 'scanner.dart' show Token;
8 /**
9 * Instances of the enumeration `ErrorSeverity` represent the severity of an [Er rorCode]
10 * .
11 *
12 * @coverage dart.engine.error
13 */
14 class ErrorSeverity extends Enum<ErrorSeverity> {
15
16 /**
17 * The severity representing a non-error. This is never used for any error cod e, but is useful for
18 * clients.
19 */
20 static final ErrorSeverity NONE = new ErrorSeverity('NONE', 0, " ", "none");
21
22 /**
23 * The severity representing an informational level analysis issue.
24 */
25 static final ErrorSeverity INFO = new ErrorSeverity('INFO', 1, "I", "info");
26
27 /**
28 * The severity representing a warning. Warnings can become errors if the `-We rror` command
29 * line flag is specified.
30 */
31 static final ErrorSeverity WARNING = new ErrorSeverity('WARNING', 2, "W", "war ning");
32
33 /**
34 * The severity representing an error.
35 */
36 static final ErrorSeverity ERROR = new ErrorSeverity('ERROR', 3, "E", "error") ;
37 static final List<ErrorSeverity> values = [NONE, INFO, WARNING, ERROR];
38
39 /**
40 * The name of the severity used when producing machine output.
41 */
42 String machineCode;
43
44 /**
45 * The name of the severity used when producing readable output.
46 */
47 String displayName;
48
49 /**
50 * Initialize a newly created severity with the given names.
51 *
52 * @param machineCode the name of the severity used when producing machine out put
53 * @param displayName the name of the severity used when producing readable ou tput
54 */
55 ErrorSeverity(String name, int ordinal, String machineCode, String displayName ) : super(name, ordinal) {
56 this.machineCode = machineCode;
57 this.displayName = displayName;
58 }
59
60 /**
61 * Return the severity constant that represents the greatest severity.
62 *
63 * @param severity the severity being compared against
64 * @return the most sever of this or the given severity
65 */
66 ErrorSeverity max(ErrorSeverity severity) => this.ordinal >= severity.ordinal ? this : severity;
67 }
68 /**
69 * Instances of the class `AnalysisErrorWithProperties`
70 */
71 class AnalysisErrorWithProperties extends AnalysisError {
72
73 /**
74 * The properties associated with this error.
75 */
76 Map<ErrorProperty, Object> _propertyMap = new Map<ErrorProperty, Object>();
77
78 /**
79 * Initialize a newly created analysis error for the specified source. The err or has no location
80 * information.
81 *
82 * @param source the source for which the exception occurred
83 * @param errorCode the error code to be associated with this error
84 * @param arguments the arguments used to build the error message
85 */
86 AnalysisErrorWithProperties.con1(Source source, ErrorCode errorCode, List<Obje ct> arguments) : super.con1(source, errorCode, arguments);
87
88 /**
89 * Initialize a newly created analysis error for the specified source at the g iven location.
90 *
91 * @param source the source for which the exception occurred
92 * @param offset the offset of the location of the error
93 * @param length the length of the location of the error
94 * @param errorCode the error code to be associated with this error
95 * @param arguments the arguments used to build the error message
96 */
97 AnalysisErrorWithProperties.con2(Source source, int offset, int length, ErrorC ode errorCode, List<Object> arguments) : super.con2(source, offset, length, erro rCode, arguments);
98 Object getProperty(ErrorProperty property) => _propertyMap[property];
99
100 /**
101 * Set the value of the given property to the given value. Using a value of `n ull` will
102 * effectively remove the property from this error.
103 *
104 * @param property the property whose value is to be returned
105 * @param value the new value of the given property
106 */
107 void setProperty(ErrorProperty property, Object value) {
108 _propertyMap[property] = value;
109 }
110 }
111 /**
112 * Instances of the class `ErrorReporter` wrap an error listener with utility me thods used to
113 * create the errors being reported.
114 *
115 * @coverage dart.engine.error
116 */
117 class ErrorReporter {
118
119 /**
120 * The error listener to which errors will be reported.
121 */
122 AnalysisErrorListener _errorListener;
123
124 /**
125 * The default source to be used when reporting errors.
126 */
127 Source _defaultSource;
128
129 /**
130 * The source to be used when reporting errors.
131 */
132 Source _source;
133
134 /**
135 * Initialize a newly created error reporter that will report errors to the gi ven listener.
136 *
137 * @param errorListener the error listener to which errors will be reported
138 * @param defaultSource the default source to be used when reporting errors
139 */
140 ErrorReporter(AnalysisErrorListener errorListener, Source defaultSource) {
141 if (errorListener == null) {
142 throw new IllegalArgumentException("An error listener must be provided");
143 } else if (defaultSource == null) {
144 throw new IllegalArgumentException("A default source must be provided");
145 }
146 this._errorListener = errorListener;
147 this._defaultSource = defaultSource;
148 this._source = defaultSource;
149 }
150
151 /**
152 * Creates an error with properties with the given error code and arguments.
153 *
154 * @param errorCode the error code of the error to be reported
155 * @param node the node specifying the location of the error
156 * @param arguments the arguments to the error, used to compose the error mess age
157 */
158 AnalysisErrorWithProperties newErrorWithProperties(ErrorCode errorCode, ASTNod e node, List<Object> arguments) => new AnalysisErrorWithProperties.con2(_source, node.offset, node.length, errorCode, arguments);
159
160 /**
161 * Report a passed error.
162 *
163 * @param error the error to report
164 */
165 void reportError(AnalysisError error) {
166 _errorListener.onError(error);
167 }
168
169 /**
170 * Report an error with the given error code and arguments.
171 *
172 * @param errorCode the error code of the error to be reported
173 * @param node the node specifying the location of the error
174 * @param arguments the arguments to the error, used to compose the error mess age
175 */
176 void reportError2(ErrorCode errorCode, ASTNode node, List<Object> arguments) {
177 reportError3(errorCode, node.offset, node.length, arguments);
178 }
179
180 /**
181 * Report an error with the given error code and arguments.
182 *
183 * @param errorCode the error code of the error to be reported
184 * @param offset the offset of the location of the error
185 * @param length the length of the location of the error
186 * @param arguments the arguments to the error, used to compose the error mess age
187 */
188 void reportError3(ErrorCode errorCode, int offset, int length, List<Object> ar guments) {
189 _errorListener.onError(new AnalysisError.con2(_source, offset, length, error Code, arguments));
190 }
191
192 /**
193 * Report an error with the given error code and arguments.
194 *
195 * @param errorCode the error code of the error to be reported
196 * @param token the token specifying the location of the error
197 * @param arguments the arguments to the error, used to compose the error mess age
198 */
199 void reportError4(ErrorCode errorCode, Token token, List<Object> arguments) {
200 reportError3(errorCode, token.offset, token.length, arguments);
201 }
202
203 /**
204 * Set the source to be used when reporting errors. Setting the source to `nul l` will cause
205 * the default source to be used.
206 *
207 * @param source the source to be used when reporting errors
208 */
209 void set source(Source source) {
210 this._source = source == null ? _defaultSource : source;
211 }
212 }
213 /**
214 * Instances of the class `AnalysisError` represent an error discovered during t he analysis of
215 * some Dart code.
216 *
217 * @see AnalysisErrorListener
218 * @coverage dart.engine.error
219 */
220 class AnalysisError {
221
222 /**
223 * An empty array of errors used when no errors are expected.
224 */
225 static List<AnalysisError> NO_ERRORS = new List<AnalysisError>(0);
226
227 /**
228 * A [Comparator] that sorts by the name of the file that the [AnalysisError] was
229 * found.
230 */
231 static Comparator<AnalysisError> FILE_COMPARATOR = (AnalysisError o1, Analysis Error o2) => o1.source.shortName.compareTo(o2.source.shortName);
232
233 /**
234 * A [Comparator] that sorts error codes first by their severity (errors first , warnings
235 * second), and then by the the error code type.
236 */
237 static Comparator<AnalysisError> ERROR_CODE_COMPARATOR = (AnalysisError o1, An alysisError o2) {
238 ErrorCode errorCode1 = o1.errorCode;
239 ErrorCode errorCode2 = o2.errorCode;
240 ErrorSeverity errorSeverity1 = errorCode1.errorSeverity;
241 ErrorSeverity errorSeverity2 = errorCode2.errorSeverity;
242 ErrorType errorType1 = errorCode1.type;
243 ErrorType errorType2 = errorCode2.type;
244 if (errorSeverity1 == errorSeverity2) {
245 return errorType1.compareTo(errorType2);
246 } else {
247 return errorSeverity2.compareTo(errorSeverity1);
248 }
249 };
250
251 /**
252 * The error code associated with the error.
253 */
254 ErrorCode errorCode;
255
256 /**
257 * The localized error message.
258 */
259 String message;
260
261 /**
262 * The correction to be displayed for this error, or `null` if there is no cor rection
263 * information for this error.
264 */
265 String correction;
266
267 /**
268 * The source in which the error occurred, or `null` if unknown.
269 */
270 Source source;
271
272 /**
273 * The character offset from the beginning of the source (zero based) where th e error occurred.
274 */
275 int offset = 0;
276
277 /**
278 * The number of characters from the offset to the end of the source which enc ompasses the
279 * compilation error.
280 */
281 int length = 0;
282
283 /**
284 * A flag indicating whether this error can be shown to be a non-issue because of the result of
285 * type propagation.
286 */
287 bool isStaticOnly = false;
288
289 /**
290 * Initialize a newly created analysis error for the specified source. The err or has no location
291 * information.
292 *
293 * @param source the source for which the exception occurred
294 * @param errorCode the error code to be associated with this error
295 * @param arguments the arguments used to build the error message
296 */
297 AnalysisError.con1(Source source, ErrorCode errorCode, List<Object> arguments) {
298 this.source = source;
299 this.errorCode = errorCode;
300 this.message = JavaString.format(errorCode.message, arguments);
301 }
302
303 /**
304 * Initialize a newly created analysis error for the specified source at the g iven location.
305 *
306 * @param source the source for which the exception occurred
307 * @param offset the offset of the location of the error
308 * @param length the length of the location of the error
309 * @param errorCode the error code to be associated with this error
310 * @param arguments the arguments used to build the error message
311 */
312 AnalysisError.con2(Source source, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
313 this.source = source;
314 this.offset = offset;
315 this.length = length;
316 this.errorCode = errorCode;
317 this.message = JavaString.format(errorCode.message, arguments);
318 String correctionTemplate = errorCode.correction;
319 if (correctionTemplate != null) {
320 this.correction = JavaString.format(correctionTemplate, arguments);
321 }
322 }
323 bool operator ==(Object obj) {
324 if (identical(obj, this)) {
325 return true;
326 }
327 if (obj is! AnalysisError) {
328 return false;
329 }
330 AnalysisError other = obj as AnalysisError;
331 if (errorCode != other.errorCode) {
332 return false;
333 }
334 if (offset != other.offset || length != other.length) {
335 return false;
336 }
337 if (isStaticOnly != other.isStaticOnly) {
338 return false;
339 }
340 if (message != other.message) {
341 return false;
342 }
343 if (source != other.source) {
344 return false;
345 }
346 return true;
347 }
348
349 /**
350 * Return the value of the given property, or `null` if the given property is not defined
351 * for this error.
352 *
353 * @param property the property whose value is to be returned
354 * @return the value of the given property
355 */
356 Object getProperty(ErrorProperty property) => null;
357 int get hashCode {
358 int hashCode = offset;
359 hashCode ^= (message != null) ? message.hashCode : 0;
360 hashCode ^= (source != null) ? source.hashCode : 0;
361 return hashCode;
362 }
363 String toString() {
364 JavaStringBuilder builder = new JavaStringBuilder();
365 builder.append((source != null) ? source.fullName : "<unknown source>");
366 builder.append("(");
367 builder.append(offset);
368 builder.append("..");
369 builder.append(offset + length - 1);
370 builder.append("): ");
371 builder.append(message);
372 return builder.toString();
373 }
374 }
375 /**
376 * The enumeration `ErrorProperty` defines the properties that can be associated with an
377 * [AnalysisError].
378 */
379 class ErrorProperty extends Enum<ErrorProperty> {
380
381 /**
382 * A property whose value is an array of [ExecutableElement] that should
383 * be but are not implemented by a concrete class.
384 */
385 static final ErrorProperty UNIMPLEMENTED_METHODS = new ErrorProperty('UNIMPLEM ENTED_METHODS', 0);
386 static final List<ErrorProperty> values = [UNIMPLEMENTED_METHODS];
387 ErrorProperty(String name, int ordinal) : super(name, ordinal);
388 }
389 /**
390 * The enumeration `TodoCode` defines the single TODO `ErrorCode`.
391 */
392 class TodoCode extends Enum<TodoCode> implements ErrorCode {
393
394 /**
395 * The single enum of TodoCode.
396 */
397 static final TodoCode TODO = new TodoCode('TODO', 0);
398 static final List<TodoCode> values = [TODO];
399
400 /**
401 * This matches the two common Dart task styles
402 *
403 * * TODO:
404 * * TODO(username):
405 *
406 * As well as
407 * * TODO
408 *
409 * But not
410 * * todo
411 * * TODOS
412 */
413 static RegExp TODO_REGEX = new RegExp("([\\s/\\*])((TODO[^\\w\\d][^\\r\\n]*)|( TODO:?\$))");
414 TodoCode(String name, int ordinal) : super(name, ordinal);
415 String get correction => null;
416 ErrorSeverity get errorSeverity => ErrorSeverity.INFO;
417 String get message => "%s";
418 ErrorType get type => ErrorType.TODO;
419 }
420 /**
421 * The enumeration `HintCode` defines the hints and coding recommendations for b est practices
422 * which are not mentioned in the Dart Language Specification.
423 */
424 class HintCode extends Enum<HintCode> implements ErrorCode {
425
426 /**
427 * Dead code is code that is never reached, this can happen for instance if a statement follows a
428 * return statement.
429 */
430 static final HintCode DEAD_CODE = new HintCode.con1('DEAD_CODE', 0, "Dead code ");
431
432 /**
433 * Dead code is code that is never reached. This case covers cases where the u ser has catch
434 * clauses after `catch (e)` or `on Object catch (e)`.
435 */
436 static final HintCode DEAD_CODE_CATCH_FOLLOWING_CATCH = new HintCode.con1('DEA D_CODE_CATCH_FOLLOWING_CATCH', 1, "Dead code, catch clauses after a 'catch (e)' or an 'on Object catch (e)' are never reached");
437
438 /**
439 * Dead code is code that is never reached. This case covers cases where the u ser has an on-catch
440 * clause such as `on A catch (e)`, where a supertype of `A` was already caugh t.
441 *
442 * @param subtypeName name of the subtype
443 * @param supertypeName name of the supertype
444 */
445 static final HintCode DEAD_CODE_ON_CATCH_SUBTYPE = new HintCode.con1('DEAD_COD E_ON_CATCH_SUBTYPE', 2, "Dead code, this on-catch block will never be executed s ince '%s' is a subtype of '%s'");
446
447 /**
448 * Duplicate imports.
449 */
450 static final HintCode DUPLICATE_IMPORT = new HintCode.con1('DUPLICATE_IMPORT', 3, "Duplicate import");
451
452 /**
453 * Hint to use the ~/ operator.
454 */
455 static final HintCode DIVISION_OPTIMIZATION = new HintCode.con1('DIVISION_OPTI MIZATION', 4, "The operator x ~/ y is more efficient than (x / y).toInt()");
456
457 /**
458 * Hint for the `x is double` type checks.
459 */
460 static final HintCode IS_DOUBLE = new HintCode.con1('IS_DOUBLE', 5, "When comp iled to JS, this test might return true when the left hand side is an int");
461
462 /**
463 * Hint for the `x is int` type checks.
464 */
465 static final HintCode IS_INT = new HintCode.con1('IS_INT', 6, "When compiled t o JS, this test might return true when the left hand side is a double");
466
467 /**
468 * Hint for the `x is! double` type checks.
469 */
470 static final HintCode IS_NOT_DOUBLE = new HintCode.con1('IS_NOT_DOUBLE', 7, "W hen compiled to JS, this test might return false when the left hand side is an i nt");
471
472 /**
473 * Hint for the `x is! int` type checks.
474 */
475 static final HintCode IS_NOT_INT = new HintCode.con1('IS_NOT_INT', 8, "When co mpiled to JS, this test might return false when the left hand side is a double") ;
476
477 /**
478 * It is not in best practice to declare a private method that happens to over ride the method in a
479 * superclass- depending on where the superclass is (either in the same librar y, or out of the
480 * same library), behavior can be different.
481 *
482 * @param memberType this is either "method", "getter" or "setter"
483 * @param memberName some private member name
484 * @param className the class name where the member is overriding the function ality
485 */
486 static final HintCode OVERRIDDING_PRIVATE_MEMBER = new HintCode.con1('OVERRIDD ING_PRIVATE_MEMBER', 9, "The %s '%s' does not override the definition from '%s' because it is private and in a different library");
487
488 /**
489 * Hint for classes that override equals, but not hashCode.
490 *
491 * @param className the name of the current class
492 */
493 static final HintCode OVERRIDE_EQUALS_BUT_NOT_HASH_CODE = new HintCode.con1('O VERRIDE_EQUALS_BUT_NOT_HASH_CODE', 10, "The class '%s' overrides 'operator==', b ut not 'get hashCode'");
494
495 /**
496 * Type checks of the type `x is! Null` should be done with `x != null`.
497 */
498 static final HintCode TYPE_CHECK_IS_NOT_NULL = new HintCode.con1('TYPE_CHECK_I S_NOT_NULL', 11, "Tests for non-null should be done with '!= null'");
499
500 /**
501 * Type checks of the type `x is Null` should be done with `x == null`.
502 */
503 static final HintCode TYPE_CHECK_IS_NULL = new HintCode.con1('TYPE_CHECK_IS_NU LL', 12, "Tests for null should be done with '== null'");
504
505 /**
506 * This hint is generated anywhere where the [StaticTypeWarningCode#UNDEFINED_ GETTER] or
507 * [StaticWarningCode#UNDEFINED_GETTER] would have been generated, if we used propagated
508 * information for the warnings.
509 *
510 * @param getterName the name of the getter
511 * @param enclosingType the name of the enclosing type where the getter is bei ng looked for
512 * @see StaticTypeWarningCode#UNDEFINED_GETTER
513 * @see StaticWarningCode#UNDEFINED_GETTER
514 */
515 static final HintCode UNDEFINED_GETTER = new HintCode.con1('UNDEFINED_GETTER', 13, StaticTypeWarningCode.UNDEFINED_GETTER.message);
516
517 /**
518 * This hint is generated anywhere where the [StaticTypeWarningCode#UNDEFINED_ METHOD] would
519 * have been generated, if we used propagated information for the warnings.
520 *
521 * @param methodName the name of the method that is undefined
522 * @param typeName the resolved type name that the method lookup is happening on
523 * @see StaticTypeWarningCode#UNDEFINED_METHOD
524 */
525 static final HintCode UNDEFINED_METHOD = new HintCode.con1('UNDEFINED_METHOD', 14, StaticTypeWarningCode.UNDEFINED_METHOD.message);
526
527 /**
528 * This hint is generated anywhere where the [StaticTypeWarningCode#UNDEFINED_ OPERATOR]
529 * would have been generated, if we used propagated information for the warnin gs.
530 *
531 * @param operator the name of the operator
532 * @param enclosingType the name of the enclosing type where the operator is b eing looked for
533 * @see StaticTypeWarningCode#UNDEFINED_OPERATOR
534 */
535 static final HintCode UNDEFINED_OPERATOR = new HintCode.con1('UNDEFINED_OPERAT OR', 15, StaticTypeWarningCode.UNDEFINED_OPERATOR.message);
536
537 /**
538 * This hint is generated anywhere where the [StaticTypeWarningCode#UNDEFINED_ SETTER] or
539 * [StaticWarningCode#UNDEFINED_SETTER] would have been generated, if we used propagated
540 * information for the warnings.
541 *
542 * @param setterName the name of the setter
543 * @param enclosingType the name of the enclosing type where the setter is bei ng looked for
544 * @see StaticTypeWarningCode#UNDEFINED_SETTER
545 * @see StaticWarningCode#UNDEFINED_SETTER
546 */
547 static final HintCode UNDEFINED_SETTER = new HintCode.con1('UNDEFINED_SETTER', 16, StaticTypeWarningCode.UNDEFINED_SETTER.message);
548
549 /**
550 * Unnecessary cast.
551 */
552 static final HintCode UNNECESSARY_CAST = new HintCode.con1('UNNECESSARY_CAST', 17, "Unnecessary cast");
553
554 /**
555 * Unnecessary type checks, the result is always true.
556 */
557 static final HintCode UNNECESSARY_TYPE_CHECK_FALSE = new HintCode.con1('UNNECE SSARY_TYPE_CHECK_FALSE', 18, "Unnecessary type check, the result is always false ");
558
559 /**
560 * Unnecessary type checks, the result is always false.
561 */
562 static final HintCode UNNECESSARY_TYPE_CHECK_TRUE = new HintCode.con1('UNNECES SARY_TYPE_CHECK_TRUE', 19, "Unnecessary type check, the result is always true");
563
564 /**
565 * Unused imports are imports which are never not used.
566 */
567 static final HintCode UNUSED_IMPORT = new HintCode.con1('UNUSED_IMPORT', 20, " Unused import");
568 static final List<HintCode> values = [
569 DEAD_CODE,
570 DEAD_CODE_CATCH_FOLLOWING_CATCH,
571 DEAD_CODE_ON_CATCH_SUBTYPE,
572 DUPLICATE_IMPORT,
573 DIVISION_OPTIMIZATION,
574 IS_DOUBLE,
575 IS_INT,
576 IS_NOT_DOUBLE,
577 IS_NOT_INT,
578 OVERRIDDING_PRIVATE_MEMBER,
579 OVERRIDE_EQUALS_BUT_NOT_HASH_CODE,
580 TYPE_CHECK_IS_NOT_NULL,
581 TYPE_CHECK_IS_NULL,
582 UNDEFINED_GETTER,
583 UNDEFINED_METHOD,
584 UNDEFINED_OPERATOR,
585 UNDEFINED_SETTER,
586 UNNECESSARY_CAST,
587 UNNECESSARY_TYPE_CHECK_FALSE,
588 UNNECESSARY_TYPE_CHECK_TRUE,
589 UNUSED_IMPORT];
590
591 /**
592 * The template used to create the message to be displayed for this error.
593 */
594 String _message;
595
596 /**
597 * The template used to create the correction to be displayed for this error, or `null` if
598 * there is no correction information for this error.
599 */
600 String correction3;
601
602 /**
603 * Initialize a newly created error code to have the given message.
604 *
605 * @param message the message template used to create the message to be displa yed for the error
606 */
607 HintCode.con1(String name, int ordinal, String message) : super(name, ordinal) {
608 this._message = message;
609 }
610
611 /**
612 * Initialize a newly created error code to have the given message and correct ion.
613 *
614 * @param message the template used to create the message to be displayed for the error
615 * @param correction the template used to create the correction to be displaye d for the error
616 */
617 HintCode.con2(String name, int ordinal, String message, String correction) : s uper(name, ordinal) {
618 this._message = message;
619 this.correction3 = correction;
620 }
621 String get correction => correction3;
622 ErrorSeverity get errorSeverity => ErrorType.HINT.severity;
623 String get message => _message;
624 ErrorType get type => ErrorType.HINT;
625 }
626 /**
627 * The interface `ErrorCode` defines the behavior common to objects representing error codes
628 * associated with [AnalysisError].
629 *
630 * Generally, we want to provide messages that consist of three sentences: 1. wh at is wrong, 2. why
631 * is it wrong, and 3. how do I fix it. However, we combine the first two in the result of
632 * [getMessage] and the last in the result of [getCorrection].
633 *
634 * @coverage dart.engine.error
635 */
636 abstract class ErrorCode {
637
638 /**
639 * Return the template used to create the correction to be displayed for this error, or
640 * `null` if there is no correction information for this error. The correction should
641 * indicate how the user can fix the error.
642 *
643 * @return the template used to create the correction to be displayed for this error
644 */
645 String get correction;
646
647 /**
648 * Return the severity of this error.
649 *
650 * @return the severity of this error
651 */
652 ErrorSeverity get errorSeverity;
653
654 /**
655 * Return the template used to create the message to be displayed for this err or. The message
656 * should indicate what is wrong and why it is wrong.
657 *
658 * @return the template used to create the message to be displayed for this er ror
659 */
660 String get message;
661
662 /**
663 * Return the type of the error.
664 *
665 * @return the type of the error
666 */
667 ErrorType get type;
668 }
669 /**
670 * Instances of the enumeration `ErrorType` represent the type of an [ErrorCode] .
671 *
672 * @coverage dart.engine.error
673 */
674 class ErrorType extends Enum<ErrorType> {
675
676 /**
677 * Task (todo) comments in user code.
678 */
679 static final ErrorType TODO = new ErrorType('TODO', 0, ErrorSeverity.INFO);
680
681 /**
682 * Extra analysis run over the code to follow best practices, which are not in the Dart Language
683 * Specification.
684 */
685 static final ErrorType HINT = new ErrorType('HINT', 1, ErrorSeverity.INFO);
686
687 /**
688 * Compile-time errors are errors that preclude execution. A compile time erro r must be reported
689 * by a Dart compiler before the erroneous code is executed.
690 */
691 static final ErrorType COMPILE_TIME_ERROR = new ErrorType('COMPILE_TIME_ERROR' , 2, ErrorSeverity.ERROR);
692
693 /**
694 * Suggestions made in situations where the user has deviated from recommended pub programming
695 * practices.
696 */
697 static final ErrorType PUB_SUGGESTION = new ErrorType('PUB_SUGGESTION', 3, Err orSeverity.WARNING);
698
699 /**
700 * Static warnings are those warnings reported by the static checker. They hav e no effect on
701 * execution. Static warnings must be provided by Dart compilers used during d evelopment.
702 */
703 static final ErrorType STATIC_WARNING = new ErrorType('STATIC_WARNING', 4, Err orSeverity.WARNING);
704
705 /**
706 * Many, but not all, static warnings relate to types, in which case they are known as static type
707 * warnings.
708 */
709 static final ErrorType STATIC_TYPE_WARNING = new ErrorType('STATIC_TYPE_WARNIN G', 5, ErrorSeverity.WARNING);
710
711 /**
712 * Syntactic errors are errors produced as a result of input that does not con form to the grammar.
713 */
714 static final ErrorType SYNTACTIC_ERROR = new ErrorType('SYNTACTIC_ERROR', 6, E rrorSeverity.ERROR);
715 static final List<ErrorType> values = [
716 TODO,
717 HINT,
718 COMPILE_TIME_ERROR,
719 PUB_SUGGESTION,
720 STATIC_WARNING,
721 STATIC_TYPE_WARNING,
722 SYNTACTIC_ERROR];
723
724 /**
725 * The severity of this type of error.
726 */
727 ErrorSeverity severity;
728
729 /**
730 * Initialize a newly created error type to have the given severity.
731 *
732 * @param severity the severity of this type of error
733 */
734 ErrorType(String name, int ordinal, ErrorSeverity severity) : super(name, ordi nal) {
735 this.severity = severity;
736 }
737 String get displayName => name.toLowerCase().replaceAll('_', ' ');
738 }
739 /**
740 * The enumeration `CompileTimeErrorCode` defines the error codes used for compi le time
741 * errors. The convention for this class is for the name of the error code to in dicate the problem
742 * that caused the error to be generated and for the error message to explain wh at is wrong and,
743 * when appropriate, how the problem can be corrected.
744 *
745 * @coverage dart.engine.error
746 */
747 class CompileTimeErrorCode extends Enum<CompileTimeErrorCode> implements ErrorCo de {
748
749 /**
750 * 14.2 Exports: It is a compile-time error if a name <i>N</i> is re-exported by a library
751 * <i>L</i> and <i>N</i> is introduced into the export namespace of <i>L</i> b y more than one
752 * export.
753 *
754 * @param ambiguousElementName the name of the ambiguous element
755 * @param firstLibraryName the name of the first library that the type is foun d
756 * @param secondLibraryName the name of the second library that the type is fo und
757 */
758 static final CompileTimeErrorCode AMBIGUOUS_EXPORT = new CompileTimeErrorCode. con1('AMBIGUOUS_EXPORT', 0, "The element '%s' is defined in the libraries '%s' a nd '%s'");
759
760 /**
761 * 12.33 Argument Definition Test: It is a compile time error if <i>v</i> does not denote a formal
762 * parameter.
763 *
764 * @param the name of the identifier in the argument definition test that is n ot a parameter
765 */
766 static final CompileTimeErrorCode ARGUMENT_DEFINITION_TEST_NON_PARAMETER = new CompileTimeErrorCode.con1('ARGUMENT_DEFINITION_TEST_NON_PARAMETER', 1, "'%s' is not a parameter");
767
768 /**
769 * 12.30 Identifier Reference: It is a compile-time error to use a built-in id entifier other than
770 * dynamic as a type annotation.
771 */
772 static final CompileTimeErrorCode BUILT_IN_IDENTIFIER_AS_TYPE = new CompileTim eErrorCode.con1('BUILT_IN_IDENTIFIER_AS_TYPE', 2, "The built-in identifier '%s' cannot be as a type");
773
774 /**
775 * 12.30 Identifier Reference: It is a compile-time error if a built-in identi fier is used as the
776 * declared name of a class, type parameter or type alias.
777 */
778 static final CompileTimeErrorCode BUILT_IN_IDENTIFIER_AS_TYPE_NAME = new Compi leTimeErrorCode.con1('BUILT_IN_IDENTIFIER_AS_TYPE_NAME', 3, "The built-in identi fier '%s' cannot be used as a type name");
779
780 /**
781 * 12.30 Identifier Reference: It is a compile-time error if a built-in identi fier is used as the
782 * declared name of a class, type parameter or type alias.
783 */
784 static final CompileTimeErrorCode BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME = new Co mpileTimeErrorCode.con1('BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME', 4, "The built-in identifier '%s' cannot be used as a type alias name");
785
786 /**
787 * 12.30 Identifier Reference: It is a compile-time error if a built-in identi fier is used as the
788 * declared name of a class, type parameter or type alias.
789 */
790 static final CompileTimeErrorCode BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME = new CompileTimeErrorCode.con1('BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME', 5, "The built-in identifier '%s' cannot be used as a type parameter name");
791
792 /**
793 * 13.9 Switch: It is a compile-time error if the class <i>C</i> implements th e operator
794 * <i>==</i>.
795 */
796 static final CompileTimeErrorCode CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS = new CompileTimeErrorCode.con1('CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS', 6, "The swi tch case expression type '%s' cannot override the == operator");
797
798 /**
799 * 12.1 Constants: It is a compile-time error if evaluation of a compile-time constant would raise
800 * an exception.
801 */
802 static final CompileTimeErrorCode COMPILE_TIME_CONSTANT_RAISES_EXCEPTION = new CompileTimeErrorCode.con1('COMPILE_TIME_CONSTANT_RAISES_EXCEPTION', 7, "");
803
804 /**
805 * 7.2 Getters: It is a compile-time error if a class has both a getter and a method with the same
806 * name. This restriction holds regardless of whether the getter is defined ex plicitly or
807 * implicitly, or whether the getter or the method are inherited or not.
808 */
809 static final CompileTimeErrorCode CONFLICTING_GETTER_AND_METHOD = new CompileT imeErrorCode.con1('CONFLICTING_GETTER_AND_METHOD', 8, "Class '%s' cannot have bo th getter '%s.%s' and method with the same name");
810
811 /**
812 * 7.2 Getters: It is a compile-time error if a class has both a getter and a method with the same
813 * name. This restriction holds regardless of whether the getter is defined ex plicitly or
814 * implicitly, or whether the getter or the method are inherited or not.
815 */
816 static final CompileTimeErrorCode CONFLICTING_METHOD_AND_GETTER = new CompileT imeErrorCode.con1('CONFLICTING_METHOD_AND_GETTER', 9, "Class '%s' cannot have bo th method '%s.%s' and getter with the same name");
817
818 /**
819 * 7.6 Constructors: A constructor name always begins with the name of its imm ediately enclosing
820 * class, and may optionally be followed by a dot and an identifier <i>id</i>. It is a
821 * compile-time error if <i>id</i> is the name of a member declared in the imm ediately enclosing
822 * class.
823 */
824 static final CompileTimeErrorCode CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD = new CompileTimeErrorCode.con1('CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD', 10, "'%s' c annot be used to name a constructor and a field in this class");
825
826 /**
827 * 7.6 Constructors: A constructor name always begins with the name of its imm ediately enclosing
828 * class, and may optionally be followed by a dot and an identifier <i>id</i>. It is a
829 * compile-time error if <i>id</i> is the name of a member declared in the imm ediately enclosing
830 * class.
831 */
832 static final CompileTimeErrorCode CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD = ne w CompileTimeErrorCode.con1('CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD', 11, "'%s' cannot be used to name a constructor and a method in this class");
833
834 /**
835 * 7. Classes: It is a compile time error if a generic class declares a type v ariable with the
836 * same name as the class or any of its members or constructors.
837 */
838 static final CompileTimeErrorCode CONFLICTING_TYPE_VARIABLE_AND_CLASS = new Co mpileTimeErrorCode.con1('CONFLICTING_TYPE_VARIABLE_AND_CLASS', 12, "'%s' cannot be used to name a type varaible in a class with the same name");
839
840 /**
841 * 7. Classes: It is a compile time error if a generic class declares a type v ariable with the
842 * same name as the class or any of its members or constructors.
843 */
844 static final CompileTimeErrorCode CONFLICTING_TYPE_VARIABLE_AND_MEMBER = new C ompileTimeErrorCode.con1('CONFLICTING_TYPE_VARIABLE_AND_MEMBER', 13, "'%s' canno t be used to name a type varaible and member in this class");
845
846 /**
847 * 12.11.2 Const: It is a compile-time error if evaluation of a constant objec t results in an
848 * uncaught exception being thrown.
849 */
850 static final CompileTimeErrorCode CONST_CONSTRUCTOR_THROWS_EXCEPTION = new Com pileTimeErrorCode.con1('CONST_CONSTRUCTOR_THROWS_EXCEPTION', 14, "'const' constr uctors cannot throw exceptions");
851
852 /**
853 * 7.6.3 Constant Constructors: The superinitializer that appears, explicitly or implicitly, in
854 * the initializer list of a constant constructor must specify a constant cons tructor of the
855 * superclass of the immediately enclosing class or a compile-time error occur s.
856 */
857 static final CompileTimeErrorCode CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER = new CompileTimeErrorCode.con1('CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER', 15, "Consta nt constructor cannot call non-constant super constructor");
858
859 /**
860 * 7.6.3 Constant Constructors: It is a compile-time error if a constant const ructor is declared
861 * by a class that has a non-final instance variable.
862 *
863 * The above refers to both locally declared and inherited instance variables.
864 */
865 static final CompileTimeErrorCode CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD = new CompileTimeErrorCode.con1('CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD', 16, "Cannot define the 'const' constructor for a class with non-final fields");
866
867 /**
868 * 7.6.1 Generative Constructors: In checked mode, it is a dynamic type error if o is not
869 * <b>null</b> and the interface of the class of <i>o</i> is not a subtype of the static type of
870 * the field <i>v</i>.
871 *
872 * 12.11.2 Const: It is a compile-time error if evaluation of a constant objec t results in an
873 * uncaught exception being thrown.
874 *
875 * @param initializerType the name of the type of the initializer expression
876 * @param fieldType the name of the type of the field
877 */
878 static final CompileTimeErrorCode CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE = new CompileTimeErrorCode.con1('CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE', 17, "The in itializer type '%s' cannot be assigned to the field type '%s'");
879
880 /**
881 * 6.2 Formal Parameters: It is a compile-time error if a formal parameter is declared as a
882 * constant variable.
883 */
884 static final CompileTimeErrorCode CONST_FORMAL_PARAMETER = new CompileTimeErro rCode.con1('CONST_FORMAL_PARAMETER', 18, "Parameters cannot be 'const'");
885
886 /**
887 * 5 Variables: A constant variable must be initialized to a compile-time cons tant or a
888 * compile-time error occurs.
889 */
890 static final CompileTimeErrorCode CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE = new CompileTimeErrorCode.con1('CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE', 19, " 'const' variables must be constant value");
891
892 /**
893 * 7.5 Instance Variables: It is a compile-time error if an instance variable is declared to be
894 * constant.
895 */
896 static final CompileTimeErrorCode CONST_INSTANCE_FIELD = new CompileTimeErrorC ode.con1('CONST_INSTANCE_FIELD', 20, "Only static fields can be declared as 'con st'");
897
898 /**
899 * 12.8 Maps: It is a compile-time error if the key of an entry in a constant map literal is an
900 * instance of a class that implements the operator <i>==</i> unless the key i s a string or
901 * integer.
902 */
903 static final CompileTimeErrorCode CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQU ALS = new CompileTimeErrorCode.con1('CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQ UALS', 21, "The constant map entry key expression type '%s' cannot override the == operator");
904
905 /**
906 * 5 Variables: A constant variable must be initialized to a compile-time cons tant (12.1) or a
907 * compile-time error occurs.
908 *
909 * @param name the name of the uninitialized final variable
910 */
911 static final CompileTimeErrorCode CONST_NOT_INITIALIZED = new CompileTimeError Code.con1('CONST_NOT_INITIALIZED', 22, "The const variable '%s' must be initiali zed");
912
913 /**
914 * 12.11.2 Const: An expression of one of the forms !e, e1 && e2 or e1 || e2, where e, e1 and e2
915 * are constant expressions that evaluate to a boolean value.
916 */
917 static final CompileTimeErrorCode CONST_EVAL_TYPE_BOOL = new CompileTimeErrorC ode.con1('CONST_EVAL_TYPE_BOOL', 23, "An expression of type 'bool' was expected" );
918
919 /**
920 * 12.11.2 Const: An expression of one of the forms e1 == e2 or e1 != e2 where e1 and e2 are
921 * constant expressions that evaluate to a numeric, string or boolean value or to null.
922 */
923 static final CompileTimeErrorCode CONST_EVAL_TYPE_BOOL_NUM_STRING = new Compil eTimeErrorCode.con1('CONST_EVAL_TYPE_BOOL_NUM_STRING', 24, "An expression of typ e 'bool', 'num', 'String' or 'null' was expected");
924
925 /**
926 * 12.11.2 Const: An expression of one of the forms ~e, e1 ^ e2, e1 & e2, e1 | e2, e1 >> e2 or e1
927 * << e2, where e, e1 and e2 are constant expressions that evaluate to an inte ger value or to
928 * null.
929 */
930 static final CompileTimeErrorCode CONST_EVAL_TYPE_INT = new CompileTimeErrorCo de.con1('CONST_EVAL_TYPE_INT', 25, "An expression of type 'int' was expected");
931
932 /**
933 * 12.11.2 Const: An expression of one of the forms e, e1 + e2, e1 - e2, e1 * e2, e1 / e2, e1 ~/
934 * e2, e1 > e2, e1 < e2, e1 >= e2, e1 <= e2 or e1 % e2, where e, e1 and e2 are constant
935 * expressions that evaluate to a numeric value or to null..
936 */
937 static final CompileTimeErrorCode CONST_EVAL_TYPE_NUM = new CompileTimeErrorCo de.con1('CONST_EVAL_TYPE_NUM', 26, "An expression of type 'num' was expected");
938
939 /**
940 * 12.11.2 Const: It is a compile-time error if evaluation of a constant objec t results in an
941 * uncaught exception being thrown.
942 */
943 static final CompileTimeErrorCode CONST_EVAL_THROWS_EXCEPTION = new CompileTim eErrorCode.con1('CONST_EVAL_THROWS_EXCEPTION', 27, "Evaluation of this constant expression causes exception");
944
945 /**
946 * 12.11.2 Const: It is a compile-time error if evaluation of a constant objec t results in an
947 * uncaught exception being thrown.
948 */
949 static final CompileTimeErrorCode CONST_EVAL_THROWS_IDBZE = new CompileTimeErr orCode.con1('CONST_EVAL_THROWS_IDBZE', 28, "Evaluation of this constant expressi on throws IntegerDivisionByZeroException");
950
951 /**
952 * 12.11.2 Const: If <i>T</i> is a parameterized type <i>S&lt;U<sub>1</sub>, & hellip;,
953 * U<sub>m</sub>&gt;</i>, let <i>R = S</i>; It is a compile time error if <i>S </i> is not a
954 * generic type with <i>m</i> type parameters.
955 *
956 * @param typeName the name of the type being referenced (<i>S</i>)
957 * @param parameterCount the number of type parameters that were declared
958 * @param argumentCount the number of type arguments provided
959 * @see CompileTimeErrorCode#NEW_WITH_INVALID_TYPE_PARAMETERS
960 * @see StaticTypeWarningCode#WRONG_NUMBER_OF_TYPE_ARGUMENTS
961 */
962 static final CompileTimeErrorCode CONST_WITH_INVALID_TYPE_PARAMETERS = new Com pileTimeErrorCode.con1('CONST_WITH_INVALID_TYPE_PARAMETERS', 29, "The type '%s' is declared with %d type parameters, but %d type arguments were given");
963
964 /**
965 * 12.11.2 Const: If <i>e</i> is of the form <i>const T(a<sub>1</sub>, &hellip ;, a<sub>n</sub>,
966 * x<sub>n+1</sub>: a<sub>n+1</sub>, &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub >)</i> it is a
967 * compile-time error if the type <i>T</i> does not declare a constant constru ctor with the same
968 * name as the declaration of <i>T</i>.
969 */
970 static final CompileTimeErrorCode CONST_WITH_NON_CONST = new CompileTimeErrorC ode.con1('CONST_WITH_NON_CONST', 30, "The constructor being called is not a 'con st' constructor");
971
972 /**
973 * 12.11.2 Const: In all of the above cases, it is a compile-time error if <i> a<sub>i</sub>, 1
974 * &lt;= i &lt;= n + k</i>, is not a compile-time constant expression.
975 */
976 static final CompileTimeErrorCode CONST_WITH_NON_CONSTANT_ARGUMENT = new Compi leTimeErrorCode.con1('CONST_WITH_NON_CONSTANT_ARGUMENT', 31, "Arguments of a con stant creation must be constant expressions");
977
978 /**
979 * 12.11.2 Const: It is a compile-time error if <i>T</i> is not a class access ible in the current
980 * scope, optionally followed by type arguments.
981 *
982 * 12.11.2 Const: If <i>e</i> is of the form <i>const T.id(a<sub>1</sub>, &hel lip;, a<sub>n</sub>,
983 * x<sub>n+1</sub>: a<sub>n+1</sub>, &hellip; x<sub>n+k</sub>: a<sub>n+k</sub> )</i> it is a
984 * compile-time error if <i>T</i> is not a class accessible in the current sco pe, optionally
985 * followed by type arguments.
986 *
987 * @param name the name of the non-type element
988 */
989 static final CompileTimeErrorCode CONST_WITH_NON_TYPE = new CompileTimeErrorCo de.con1('CONST_WITH_NON_TYPE', 32, "The name '%s' is not a class");
990
991 /**
992 * 12.11.2 Const: It is a compile-time error if <i>T</i> includes any type par ameters.
993 */
994 static final CompileTimeErrorCode CONST_WITH_TYPE_PARAMETERS = new CompileTime ErrorCode.con1('CONST_WITH_TYPE_PARAMETERS', 33, "The constant creation cannot u se a type parameter");
995
996 /**
997 * 12.11.2 Const: It is a compile-time error if <i>T.id</i> is not the name of a constant
998 * constructor declared by the type <i>T</i>.
999 *
1000 * @param typeName the name of the type
1001 * @param constructorName the name of the requested constant constructor
1002 */
1003 static final CompileTimeErrorCode CONST_WITH_UNDEFINED_CONSTRUCTOR = new Compi leTimeErrorCode.con1('CONST_WITH_UNDEFINED_CONSTRUCTOR', 34, "The class '%s' doe s not have a constant constructor '%s'");
1004
1005 /**
1006 * 12.11.2 Const: It is a compile-time error if <i>T.id</i> is not the name of a constant
1007 * constructor declared by the type <i>T</i>.
1008 *
1009 * @param typeName the name of the type
1010 */
1011 static final CompileTimeErrorCode CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT = n ew CompileTimeErrorCode.con1('CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT', 35, "Th e class '%s' does not have a default constant constructor");
1012
1013 /**
1014 * 15.3.1 Typedef: It is a compile-time error if any default values are specif ied in the signature
1015 * of a function type alias.
1016 */
1017 static final CompileTimeErrorCode DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS = new C ompileTimeErrorCode.con1('DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS', 36, "Default va lues aren't allowed in typedefs");
1018
1019 /**
1020 * 6.2.1 Required Formals: By means of a function signature that names the par ameter and describes
1021 * its type as a function type. It is a compile-time error if any default valu es are specified in
1022 * the signature of such a function type.
1023 */
1024 static final CompileTimeErrorCode DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER = new CompileTimeErrorCode.con1('DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER', 37, " Default values aren't allowed in function type parameters");
1025
1026 /**
1027 * 7.6.2 Factories: It is a compile-time error if <i>k</i> explicitly specifie s a default value
1028 * for an optional parameter.
1029 */
1030 static final CompileTimeErrorCode DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRU CTOR = new CompileTimeErrorCode.con1('DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONST RUCTOR', 38, "Default values aren't allowed in factory constructors that redirec t to another constructor");
1031
1032 /**
1033 * 3.1 Scoping: It is a compile-time error if there is more than one entity wi th the same name
1034 * declared in the same scope.
1035 */
1036 static final CompileTimeErrorCode DUPLICATE_CONSTRUCTOR_DEFAULT = new CompileT imeErrorCode.con1('DUPLICATE_CONSTRUCTOR_DEFAULT', 39, "The default constructor is already defined");
1037
1038 /**
1039 * 3.1 Scoping: It is a compile-time error if there is more than one entity wi th the same name
1040 * declared in the same scope.
1041 *
1042 * @param duplicateName the name of the duplicate entity
1043 */
1044 static final CompileTimeErrorCode DUPLICATE_CONSTRUCTOR_NAME = new CompileTime ErrorCode.con1('DUPLICATE_CONSTRUCTOR_NAME', 40, "The constructor with name '%s' is already defined");
1045
1046 /**
1047 * 3.1 Scoping: It is a compile-time error if there is more than one entity wi th the same name
1048 * declared in the same scope.
1049 *
1050 * 7 Classes: It is a compile-time error if a class declares two members of th e same name.
1051 *
1052 * 7 Classes: It is a compile-time error if a class has an instance member and a static member
1053 * with the same name.
1054 *
1055 * @param duplicateName the name of the duplicate entity
1056 */
1057 static final CompileTimeErrorCode DUPLICATE_DEFINITION = new CompileTimeErrorC ode.con1('DUPLICATE_DEFINITION', 41, "The name '%s' is already defined");
1058
1059 /**
1060 * 7. Classes: It is a compile-time error if a class has an instance member an d a static member
1061 * with the same name.
1062 *
1063 * This covers the additional duplicate definition cases where inheritance has to be considered.
1064 *
1065 * @param className the name of the class that has conflicting instance/static members
1066 * @param name the name of the conflicting members
1067 * @see #DUPLICATE_DEFINITION
1068 */
1069 static final CompileTimeErrorCode DUPLICATE_DEFINITION_INHERITANCE = new Compi leTimeErrorCode.con1('DUPLICATE_DEFINITION_INHERITANCE', 42, "The name '%s' is a lready defined in '%s'");
1070
1071 /**
1072 * 12.14.2 Binding Actuals to Formals: It is a compile-time error if <i>q<sub> i</sub> =
1073 * q<sub>j</sub></i> for any <i>i != j</i> [where <i>q<sub>i</sub></i> is the label for a named
1074 * argument].
1075 */
1076 static final CompileTimeErrorCode DUPLICATE_NAMED_ARGUMENT = new CompileTimeEr rorCode.con1('DUPLICATE_NAMED_ARGUMENT', 43, "The argument for the named paramet er '%s' was already specified");
1077
1078 /**
1079 * SDK implementation libraries can be exported only by other SDK libraries.
1080 *
1081 * @param uri the uri pointing to a library
1082 */
1083 static final CompileTimeErrorCode EXPORT_INTERNAL_LIBRARY = new CompileTimeErr orCode.con1('EXPORT_INTERNAL_LIBRARY', 44, "The library '%s' is internal and can not be exported");
1084
1085 /**
1086 * 14.2 Exports: It is a compile-time error if the compilation unit found at t he specified URI is
1087 * not a library declaration.
1088 *
1089 * @param uri the uri pointing to a non-library declaration
1090 */
1091 static final CompileTimeErrorCode EXPORT_OF_NON_LIBRARY = new CompileTimeError Code.con1('EXPORT_OF_NON_LIBRARY', 45, "The exported library '%s' must not have a part-of directive");
1092
1093 /**
1094 * 7.9 Superclasses: It is a compile-time error if the extends clause of a cla ss <i>C</i> includes
1095 * a type expression that does not denote a class available in the lexical sco pe of <i>C</i>.
1096 *
1097 * @param typeName the name of the superclass that was not found
1098 */
1099 static final CompileTimeErrorCode EXTENDS_NON_CLASS = new CompileTimeErrorCode .con1('EXTENDS_NON_CLASS', 46, "Classes can only extend other classes");
1100
1101 /**
1102 * 12.2 Null: It is a compile-time error for a class to attempt to extend or i mplement Null.
1103 *
1104 * 12.3 Numbers: It is a compile-time error for a class to attempt to extend o r implement int.
1105 *
1106 * 12.3 Numbers: It is a compile-time error for a class to attempt to extend o r implement double.
1107 *
1108 * 12.3 Numbers: It is a compile-time error for any type other than the types int and double to
1109 * attempt to extend or implement num.
1110 *
1111 * 12.4 Booleans: It is a compile-time error for a class to attempt to extend or implement bool.
1112 *
1113 * 12.5 Strings: It is a compile-time error for a class to attempt to extend o r implement String.
1114 *
1115 * @param typeName the name of the type that cannot be extended
1116 * @see #IMPLEMENTS_DISALLOWED_CLASS
1117 */
1118 static final CompileTimeErrorCode EXTENDS_DISALLOWED_CLASS = new CompileTimeEr rorCode.con1('EXTENDS_DISALLOWED_CLASS', 47, "Classes cannot extend '%s'");
1119
1120 /**
1121 * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m &lt; h</ i> or if <i>m &gt;
1122 * n</i>.
1123 *
1124 * 12.11.2 Const: It is a compile-time error if evaluation of a constant objec t results in an
1125 * uncaught exception being thrown.
1126 *
1127 * @param requiredCount the maximum number of positional arguments
1128 * @param argumentCount the actual number of positional arguments given
1129 */
1130 static final CompileTimeErrorCode EXTRA_POSITIONAL_ARGUMENTS = new CompileTime ErrorCode.con1('EXTRA_POSITIONAL_ARGUMENTS', 48, "%d positional arguments expect ed, but %d found");
1131
1132 /**
1133 * 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. It is a compile time
1134 * error if more than one initializer corresponding to a given instance variab le appears in
1135 * <i>k</i>'s list.
1136 */
1137 static final CompileTimeErrorCode FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS = new CompileTimeErrorCode.con1('FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS', 49, "The field '%s' cannot be initialized twice in the same constructor");
1138
1139 /**
1140 * 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. It is a compile time
1141 * error if <i>k</i>'s initializer list contains an initializer for a variable that is initialized
1142 * by means of an initializing formal of <i>k</i>.
1143 */
1144 static final CompileTimeErrorCode FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZ ER = new CompileTimeErrorCode.con1('FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZ ER', 50, "Fields cannot be initialized in both the parameter list and the initia lizers");
1145
1146 /**
1147 * 5 Variables: It is a compile-time error if a final instance variable that h as is initialized by
1148 * means of an initializing formal of a constructor is also initialized elsewh ere in the same
1149 * constructor.
1150 *
1151 * @param name the name of the field in question
1152 */
1153 static final CompileTimeErrorCode FINAL_INITIALIZED_MULTIPLE_TIMES = new Compi leTimeErrorCode.con1('FINAL_INITIALIZED_MULTIPLE_TIMES', 51, "'%s' is a final fi eld and so can only be set once");
1154
1155 /**
1156 * 7.6.1 Generative Constructors: It is a compile-time error if an initializin g formal is used by
1157 * a function other than a non-redirecting generative constructor.
1158 */
1159 static final CompileTimeErrorCode FIELD_INITIALIZER_FACTORY_CONSTRUCTOR = new CompileTimeErrorCode.con1('FIELD_INITIALIZER_FACTORY_CONSTRUCTOR', 52, "Initiali zing formal fields cannot be used in factory constructors");
1160
1161 /**
1162 * 7.6.1 Generative Constructors: It is a compile-time error if an initializin g formal is used by
1163 * a function other than a non-redirecting generative constructor.
1164 */
1165 static final CompileTimeErrorCode FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR = new CompileTimeErrorCode.con1('FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR', 53, "Initiali zing formal fields can only be used in constructors");
1166
1167 /**
1168 * 7.6.1 Generative Constructors: A generative constructor may be redirecting, in which case its
1169 * only action is to invoke another generative constructor.
1170 *
1171 * 7.6.1 Generative Constructors: It is a compile-time error if an initializin g formal is used by
1172 * a function other than a non-redirecting generative constructor.
1173 */
1174 static final CompileTimeErrorCode FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR = new CompileTimeErrorCode.con1('FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR', 54, " The redirecting constructor cannot have a field initializer");
1175
1176 /**
1177 * 7.2 Getters: It is a compile-time error if a class has both a getter and a method with the same
1178 * name.
1179 *
1180 * @param name the conflicting name of the getter and method
1181 */
1182 static final CompileTimeErrorCode GETTER_AND_METHOD_WITH_SAME_NAME = new Compi leTimeErrorCode.con1('GETTER_AND_METHOD_WITH_SAME_NAME', 55, "'%s' cannot be use d to name a getter, there is already a method with the same name");
1183
1184 /**
1185 * 12.2 Null: It is a compile-time error for a class to attempt to extend or i mplement Null.
1186 *
1187 * 12.3 Numbers: It is a compile-time error for a class to attempt to extend o r implement int.
1188 *
1189 * 12.3 Numbers: It is a compile-time error for a class to attempt to extend o r implement double.
1190 *
1191 * 12.3 Numbers: It is a compile-time error for any type other than the types int and double to
1192 * attempt to extend or implement num.
1193 *
1194 * 12.4 Booleans: It is a compile-time error for a class to attempt to extend or implement bool.
1195 *
1196 * 12.5 Strings: It is a compile-time error for a class to attempt to extend o r implement String.
1197 *
1198 * @param typeName the name of the type that cannot be implemented
1199 * @see #EXTENDS_DISALLOWED_CLASS
1200 */
1201 static final CompileTimeErrorCode IMPLEMENTS_DISALLOWED_CLASS = new CompileTim eErrorCode.con1('IMPLEMENTS_DISALLOWED_CLASS', 56, "Classes cannot implement '%s '");
1202
1203 /**
1204 * 7.10 Superinterfaces: It is a compile-time error if the implements clause o f a class includes
1205 * type dynamic.
1206 */
1207 static final CompileTimeErrorCode IMPLEMENTS_DYNAMIC = new CompileTimeErrorCod e.con1('IMPLEMENTS_DYNAMIC', 57, "Classes cannot implement 'dynamic'");
1208
1209 /**
1210 * 7.10 Superinterfaces: It is a compile-time error if the implements clause o f a class <i>C</i>
1211 * includes a type expression that does not denote a class available in the le xical scope of
1212 * <i>C</i>.
1213 *
1214 * @param typeName the name of the interface that was not found
1215 */
1216 static final CompileTimeErrorCode IMPLEMENTS_NON_CLASS = new CompileTimeErrorC ode.con1('IMPLEMENTS_NON_CLASS', 58, "Classes can only implement other classes") ;
1217
1218 /**
1219 * 7.10 Superinterfaces: It is a compile-time error if a type <i>T</i> appears more than once in
1220 * the implements clause of a class.
1221 *
1222 * @param className the name of the class that is implemented more than once
1223 */
1224 static final CompileTimeErrorCode IMPLEMENTS_REPEATED = new CompileTimeErrorCo de.con1('IMPLEMENTS_REPEATED', 59, "'%s' can only be implemented once");
1225
1226 /**
1227 * 7.10 Superinterfaces: It is a compile-time error if the superclass of a cla ss <i>C</i> appears
1228 * in the implements clause of <i>C</i>.
1229 *
1230 * @param className the name of the class that appears in both "extends" and " implements" clauses
1231 */
1232 static final CompileTimeErrorCode IMPLEMENTS_SUPER_CLASS = new CompileTimeErro rCode.con1('IMPLEMENTS_SUPER_CLASS', 60, "'%s' cannot be used in both 'extends' and 'implements' clauses");
1233
1234 /**
1235 * 7.6.1 Generative Constructors: Note that <b>this</b> is not in scope on the right hand side of
1236 * an initializer.
1237 *
1238 * 12.10 This: It is a compile-time error if this appears in a top-level funct ion or variable
1239 * initializer, in a factory constructor, or in a static method or variable in itializer, or in the
1240 * initializer of an instance variable.
1241 *
1242 * @param name the name of the type in question
1243 */
1244 static final CompileTimeErrorCode IMPLICIT_THIS_REFERENCE_IN_INITIALIZER = new CompileTimeErrorCode.con1('IMPLICIT_THIS_REFERENCE_IN_INITIALIZER', 61, "Only s tatic members can be accessed in initializers");
1245
1246 /**
1247 * SDK implementation libraries can be imported only by other SDK libraries.
1248 *
1249 * @param uri the uri pointing to a library
1250 */
1251 static final CompileTimeErrorCode IMPORT_INTERNAL_LIBRARY = new CompileTimeErr orCode.con1('IMPORT_INTERNAL_LIBRARY', 62, "The library '%s' is internal and can not be imported");
1252
1253 /**
1254 * 14.1 Imports: It is a compile-time error if the compilation unit found at t he specified URI is
1255 * not a library declaration.
1256 *
1257 * @param uri the uri pointing to a non-library declaration
1258 */
1259 static final CompileTimeErrorCode IMPORT_OF_NON_LIBRARY = new CompileTimeError Code.con1('IMPORT_OF_NON_LIBRARY', 63, "The imported library '%s' must not have a part-of directive");
1260
1261 /**
1262 * 13.9 Switch: It is a compile-time error if values of the expressions <i>e<s ub>k</sub></i> are
1263 * not instances of the same class <i>C</i>, for all <i>1 &lt;= k &lt;= n</i>.
1264 *
1265 * @param expressionSource the expression source code that is the unexpected t ype
1266 * @param expectedType the name of the expected type
1267 */
1268 static final CompileTimeErrorCode INCONSISTENT_CASE_EXPRESSION_TYPES = new Com pileTimeErrorCode.con1('INCONSISTENT_CASE_EXPRESSION_TYPES', 64, "Case expressio ns must have the same types, '%s' is not a %s'");
1269
1270 /**
1271 * 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. It is a compile-time
1272 * error if <i>k</i>'s initializer list contains an initializer for a variable that is not an
1273 * instance variable declared in the immediately surrounding class.
1274 *
1275 * @param id the name of the initializing formal that is not an instance varia ble in the
1276 * immediately enclosing class
1277 * @see #INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD
1278 */
1279 static final CompileTimeErrorCode INITIALIZER_FOR_NON_EXISTANT_FIELD = new Com pileTimeErrorCode.con1('INITIALIZER_FOR_NON_EXISTANT_FIELD', 65, "'%s' is not a variable in the enclosing class");
1280
1281 /**
1282 * 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. It is a compile-time
1283 * error if <i>k</i>'s initializer list contains an initializer for a variable that is not an
1284 * instance variable declared in the immediately surrounding class.
1285 *
1286 * @param id the name of the initializing formal that is a static variable in the immediately
1287 * enclosing class
1288 * @see #INITIALIZING_FORMAL_FOR_STATIC_FIELD
1289 */
1290 static final CompileTimeErrorCode INITIALIZER_FOR_STATIC_FIELD = new CompileTi meErrorCode.con1('INITIALIZER_FOR_STATIC_FIELD', 66, "'%s' is a static variable in the enclosing class, variables initialized in a constructor cannot be static" );
1291
1292 /**
1293 * 7.6.1 Generative Constructors: An initializing formal has the form <i>this. id</i>. It is a
1294 * compile-time error if <i>id</i> is not the name of an instance variable of the immediately
1295 * enclosing class.
1296 *
1297 * @param id the name of the initializing formal that is not an instance varia ble in the
1298 * immediately enclosing class
1299 * @see #INITIALIZING_FORMAL_FOR_STATIC_FIELD
1300 * @see #INITIALIZER_FOR_NON_EXISTANT_FIELD
1301 */
1302 static final CompileTimeErrorCode INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD = new CompileTimeErrorCode.con1('INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD', 67, "'%s' is not a variable in the enclosing class");
1303
1304 /**
1305 * 7.6.1 Generative Constructors: An initializing formal has the form <i>this. id</i>. It is a
1306 * compile-time error if <i>id</i> is not the name of an instance variable of the immediately
1307 * enclosing class.
1308 *
1309 * @param id the name of the initializing formal that is a static variable in the immediately
1310 * enclosing class
1311 * @see #INITIALIZER_FOR_STATIC_FIELD
1312 */
1313 static final CompileTimeErrorCode INITIALIZING_FORMAL_FOR_STATIC_FIELD = new C ompileTimeErrorCode.con1('INITIALIZING_FORMAL_FOR_STATIC_FIELD', 68, "'%s' is a static variable in the enclosing class, variables initialized in a constructor c annot be static");
1314
1315 /**
1316 * 12.30 Identifier Reference: Otherwise, e is equivalent to the property extr action
1317 * <b>this</b>.<i>id</i>.
1318 */
1319 static final CompileTimeErrorCode INSTANCE_MEMBER_ACCESS_FROM_STATIC = new Com pileTimeErrorCode.con1('INSTANCE_MEMBER_ACCESS_FROM_STATIC', 69, "Instance membe r cannot be accessed from static method");
1320
1321 /**
1322 * 11 Metadata: Metadata consists of a series of annotations, each of which be gin with the
1323 * character @, followed by a constant expression that must be either a refere nce to a
1324 * compile-time constant variable, or a call to a constant constructor.
1325 */
1326 static final CompileTimeErrorCode INVALID_ANNOTATION = new CompileTimeErrorCod e.con1('INVALID_ANNOTATION', 70, "Annotation can be only constant variable or co nstant constructor invocation");
1327
1328 /**
1329 * TODO(brianwilkerson) Remove this when we have decided on how to report erro rs in compile-time
1330 * constants. Until then, this acts as a placeholder for more informative erro rs.
1331 *
1332 * See TODOs in ConstantVisitor
1333 */
1334 static final CompileTimeErrorCode INVALID_CONSTANT = new CompileTimeErrorCode. con1('INVALID_CONSTANT', 71, "Invalid constant value");
1335
1336 /**
1337 * 7.6 Constructors: It is a compile-time error if the name of a constructor i s not a constructor
1338 * name.
1339 */
1340 static final CompileTimeErrorCode INVALID_CONSTRUCTOR_NAME = new CompileTimeEr rorCode.con1('INVALID_CONSTRUCTOR_NAME', 72, "Invalid constructor name");
1341
1342 /**
1343 * 7.6.2 Factories: It is a compile-time error if <i>M</i> is not the name of the immediately
1344 * enclosing class.
1345 */
1346 static final CompileTimeErrorCode INVALID_FACTORY_NAME_NOT_A_CLASS = new Compi leTimeErrorCode.con1('INVALID_FACTORY_NAME_NOT_A_CLASS', 73, "The name of the im mediately enclosing class expected");
1347
1348 /**
1349 * 12.10 This: It is a compile-time error if this appears in a top-level funct ion or variable
1350 * initializer, in a factory constructor, or in a static method or variable in itializer, or in the
1351 * initializer of an instance variable.
1352 */
1353 static final CompileTimeErrorCode INVALID_REFERENCE_TO_THIS = new CompileTimeE rrorCode.con1('INVALID_REFERENCE_TO_THIS', 74, "Invalid reference to 'this' expr ession");
1354
1355 /**
1356 * 12.6 Lists: It is a compile time error if the type argument of a constant l ist literal includes
1357 * a type parameter.
1358 *
1359 * @name the name of the type parameter
1360 */
1361 static final CompileTimeErrorCode INVALID_TYPE_ARGUMENT_IN_CONST_LIST = new Co mpileTimeErrorCode.con1('INVALID_TYPE_ARGUMENT_IN_CONST_LIST', 75, "Constant lis t literals cannot include a type parameter as a type argument, such as '%s'");
1362
1363 /**
1364 * 12.7 Maps: It is a compile time error if the type arguments of a constant m ap literal include a
1365 * type parameter.
1366 *
1367 * @name the name of the type parameter
1368 */
1369 static final CompileTimeErrorCode INVALID_TYPE_ARGUMENT_IN_CONST_MAP = new Com pileTimeErrorCode.con1('INVALID_TYPE_ARGUMENT_IN_CONST_MAP', 76, "Constant map l iterals cannot include a type parameter as a type argument, such as '%s'");
1370
1371 /**
1372 * 14.2 Exports: It is a compile-time error if the compilation unit found at t he specified URI is
1373 * not a library declaration.
1374 *
1375 * 14.1 Imports: It is a compile-time error if the compilation unit found at t he specified URI is
1376 * not a library declaration.
1377 *
1378 * 14.3 Parts: It is a compile time error if the contents of the URI are not a valid part
1379 * declaration.
1380 *
1381 * @param uri the URI that is invalid
1382 * @see #URI_DOES_NOT_EXIST
1383 */
1384 static final CompileTimeErrorCode INVALID_URI = new CompileTimeErrorCode.con1( 'INVALID_URI', 77, "Invalid URI syntax: '%s'");
1385
1386 /**
1387 * 13.13 Break: It is a compile-time error if no such statement <i>s<sub>E</su b></i> exists within
1388 * the innermost function in which <i>s<sub>b</sub></i> occurs.
1389 *
1390 * 13.14 Continue: It is a compile-time error if no such statement or case cla use
1391 * <i>s<sub>E</sub></i> exists within the innermost function in which <i>s<sub >c</sub></i> occurs.
1392 *
1393 * @param labelName the name of the unresolvable label
1394 */
1395 static final CompileTimeErrorCode LABEL_IN_OUTER_SCOPE = new CompileTimeErrorC ode.con1('LABEL_IN_OUTER_SCOPE', 78, "Cannot reference label '%s' declared in an outer method");
1396
1397 /**
1398 * 13.13 Break: It is a compile-time error if no such statement <i>s<sub>E</su b></i> exists within
1399 * the innermost function in which <i>s<sub>b</sub></i> occurs.
1400 *
1401 * 13.14 Continue: It is a compile-time error if no such statement or case cla use
1402 * <i>s<sub>E</sub></i> exists within the innermost function in which <i>s<sub >c</sub></i> occurs.
1403 *
1404 * @param labelName the name of the unresolvable label
1405 */
1406 static final CompileTimeErrorCode LABEL_UNDEFINED = new CompileTimeErrorCode.c on1('LABEL_UNDEFINED', 79, "Cannot reference undefined label '%s'");
1407
1408 /**
1409 * 12.6 Lists: A run-time list literal &lt;<i>E</i>&gt; [<i>e<sub>1</sub></i> ...
1410 * <i>e<sub>n</sub></i>] is evaluated as follows:
1411 *
1412 * * The operator []= is invoked on <i>a</i> with first argument <i>i</i> and second argument
1413 * <i>o<sub>i+1</sub></i><i>, 1 &lt;= i &lt;= n</i>
1414 *
1415 *
1416 * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static type of
1417 * <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of <i>p<sub>i</s ub>, 1 &lt;= i &lt;=
1418 * n+k</i> and let <i>S<sub>q</sub></i> be the type of the named parameter <i> q</i> of <i>f</i>.
1419 * It is a static warning if <i>T<sub>j</sub></i> may not be assigned to <i>S< sub>j</sub>, 1 &lt;=
1420 * j &lt;= m</i>.
1421 */
1422 static final CompileTimeErrorCode LIST_ELEMENT_TYPE_NOT_ASSIGNABLE = new Compi leTimeErrorCode.con1('LIST_ELEMENT_TYPE_NOT_ASSIGNABLE', 80, "The element type ' %s' cannot be assigned to the list type '%s'");
1423
1424 /**
1425 * 12.7 Map: A run-time map literal &lt;<i>K</i>, <i>V</i>&gt; [<i>k<sub>1</su b></i> :
1426 * <i>e<sub>1</sub></i> ... <i>k<sub>n</sub></i> : <i>e<sub>n</sub></i>] is ev aluated as follows:
1427 *
1428 * * The operator []= is invoked on <i>m</i> with first argument <i>k<sub>i</s ub></i> and second
1429 * argument <i>e<sub>i</sub></i><i>, 1 &lt;= i &lt;= n</i>
1430 *
1431 *
1432 * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static type of
1433 * <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of <i>p<sub>i</s ub>, 1 &lt;= i &lt;=
1434 * n+k</i> and let <i>S<sub>q</sub></i> be the type of the named parameter <i> q</i> of <i>f</i>.
1435 * It is a static warning if <i>T<sub>j</sub></i> may not be assigned to <i>S< sub>j</sub>, 1 &lt;=
1436 * j &lt;= m</i>.
1437 */
1438 static final CompileTimeErrorCode MAP_KEY_TYPE_NOT_ASSIGNABLE = new CompileTim eErrorCode.con1('MAP_KEY_TYPE_NOT_ASSIGNABLE', 81, "The element type '%s' cannot be assigned to the map key type '%s'");
1439
1440 /**
1441 * 12.7 Map: A run-time map literal &lt;<i>K</i>, <i>V</i>&gt; [<i>k<sub>1</su b></i> :
1442 * <i>e<sub>1</sub></i> ... <i>k<sub>n</sub></i> : <i>e<sub>n</sub></i>] is ev aluated as follows:
1443 *
1444 * * The operator []= is invoked on <i>m</i> with first argument <i>k<sub>i</s ub></i> and second
1445 * argument <i>e<sub>i</sub></i><i>, 1 &lt;= i &lt;= n</i>
1446 *
1447 *
1448 * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static type of
1449 * <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of <i>p<sub>i</s ub>, 1 &lt;= i &lt;=
1450 * n+k</i> and let <i>S<sub>q</sub></i> be the type of the named parameter <i> q</i> of <i>f</i>.
1451 * It is a static warning if <i>T<sub>j</sub></i> may not be assigned to <i>S< sub>j</sub>, 1 &lt;=
1452 * j &lt;= m</i>.
1453 */
1454 static final CompileTimeErrorCode MAP_VALUE_TYPE_NOT_ASSIGNABLE = new CompileT imeErrorCode.con1('MAP_VALUE_TYPE_NOT_ASSIGNABLE', 82, "The element type '%s' ca nnot be assigned to the map value type '%s'");
1455
1456 /**
1457 * 7 Classes: It is a compile time error if a class <i>C</i> declares a member with the same name
1458 * as <i>C</i>.
1459 */
1460 static final CompileTimeErrorCode MEMBER_WITH_CLASS_NAME = new CompileTimeErro rCode.con1('MEMBER_WITH_CLASS_NAME', 83, "Class members cannot have the same nam e as the enclosing class");
1461
1462 /**
1463 * 7.2 Getters: It is a compile-time error if a class has both a getter and a method with the same
1464 * name.
1465 *
1466 * @param name the conflicting name of the getter and method
1467 */
1468 static final CompileTimeErrorCode METHOD_AND_GETTER_WITH_SAME_NAME = new Compi leTimeErrorCode.con1('METHOD_AND_GETTER_WITH_SAME_NAME', 84, "'%s' cannot be use d to name a method, there is already a getter with the same name");
1469
1470 /**
1471 * 12.1 Constants: A constant expression is ... a constant list literal.
1472 */
1473 static final CompileTimeErrorCode MISSING_CONST_IN_LIST_LITERAL = new CompileT imeErrorCode.con1('MISSING_CONST_IN_LIST_LITERAL', 85, "List literals must be pr efixed with 'const' when used as a constant expression");
1474
1475 /**
1476 * 12.1 Constants: A constant expression is ... a constant map literal.
1477 */
1478 static final CompileTimeErrorCode MISSING_CONST_IN_MAP_LITERAL = new CompileTi meErrorCode.con1('MISSING_CONST_IN_MAP_LITERAL', 86, "Map literals must be prefi xed with 'const' when used as a constant expression");
1479
1480 /**
1481 * 9 Mixins: It is a compile-time error if a declared or derived mixin explici tly declares a
1482 * constructor.
1483 *
1484 * @param typeName the name of the mixin that is invalid
1485 */
1486 static final CompileTimeErrorCode MIXIN_DECLARES_CONSTRUCTOR = new CompileTime ErrorCode.con1('MIXIN_DECLARES_CONSTRUCTOR', 87, "The class '%s' cannot be used as a mixin because it declares a constructor");
1487
1488 /**
1489 * 9 Mixins: It is a compile-time error if a mixin is derived from a class who se superclass is not
1490 * Object.
1491 *
1492 * @param typeName the name of the mixin that is invalid
1493 */
1494 static final CompileTimeErrorCode MIXIN_INHERITS_FROM_NOT_OBJECT = new Compile TimeErrorCode.con1('MIXIN_INHERITS_FROM_NOT_OBJECT', 88, "The class '%s' cannot be used as a mixin because it extends a class other than Object");
1495
1496 /**
1497 * 12.2 Null: It is a compile-time error for a class to attempt to extend or i mplement Null.
1498 *
1499 * 12.3 Numbers: It is a compile-time error for a class to attempt to extend o r implement int.
1500 *
1501 * 12.3 Numbers: It is a compile-time error for a class to attempt to extend o r implement double.
1502 *
1503 * 12.3 Numbers: It is a compile-time error for any type other than the types int and double to
1504 * attempt to extend or implement num.
1505 *
1506 * 12.4 Booleans: It is a compile-time error for a class to attempt to extend or implement bool.
1507 *
1508 * 12.5 Strings: It is a compile-time error for a class to attempt to extend o r implement String.
1509 *
1510 * @param typeName the name of the type that cannot be extended
1511 * @see #IMPLEMENTS_DISALLOWED_CLASS
1512 */
1513 static final CompileTimeErrorCode MIXIN_OF_DISALLOWED_CLASS = new CompileTimeE rrorCode.con1('MIXIN_OF_DISALLOWED_CLASS', 89, "Classes cannot mixin '%s'");
1514
1515 /**
1516 * 9.1 Mixin Application: It is a compile-time error if <i>M</i> does not deno te a class or mixin
1517 * available in the immediately enclosing scope.
1518 */
1519 static final CompileTimeErrorCode MIXIN_OF_NON_CLASS = new CompileTimeErrorCod e.con1('MIXIN_OF_NON_CLASS', 90, "Classes can only mixin other classes");
1520
1521 /**
1522 * 9 Mixins: It is a compile-time error if a declared or derived mixin refers to super.
1523 */
1524 static final CompileTimeErrorCode MIXIN_REFERENCES_SUPER = new CompileTimeErro rCode.con1('MIXIN_REFERENCES_SUPER', 91, "The class '%s' cannot be used as a mix in because it references 'super'");
1525
1526 /**
1527 * 9.1 Mixin Application: It is a compile-time error if <i>S</i> does not deno te a class available
1528 * in the immediately enclosing scope.
1529 */
1530 static final CompileTimeErrorCode MIXIN_WITH_NON_CLASS_SUPERCLASS = new Compil eTimeErrorCode.con1('MIXIN_WITH_NON_CLASS_SUPERCLASS', 92, "Mixin can only be ap plied to class");
1531
1532 /**
1533 * 7.6.1 Generative Constructors: A generative constructor may be redirecting, in which case its
1534 * only action is to invoke another generative constructor.
1535 */
1536 static final CompileTimeErrorCode MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS = new CompileTimeErrorCode.con1('MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS', 93, "Constructor may have at most one 'this' redirection");
1537
1538 /**
1539 * 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. Th en <i>k</i> may
1540 * include at most one superinitializer in its initializer list or a compile t ime error occurs.
1541 */
1542 static final CompileTimeErrorCode MULTIPLE_SUPER_INITIALIZERS = new CompileTim eErrorCode.con1('MULTIPLE_SUPER_INITIALIZERS', 94, "Constructor may have at most one 'super' initializer");
1543
1544 /**
1545 * 11 Metadata: Metadata consists of a series of annotations, each of which be gin with the
1546 * character @, followed by a constant expression that must be either a refere nce to a
1547 * compile-time constant variable, or a call to a constant constructor.
1548 */
1549 static final CompileTimeErrorCode NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS = new Co mpileTimeErrorCode.con1('NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS', 95, "Annotation c reation must have arguments");
1550
1551 /**
1552 * 7.6.1 Generative Constructors: If no superinitializer is provided, an impli cit superinitializer
1553 * of the form <b>super</b>() is added at the end of <i>k</i>'s initializer li st, unless the
1554 * enclosing class is class <i>Object</i>.
1555 *
1556 * 7.6.1 Generative constructors. It is a compile-time error if class <i>S</i> does not declare a
1557 * generative constructor named <i>S</i> (respectively <i>S.id</i>)
1558 */
1559 static final CompileTimeErrorCode NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT = new CompileTimeErrorCode.con1('NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT', 96, "The clas s '%s' does not have a default constructor");
1560
1561 /**
1562 * 7.6 Constructors: Iff no constructor is specified for a class <i>C</i>, it implicitly has a
1563 * default constructor C() : <b>super<b>() {}, unless <i>C</i> is class <i>Obj ect</i>.
1564 *
1565 * 7.6.1 Generative constructors. It is a compile-time error if class <i>S</i> does not declare a
1566 * generative constructor named <i>S</i> (respectively <i>S.id</i>)
1567 */
1568 static final CompileTimeErrorCode NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT = new CompileTimeErrorCode.con1('NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT', 97, "The clas s '%s' does not have a default constructor");
1569
1570 /**
1571 * 13.2 Expression Statements: It is a compile-time error if a non-constant ma p literal that has
1572 * no explicit type arguments appears in a place where a statement is expected .
1573 */
1574 static final CompileTimeErrorCode NON_CONST_MAP_AS_EXPRESSION_STATEMENT = new CompileTimeErrorCode.con1('NON_CONST_MAP_AS_EXPRESSION_STATEMENT', 98, "A non-co nstant map literal without type arguments cannot be used as an expression statem ent");
1575
1576 /**
1577 * 13.9 Switch: Given a switch statement of the form <i>switch (e) { label<sub >11</sub> &hellip;
1578 * label<sub>1j1</sub> case e<sub>1</sub>: s<sub>1</sub> &hellip; label<sub>n1 </sub> &hellip;
1579 * label<sub>njn</sub> case e<sub>n</sub>: s<sub>n</sub> default: s<sub>n+1</s ub>}</i> or the form
1580 * <i>switch (e) { label<sub>11</sub> &hellip; label<sub>1j1</sub> case e<sub> 1</sub>:
1581 * s<sub>1</sub> &hellip; label<sub>n1</sub> &hellip; label<sub>njn</sub> case e<sub>n</sub>:
1582 * s<sub>n</sub>}</i>, it is a compile-time error if the expressions <i>e<sub> k</sub></i> are not
1583 * compile-time constants, for all <i>1 &lt;= k &lt;= n</i>.
1584 */
1585 static final CompileTimeErrorCode NON_CONSTANT_CASE_EXPRESSION = new CompileTi meErrorCode.con1('NON_CONSTANT_CASE_EXPRESSION', 99, "Case expressions must be c onstant");
1586
1587 /**
1588 * 6.2.2 Optional Formals: It is a compile-time error if the default value of an optional
1589 * parameter is not a compile-time constant.
1590 */
1591 static final CompileTimeErrorCode NON_CONSTANT_DEFAULT_VALUE = new CompileTime ErrorCode.con1('NON_CONSTANT_DEFAULT_VALUE', 100, "Default values of an optional parameter must be constant");
1592
1593 /**
1594 * 12.6 Lists: It is a compile time error if an element of a constant list lit eral is not a
1595 * compile-time constant.
1596 */
1597 static final CompileTimeErrorCode NON_CONSTANT_LIST_ELEMENT = new CompileTimeE rrorCode.con1('NON_CONSTANT_LIST_ELEMENT', 101, "'const' lists must have all con stant values");
1598
1599 /**
1600 * 12.7 Maps: It is a compile time error if either a key or a value of an entr y in a constant map
1601 * literal is not a compile-time constant.
1602 */
1603 static final CompileTimeErrorCode NON_CONSTANT_MAP_KEY = new CompileTimeErrorC ode.con1('NON_CONSTANT_MAP_KEY', 102, "The keys in a map must be constant");
1604
1605 /**
1606 * 12.7 Maps: It is a compile time error if either a key or a value of an entr y in a constant map
1607 * literal is not a compile-time constant.
1608 */
1609 static final CompileTimeErrorCode NON_CONSTANT_MAP_VALUE = new CompileTimeErro rCode.con1('NON_CONSTANT_MAP_VALUE', 103, "The values in a 'const' map must be c onstant");
1610
1611 /**
1612 * 11 Metadata: Metadata consists of a series of annotations, each of which be gin with the
1613 * character @, followed by a constant expression that must be either a refere nce to a
1614 * compile-time constant variable, or a call to a constant constructor.
1615 */
1616 static final CompileTimeErrorCode NON_CONSTANT_ANNOTATION_CONSTRUCTOR = new Co mpileTimeErrorCode.con1('NON_CONSTANT_ANNOTATION_CONSTRUCTOR', 104, "Annotation creation can use only 'const' constructor");
1617
1618 /**
1619 * 7.6.3 Constant Constructors: Any expression that appears within the initial izer list of a
1620 * constant constructor must be a potentially constant expression, or a compil e-time error occurs.
1621 */
1622 static final CompileTimeErrorCode NON_CONSTANT_VALUE_IN_INITIALIZER = new Comp ileTimeErrorCode.con1('NON_CONSTANT_VALUE_IN_INITIALIZER', 105, "Initializer exp ressions in constant constructors must be constants");
1623
1624 /**
1625 * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m < h</i> or if <i>m > n</i>.
1626 *
1627 * 12.11.2 Const: It is a compile-time error if evaluation of a constant objec t results in an
1628 * uncaught exception being thrown.
1629 *
1630 * @param requiredCount the expected number of required arguments
1631 * @param argumentCount the actual number of positional arguments given
1632 */
1633 static final CompileTimeErrorCode NOT_ENOUGH_REQUIRED_ARGUMENTS = new CompileT imeErrorCode.con1('NOT_ENOUGH_REQUIRED_ARGUMENTS', 106, "%d required argument(s) expected, but %d found");
1634
1635 /**
1636 * 7.6.1 Generative Constructors: Let <i>C</i> be the class in which the super initializer appears
1637 * and let <i>S</i> be the superclass of <i>C</i>. Let <i>k</i> be a generativ e constructor. It is
1638 * a compile-time error if class <i>S</i> does not declare a generative constr uctor named <i>S</i>
1639 * (respectively <i>S.id</i>)
1640 */
1641 static final CompileTimeErrorCode NON_GENERATIVE_CONSTRUCTOR = new CompileTime ErrorCode.con1('NON_GENERATIVE_CONSTRUCTOR', 107, "The generative constructor '% s' expected, but factory found");
1642
1643 /**
1644 * 7.9 Superclasses: It is a compile-time error to specify an extends clause f or class Object.
1645 */
1646 static final CompileTimeErrorCode OBJECT_CANNOT_EXTEND_ANOTHER_CLASS = new Com pileTimeErrorCode.con1('OBJECT_CANNOT_EXTEND_ANOTHER_CLASS', 108, "");
1647
1648 /**
1649 * 7.1.1 Operators: It is a compile-time error to declare an optional paramete r in an operator.
1650 */
1651 static final CompileTimeErrorCode OPTIONAL_PARAMETER_IN_OPERATOR = new Compile TimeErrorCode.con1('OPTIONAL_PARAMETER_IN_OPERATOR', 109, "Optional parameters a re not allowed when defining an operator");
1652
1653 /**
1654 * 14.3 Parts: It is a compile time error if the contents of the URI are not a valid part
1655 * declaration.
1656 *
1657 * @param uri the uri pointing to a non-library declaration
1658 */
1659 static final CompileTimeErrorCode PART_OF_NON_PART = new CompileTimeErrorCode. con1('PART_OF_NON_PART', 110, "The included part '%s' must have a part-of direct ive");
1660
1661 /**
1662 * 14.1 Imports: It is a compile-time error if the current library declares a top-level member
1663 * named <i>p</i>.
1664 */
1665 static final CompileTimeErrorCode PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER = new CompileTimeErrorCode.con1('PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER', 111, "The nam e '%s' is already used as an import prefix and cannot be used to name a top-leve l element");
1666
1667 /**
1668 * 6.2.2 Optional Formals: It is a compile-time error if the name of a named o ptional parameter
1669 * begins with an '_' character.
1670 */
1671 static final CompileTimeErrorCode PRIVATE_OPTIONAL_PARAMETER = new CompileTime ErrorCode.con1('PRIVATE_OPTIONAL_PARAMETER', 112, "Named optional parameters can not start with an underscore");
1672
1673 /**
1674 * 12.1 Constants: It is a compile-time error if the value of a compile-time c onstant expression
1675 * depends on itself.
1676 */
1677 static final CompileTimeErrorCode RECURSIVE_COMPILE_TIME_CONSTANT = new Compil eTimeErrorCode.con1('RECURSIVE_COMPILE_TIME_CONSTANT', 113, "");
1678
1679 /**
1680 * 7.6.1 Generative Constructors: A generative constructor may be redirecting, in which case its
1681 * only action is to invoke another generative constructor.
1682 *
1683 * TODO(scheglov) review this later, there are no explicit "it is a compile-ti me error" in
1684 * specification. But it was added to the co19 and there is same error for fac tories.
1685 *
1686 * https://code.google.com/p/dart/issues/detail?id=954
1687 */
1688 static final CompileTimeErrorCode RECURSIVE_CONSTRUCTOR_REDIRECT = new Compile TimeErrorCode.con1('RECURSIVE_CONSTRUCTOR_REDIRECT', 114, "Cycle in redirecting generative constructors");
1689
1690 /**
1691 * 7.6.2 Factories: It is a compile-time error if a redirecting factory constr uctor redirects to
1692 * itself, either directly or indirectly via a sequence of redirections.
1693 */
1694 static final CompileTimeErrorCode RECURSIVE_FACTORY_REDIRECT = new CompileTime ErrorCode.con1('RECURSIVE_FACTORY_REDIRECT', 115, "Cycle in redirecting factory constructors");
1695
1696 /**
1697 * 7.10 Superinterfaces: It is a compile-time error if the interface of a clas s <i>C</i> is a
1698 * superinterface of itself.
1699 *
1700 * 8.1 Superinterfaces: It is a compile-time error if an interface is a superi nterface of itself.
1701 *
1702 * 7.9 Superclasses: It is a compile-time error if a class <i>C</i> is a super class of itself.
1703 *
1704 * @param className the name of the class that implements itself recursively
1705 * @param strImplementsPath a string representation of the implements loop
1706 */
1707 static final CompileTimeErrorCode RECURSIVE_INTERFACE_INHERITANCE = new Compil eTimeErrorCode.con1('RECURSIVE_INTERFACE_INHERITANCE', 116, "'%s' cannot be a su perinterface of itself: %s");
1708
1709 /**
1710 * 7.10 Superinterfaces: It is a compile-time error if the interface of a clas s <i>C</i> is a
1711 * superinterface of itself.
1712 *
1713 * 8.1 Superinterfaces: It is a compile-time error if an interface is a superi nterface of itself.
1714 *
1715 * 7.9 Superclasses: It is a compile-time error if a class <i>C</i> is a super class of itself.
1716 *
1717 * @param className the name of the class that implements itself recursively
1718 */
1719 static final CompileTimeErrorCode RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EX TENDS = new CompileTimeErrorCode.con1('RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE _EXTENDS', 117, "'%s' cannot extend itself");
1720
1721 /**
1722 * 7.10 Superinterfaces: It is a compile-time error if the interface of a clas s <i>C</i> is a
1723 * superinterface of itself.
1724 *
1725 * 8.1 Superinterfaces: It is a compile-time error if an interface is a superi nterface of itself.
1726 *
1727 * 7.9 Superclasses: It is a compile-time error if a class <i>C</i> is a super class of itself.
1728 *
1729 * @param className the name of the class that implements itself recursively
1730 */
1731 static final CompileTimeErrorCode RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IM PLEMENTS = new CompileTimeErrorCode.con1('RECURSIVE_INTERFACE_INHERITANCE_BASE_C ASE_IMPLEMENTS', 118, "'%s' cannot implement itself");
1732
1733 /**
1734 * 7.6.2 Factories: It is a compile-time error if <i>k</i> is prefixed with th e const modifier but
1735 * <i>k'</i> is not a constant constructor.
1736 */
1737 static final CompileTimeErrorCode REDIRECT_TO_NON_CONST_CONSTRUCTOR = new Comp ileTimeErrorCode.con1('REDIRECT_TO_NON_CONST_CONSTRUCTOR', 119, "Constant factor y constructor cannot delegate to a non-constant constructor");
1738
1739 /**
1740 * 13.3 Local Variable Declaration: It is a compile-time error if <i>e</i> ref ers to the name
1741 * <i>v</i> or the name <i>v=</i>.
1742 */
1743 static final CompileTimeErrorCode REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZE R = new CompileTimeErrorCode.con1('REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER ', 120, "The name '%s' cannot be referenced in the initializer of a variable wit h the same name");
1744
1745 /**
1746 * 5 Variables: A local variable may only be referenced at a source code locat ion that is after
1747 * its initializer, if any, is complete, or a compile-time error occurs.
1748 */
1749 static final CompileTimeErrorCode REFERENCED_BEFORE_DECLARATION = new CompileT imeErrorCode.con1('REFERENCED_BEFORE_DECLARATION', 121, "Local variables cannot be referenced before they are declared");
1750
1751 /**
1752 * 12.8.1 Rethrow: It is a compile-time error if an expression of the form <i> rethrow;</i> is not
1753 * enclosed within a on-catch clause.
1754 */
1755 static final CompileTimeErrorCode RETHROW_OUTSIDE_CATCH = new CompileTimeError Code.con1('RETHROW_OUTSIDE_CATCH', 122, "rethrow must be inside of a catch claus e");
1756
1757 /**
1758 * 13.11 Return: It is a compile-time error if a return statement of the form <i>return e;</i>
1759 * appears in a generative constructor.
1760 */
1761 static final CompileTimeErrorCode RETURN_IN_GENERATIVE_CONSTRUCTOR = new Compi leTimeErrorCode.con1('RETURN_IN_GENERATIVE_CONSTRUCTOR', 123, "Constructors cann ot return a value");
1762
1763 /**
1764 * 12.15.4 Super Invocation: A super method invocation <i>i</i> has the form
1765 * <i>super.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n +1</sub>, &hellip;
1766 * x<sub>n+k</sub>: a<sub>n+k</sub>)</i>. It is a compile-time error if a supe r method invocation
1767 * occurs in a top-level function or variable initializer, in an instance vari able initializer or
1768 * initializer list, in class Object, in a factory constructor, or in a static method or variable
1769 * initializer.
1770 */
1771 static final CompileTimeErrorCode SUPER_IN_INVALID_CONTEXT = new CompileTimeEr rorCode.con1('SUPER_IN_INVALID_CONTEXT', 124, "Invalid context for 'super' invoc ation");
1772
1773 /**
1774 * 7.6.1 Generative Constructors: A generative constructor may be redirecting, in which case its
1775 * only action is to invoke another generative constructor.
1776 */
1777 static final CompileTimeErrorCode SUPER_IN_REDIRECTING_CONSTRUCTOR = new Compi leTimeErrorCode.con1('SUPER_IN_REDIRECTING_CONSTRUCTOR', 125, "The redirecting c onstructor cannot have a 'super' initializer");
1778
1779 /**
1780 * 7.6.1 Generative Constructors: Let <i>k</i> be a generative constructor. It is a compile-time
1781 * error if a generative constructor of class Object includes a superinitializ er.
1782 */
1783 static final CompileTimeErrorCode SUPER_INITIALIZER_IN_OBJECT = new CompileTim eErrorCode.con1('SUPER_INITIALIZER_IN_OBJECT', 126, "");
1784
1785 /**
1786 * 12.11 Instance Creation: It is a static type warning if any of the type arg uments to a
1787 * constructor of a generic type <i>G</i> invoked by a new expression or a con stant object
1788 * expression are not subtypes of the bounds of the corresponding formal type parameters of
1789 * <i>G</i>.
1790 *
1791 * 12.11.1 New: If T is malformed a dynamic error occurs. In checked mode, if T is mal-bounded a
1792 * dynamic error occurs.
1793 *
1794 * 12.1 Constants: It is a compile-time error if evaluation of a compile-time constant would raise
1795 * an exception.
1796 *
1797 * @param boundedTypeName the name of the type used in the instance creation t hat should be
1798 * limited by the bound as specified in the class declaration
1799 * @param boundingTypeName the name of the bounding type
1800 * @see StaticTypeWarningCode#TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
1801 */
1802 static final CompileTimeErrorCode TYPE_ARGUMENT_NOT_MATCHING_BOUNDS = new Comp ileTimeErrorCode.con1('TYPE_ARGUMENT_NOT_MATCHING_BOUNDS', 127, "'%s' does not e xtend '%s'");
1803
1804 /**
1805 * 15.3.1 Typedef: Any self reference, either directly, or recursively via ano ther typedef, is a
1806 * compile time error.
1807 */
1808 static final CompileTimeErrorCode TYPE_ALIAS_CANNOT_REFERENCE_ITSELF = new Com pileTimeErrorCode.con1('TYPE_ALIAS_CANNOT_REFERENCE_ITSELF', 128, "Type alias ca nnot reference itself directly or recursively via another typedef");
1809
1810 /**
1811 * 12.11.2 Const: It is a compile-time error if <i>T</i> is not a class access ible in the current
1812 * scope, optionally followed by type arguments.
1813 */
1814 static final CompileTimeErrorCode UNDEFINED_CLASS = new CompileTimeErrorCode.c on1('UNDEFINED_CLASS', 129, "Undefined class '%s'");
1815
1816 /**
1817 * 7.6.1 Generative Constructors: Let <i>C</i> be the class in which the super initializer appears
1818 * and let <i>S</i> be the superclass of <i>C</i>. Let <i>k</i> be a generativ e constructor. It is
1819 * a compile-time error if class <i>S</i> does not declare a generative constr uctor named <i>S</i>
1820 * (respectively <i>S.id</i>)
1821 */
1822 static final CompileTimeErrorCode UNDEFINED_CONSTRUCTOR_IN_INITIALIZER = new C ompileTimeErrorCode.con1('UNDEFINED_CONSTRUCTOR_IN_INITIALIZER', 130, "The class '%s' does not have a generative constructor '%s'");
1823
1824 /**
1825 * 7.6.1 Generative Constructors: Let <i>C</i> be the class in which the super initializer appears
1826 * and let <i>S</i> be the superclass of <i>C</i>. Let <i>k</i> be a generativ e constructor. It is
1827 * a compile-time error if class <i>S</i> does not declare a generative constr uctor named <i>S</i>
1828 * (respectively <i>S.id</i>)
1829 */
1830 static final CompileTimeErrorCode UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT = new CompileTimeErrorCode.con1('UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT', 131, "The class '%s' does not have a default generative constructor");
1831
1832 /**
1833 * 12.14.3 Unqualified Invocation: If there exists a lexically visible declara tion named
1834 * <i>id</i>, let <i>f<sub>id</sub></i> be the innermost such declaration. The n: [skip].
1835 * Otherwise, <i>i</i> is equivalent to <b>this</b>.<i>id</i>(<i>a<sub>1</sub> </i>; ...
1836 * <i>x<sub>n+k</sub></i> : <i>a<sub>n+k</sub></i>).
1837 *
1838 * @param methodName the name of the method that is undefined
1839 */
1840 static final CompileTimeErrorCode UNDEFINED_FUNCTION = new CompileTimeErrorCod e.con1('UNDEFINED_FUNCTION', 132, "The function '%s' is not defined");
1841
1842 /**
1843 * 12.14.2 Binding Actuals to Formals: Furthermore, each <i>q<sub>i</sub></i>, <i>1<=i<=l</i>,
1844 * must have a corresponding named parameter in the set {<i>p<sub>n+1</sub></i > ...
1845 * <i>p<sub>n+k</sub></i>} or a static warning occurs.
1846 *
1847 * 12.11.2 Const: It is a compile-time error if evaluation of a constant objec t results in an
1848 * uncaught exception being thrown.
1849 *
1850 * @param name the name of the requested named parameter
1851 */
1852 static final CompileTimeErrorCode UNDEFINED_NAMED_PARAMETER = new CompileTimeE rrorCode.con1('UNDEFINED_NAMED_PARAMETER', 133, "The named parameter '%s' is not defined");
1853
1854 /**
1855 * 14.2 Exports: It is a compile-time error if the compilation unit found at t he specified URI is
1856 * not a library declaration.
1857 *
1858 * 14.1 Imports: It is a compile-time error if the compilation unit found at t he specified URI is
1859 * not a library declaration.
1860 *
1861 * 14.3 Parts: It is a compile time error if the contents of the URI are not a valid part
1862 * declaration.
1863 *
1864 * @param uri the URI pointing to a non-existent file
1865 * @see #INVALID_URI
1866 */
1867 static final CompileTimeErrorCode URI_DOES_NOT_EXIST = new CompileTimeErrorCod e.con1('URI_DOES_NOT_EXIST', 134, "Target of URI does not exist: '%s'");
1868
1869 /**
1870 * 14.1 Imports: It is a compile-time error if <i>x</i> is not a compile-time constant, or if
1871 * <i>x</i> involves string interpolation.
1872 *
1873 * 14.3 Parts: It is a compile-time error if <i>s</i> is not a compile-time co nstant, or if
1874 * <i>s</i> involves string interpolation.
1875 *
1876 * 14.5 URIs: It is a compile-time error if the string literal <i>x</i> that d escribes a URI is
1877 * not a compile-time constant, or if <i>x</i> involves string interpolation.
1878 */
1879 static final CompileTimeErrorCode URI_WITH_INTERPOLATION = new CompileTimeErro rCode.con1('URI_WITH_INTERPOLATION', 135, "URIs cannot use string interpolation" );
1880
1881 /**
1882 * 7.1.1 Operators: It is a compile-time error if the arity of the user-declar ed operator []= is
1883 * not 2. It is a compile time error if the arity of a user-declared operator with one of the
1884 * names: &lt;, &gt;, &lt;=, &gt;=, ==, +, /, ~/, *, %, |, ^, &, &lt;&lt;, &gt ;&gt;, [] is not 1.
1885 * It is a compile time error if the arity of the user-declared operator - is not 0 or 1. It is a
1886 * compile time error if the arity of the user-declared operator ~ is not 0.
1887 *
1888 * @param operatorName the name of the declared operator
1889 * @param expectedNumberOfParameters the number of parameters expected
1890 * @param actualNumberOfParameters the number of parameters found in the opera tor declaration
1891 */
1892 static final CompileTimeErrorCode WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR = ne w CompileTimeErrorCode.con1('WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR', 136, "Ope rator '%s' should declare exactly %d parameter(s), but %d found");
1893
1894 /**
1895 * 7.1.1 Operators: It is a compile time error if the arity of the user-declar ed operator - is not
1896 * 0 or 1.
1897 *
1898 * @param actualNumberOfParameters the number of parameters found in the opera tor declaration
1899 */
1900 static final CompileTimeErrorCode WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINU S = new CompileTimeErrorCode.con1('WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS ', 137, "Operator '-' should declare 0 or 1 parameter, but %d found");
1901
1902 /**
1903 * 7.3 Setters: It is a compile-time error if a setter's formal parameter list does not include
1904 * exactly one required formal parameter <i>p</i>.
1905 */
1906 static final CompileTimeErrorCode WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER = new CompileTimeErrorCode.con1('WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER', 138, "Setters should declare exactly one required parameter");
1907 static final List<CompileTimeErrorCode> values = [
1908 AMBIGUOUS_EXPORT,
1909 ARGUMENT_DEFINITION_TEST_NON_PARAMETER,
1910 BUILT_IN_IDENTIFIER_AS_TYPE,
1911 BUILT_IN_IDENTIFIER_AS_TYPE_NAME,
1912 BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME,
1913 BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME,
1914 CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
1915 COMPILE_TIME_CONSTANT_RAISES_EXCEPTION,
1916 CONFLICTING_GETTER_AND_METHOD,
1917 CONFLICTING_METHOD_AND_GETTER,
1918 CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD,
1919 CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD,
1920 CONFLICTING_TYPE_VARIABLE_AND_CLASS,
1921 CONFLICTING_TYPE_VARIABLE_AND_MEMBER,
1922 CONST_CONSTRUCTOR_THROWS_EXCEPTION,
1923 CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER,
1924 CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD,
1925 CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE,
1926 CONST_FORMAL_PARAMETER,
1927 CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE,
1928 CONST_INSTANCE_FIELD,
1929 CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS,
1930 CONST_NOT_INITIALIZED,
1931 CONST_EVAL_TYPE_BOOL,
1932 CONST_EVAL_TYPE_BOOL_NUM_STRING,
1933 CONST_EVAL_TYPE_INT,
1934 CONST_EVAL_TYPE_NUM,
1935 CONST_EVAL_THROWS_EXCEPTION,
1936 CONST_EVAL_THROWS_IDBZE,
1937 CONST_WITH_INVALID_TYPE_PARAMETERS,
1938 CONST_WITH_NON_CONST,
1939 CONST_WITH_NON_CONSTANT_ARGUMENT,
1940 CONST_WITH_NON_TYPE,
1941 CONST_WITH_TYPE_PARAMETERS,
1942 CONST_WITH_UNDEFINED_CONSTRUCTOR,
1943 CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
1944 DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS,
1945 DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER,
1946 DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR,
1947 DUPLICATE_CONSTRUCTOR_DEFAULT,
1948 DUPLICATE_CONSTRUCTOR_NAME,
1949 DUPLICATE_DEFINITION,
1950 DUPLICATE_DEFINITION_INHERITANCE,
1951 DUPLICATE_NAMED_ARGUMENT,
1952 EXPORT_INTERNAL_LIBRARY,
1953 EXPORT_OF_NON_LIBRARY,
1954 EXTENDS_NON_CLASS,
1955 EXTENDS_DISALLOWED_CLASS,
1956 EXTRA_POSITIONAL_ARGUMENTS,
1957 FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS,
1958 FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER,
1959 FINAL_INITIALIZED_MULTIPLE_TIMES,
1960 FIELD_INITIALIZER_FACTORY_CONSTRUCTOR,
1961 FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR,
1962 FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR,
1963 GETTER_AND_METHOD_WITH_SAME_NAME,
1964 IMPLEMENTS_DISALLOWED_CLASS,
1965 IMPLEMENTS_DYNAMIC,
1966 IMPLEMENTS_NON_CLASS,
1967 IMPLEMENTS_REPEATED,
1968 IMPLEMENTS_SUPER_CLASS,
1969 IMPLICIT_THIS_REFERENCE_IN_INITIALIZER,
1970 IMPORT_INTERNAL_LIBRARY,
1971 IMPORT_OF_NON_LIBRARY,
1972 INCONSISTENT_CASE_EXPRESSION_TYPES,
1973 INITIALIZER_FOR_NON_EXISTANT_FIELD,
1974 INITIALIZER_FOR_STATIC_FIELD,
1975 INITIALIZING_FORMAL_FOR_NON_EXISTANT_FIELD,
1976 INITIALIZING_FORMAL_FOR_STATIC_FIELD,
1977 INSTANCE_MEMBER_ACCESS_FROM_STATIC,
1978 INVALID_ANNOTATION,
1979 INVALID_CONSTANT,
1980 INVALID_CONSTRUCTOR_NAME,
1981 INVALID_FACTORY_NAME_NOT_A_CLASS,
1982 INVALID_REFERENCE_TO_THIS,
1983 INVALID_TYPE_ARGUMENT_IN_CONST_LIST,
1984 INVALID_TYPE_ARGUMENT_IN_CONST_MAP,
1985 INVALID_URI,
1986 LABEL_IN_OUTER_SCOPE,
1987 LABEL_UNDEFINED,
1988 LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,
1989 MAP_KEY_TYPE_NOT_ASSIGNABLE,
1990 MAP_VALUE_TYPE_NOT_ASSIGNABLE,
1991 MEMBER_WITH_CLASS_NAME,
1992 METHOD_AND_GETTER_WITH_SAME_NAME,
1993 MISSING_CONST_IN_LIST_LITERAL,
1994 MISSING_CONST_IN_MAP_LITERAL,
1995 MIXIN_DECLARES_CONSTRUCTOR,
1996 MIXIN_INHERITS_FROM_NOT_OBJECT,
1997 MIXIN_OF_DISALLOWED_CLASS,
1998 MIXIN_OF_NON_CLASS,
1999 MIXIN_REFERENCES_SUPER,
2000 MIXIN_WITH_NON_CLASS_SUPERCLASS,
2001 MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS,
2002 MULTIPLE_SUPER_INITIALIZERS,
2003 NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS,
2004 NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT,
2005 NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT,
2006 NON_CONST_MAP_AS_EXPRESSION_STATEMENT,
2007 NON_CONSTANT_CASE_EXPRESSION,
2008 NON_CONSTANT_DEFAULT_VALUE,
2009 NON_CONSTANT_LIST_ELEMENT,
2010 NON_CONSTANT_MAP_KEY,
2011 NON_CONSTANT_MAP_VALUE,
2012 NON_CONSTANT_ANNOTATION_CONSTRUCTOR,
2013 NON_CONSTANT_VALUE_IN_INITIALIZER,
2014 NOT_ENOUGH_REQUIRED_ARGUMENTS,
2015 NON_GENERATIVE_CONSTRUCTOR,
2016 OBJECT_CANNOT_EXTEND_ANOTHER_CLASS,
2017 OPTIONAL_PARAMETER_IN_OPERATOR,
2018 PART_OF_NON_PART,
2019 PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER,
2020 PRIVATE_OPTIONAL_PARAMETER,
2021 RECURSIVE_COMPILE_TIME_CONSTANT,
2022 RECURSIVE_CONSTRUCTOR_REDIRECT,
2023 RECURSIVE_FACTORY_REDIRECT,
2024 RECURSIVE_INTERFACE_INHERITANCE,
2025 RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS,
2026 RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS,
2027 REDIRECT_TO_NON_CONST_CONSTRUCTOR,
2028 REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER,
2029 REFERENCED_BEFORE_DECLARATION,
2030 RETHROW_OUTSIDE_CATCH,
2031 RETURN_IN_GENERATIVE_CONSTRUCTOR,
2032 SUPER_IN_INVALID_CONTEXT,
2033 SUPER_IN_REDIRECTING_CONSTRUCTOR,
2034 SUPER_INITIALIZER_IN_OBJECT,
2035 TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
2036 TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
2037 UNDEFINED_CLASS,
2038 UNDEFINED_CONSTRUCTOR_IN_INITIALIZER,
2039 UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT,
2040 UNDEFINED_FUNCTION,
2041 UNDEFINED_NAMED_PARAMETER,
2042 URI_DOES_NOT_EXIST,
2043 URI_WITH_INTERPOLATION,
2044 WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR,
2045 WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS,
2046 WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER];
2047
2048 /**
2049 * The template used to create the message to be displayed for this error.
2050 */
2051 String _message;
2052
2053 /**
2054 * The template used to create the correction to be displayed for this error, or `null` if
2055 * there is no correction information for this error.
2056 */
2057 String correction2;
2058
2059 /**
2060 * Initialize a newly created error code to have the given message.
2061 *
2062 * @param message the message template used to create the message to be displa yed for the error
2063 */
2064 CompileTimeErrorCode.con1(String name, int ordinal, String message) : super(na me, ordinal) {
2065 this._message = message;
2066 }
2067
2068 /**
2069 * Initialize a newly created error code to have the given message and correct ion.
2070 *
2071 * @param message the template used to create the message to be displayed for the error
2072 * @param correction the template used to create the correction to be displaye d for the error
2073 */
2074 CompileTimeErrorCode.con2(String name, int ordinal, String message, String cor rection) : super(name, ordinal) {
2075 this._message = message;
2076 this.correction2 = correction;
2077 }
2078 String get correction => correction2;
2079 ErrorSeverity get errorSeverity => ErrorType.COMPILE_TIME_ERROR.severity;
2080 String get message => _message;
2081 ErrorType get type => ErrorType.COMPILE_TIME_ERROR;
2082 }
2083 /**
2084 * The enumeration `PubSuggestionCode` defines the suggestions used for reportin g deviations
2085 * from pub best practices. The convention for this class is for the name of the bad practice to
2086 * indicate the problem that caused the suggestion to be generated and for the m essage to explain
2087 * what is wrong and, when appropriate, how the situation can be corrected.
2088 */
2089 class PubSuggestionCode extends Enum<PubSuggestionCode> implements ErrorCode {
2090
2091 /**
2092 * It is a bad practice for a source file in a package "lib" directory hierarc hy to traverse
2093 * outside that directory hierarchy. For example, a source file in the "lib" d irectory should not
2094 * contain a directive such as `import '../web/some.dart'` which references a file outside
2095 * the lib directory.
2096 */
2097 static final PubSuggestionCode FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE = new PubSuggestionCode.con1('FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE', 0 , "A file in the 'lib' directory hierarchy should not reference a file outside t hat hierarchy");
2098
2099 /**
2100 * It is a bad practice for a source file ouside a package "lib" directory hie rarchy to traverse
2101 * into that directory hierarchy. For example, a source file in the "web" dire ctory should not
2102 * contain a directive such as `import '../lib/some.dart'` which references a file inside
2103 * the lib directory.
2104 */
2105 static final PubSuggestionCode FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE = new PubSuggestionCode.con1('FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE', 1 , "A file outside the 'lib' directory hierarchy should not reference a file insi de that hierarchy. Use a package: reference instead.");
2106
2107 /**
2108 * It is a bad practice for a package import to reference anything outside the given package, or
2109 * more generally, it is bad practice for a package import to contain a "..". For example, a
2110 * source file should not contain a directive such as `import 'package:foo/../ some.dart'`.
2111 */
2112 static final PubSuggestionCode PACKAGE_IMPORT_CONTAINS_DOT_DOT = new PubSugges tionCode.con1('PACKAGE_IMPORT_CONTAINS_DOT_DOT', 2, "A package import should not contain '..'");
2113 static final List<PubSuggestionCode> values = [
2114 FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE,
2115 FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE,
2116 PACKAGE_IMPORT_CONTAINS_DOT_DOT];
2117
2118 /**
2119 * The template used to create the message to be displayed for this error.
2120 */
2121 String _message;
2122
2123 /**
2124 * The template used to create the correction to be displayed for this error, or `null` if
2125 * there is no correction information for this error.
2126 */
2127 String correction5;
2128
2129 /**
2130 * Initialize a newly created error code to have the given message.
2131 *
2132 * @param message the message template used to create the message to be displa yed for the error
2133 */
2134 PubSuggestionCode.con1(String name, int ordinal, String message) : super(name, ordinal) {
2135 this._message = message;
2136 }
2137
2138 /**
2139 * Initialize a newly created error code to have the given message and correct ion.
2140 *
2141 * @param message the template used to create the message to be displayed for the error
2142 * @param correction the template used to create the correction to be displaye d for the error
2143 */
2144 PubSuggestionCode.con2(String name, int ordinal, String message, String correc tion) : super(name, ordinal) {
2145 this._message = message;
2146 this.correction5 = correction;
2147 }
2148 String get correction => correction5;
2149 ErrorSeverity get errorSeverity => ErrorType.PUB_SUGGESTION.severity;
2150 String get message => _message;
2151 ErrorType get type => ErrorType.PUB_SUGGESTION;
2152 }
2153 /**
2154 * The enumeration `StaticWarningCode` defines the error codes used for static w arnings. The
2155 * convention for this class is for the name of the error code to indicate the p roblem that caused
2156 * the error to be generated and for the error message to explain what is wrong and, when
2157 * appropriate, how the problem can be corrected.
2158 *
2159 * @coverage dart.engine.error
2160 */
2161 class StaticWarningCode extends Enum<StaticWarningCode> implements ErrorCode {
2162
2163 /**
2164 * 14.1 Imports: If a name <i>N</i> is referenced by a library <i>L</i> and <i >N</i> is introduced
2165 * into the top level scope <i>L</i> by more than one import then:
2166 * <ol>
2167 * * A static warning occurs.
2168 * * If <i>N</i> is referenced as a function, getter or setter, a <i>NoSuchMet hodError</i> is
2169 * raised.
2170 * * If <i>N</i> is referenced as a type, it is treated as a malformed type.
2171 * </ol>
2172 *
2173 * @param ambiguousTypeName the name of the ambiguous type
2174 * @param firstLibraryName the name of the first library that the type is foun d
2175 * @param secondLibraryName the name of the second library that the type is fo und
2176 */
2177 static final StaticWarningCode AMBIGUOUS_IMPORT = new StaticWarningCode.con1(' AMBIGUOUS_IMPORT', 0, "The type '%s' is defined in the libraries '%s' and '%s'") ;
2178
2179 /**
2180 * 12.11.1 New: It is a static warning if the static type of <i>a<sub>i</sub>, 1 &lt;= i &lt;= n+
2181 * k</i> may not be assigned to the type of the corresponding formal parameter of the constructor
2182 * <i>T.id</i> (respectively <i>T</i>).
2183 *
2184 * 12.11.2 Const: It is a static warning if the static type of <i>a<sub>i</sub >, 1 &lt;= i &lt;=
2185 * n+ k</i> may not be assigned to the type of the corresponding formal parame ter of the
2186 * constructor <i>T.id</i> (respectively <i>T</i>).
2187 *
2188 * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static type of
2189 * <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of <i>p<sub>i</s ub>, 1 &lt;= i &lt;=
2190 * n+k</i> and let <i>S<sub>q</sub></i> be the type of the named parameter <i> q</i> of <i>f</i>.
2191 * It is a static warning if <i>T<sub>j</sub></i> may not be assigned to <i>S< sub>j</sub>, 1 &lt;=
2192 * j &lt;= m</i>.
2193 *
2194 * 12.14.2 Binding Actuals to Formals: Furthermore, each <i>q<sub>i</sub>, 1 & lt;= i &lt;= l</i>,
2195 * must have a corresponding named parameter in the set <i>{p<sub>n+1</sub>, & hellip;
2196 * p<sub>n+k</sub>}</i> or a static warning occurs. It is a static warning if
2197 * <i>T<sub>m+j</sub></i> may not be assigned to <i>S<sub>r</sub></i>, where < i>r = q<sub>j</sub>,
2198 * 1 &lt;= j &lt;= l</i>.
2199 */
2200 static final StaticWarningCode ARGUMENT_TYPE_NOT_ASSIGNABLE = new StaticWarnin gCode.con1('ARGUMENT_TYPE_NOT_ASSIGNABLE', 1, "The argument type '%s' cannot be assigned to the parameter type '%s'");
2201
2202 /**
2203 * 5 Variables: Attempting to assign to a final variable elsewhere will cause a NoSuchMethodError
2204 * to be thrown, because no setter is defined for it. The assignment will also give rise to a
2205 * static warning for the same reason.
2206 *
2207 * A constant variable is always implicitly final.
2208 */
2209 static final StaticWarningCode ASSIGNMENT_TO_CONST = new StaticWarningCode.con 1('ASSIGNMENT_TO_CONST', 2, "Constant variables cannot be assigned a value");
2210
2211 /**
2212 * 5 Variables: Attempting to assign to a final variable elsewhere will cause a NoSuchMethodError
2213 * to be thrown, because no setter is defined for it. The assignment will also give rise to a
2214 * static warning for the same reason.
2215 */
2216 static final StaticWarningCode ASSIGNMENT_TO_FINAL = new StaticWarningCode.con 1('ASSIGNMENT_TO_FINAL', 3, "Final variables cannot be assigned a value");
2217
2218 /**
2219 * 12.18 Assignment: Let <i>T</i> be the static type of <i>e<sub>1</sub></i>. It is a static type
2220 * warning if <i>T</i> does not have an accessible instance setter named <i>v =</i>.
2221 */
2222 static final StaticWarningCode ASSIGNMENT_TO_METHOD = new StaticWarningCode.co n1('ASSIGNMENT_TO_METHOD', 4, "Methods cannot be assigned a value");
2223
2224 /**
2225 * 13.9 Switch: It is a static warning if the last statement of the statement sequence
2226 * <i>s<sub>k</sub></i> is not a break, continue, return or throw statement.
2227 */
2228 static final StaticWarningCode CASE_BLOCK_NOT_TERMINATED = new StaticWarningCo de.con1('CASE_BLOCK_NOT_TERMINATED', 5, "The last statement of the 'case' should be 'break', 'continue', 'return' or 'throw'");
2229
2230 /**
2231 * 12.32 Type Cast: It is a static warning if <i>T</i> does not denote a type available in the
2232 * current lexical scope.
2233 */
2234 static final StaticWarningCode CAST_TO_NON_TYPE = new StaticWarningCode.con1(' CAST_TO_NON_TYPE', 6, "The name '%s' is not a type and cannot be used in an 'as' expression");
2235
2236 /**
2237 * 7.4 Abstract Instance Members: It is a static warning if an abstract member is declared or
2238 * inherited in a concrete class.
2239 */
2240 static final StaticWarningCode CONCRETE_CLASS_WITH_ABSTRACT_MEMBER = new Stati cWarningCode.con1('CONCRETE_CLASS_WITH_ABSTRACT_MEMBER', 7, "'%s' must have a me thod body because '%s' is not abstract");
2241
2242 /**
2243 * 14.1 Imports: If a name <i>N</i> is referenced by a library <i>L</i> and <i >N</i> would be
2244 * introduced into the top level scope of <i>L</i> by an import from a library whose URI begins
2245 * with <i>dart:</i> and an import from a library whose URI does not begin wit h <i>dart:</i>:
2246 *
2247 * * The import from <i>dart:</i> is implicitly extended by a hide N clause.
2248 * * A static warning is issued.
2249 *
2250 *
2251 * @param ambiguousName the ambiguous name
2252 * @param sdkLibraryName the name of the dart: library that the element is fou nd
2253 * @param otherLibraryName the name of the non-dart: library that the element is found
2254 */
2255 static final StaticWarningCode CONFLICTING_DART_IMPORT = new StaticWarningCode .con1('CONFLICTING_DART_IMPORT', 8, "Element '%s' from SDK library '%s' is impli citly hidden by '%s'");
2256
2257 /**
2258 * 7.2 Getters: It is a static warning if a class <i>C</i> declares an instanc e getter named
2259 * <i>v</i> and an accessible static member named <i>v</i> or <i>v=</i> is dec lared in a
2260 * superclass of <i>C</i>.
2261 *
2262 * @param superName the name of the super class declaring a static member
2263 */
2264 static final StaticWarningCode CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMB ER = new StaticWarningCode.con1('CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMB ER', 9, "Superclass '%s' declares static member with the same name");
2265
2266 /**
2267 * 7.3 Setters: It is a static warning if a class <i>C</i> declares an instanc e setter named
2268 * <i>v=</i> and an accessible static member named <i>v=</i> or <i>v</i> is de clared in a
2269 * superclass of <i>C</i>.
2270 *
2271 * @param superName the name of the super class declaring a static member
2272 */
2273 static final StaticWarningCode CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMB ER = new StaticWarningCode.con1('CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMB ER', 10, "Superclass '%s' declares static member with the same name");
2274
2275 /**
2276 * 7.2 Getters: It is a static warning if a class declares a static getter nam ed <i>v</i> and also
2277 * has a non-static setter named <i>v=</i>.
2278 */
2279 static final StaticWarningCode CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER = new StaticWarningCode.con1('CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER', 11, "Class '%s' declares non-static setter with the same name");
2280
2281 /**
2282 * 7.3 Setters: It is a static warning if a class declares a static setter nam ed <i>v=</i> and
2283 * also has a non-static member named <i>v</i>.
2284 */
2285 static final StaticWarningCode CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER = new StaticWarningCode.con1('CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER', 12, "Class '%s' declares non-static member with the same name");
2286
2287 /**
2288 * 12.11.2 Const: Given an instance creation expression of the form <i>const q (a<sub>1</sub>,
2289 * &hellip; a<sub>n</sub>)</i> it is a static warning if <i>q</i> is the const ructor of an
2290 * abstract class but <i>q</i> is not a factory constructor.
2291 */
2292 static final StaticWarningCode CONST_WITH_ABSTRACT_CLASS = new StaticWarningCo de.con1('CONST_WITH_ABSTRACT_CLASS', 13, "Abstract classes cannot be created wit h a 'const' expression");
2293
2294 /**
2295 * 12.7 Maps: It is a static warning if the values of any two keys in a map li teral are equal.
2296 */
2297 static final StaticWarningCode EQUAL_KEYS_IN_MAP = new StaticWarningCode.con1( 'EQUAL_KEYS_IN_MAP', 14, "Keys in a map cannot be equal");
2298
2299 /**
2300 * 14.2 Exports: It is a static warning to export two different libraries with the same name.
2301 *
2302 * @param uri1 the uri pointing to a first library
2303 * @param uri2 the uri pointing to a second library
2304 * @param name the shared name of the exported libraries
2305 */
2306 static final StaticWarningCode EXPORT_DUPLICATED_LIBRARY_NAME = new StaticWarn ingCode.con1('EXPORT_DUPLICATED_LIBRARY_NAME', 15, "The exported libraries '%s' and '%s' should not have the same name '%s'");
2307
2308 /**
2309 * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m &lt; h</ i> or if <i>m &gt;
2310 * n</i>.
2311 *
2312 * @param requiredCount the maximum number of positional arguments
2313 * @param argumentCount the actual number of positional arguments given
2314 * @see #NOT_ENOUGH_REQUIRED_ARGUMENTS
2315 */
2316 static final StaticWarningCode EXTRA_POSITIONAL_ARGUMENTS = new StaticWarningC ode.con1('EXTRA_POSITIONAL_ARGUMENTS', 16, "%d positional arguments expected, bu t %d found");
2317
2318 /**
2319 * 5. Variables: It is a static warning if a final instance variable that has been initialized at
2320 * its point of declaration is also initialized in a constructor.
2321 */
2322 static final StaticWarningCode FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATIO N = new StaticWarningCode.con1('FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION ', 17, "Values cannot be set in the constructor if they are final, and have alre ady been set");
2323
2324 /**
2325 * 5. Variables: It is a static warning if a final instance variable that has been initialized at
2326 * its point of declaration is also initialized in a constructor.
2327 *
2328 * @param name the name of the field in question
2329 */
2330 static final StaticWarningCode FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTO R = new StaticWarningCode.con1('FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR ', 18, "'%s' is final and was given a value when it was declared, so it cannot b e set to a new value");
2331
2332 /**
2333 * 7.6.1 Generative Constructors: Execution of an initializer of the form <b>t his</b>.<i>v</i> =
2334 * <i>e</i> proceeds as follows: First, the expression <i>e</i> is evaluated t o an object
2335 * <i>o</i>. Then, the instance variable <i>v</i> of the object denoted by thi s is bound to
2336 * <i>o</i>.
2337 *
2338 * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static type of
2339 * <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of <i>p<sub>i</s ub>, 1 &lt;= i &lt;=
2340 * n+k</i> and let <i>S<sub>q</sub></i> be the type of the named parameter <i> q</i> of <i>f</i>.
2341 * It is a static warning if <i>T<sub>j</sub></i> may not be assigned to <i>S< sub>j</sub>, 1 &lt;=
2342 * j &lt;= m</i>.
2343 *
2344 * @param initializerType the name of the type of the initializer expression
2345 * @param fieldType the name of the type of the field
2346 */
2347 static final StaticWarningCode FIELD_INITIALIZER_NOT_ASSIGNABLE = new StaticWa rningCode.con1('FIELD_INITIALIZER_NOT_ASSIGNABLE', 19, "The initializer type '%s ' cannot be assigned to the field type '%s'");
2348
2349 /**
2350 * 7.6.1 Generative Constructors: An initializing formal has the form <i>this. id</i>. It is a
2351 * static warning if the static type of <i>id</i> is not assignable to <i>T<su b>id</sub></i>.
2352 *
2353 * @param parameterType the name of the type of the field formal parameter
2354 * @param fieldType the name of the type of the field
2355 */
2356 static final StaticWarningCode FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE = new StaticWarningCode.con1('FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE', 20, "The para meter type '%s' is incompatable with the field type '%s'");
2357
2358 /**
2359 * 5 Variables: It is a static warning if a library, static or local variable <i>v</i> is final
2360 * and <i>v</i> is not initialized at its point of declaration.
2361 *
2362 * 7.6.1 Generative Constructors: Each final instance variable <i>f</i> declar ed in the
2363 * immediately enclosing class must have an initializer in <i>k</i>'s initiali zer list unless it
2364 * has already been initialized by one of the following means:
2365 *
2366 * * Initialization at the declaration of <i>f</i>.
2367 * * Initialization by means of an initializing formal of <i>k</i>.
2368 *
2369 * or a static warning occurs.
2370 *
2371 * @param name the name of the uninitialized final variable
2372 */
2373 static final StaticWarningCode FINAL_NOT_INITIALIZED = new StaticWarningCode.c on1('FINAL_NOT_INITIALIZED', 21, "The final variable '%s' must be initialized");
2374
2375 /**
2376 * 15.5 Function Types: It is a static warning if a concrete class implements Function and does
2377 * not have a concrete method named call().
2378 */
2379 static final StaticWarningCode FUNCTION_WITHOUT_CALL = new StaticWarningCode.c on1('FUNCTION_WITHOUT_CALL', 22, "Concrete classes that implement Function must implement the method call()");
2380
2381 /**
2382 * 14.1 Imports: It is a static warning to import two different libraries with the same name.
2383 *
2384 * @param uri1 the uri pointing to a first library
2385 * @param uri2 the uri pointing to a second library
2386 * @param name the shared name of the imported libraries
2387 */
2388 static final StaticWarningCode IMPORT_DUPLICATED_LIBRARY_NAME = new StaticWarn ingCode.con1('IMPORT_DUPLICATED_LIBRARY_NAME', 23, "The imported libraries '%s' and '%s' should not have the same name '%s'");
2389
2390 /**
2391 * 8.1.1 Inheritance and Overriding: However, if there are multiple members <i >m<sub>1</sub>,
2392 * &hellip; m<sub>k</sub></i> with the same name <i>n</i> that would be inheri ted (because
2393 * identically named members existed in several superinterfaces) then at most one member is
2394 * inherited.
2395 *
2396 * If some but not all of the <i>m<sub>i</sub>, 1 &lt;= i &lt;= k</i>, are get ters, or if some but
2397 * not all of the <i>m<sub>i</sub></i> are setters, none of the <i>m<sub>i</su b></i> are
2398 * inherited, and a static warning is issued.
2399 */
2400 static final StaticWarningCode INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METH OD = new StaticWarningCode.con1('INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METH OD', 24, "'%s' is inherited as a getter and also a method");
2401
2402 /**
2403 * 7.1 Instance Methods: It is a static warning if a class <i>C</i> declares a n instance method
2404 * named <i>n</i> and an accessible static member named <i>n</i> is declared i n a superclass of
2405 * <i>C</i>.
2406 *
2407 * @param memberName the name of the member with the name conflict
2408 * @param superclassName the name of the enclosing class that has the static m ember
2409 */
2410 static final StaticWarningCode INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_S TATIC = new StaticWarningCode.con1('INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLAS S_STATIC', 25, "'%s' collides with a static member in the superclass '%s'");
2411
2412 /**
2413 * 7.2 Getters: It is a static warning if a getter <i>m1</i> overrides a gette r <i>m2</i> and the
2414 * type of <i>m1</i> is not a subtype of the type of <i>m2</i>.
2415 *
2416 * @param actualReturnTypeName the name of the expected return type
2417 * @param expectedReturnType the name of the actual return type, not assignabl e to the
2418 * actualReturnTypeName
2419 * @param className the name of the class where the overridden getter is decla red
2420 * @see #INVALID_METHOD_OVERRIDE_RETURN_TYPE
2421 */
2422 static final StaticWarningCode INVALID_GETTER_OVERRIDE_RETURN_TYPE = new Stati cWarningCode.con1('INVALID_GETTER_OVERRIDE_RETURN_TYPE', 26, "The return type '% s' is not assignable to '%s' as required by the getter it is overriding from '%s '");
2423
2424 /**
2425 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2426 * instance method <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of <i>m2</i>.
2427 *
2428 * @param actualParamTypeName the name of the expected parameter type
2429 * @param expectedParamType the name of the actual parameter type, not assigna ble to the
2430 * actualParamTypeName
2431 * @param className the name of the class where the overridden method is decla red
2432 */
2433 static final StaticWarningCode INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE = new StaticWarningCode.con1('INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE', 27, "The para meter type '%s' is not assignable to '%s' as required by the method it is overri ding from '%s'");
2434
2435 /**
2436 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2437 * instance method <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of <i>m2</i>.
2438 *
2439 * @param actualParamTypeName the name of the expected parameter type
2440 * @param expectedParamType the name of the actual parameter type, not assigna ble to the
2441 * actualParamTypeName
2442 * @param className the name of the class where the overridden method is decla red
2443 * @see #INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE
2444 */
2445 static final StaticWarningCode INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE = new StaticWarningCode.con1('INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE', 28, "The pa rameter type '%s' is not assignable to '%s' as required by the method it is over riding from '%s'");
2446
2447 /**
2448 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2449 * instance method <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of <i>m2</i>.
2450 *
2451 * @param actualParamTypeName the name of the expected parameter type
2452 * @param expectedParamType the name of the actual parameter type, not assigna ble to the
2453 * actualParamTypeName
2454 * @param className the name of the class where the overridden method is decla red
2455 */
2456 static final StaticWarningCode INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE = n ew StaticWarningCode.con1('INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE', 29, "Th e parameter type '%s' is not assignable to '%s' as required by the method it is overriding from '%s'");
2457
2458 /**
2459 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2460 * instance method <i>m2</i> and the type of <i>m1</i> is not a subtype of the type of <i>m2</i>.
2461 *
2462 * @param actualReturnTypeName the name of the expected return type
2463 * @param expectedReturnType the name of the actual return type, not assignabl e to the
2464 * actualReturnTypeName
2465 * @param className the name of the class where the overridden method is decla red
2466 * @see #INVALID_GETTER_OVERRIDE_RETURN_TYPE
2467 */
2468 static final StaticWarningCode INVALID_METHOD_OVERRIDE_RETURN_TYPE = new Stati cWarningCode.con1('INVALID_METHOD_OVERRIDE_RETURN_TYPE', 30, "The return type '% s' is not assignable to '%s' as required by the method it is overriding from '%s '");
2469
2470 /**
2471 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2472 * instance member <i>m2</i>, the signature of <i>m2</i> explicitly specifies a default value for
2473 * a formal parameter <i>p</i> and the signature of <i>m1</i> specifies a diff erent default value
2474 * for <i>p</i>.
2475 */
2476 static final StaticWarningCode INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED = new StaticWarningCode.con1('INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED', 31, "Parameters cannot override default values, this method overrides '%s.%s' w here '%s' has a different value");
2477
2478 /**
2479 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2480 * instance member <i>m2</i>, the signature of <i>m2</i> explicitly specifies a default value for
2481 * a formal parameter <i>p</i> and the signature of <i>m1</i> specifies a diff erent default value
2482 * for <i>p</i>.
2483 */
2484 static final StaticWarningCode INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSIT IONAL = new StaticWarningCode.con1('INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_PO SITIONAL', 32, "Parameters cannot override default values, this method overrides '%s.%s' where this positional parameter has a different value");
2485
2486 /**
2487 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2488 * instance member <i>m2</i> and <i>m1</i> does not declare all the named para meters declared by
2489 * <i>m2</i>.
2490 *
2491 * @param paramCount the number of named parameters in the overridden member
2492 * @param className the name of the class from the overridden method
2493 */
2494 static final StaticWarningCode INVALID_OVERRIDE_NAMED = new StaticWarningCode. con1('INVALID_OVERRIDE_NAMED', 33, "Missing the named parameter '%s' to match th e overridden method from '%s'");
2495
2496 /**
2497 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2498 * instance member <i>m2</i> and <i>m1</i> has fewer positional parameters tha n <i>m2</i>.
2499 *
2500 * @param paramCount the number of positional parameters in the overridden mem ber
2501 * @param className the name of the class from the overridden method
2502 */
2503 static final StaticWarningCode INVALID_OVERRIDE_POSITIONAL = new StaticWarning Code.con1('INVALID_OVERRIDE_POSITIONAL', 34, "Must have at least %d parameters t o match the overridden method from '%s'");
2504
2505 /**
2506 * 7.1 Instance Methods: It is a static warning if an instance method <i>m1</i > overrides an
2507 * instance member <i>m2</i> and <i>m1</i> has a greater number of required pa rameters than
2508 * <i>m2</i>.
2509 *
2510 * @param paramCount the number of required parameters in the overridden membe r
2511 * @param className the name of the class from the overridden method
2512 */
2513 static final StaticWarningCode INVALID_OVERRIDE_REQUIRED = new StaticWarningCo de.con1('INVALID_OVERRIDE_REQUIRED', 35, "Must have %d required parameters or le ss to match the overridden method from '%s'");
2514
2515 /**
2516 * 7.3 Setters: It is a static warning if a setter <i>m1</i> overrides a sette r <i>m2</i> and the
2517 * type of <i>m1</i> is not a subtype of the type of <i>m2</i>.
2518 *
2519 * @param actualParamTypeName the name of the expected parameter type
2520 * @param expectedParamType the name of the actual parameter type, not assigna ble to the
2521 * actualParamTypeName
2522 * @param className the name of the class where the overridden setter is decla red
2523 * @see #INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
2524 */
2525 static final StaticWarningCode INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE = new StaticWarningCode.con1('INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE', 36, "The pa rameter type '%s' is not assignable to '%s' as required by the setter it is over riding from '%s'");
2526
2527 /**
2528 * 12.6 Lists: A run-time list literal &lt;<i>E</i>&gt; [<i>e<sub>1</sub></i> ...
2529 * <i>e<sub>n</sub></i>] is evaluated as follows:
2530 *
2531 * * The operator []= is invoked on <i>a</i> with first argument <i>i</i> and second argument
2532 * <i>o<sub>i+1</sub></i><i>, 1 &lt;= i &lt;= n</i>
2533 *
2534 *
2535 * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static type of
2536 * <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of <i>p<sub>i</s ub>, 1 &lt;= i &lt;=
2537 * n+k</i> and let <i>S<sub>q</sub></i> be the type of the named parameter <i> q</i> of <i>f</i>.
2538 * It is a static warning if <i>T<sub>j</sub></i> may not be assigned to <i>S< sub>j</sub>, 1 &lt;=
2539 * j &lt;= m</i>.
2540 */
2541 static final StaticWarningCode LIST_ELEMENT_TYPE_NOT_ASSIGNABLE = new StaticWa rningCode.con1('LIST_ELEMENT_TYPE_NOT_ASSIGNABLE', 37, "The element type '%s' ca nnot be assigned to the list type '%s'");
2542
2543 /**
2544 * 12.7 Map: A run-time map literal &lt;<i>K</i>, <i>V</i>&gt; [<i>k<sub>1</su b></i> :
2545 * <i>e<sub>1</sub></i> ... <i>k<sub>n</sub></i> : <i>e<sub>n</sub></i>] is ev aluated as follows:
2546 *
2547 * * The operator []= is invoked on <i>m</i> with first argument <i>k<sub>i</s ub></i> and second
2548 * argument <i>e<sub>i</sub></i><i>, 1 &lt;= i &lt;= n</i>
2549 *
2550 *
2551 * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static type of
2552 * <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of <i>p<sub>i</s ub>, 1 &lt;= i &lt;=
2553 * n+k</i> and let <i>S<sub>q</sub></i> be the type of the named parameter <i> q</i> of <i>f</i>.
2554 * It is a static warning if <i>T<sub>j</sub></i> may not be assigned to <i>S< sub>j</sub>, 1 &lt;=
2555 * j &lt;= m</i>.
2556 */
2557 static final StaticWarningCode MAP_KEY_TYPE_NOT_ASSIGNABLE = new StaticWarning Code.con1('MAP_KEY_TYPE_NOT_ASSIGNABLE', 38, "The element type '%s' cannot be as signed to the map key type '%s'");
2558
2559 /**
2560 * 12.7 Map: A run-time map literal &lt;<i>K</i>, <i>V</i>&gt; [<i>k<sub>1</su b></i> :
2561 * <i>e<sub>1</sub></i> ... <i>k<sub>n</sub></i> : <i>e<sub>n</sub></i>] is ev aluated as follows:
2562 *
2563 * * The operator []= is invoked on <i>m</i> with first argument <i>k<sub>i</s ub></i> and second
2564 * argument <i>e<sub>i</sub></i><i>, 1 &lt;= i &lt;= n</i>
2565 *
2566 *
2567 * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static type of
2568 * <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of <i>p<sub>i</s ub>, 1 &lt;= i &lt;=
2569 * n+k</i> and let <i>S<sub>q</sub></i> be the type of the named parameter <i> q</i> of <i>f</i>.
2570 * It is a static warning if <i>T<sub>j</sub></i> may not be assigned to <i>S< sub>j</sub>, 1 &lt;=
2571 * j &lt;= m</i>.
2572 */
2573 static final StaticWarningCode MAP_VALUE_TYPE_NOT_ASSIGNABLE = new StaticWarni ngCode.con1('MAP_VALUE_TYPE_NOT_ASSIGNABLE', 39, "The element type '%s' cannot b e assigned to the map value type '%s'");
2574
2575 /**
2576 * 7.3 Setters: It is a static warning if a class has a setter named <i>v=</i> with argument type
2577 * <i>T</i> and a getter named <i>v</i> with return type <i>S</i>, and <i>T</i > may not be
2578 * assigned to <i>S</i>.
2579 */
2580 static final StaticWarningCode MISMATCHED_GETTER_AND_SETTER_TYPES = new Static WarningCode.con1('MISMATCHED_GETTER_AND_SETTER_TYPES', 40, "The parameter type f or setter '%s' is '%s' which is not assignable to its getter (of type '%s')");
2581
2582 /**
2583 * 7.3 Setters: It is a static warning if a class has a setter named <i>v=</i> with argument type
2584 * <i>T</i> and a getter named <i>v</i> with return type <i>S</i>, and <i>T</i > may not be
2585 * assigned to <i>S</i>.
2586 */
2587 static final StaticWarningCode MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTY PE = new StaticWarningCode.con1('MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTY PE', 41, "The parameter type for setter '%s' is '%s' which is not assignable to its getter (of type '%s'), from superclass '%s'");
2588
2589 /**
2590 * 13.12 Return: It is a static warning if a function contains both one or mor e return statements
2591 * of the form <i>return;</i> and one or more return statements of the form <i >return e;</i>.
2592 */
2593 static final StaticWarningCode MIXED_RETURN_TYPES = new StaticWarningCode.con1 ('MIXED_RETURN_TYPES', 42, "Methods and functions cannot use return both with an d without values");
2594
2595 /**
2596 * 12.11.1 New: It is a static warning if <i>q</i> is a constructor of an abst ract class and
2597 * <i>q</i> is not a factory constructor.
2598 */
2599 static final StaticWarningCode NEW_WITH_ABSTRACT_CLASS = new StaticWarningCode .con1('NEW_WITH_ABSTRACT_CLASS', 43, "Abstract classes cannot be created with a 'new' expression");
2600
2601 /**
2602 * 15.8 Parameterized Types: Any use of a malbounded type gives rise to a stat ic warning.
2603 *
2604 * @param typeName the name of the type being referenced (<i>S</i>)
2605 * @param parameterCount the number of type parameters that were declared
2606 * @param argumentCount the number of type arguments provided
2607 * @see CompileTimeErrorCode#CONST_WITH_INVALID_TYPE_PARAMETERS
2608 * @see StaticTypeWarningCode#WRONG_NUMBER_OF_TYPE_ARGUMENTS
2609 */
2610 static final StaticWarningCode NEW_WITH_INVALID_TYPE_PARAMETERS = new StaticWa rningCode.con1('NEW_WITH_INVALID_TYPE_PARAMETERS', 44, "The type '%s' is declare d with %d type parameters, but %d type arguments were given");
2611
2612 /**
2613 * 12.11.1 New: It is a static warning if <i>T</i> is not a class accessible i n the current scope,
2614 * optionally followed by type arguments.
2615 *
2616 * @param name the name of the non-type element
2617 */
2618 static final StaticWarningCode NEW_WITH_NON_TYPE = new StaticWarningCode.con1( 'NEW_WITH_NON_TYPE', 45, "The name '%s' is not a class");
2619
2620 /**
2621 * 12.11.1 New: If <i>T</i> is a class or parameterized type accessible in the current scope then:
2622 * 1. If <i>e</i> is of the form <i>new T.id(a<sub>1</sub>, &hellip;, a<sub>n< /sub>,
2623 * x<sub>n+1</sub>: a<sub>n+1</sub>, &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub >)</i> it is a
2624 * static warning if <i>T.id</i> is not the name of a constructor declared by the type <i>T</i>.
2625 * If <i>e</i> of the form <i>new T(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x< sub>n+1</sub>:
2626 * a<sub>n+1</sub>, &hellip; x<sub>n+k</sub>: a<sub>n+kM/sub>)</i> it is a sta tic warning if the
2627 * type <i>T</i> does not declare a constructor with the same name as the decl aration of <i>T</i>.
2628 */
2629 static final StaticWarningCode NEW_WITH_UNDEFINED_CONSTRUCTOR = new StaticWarn ingCode.con1('NEW_WITH_UNDEFINED_CONSTRUCTOR', 46, "The class '%s' does not have a constructor '%s'");
2630
2631 /**
2632 * 12.11.1 New: If <i>T</i> is a class or parameterized type accessible in the current scope then:
2633 * 1. If <i>e</i> is of the form <i>new T.id(a<sub>1</sub>, &hellip;, a<sub>n< /sub>,
2634 * x<sub>n+1</sub>: a<sub>n+1</sub>, &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub >)</i> it is a
2635 * static warning if <i>T.id</i> is not the name of a constructor declared by the type <i>T</i>.
2636 * If <i>e</i> of the form <i>new T(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x< sub>n+1</sub>:
2637 * a<sub>n+1</sub>, &hellip; x<sub>n+k</sub>: a<sub>n+kM/sub>)</i> it is a sta tic warning if the
2638 * type <i>T</i> does not declare a constructor with the same name as the decl aration of <i>T</i>.
2639 */
2640 static final StaticWarningCode NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT = new St aticWarningCode.con1('NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT', 47, "The class '% s' does not have a default constructor");
2641
2642 /**
2643 * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract class inherits an
2644 * abstract method.
2645 *
2646 * 7.10 Superinterfaces: Let <i>C</i> be a concrete class that does not declar e its own
2647 * <i>noSuchMethod()</i> method. It is a static warning if the implicit interf ace of <i>C</i>
2648 * includes an instance member <i>m</i> of type <i>F</i> and <i>C</i> does not declare or inherit
2649 * a corresponding instance member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
2650 *
2651 * 7.4 Abstract Instance Members: It is a static warning if an abstract member is declared or
2652 * inherited in a concrete class unless that member overrides a concrete one.
2653 *
2654 * @param memberName the name of the first member
2655 * @param memberName the name of the second member
2656 * @param memberName the name of the third member
2657 * @param memberName the name of the fourth member
2658 * @param additionalCount the number of additional missing members that aren't listed
2659 */
2660 static final StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIV E_PLUS = new StaticWarningCode.con1('NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER _FIVE_PLUS', 48, "Missing inherited members: '%s', '%s', '%s', '%s' and %d more" );
2661
2662 /**
2663 * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract class inherits an
2664 * abstract method.
2665 *
2666 * 7.10 Superinterfaces: Let <i>C</i> be a concrete class that does not declar e its own
2667 * <i>noSuchMethod()</i> method. It is a static warning if the implicit interf ace of <i>C</i>
2668 * includes an instance member <i>m</i> of type <i>F</i> and <i>C</i> does not declare or inherit
2669 * a corresponding instance member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
2670 *
2671 * 7.4 Abstract Instance Members: It is a static warning if an abstract member is declared or
2672 * inherited in a concrete class unless that member overrides a concrete one.
2673 *
2674 * @param memberName the name of the first member
2675 * @param memberName the name of the second member
2676 * @param memberName the name of the third member
2677 * @param memberName the name of the fourth member
2678 */
2679 static final StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOU R = new StaticWarningCode.con1('NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR ', 49, "Missing inherited members: '%s', '%s', '%s' and '%s'");
2680
2681 /**
2682 * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract class inherits an
2683 * abstract method.
2684 *
2685 * 7.10 Superinterfaces: Let <i>C</i> be a concrete class that does not declar e its own
2686 * <i>noSuchMethod()</i> method. It is a static warning if the implicit interf ace of <i>C</i>
2687 * includes an instance member <i>m</i> of type <i>F</i> and <i>C</i> does not declare or inherit
2688 * a corresponding instance member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
2689 *
2690 * 7.4 Abstract Instance Members: It is a static warning if an abstract member is declared or
2691 * inherited in a concrete class unless that member overrides a concrete one.
2692 *
2693 * @param memberName the name of the member
2694 */
2695 static final StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE = new StaticWarningCode.con1('NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE', 50, "Missing inherited member '%s'");
2696
2697 /**
2698 * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract class inherits an
2699 * abstract method.
2700 *
2701 * 7.10 Superinterfaces: Let <i>C</i> be a concrete class that does not declar e its own
2702 * <i>noSuchMethod()</i> method. It is a static warning if the implicit interf ace of <i>C</i>
2703 * includes an instance member <i>m</i> of type <i>F</i> and <i>C</i> does not declare or inherit
2704 * a corresponding instance member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
2705 *
2706 * 7.4 Abstract Instance Members: It is a static warning if an abstract member is declared or
2707 * inherited in a concrete class unless that member overrides a concrete one.
2708 *
2709 * @param memberName the name of the first member
2710 * @param memberName the name of the second member
2711 * @param memberName the name of the third member
2712 */
2713 static final StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THR EE = new StaticWarningCode.con1('NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THR EE', 51, "Missing inherited members: '%s', '%s' and '%s'");
2714
2715 /**
2716 * 7.9.1 Inheritance and Overriding: It is a static warning if a non-abstract class inherits an
2717 * abstract method.
2718 *
2719 * 7.10 Superinterfaces: Let <i>C</i> be a concrete class that does not declar e its own
2720 * <i>noSuchMethod()</i> method. It is a static warning if the implicit interf ace of <i>C</i>
2721 * includes an instance member <i>m</i> of type <i>F</i> and <i>C</i> does not declare or inherit
2722 * a corresponding instance member <i>m</i> of type <i>F'</i> such that <i>F' <: F</i>.
2723 *
2724 * 7.4 Abstract Instance Members: It is a static warning if an abstract member is declared or
2725 * inherited in a concrete class unless that member overrides a concrete one.
2726 *
2727 * @param memberName the name of the first member
2728 * @param memberName the name of the second member
2729 */
2730 static final StaticWarningCode NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO = new StaticWarningCode.con1('NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO', 52, "Missing inherited members: '%s' and '%s'");
2731
2732 /**
2733 * 13.11 Try: An on-catch clause of the form <i>on T catch (p<sub>1</sub>, p<s ub>2</sub>) s</i> or
2734 * <i>on T s</i> matches an object <i>o</i> if the type of <i>o</i> is a subty pe of <i>T</i>. It
2735 * is a static warning if <i>T</i> does not denote a type available in the lex ical scope of the
2736 * catch clause.
2737 *
2738 * @param name the name of the non-type element
2739 */
2740 static final StaticWarningCode NON_TYPE_IN_CATCH_CLAUSE = new StaticWarningCod e.con1('NON_TYPE_IN_CATCH_CLAUSE', 53, "The name '%s' is not a type and cannot b e used in an on-catch clause");
2741
2742 /**
2743 * 7.1.1 Operators: It is a static warning if the return type of the user-decl ared operator []= is
2744 * explicitly declared and not void.
2745 */
2746 static final StaticWarningCode NON_VOID_RETURN_FOR_OPERATOR = new StaticWarnin gCode.con1('NON_VOID_RETURN_FOR_OPERATOR', 54, "The return type of the operator []= must be 'void'");
2747
2748 /**
2749 * 7.3 Setters: It is a static warning if a setter declares a return type othe r than void.
2750 */
2751 static final StaticWarningCode NON_VOID_RETURN_FOR_SETTER = new StaticWarningC ode.con1('NON_VOID_RETURN_FOR_SETTER', 55, "The return type of the setter must b e 'void'");
2752
2753 /**
2754 * 15.1 Static Types: A type <i>T</i> is malformed iff: * <i>T</i> has the for m <i>id</i> or the
2755 * form <i>prefix.id</i>, and in the enclosing lexical scope, the name <i>id</ i> (respectively
2756 * <i>prefix.id</i>) does not denote a type. * <i>T</i> denotes a type paramet er in the
2757 * enclosing lexical scope, but occurs in the signature or body of a static me mber. *
2758 * <i>T</i> is a parameterized type of the form <i>G&lt;S<sub>1</sub>, .., S<s ub>n</sub>&gt;</i>,
2759 * and <i>G</i> is malformed.
2760 *
2761 * Any use of a malformed type gives rise to a static warning.
2762 *
2763 * @param nonTypeName the name that is not a type
2764 */
2765 static final StaticWarningCode NOT_A_TYPE = new StaticWarningCode.con1('NOT_A_ TYPE', 56, "%s is not a type");
2766
2767 /**
2768 * 12.14.2 Binding Actuals to Formals: It is a static warning if <i>m &lt; h</ i> or if <i>m &gt;
2769 * n</i>.
2770 *
2771 * @param requiredCount the expected number of required arguments
2772 * @param argumentCount the actual number of positional arguments given
2773 * @see #EXTRA_POSITIONAL_ARGUMENTS
2774 */
2775 static final StaticWarningCode NOT_ENOUGH_REQUIRED_ARGUMENTS = new StaticWarni ngCode.con1('NOT_ENOUGH_REQUIRED_ARGUMENTS', 57, "%d required argument(s) expect ed, but %d found");
2776
2777 /**
2778 * 14.3 Parts: It is a static warning if the referenced part declaration <i>p< /i> names a library
2779 * other than the current library as the library to which <i>p</i> belongs.
2780 *
2781 * @param expectedLibraryName the name of expected library name
2782 * @param actualLibraryName the non-matching actual library name from the "par t of" declaration
2783 */
2784 static final StaticWarningCode PART_OF_DIFFERENT_LIBRARY = new StaticWarningCo de.con1('PART_OF_DIFFERENT_LIBRARY', 58, "Expected this library to be part of '% s', not '%s'");
2785
2786 /**
2787 * 7.6.2 Factories: It is a static warning if the function type of <i>k'</i> i s not a subtype of
2788 * the type of <i>k</i>.
2789 *
2790 * @param redirectedName the name of the redirected constructor
2791 * @param redirectingName the name of the redirecting constructor
2792 */
2793 static final StaticWarningCode REDIRECT_TO_INVALID_FUNCTION_TYPE = new StaticW arningCode.con1('REDIRECT_TO_INVALID_FUNCTION_TYPE', 59, "The redirected constru ctor '%s' has incompatible parameters with '%s'");
2794
2795 /**
2796 * 7.6.2 Factories: It is a static warning if the function type of <i>k'</i> i s not a subtype of
2797 * the type of <i>k</i>.
2798 *
2799 * @param redirectedName the name of the redirected constructor return type
2800 * @param redirectingName the name of the redirecting constructor return type
2801 */
2802 static final StaticWarningCode REDIRECT_TO_INVALID_RETURN_TYPE = new StaticWar ningCode.con1('REDIRECT_TO_INVALID_RETURN_TYPE', 60, "The return type '%s' of th e redirected constructor is not assignable to '%s'");
2803
2804 /**
2805 * 7.6.2 Factories: It is a static warning if type does not denote a class acc essible in the
2806 * current scope; if type does denote such a class <i>C</i> it is a static war ning if the
2807 * referenced constructor (be it <i>type</i> or <i>type.id</i>) is not a const ructor of <i>C</i>.
2808 */
2809 static final StaticWarningCode REDIRECT_TO_MISSING_CONSTRUCTOR = new StaticWar ningCode.con1('REDIRECT_TO_MISSING_CONSTRUCTOR', 61, "The constructor '%s' could not be found in '%s'");
2810
2811 /**
2812 * 7.6.2 Factories: It is a static warning if type does not denote a class acc essible in the
2813 * current scope; if type does denote such a class <i>C</i> it is a static war ning if the
2814 * referenced constructor (be it <i>type</i> or <i>type.id</i>) is not a const ructor of <i>C</i>.
2815 */
2816 static final StaticWarningCode REDIRECT_TO_NON_CLASS = new StaticWarningCode.c on1('REDIRECT_TO_NON_CLASS', 62, "The name '%s' is not a type and cannot be used in a redirected constructor");
2817
2818 /**
2819 * 13.11 Return: Let <i>f</i> be the function immediately enclosing a return s tatement of the form
2820 * <i>return;</i> It is a static warning if both of the following conditions h old:
2821 * <ol>
2822 * * <i>f</i> is not a generative constructor.
2823 * * The return type of <i>f</i> may not be assigned to void.
2824 * </ol>
2825 */
2826 static final StaticWarningCode RETURN_WITHOUT_VALUE = new StaticWarningCode.co n1('RETURN_WITHOUT_VALUE', 63, "Missing return value after 'return'");
2827
2828 /**
2829 * 12.15.3 Static Invocation: It is a static warning if <i>C</i> does not decl are a static method
2830 * or getter <i>m</i>.
2831 *
2832 * @param memberName the name of the instance member
2833 */
2834 static final StaticWarningCode STATIC_ACCESS_TO_INSTANCE_MEMBER = new StaticWa rningCode.con1('STATIC_ACCESS_TO_INSTANCE_MEMBER', 64, "Instance member '%s' can not be accessed using static access");
2835
2836 /**
2837 * 13.9 Switch: It is a static warning if the type of <i>e</i> may not be assi gned to the type of
2838 * <i>e<sub>k</sub></i>.
2839 */
2840 static final StaticWarningCode SWITCH_EXPRESSION_NOT_ASSIGNABLE = new StaticWa rningCode.con1('SWITCH_EXPRESSION_NOT_ASSIGNABLE', 65, "Type '%s' of the switch expression is not assignable to the type '%s' of case expressions");
2841
2842 /**
2843 * 12.31 Type Test: It is a static warning if <i>T</i> does not denote a type available in the
2844 * current lexical scope.
2845 */
2846 static final StaticWarningCode TYPE_TEST_NON_TYPE = new StaticWarningCode.con1 ('TYPE_TEST_NON_TYPE', 66, "The name '%s' is not a type and cannot be used in an 'is' expression");
2847
2848 /**
2849 * 10 Generics: However, a type parameter is considered to be a malformed type when referenced by
2850 * a static member.
2851 *
2852 * 15.1 Static Types: Any use of a malformed type gives rise to a static warni ng. A malformed type
2853 * is then interpreted as dynamic by the static type checker and the runtime.
2854 */
2855 static final StaticWarningCode TYPE_PARAMETER_REFERENCED_BY_STATIC = new Stati cWarningCode.con1('TYPE_PARAMETER_REFERENCED_BY_STATIC', 67, "Static members can not reference type parameters");
2856
2857 /**
2858 * 12.15.3 Static Invocation: A static method invocation <i>i</i> has the form
2859 * <i>C.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</ sub>, &hellip;
2860 * x<sub>n+k</sub>: a<sub>n+k</sub>)</i>. It is a static warning if <i>C</i> d oes not denote a
2861 * class in the current scope.
2862 *
2863 * @param undefinedClassName the name of the undefined class
2864 */
2865 static final StaticWarningCode UNDEFINED_CLASS = new StaticWarningCode.con1('U NDEFINED_CLASS', 68, "Undefined class '%s'");
2866
2867 /**
2868 * Same as [UNDEFINED_CLASS], but to catch using "boolean" instead of "bool".
2869 */
2870 static final StaticWarningCode UNDEFINED_CLASS_BOOLEAN = new StaticWarningCode .con1('UNDEFINED_CLASS_BOOLEAN', 69, "Undefined class 'boolean'; did you mean 'b ool'?");
2871
2872 /**
2873 * 12.17 Getter Invocation: It is a static warning if there is no class <i>C</ i> in the enclosing
2874 * lexical scope of <i>i</i>, or if <i>C</i> does not declare, implicitly or e xplicitly, a getter
2875 * named <i>m</i>.
2876 *
2877 * @param getterName the name of the getter
2878 * @param enclosingType the name of the enclosing type where the getter is bei ng looked for
2879 */
2880 static final StaticWarningCode UNDEFINED_GETTER = new StaticWarningCode.con1(' UNDEFINED_GETTER', 70, "There is no such getter '%s' in '%s'");
2881
2882 /**
2883 * 12.30 Identifier Reference: It is as static warning if an identifier expres sion of the form
2884 * <i>id</i> occurs inside a top level or static function (be it function, met hod, getter, or
2885 * setter) or variable initializer and there is no declaration <i>d</i> with n ame <i>id</i> in the
2886 * lexical scope enclosing the expression.
2887 *
2888 * @param name the name of the identifier
2889 */
2890 static final StaticWarningCode UNDEFINED_IDENTIFIER = new StaticWarningCode.co n1('UNDEFINED_IDENTIFIER', 71, "Undefined name '%s'");
2891
2892 /**
2893 * 12.14.2 Binding Actuals to Formals: Furthermore, each <i>q<sub>i</sub></i>, <i>1<=i<=l</i>,
2894 * must have a corresponding named parameter in the set {<i>p<sub>n+1</sub></i > ...
2895 * <i>p<sub>n+k</sub></i>} or a static warning occurs.
2896 *
2897 * @param name the name of the requested named parameter
2898 */
2899 static final StaticWarningCode UNDEFINED_NAMED_PARAMETER = new StaticWarningCo de.con1('UNDEFINED_NAMED_PARAMETER', 72, "The named parameter '%s' is not define d");
2900
2901 /**
2902 * 12.18 Assignment: It is as static warning if an assignment of the form <i>v = e</i> occurs
2903 * inside a top level or static function (be it function, method, getter, or s etter) or variable
2904 * initializer and there is no declaration <i>d</i> with name <i>v=</i> in the lexical scope
2905 * enclosing the assignment.
2906 *
2907 * 12.18 Assignment: It is a static warning if there is no class <i>C</i> in t he enclosing lexical
2908 * scope of the assignment, or if <i>C</i> does not declare, implicitly or exp licitly, a setter
2909 * <i>v=</i>.
2910 *
2911 * @param setterName the name of the getter
2912 * @param enclosingType the name of the enclosing type where the setter is bei ng looked for
2913 */
2914 static final StaticWarningCode UNDEFINED_SETTER = new StaticWarningCode.con1(' UNDEFINED_SETTER', 73, "There is no such setter '%s' in '%s'");
2915
2916 /**
2917 * 12.15.3 Static Invocation: It is a static warning if <i>C</i> does not decl are a static method
2918 * or getter <i>m</i>.
2919 *
2920 * @param methodName the name of the method
2921 * @param enclosingType the name of the enclosing type where the method is bei ng looked for
2922 */
2923 static final StaticWarningCode UNDEFINED_STATIC_METHOD_OR_GETTER = new StaticW arningCode.con1('UNDEFINED_STATIC_METHOD_OR_GETTER', 74, "There is no such stati c method '%s' in '%s'");
2924 static final List<StaticWarningCode> values = [
2925 AMBIGUOUS_IMPORT,
2926 ARGUMENT_TYPE_NOT_ASSIGNABLE,
2927 ASSIGNMENT_TO_CONST,
2928 ASSIGNMENT_TO_FINAL,
2929 ASSIGNMENT_TO_METHOD,
2930 CASE_BLOCK_NOT_TERMINATED,
2931 CAST_TO_NON_TYPE,
2932 CONCRETE_CLASS_WITH_ABSTRACT_MEMBER,
2933 CONFLICTING_DART_IMPORT,
2934 CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER,
2935 CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER,
2936 CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER,
2937 CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER,
2938 CONST_WITH_ABSTRACT_CLASS,
2939 EQUAL_KEYS_IN_MAP,
2940 EXPORT_DUPLICATED_LIBRARY_NAME,
2941 EXTRA_POSITIONAL_ARGUMENTS,
2942 FIELD_INITIALIZED_IN_INITIALIZER_AND_DECLARATION,
2943 FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR,
2944 FIELD_INITIALIZER_NOT_ASSIGNABLE,
2945 FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE,
2946 FINAL_NOT_INITIALIZED,
2947 FUNCTION_WITHOUT_CALL,
2948 IMPORT_DUPLICATED_LIBRARY_NAME,
2949 INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD,
2950 INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC,
2951 INVALID_GETTER_OVERRIDE_RETURN_TYPE,
2952 INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE,
2953 INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE,
2954 INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE,
2955 INVALID_METHOD_OVERRIDE_RETURN_TYPE,
2956 INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED,
2957 INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL,
2958 INVALID_OVERRIDE_NAMED,
2959 INVALID_OVERRIDE_POSITIONAL,
2960 INVALID_OVERRIDE_REQUIRED,
2961 INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE,
2962 LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,
2963 MAP_KEY_TYPE_NOT_ASSIGNABLE,
2964 MAP_VALUE_TYPE_NOT_ASSIGNABLE,
2965 MISMATCHED_GETTER_AND_SETTER_TYPES,
2966 MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE,
2967 MIXED_RETURN_TYPES,
2968 NEW_WITH_ABSTRACT_CLASS,
2969 NEW_WITH_INVALID_TYPE_PARAMETERS,
2970 NEW_WITH_NON_TYPE,
2971 NEW_WITH_UNDEFINED_CONSTRUCTOR,
2972 NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
2973 NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS,
2974 NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR,
2975 NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE,
2976 NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE,
2977 NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO,
2978 NON_TYPE_IN_CATCH_CLAUSE,
2979 NON_VOID_RETURN_FOR_OPERATOR,
2980 NON_VOID_RETURN_FOR_SETTER,
2981 NOT_A_TYPE,
2982 NOT_ENOUGH_REQUIRED_ARGUMENTS,
2983 PART_OF_DIFFERENT_LIBRARY,
2984 REDIRECT_TO_INVALID_FUNCTION_TYPE,
2985 REDIRECT_TO_INVALID_RETURN_TYPE,
2986 REDIRECT_TO_MISSING_CONSTRUCTOR,
2987 REDIRECT_TO_NON_CLASS,
2988 RETURN_WITHOUT_VALUE,
2989 STATIC_ACCESS_TO_INSTANCE_MEMBER,
2990 SWITCH_EXPRESSION_NOT_ASSIGNABLE,
2991 TYPE_TEST_NON_TYPE,
2992 TYPE_PARAMETER_REFERENCED_BY_STATIC,
2993 UNDEFINED_CLASS,
2994 UNDEFINED_CLASS_BOOLEAN,
2995 UNDEFINED_GETTER,
2996 UNDEFINED_IDENTIFIER,
2997 UNDEFINED_NAMED_PARAMETER,
2998 UNDEFINED_SETTER,
2999 UNDEFINED_STATIC_METHOD_OR_GETTER];
3000
3001 /**
3002 * The template used to create the message to be displayed for this error.
3003 */
3004 String _message;
3005
3006 /**
3007 * The template used to create the correction to be displayed for this error, or `null` if
3008 * there is no correction information for this error.
3009 */
3010 String correction7;
3011
3012 /**
3013 * Initialize a newly created error code to have the given message.
3014 *
3015 * @param message the message template used to create the message to be displa yed for the error
3016 */
3017 StaticWarningCode.con1(String name, int ordinal, String message) : super(name, ordinal) {
3018 this._message = message;
3019 }
3020
3021 /**
3022 * Initialize a newly created error code to have the given message and correct ion.
3023 *
3024 * @param message the template used to create the message to be displayed for the error
3025 * @param correction the template used to create the correction to be displaye d for the error
3026 */
3027 StaticWarningCode.con2(String name, int ordinal, String message, String correc tion) : super(name, ordinal) {
3028 this._message = message;
3029 this.correction7 = correction;
3030 }
3031 String get correction => correction7;
3032 ErrorSeverity get errorSeverity => ErrorType.STATIC_WARNING.severity;
3033 String get message => _message;
3034 ErrorType get type => ErrorType.STATIC_WARNING;
3035 }
3036 /**
3037 * The interface `AnalysisErrorListener` defines the behavior of objects that li sten for
3038 * [AnalysisError] being produced by the analysis engine.
3039 *
3040 * @coverage dart.engine.error
3041 */
3042 abstract class AnalysisErrorListener {
3043
3044 /**
3045 * An error listener that ignores errors that are reported to it.
3046 */
3047 static final AnalysisErrorListener _NULL_LISTENER = new AnalysisErrorListener_ 6();
3048
3049 /**
3050 * This method is invoked when an error has been found by the analysis engine.
3051 *
3052 * @param error the error that was just found (not `null`)
3053 */
3054 void onError(AnalysisError error);
3055 }
3056 class AnalysisErrorListener_6 implements AnalysisErrorListener {
3057 void onError(AnalysisError event) {
3058 }
3059 }
3060 /**
3061 * The enumeration `HtmlWarningCode` defines the error codes used for warnings i n HTML files.
3062 * The convention for this class is for the name of the error code to indicate t he problem that
3063 * caused the error to be generated and for the error message to explain what is wrong and, when
3064 * appropriate, how the problem can be corrected.
3065 *
3066 * @coverage dart.engine.error
3067 */
3068 class HtmlWarningCode extends Enum<HtmlWarningCode> implements ErrorCode {
3069
3070 /**
3071 * An error code indicating that the value of the 'src' attribute of a Dart sc ript tag is not a
3072 * valid URI.
3073 *
3074 * @param uri the URI that is invalid
3075 */
3076 static final HtmlWarningCode INVALID_URI = new HtmlWarningCode.con1('INVALID_U RI', 0, "Invalid URI syntax: '%s'");
3077
3078 /**
3079 * An error code indicating that the value of the 'src' attribute of a Dart sc ript tag references
3080 * a file that does not exist.
3081 *
3082 * @param uri the URI pointing to a non-existent file
3083 */
3084 static final HtmlWarningCode URI_DOES_NOT_EXIST = new HtmlWarningCode.con1('UR I_DOES_NOT_EXIST', 1, "Target of URI does not exist: '%s'");
3085 static final List<HtmlWarningCode> values = [INVALID_URI, URI_DOES_NOT_EXIST];
3086
3087 /**
3088 * The template used to create the message to be displayed for this error.
3089 */
3090 String _message;
3091
3092 /**
3093 * The template used to create the correction to be displayed for this error, or `null` if
3094 * there is no correction information for this error.
3095 */
3096 String correction4;
3097
3098 /**
3099 * Initialize a newly created error code to have the given message.
3100 *
3101 * @param message the message template used to create the message to be displa yed for the error
3102 */
3103 HtmlWarningCode.con1(String name, int ordinal, String message) : super(name, o rdinal) {
3104 this._message = message;
3105 }
3106
3107 /**
3108 * Initialize a newly created error code to have the given message and correct ion.
3109 *
3110 * @param message the template used to create the message to be displayed for the error
3111 * @param correction the template used to create the correction to be displaye d for the error
3112 */
3113 HtmlWarningCode.con2(String name, int ordinal, String message, String correcti on) : super(name, ordinal) {
3114 this._message = message;
3115 this.correction4 = correction;
3116 }
3117 String get correction => correction4;
3118 ErrorSeverity get errorSeverity => ErrorSeverity.WARNING;
3119 String get message => _message;
3120 ErrorType get type => ErrorType.STATIC_WARNING;
3121 }
3122 /**
3123 * The enumeration `StaticTypeWarningCode` defines the error codes used for stat ic type
3124 * warnings. The convention for this class is for the name of the error code to indicate the problem
3125 * that caused the error to be generated and for the error message to explain wh at is wrong and,
3126 * when appropriate, how the problem can be corrected.
3127 *
3128 * @coverage dart.engine.error
3129 */
3130 class StaticTypeWarningCode extends Enum<StaticTypeWarningCode> implements Error Code {
3131
3132 /**
3133 * 12.7 Lists: A fresh instance (7.6.1) <i>a</i>, of size <i>n</i>, whose clas s implements the
3134 * built-in class <i>List&lt;E></i> is allocated.
3135 *
3136 * @param numTypeArgument the number of provided type arguments
3137 */
3138 static final StaticTypeWarningCode EXPECTED_ONE_LIST_TYPE_ARGUMENTS = new Stat icTypeWarningCode.con1('EXPECTED_ONE_LIST_TYPE_ARGUMENTS', 0, "List literal requ ires exactly one type arguments or none, but %d found");
3139
3140 /**
3141 * 12.8 Maps: A fresh instance (7.6.1) <i>m</i>, of size <i>n</i>, whose class implements the
3142 * built-in class <i>Map&lt;K, V></i> is allocated.
3143 *
3144 * @param numTypeArgument the number of provided type arguments
3145 */
3146 static final StaticTypeWarningCode EXPECTED_TWO_MAP_TYPE_ARGUMENTS = new Stati cTypeWarningCode.con1('EXPECTED_TWO_MAP_TYPE_ARGUMENTS', 1, "Map literal require s exactly two type arguments or none, but %d found");
3147
3148 /**
3149 * 12.18 Assignment: Let <i>T</i> be the static type of <i>e<sub>1</sub></i>. It is a static type
3150 * warning if <i>T</i> does not have an accessible instance setter named <i>v= </i>.
3151 *
3152 * @see #UNDEFINED_SETTER
3153 */
3154 static final StaticTypeWarningCode INACCESSIBLE_SETTER = new StaticTypeWarning Code.con1('INACCESSIBLE_SETTER', 2, "");
3155
3156 /**
3157 * 8.1.1 Inheritance and Overriding: However, if there are multiple members <i >m<sub>1</sub>,
3158 * &hellip; m<sub>k</sub></i> with the same name <i>n</i> that would be inheri ted (because
3159 * identically named members existed in several superinterfaces) then at most one member is
3160 * inherited.
3161 *
3162 * If the static types <i>T<sub>1</sub>, &hellip;, T<sub>k</sub></i> of the me mbers
3163 * <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></i> are not identical, then there must be a member
3164 * <i>m<sub>x</sub></i> such that <i>T<sub>x</sub> &lt; T<sub>i</sub>, 1 &lt;= x &lt;= k</i> for
3165 * all <i>i, 1 &lt;= i &lt; k</i>, or a static type warning occurs. The member that is inherited
3166 * is <i>m<sub>x</sub></i>, if it exists; otherwise:
3167 * <ol>
3168 * * If all of <i>m<sub>1</sub>, &hellip; m<sub>k</sub></i> have the same numb er <i>r</i> of
3169 * required parameters and the same set of named parameters <i>s</i>, then let <i>h = max(
3170 * numberOfOptionalPositionals( m<sub>i</sub> ) ), 1 &lt;= i &lt;= k</i>. <i>I </i> has a method
3171 * named <i>n</i>, with <i>r</i> required parameters of type dynamic, <i>h</i> optional positional
3172 * parameters of type dynamic, named parameters <i>s</i> of type dynamic and r eturn type dynamic.
3173 * * Otherwise none of the members <i>m<sub>1</sub>, &hellip;, m<sub>k</sub></ i> is inherited.
3174 * </ol>
3175 */
3176 static final StaticTypeWarningCode INCONSISTENT_METHOD_INHERITANCE = new Stati cTypeWarningCode.con1('INCONSISTENT_METHOD_INHERITANCE', 3, "'%s' is inherited b y at least two interfaces inconsistently");
3177
3178 /**
3179 * 12.15.1 Ordinary Invocation: It is a static type warning if <i>T</i> does n ot have an
3180 * accessible (3.2) instance member named <i>m</i>.
3181 *
3182 * @param memberName the name of the static member
3183 * @see UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
3184 */
3185 static final StaticTypeWarningCode INSTANCE_ACCESS_TO_STATIC_MEMBER = new Stat icTypeWarningCode.con1('INSTANCE_ACCESS_TO_STATIC_MEMBER', 4, "Static member '%s ' cannot be accessed using instance access");
3186
3187 /**
3188 * 12.18 Assignment: It is a static type warning if the static type of <i>e</i > may not be
3189 * assigned to the static type of <i>v</i>. The static type of the expression <i>v = e</i> is the
3190 * static type of <i>e</i>.
3191 *
3192 * 12.18 Assignment: It is a static type warning if the static type of <i>e</i > may not be
3193 * assigned to the static type of <i>C.v</i>. The static type of the expressio n <i>C.v = e</i> is
3194 * the static type of <i>e</i>.
3195 *
3196 * 12.18 Assignment: Let <i>T</i> be the static type of <i>e<sub>1</sub></i>. It is a static type
3197 * warning if the static type of <i>e<sub>2</sub></i> may not be assigned to < i>T</i>.
3198 *
3199 * @param rhsTypeName the name of the right hand side type
3200 * @param lhsTypeName the name of the left hand side type
3201 */
3202 static final StaticTypeWarningCode INVALID_ASSIGNMENT = new StaticTypeWarningC ode.con1('INVALID_ASSIGNMENT', 5, "A value of type '%s' cannot be assigned to a variable of type '%s'");
3203
3204 /**
3205 * 12.15.1 Ordinary Invocation: An ordinary method invocation <i>i</i> has the form
3206 * <i>o.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</ sub>, &hellip;
3207 * x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
3208 *
3209 * Let <i>T</i> be the static type of <i>o</i>. It is a static type warning if <i>T</i> does not
3210 * have an accessible instance member named <i>m</i>. If <i>T.m</i> exists, it is a static warning
3211 * if the type <i>F</i> of <i>T.m</i> may not be assigned to a function type. If <i>T.m</i> does
3212 * not exist, or if <i>F</i> is not a function type, the static type of <i>i</ i> is dynamic.
3213 *
3214 * 12.15.3 Static Invocation: It is a static type warning if the type <i>F</i> of <i>C.m</i> may
3215 * not be assigned to a function type.
3216 *
3217 * 12.15.4 Super Invocation: A super method invocation <i>i</i> has the form
3218 * <i>super.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n +1</sub>, &hellip;
3219 * x<sub>n+k</sub>: a<sub>n+k</sub>)</i>. If <i>S.m</i> exists, it is a static warning if the type
3220 * <i>F</i> of <i>S.m</i> may not be assigned to a function type.
3221 *
3222 * @param nonFunctionIdentifier the name of the identifier that is not a funct ion type
3223 */
3224 static final StaticTypeWarningCode INVOCATION_OF_NON_FUNCTION = new StaticType WarningCode.con1('INVOCATION_OF_NON_FUNCTION', 6, "'%s' is not a method");
3225
3226 /**
3227 * 12.14.4 Function Expression Invocation: A function expression invocation <i >i</i> has the form
3228 * <i>e<sub>f</sub>(a<sub>1</sub>, &hellip; a<sub>n</sub>, x<sub>n+1</sub>: a< sub>n+1</sub>,
3229 * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>, where <i>e<sub>f</sub></i> is an expression.
3230 *
3231 * It is a static type warning if the static type <i>F</i> of <i>e<sub>f</sub> </i> may not be
3232 * assigned to a function type.
3233 */
3234 static final StaticTypeWarningCode INVOCATION_OF_NON_FUNCTION_EXPRESSION = new StaticTypeWarningCode.con1('INVOCATION_OF_NON_FUNCTION_EXPRESSION', 7, "Cannot invoke a non-function");
3235
3236 /**
3237 * 12.19 Conditional: It is a static type warning if the type of <i>e<sub>1</s ub></i> may not be
3238 * assigned to bool.
3239 *
3240 * 13.5 If: It is a static type warning if the type of the expression <i>b</i> may not be assigned
3241 * to bool.
3242 *
3243 * 13.7 While: It is a static type warning if the type of <i>e</i> may not be assigned to bool.
3244 *
3245 * 13.8 Do: It is a static type warning if the type of <i>e</i> cannot be assi gned to bool.
3246 */
3247 static final StaticTypeWarningCode NON_BOOL_CONDITION = new StaticTypeWarningC ode.con1('NON_BOOL_CONDITION', 8, "Conditions must have a static type of 'bool'" );
3248
3249 /**
3250 * 13.15 Assert: It is a static type warning if the type of <i>e</i> may not b e assigned to either
3251 * bool or () &rarr; bool
3252 */
3253 static final StaticTypeWarningCode NON_BOOL_EXPRESSION = new StaticTypeWarning Code.con1('NON_BOOL_EXPRESSION', 9, "Assertions must be on either a 'bool' or '( ) -> bool'");
3254
3255 /**
3256 * 15.8 Parameterized Types: It is a static type warning if <i>A<sub>i</sub>, 1 &lt;= i &lt;=
3257 * n</i> does not denote a type in the enclosing lexical scope.
3258 */
3259 static final StaticTypeWarningCode NON_TYPE_AS_TYPE_ARGUMENT = new StaticTypeW arningCode.con1('NON_TYPE_AS_TYPE_ARGUMENT', 10, "The name '%s' is not a type an d cannot be used as a parameterized type");
3260
3261 /**
3262 * 13.11 Return: It is a static type warning if the type of <i>e</i> may not b e assigned to the
3263 * declared return type of the immediately enclosing function.
3264 *
3265 * @param actualReturnType the return type as declared in the return statement
3266 * @param expectedReturnType the expected return type as defined by the method
3267 * @param methodName the name of the method
3268 */
3269 static final StaticTypeWarningCode RETURN_OF_INVALID_TYPE = new StaticTypeWarn ingCode.con1('RETURN_OF_INVALID_TYPE', 11, "The return type '%s' is not a '%s', as defined by the method '%s'");
3270
3271 /**
3272 * 12.11 Instance Creation: It is a static type warning if any of the type arg uments to a
3273 * constructor of a generic type <i>G</i> invoked by a new expression or a con stant object
3274 * expression are not subtypes of the bounds of the corresponding formal type parameters of
3275 * <i>G</i>.
3276 *
3277 * 15.8 Parameterized Types: If <i>S</i> is the static type of a member <i>m</ i> of <i>G</i>, then
3278 * the static type of the member <i>m</i> of <i>G&lt;A<sub>1</sub>, &hellip; A <sub>n</sub>&gt;</i>
3279 * is <i>[A<sub>1</sub>, &hellip;, A<sub>n</sub>/T<sub>1</sub>, &hellip;, T<su b>n</sub>]S</i>
3280 * where <i>T<sub>1</sub>, &hellip; T<sub>n</sub></i> are the formal type para meters of <i>G</i>.
3281 * Let <i>B<sub>i</sub></i> be the bounds of <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>. It is a
3282 * static type warning if <i>A<sub>i</sub></i> is not a subtype of <i>[A<sub>1 </sub>, &hellip;,
3283 * A<sub>n</sub>/T<sub>1</sub>, &hellip;, T<sub>n</sub>]B<sub>i</sub>, 1 &lt;= i &lt;= n</i>.
3284 *
3285 * 7.6.2 Factories: It is a static type warning if any of the type arguments t o <i>k'</i> are not
3286 * subtypes of the bounds of the corresponding formal type parameters of type.
3287 *
3288 * @param boundedTypeName the name of the type used in the instance creation t hat should be
3289 * limited by the bound as specified in the class declaration
3290 * @param boundingTypeName the name of the bounding type
3291 * @see #TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND
3292 */
3293 static final StaticTypeWarningCode TYPE_ARGUMENT_NOT_MATCHING_BOUNDS = new Sta ticTypeWarningCode.con1('TYPE_ARGUMENT_NOT_MATCHING_BOUNDS', 12, "'%s' does not extend '%s'");
3294
3295 /**
3296 * 10 Generics: It is a static type warning if a type parameter is a supertype of its upper bound.
3297 *
3298 * @param typeParameterName the name of the type parameter
3299 * @see #TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
3300 */
3301 static final StaticTypeWarningCode TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND = new StaticTypeWarningCode.con1('TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND', 13, "'%s' c annot be a supertype of its upper bound");
3302
3303 /**
3304 * 12.17 Getter Invocation: Let <i>T</i> be the static type of <i>e</i>. It is a static type
3305 * warning if <i>T</i> does not have a getter named <i>m</i>.
3306 *
3307 * @param getterName the name of the getter
3308 * @param enclosingType the name of the enclosing type where the getter is bei ng looked for
3309 */
3310 static final StaticTypeWarningCode UNDEFINED_GETTER = new StaticTypeWarningCod e.con1('UNDEFINED_GETTER', 14, "There is no such getter '%s' in '%s'");
3311
3312 /**
3313 * 12.15.1 Ordinary Invocation: Let <i>T</i> be the static type of <i>o</i>. I t is a static type
3314 * warning if <i>T</i> does not have an accessible instance member named <i>m< /i>.
3315 *
3316 * @param methodName the name of the method that is undefined
3317 * @param typeName the resolved type name that the method lookup is happening on
3318 */
3319 static final StaticTypeWarningCode UNDEFINED_METHOD = new StaticTypeWarningCod e.con1('UNDEFINED_METHOD', 15, "The method '%s' is not defined for the class '%s '");
3320
3321 /**
3322 * 12.18 Assignment: Evaluation of an assignment of the form
3323 * <i>e<sub>1</sub></i>[<i>e<sub>2</sub></i>] = <i>e<sub>3</sub></i> is equiva lent to the
3324 * evaluation of the expression (a, i, e){a.[]=(i, e); return e;} (<i>e<sub>1< /sub></i>,
3325 * <i>e<sub>2</sub></i>, <i>e<sub>2</sub></i>).
3326 *
3327 * 12.29 Assignable Expressions: An assignable expression of the form
3328 * <i>e<sub>1</sub></i>[<i>e<sub>2</sub></i>] is evaluated as a method invocat ion of the operator
3329 * method [] on <i>e<sub>1</sub></i> with argument <i>e<sub>2</sub></i>.
3330 *
3331 * 12.15.1 Ordinary Invocation: Let <i>T</i> be the static type of <i>o</i>. I t is a static type
3332 * warning if <i>T</i> does not have an accessible instance member named <i>m< /i>.
3333 *
3334 * @param operator the name of the operator
3335 * @param enclosingType the name of the enclosing type where the operator is b eing looked for
3336 */
3337 static final StaticTypeWarningCode UNDEFINED_OPERATOR = new StaticTypeWarningC ode.con1('UNDEFINED_OPERATOR', 16, "There is no such operator '%s' in '%s'");
3338
3339 /**
3340 * 12.18 Assignment: Let <i>T</i> be the static type of <i>e<sub>1</sub></i>. It is a static type
3341 * warning if <i>T</i> does not have an accessible instance setter named <i>v= </i>.
3342 *
3343 * @param setterName the name of the setter
3344 * @param enclosingType the name of the enclosing type where the setter is bei ng looked for
3345 * @see #INACCESSIBLE_SETTER
3346 */
3347 static final StaticTypeWarningCode UNDEFINED_SETTER = new StaticTypeWarningCod e.con1('UNDEFINED_SETTER', 17, "There is no such setter '%s' in '%s'");
3348
3349 /**
3350 * 12.15.4 Super Invocation: A super method invocation <i>i</i> has the form
3351 * <i>super.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n +1</sub>, &hellip;
3352 * x<sub>n+k</sub>: a<sub>n+k</sub>)</i>. It is a static type warning if <i>S< /i> does not have an
3353 * accessible instance member named <i>m</i>.
3354 *
3355 * @param methodName the name of the method that is undefined
3356 * @param typeName the resolved type name that the method lookup is happening on
3357 */
3358 static final StaticTypeWarningCode UNDEFINED_SUPER_METHOD = new StaticTypeWarn ingCode.con1('UNDEFINED_SUPER_METHOD', 18, "There is no such method '%s' in '%s' ");
3359
3360 /**
3361 * 12.15.1 Ordinary Invocation: It is a static type warning if <i>T</i> does n ot have an
3362 * accessible (3.2) instance member named <i>m</i>.
3363 *
3364 * This is a specialization of [INSTANCE_ACCESS_TO_STATIC_MEMBER] that is used when we are
3365 * able to find the name defined in a supertype. It exists to provide a more i nformative error
3366 * message.
3367 */
3368 static final StaticTypeWarningCode UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_M EMBER = new StaticTypeWarningCode.con1('UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATI C_MEMBER', 19, "Static members from supertypes must be qualified by the name of the defining type");
3369
3370 /**
3371 * 15.8 Parameterized Types: It is a static type warning if <i>G</i> is not a generic type with
3372 * exactly <i>n</i> type parameters.
3373 *
3374 * @param typeName the name of the type being referenced (<i>G</i>)
3375 * @param parameterCount the number of type parameters that were declared
3376 * @param argumentCount the number of type arguments provided
3377 * @see CompileTimeErrorCode#CONST_WITH_INVALID_TYPE_PARAMETERS
3378 * @see CompileTimeErrorCode#NEW_WITH_INVALID_TYPE_PARAMETERS
3379 */
3380 static final StaticTypeWarningCode WRONG_NUMBER_OF_TYPE_ARGUMENTS = new Static TypeWarningCode.con1('WRONG_NUMBER_OF_TYPE_ARGUMENTS', 20, "The type '%s' is dec lared with %d type parameters, but %d type arguments were given");
3381 static final List<StaticTypeWarningCode> values = [
3382 EXPECTED_ONE_LIST_TYPE_ARGUMENTS,
3383 EXPECTED_TWO_MAP_TYPE_ARGUMENTS,
3384 INACCESSIBLE_SETTER,
3385 INCONSISTENT_METHOD_INHERITANCE,
3386 INSTANCE_ACCESS_TO_STATIC_MEMBER,
3387 INVALID_ASSIGNMENT,
3388 INVOCATION_OF_NON_FUNCTION,
3389 INVOCATION_OF_NON_FUNCTION_EXPRESSION,
3390 NON_BOOL_CONDITION,
3391 NON_BOOL_EXPRESSION,
3392 NON_TYPE_AS_TYPE_ARGUMENT,
3393 RETURN_OF_INVALID_TYPE,
3394 TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
3395 TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND,
3396 UNDEFINED_GETTER,
3397 UNDEFINED_METHOD,
3398 UNDEFINED_OPERATOR,
3399 UNDEFINED_SETTER,
3400 UNDEFINED_SUPER_METHOD,
3401 UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER,
3402 WRONG_NUMBER_OF_TYPE_ARGUMENTS];
3403
3404 /**
3405 * The template used to create the message to be displayed for this error.
3406 */
3407 String _message;
3408
3409 /**
3410 * The template used to create the correction to be displayed for this error, or `null` if
3411 * there is no correction information for this error.
3412 */
3413 String correction6;
3414
3415 /**
3416 * Initialize a newly created error code to have the given message.
3417 *
3418 * @param message the message template used to create the message to be displa yed for the error
3419 */
3420 StaticTypeWarningCode.con1(String name, int ordinal, String message) : super(n ame, ordinal) {
3421 this._message = message;
3422 }
3423
3424 /**
3425 * Initialize a newly created error code to have the given message and correct ion.
3426 *
3427 * @param message the template used to create the message to be displayed for the error
3428 * @param correction the template used to create the correction to be displaye d for the error
3429 */
3430 StaticTypeWarningCode.con2(String name, int ordinal, String message, String co rrection) : super(name, ordinal) {
3431 this._message = message;
3432 this.correction6 = correction;
3433 }
3434 String get correction => correction6;
3435 ErrorSeverity get errorSeverity => ErrorType.STATIC_TYPE_WARNING.severity;
3436 String get message => _message;
3437 ErrorType get type => ErrorType.STATIC_TYPE_WARNING;
3438 }
OLDNEW
« no previous file with comments | « pkg/analyzer_experimental/lib/src/generated/engine.dart ('k') | pkg/analyzer_experimental/lib/src/generated/html.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698