OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | |
2 // for details. All rights reserved. Use of this source code is governed by a | |
3 // BSD-style license that can be found in the LICENSE file. | |
4 | |
5 import "package:expect/expect.dart"; | |
6 | |
7 import "compiler_helper.dart"; | |
8 | |
9 main() { | |
10 testMoreRequiredParameters(); | |
11 testFewerPositionalParameters(); | |
12 testNotAllNamedParameters(); | |
13 testNotSubtype(); | |
14 testGetterNotSubtype(); | |
15 testSetterNotSubtype(); | |
16 testGenericNotSubtype(); | |
17 testFieldNotSubtype(); | |
18 testMixedOverride(); | |
19 testAbstractMethods(); | |
20 testNoSuchMethod(); | |
21 } | |
22 | |
23 check(String source, {errors, warnings, hints, infos}) { | |
24 MockCompiler compiler = new MockCompiler(); | |
25 compiler.diagnosticHandler = createHandler(compiler, source); | |
26 compiler.parseScript(source); | |
27 var cls = compiler.mainApp.find('Class'); | |
28 cls.ensureResolved(compiler); | |
29 | |
30 if (errors == null) errors = []; | |
karlklose
2014/01/28 12:27:45
Consider adding a helper like
toList(o) => o ==
Johnni Winther
2014/01/31 12:29:30
Done.
| |
31 if (errors is! List) errors = [errors]; | |
32 compareMessageKinds(source, errors, compiler.errors, 'error'); | |
33 | |
34 if (warnings == null) warnings = []; | |
35 if (warnings is! List) warnings = [warnings]; | |
36 compareMessageKinds(source, warnings, compiler.warnings, 'warning'); | |
37 | |
38 if (infos != null) { | |
39 if (infos is! List) infos = [infos]; | |
40 compareMessageKinds(source, infos, compiler.infos, 'info'); | |
41 } | |
42 | |
43 if (hints != null) { | |
44 if (hints is! List) hints = [hints]; | |
45 compareMessageKinds(source, hints, compiler.hints, 'hint'); | |
46 } | |
47 } | |
48 | |
49 testMoreRequiredParameters() { | |
karlklose
2014/01/28 12:27:45
This method is also testing equal numbers of requi
Johnni Winther
2014/01/31 12:29:30
Done.
| |
50 check(""" | |
51 class A { | |
52 method() => null; // testMoreRequiredParameters:0 | |
53 } | |
54 class Class extends A { | |
55 method() => null; // testMoreRequiredParameters:1 | |
56 } | |
57 """); | |
58 | |
59 check(""" | |
60 class A { | |
61 method(a) => null; // testMoreRequiredParameters:2 | |
62 } | |
63 class Class extends A { | |
64 method(b) => null; // testMoreRequiredParameters:3 | |
65 } | |
66 """); | |
67 | |
68 check(""" | |
69 class A { | |
70 method(a, b, c, d) => null; // testMoreRequiredParameters:3 | |
71 } | |
72 class Class extends A { | |
73 method(b, a, d, c) => null; // testMoreRequiredParameters:4 | |
74 } | |
75 """); | |
76 | |
77 check(""" | |
78 class A { | |
79 method() => null; // testMoreRequiredParameters:5 | |
80 } | |
81 class Class extends A { | |
82 method(a) => null; // testMoreRequiredParameters:6 | |
83 } | |
84 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
85 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
86 | |
87 check(""" | |
88 class A { | |
89 method() => null; // testMoreRequiredParameters:7 | |
90 } | |
91 class Class implements A { | |
92 method(a) => null; // testMoreRequiredParameters:8 | |
93 } | |
94 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
95 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
96 | |
97 check(""" | |
98 class A { | |
99 method(a, b, c) => null; // testMoreRequiredParameters:9 | |
100 } | |
101 class Class extends A { | |
102 method(a, b, c, d) => null; // testMoreRequiredParameters:10 | |
103 } | |
104 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
105 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
106 } | |
107 | |
108 testFewerPositionalParameters() { | |
109 check(""" | |
110 class A { | |
111 method([a]) => null; // testFewerPositionalParameters:1 | |
112 } | |
113 class Class extends A { | |
114 method([a]) => null; // testFewerPositionalParameters:2 | |
115 } | |
116 """); | |
117 | |
118 check(""" | |
119 class A { | |
120 method([a, b]) => null; // testFewerPositionalParameters:3 | |
121 } | |
122 class Class extends A { | |
123 method([b, a]) => null; // testFewerPositionalParameters:4 | |
124 } | |
125 """); | |
126 | |
127 check(""" | |
128 class A { | |
129 method([a, b, c]) => null; // testFewerPositionalParameters:5 | |
130 } | |
131 class Class extends A { | |
132 method([b, d, a, c]) => null; // testFewerPositionalParameters:6 | |
133 } | |
134 """); | |
135 | |
136 check(""" | |
137 class A { | |
138 method([a]) => null; // testFewerPositionalParameters:7 | |
139 } | |
140 class Class extends A { | |
141 method([a]) => null; // testFewerPositionalParameters:8 | |
142 } | |
143 """); | |
144 | |
145 check(""" | |
146 class A { | |
147 method(a) => null; // testFewerPositionalParameters:9 | |
148 } | |
149 class Class extends A { | |
150 method() => null; // testFewerPositionalParameters:10 | |
151 } | |
152 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
153 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
154 | |
155 check(""" | |
156 class A { | |
157 method(a, [b]) => null; // testFewerPositionalParameters:11 | |
158 } | |
159 class Class extends A { | |
160 method(a) => null; // testFewerPositionalParameters:12 | |
161 } | |
162 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
163 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
164 | |
165 check(""" | |
166 class A { | |
167 method(a, [b]) => null; // testFewerPositionalParameters:13 | |
168 } | |
169 class Class extends A { | |
170 method([a]) => null; // testFewerPositionalParameters:14 | |
171 } | |
172 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
173 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
174 | |
175 check(""" | |
176 class A { | |
177 method(a, b, [c, d, e]) => null; // testFewerPositionalParameters:15 | |
178 } | |
179 class Class extends A { | |
180 method([a, b, c, d]) => null; // testFewerPositionalParameters:16 | |
181 } | |
182 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
183 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
184 } | |
185 | |
186 testNotAllNamedParameters() { | |
187 check(""" | |
188 class A { | |
189 method({a}) => null; // testNotAllNamedParameters:1 | |
190 } | |
191 class Class extends A { | |
192 method({a}) => null; // testNotAllNamedParameters:2 | |
193 } | |
194 """); | |
195 | |
196 check(""" | |
197 class A { | |
198 method({a, b}) => null; // testNotAllNamedParameters:3 | |
199 } | |
200 class Class extends A { | |
201 method({b, a}) => null; // testNotAllNamedParameters:4 | |
202 } | |
203 """); | |
204 | |
205 check(""" | |
206 class A { | |
207 method({a, b, c}) => null; // testNotAllNamedParameters:5 | |
208 } | |
209 class Class extends A { | |
210 method({b, c, a, d}) => null; // testNotAllNamedParameters:6 | |
211 } | |
212 """); | |
213 | |
214 check(""" | |
215 class A { | |
216 method(d, {a, b, c}) => null; // testNotAllNamedParameters:7 | |
217 } | |
218 class Class extends A { | |
219 method(e, {b, c, a, d}) => null; // testNotAllNamedParameters:8 | |
220 } | |
221 """); | |
222 | |
223 check(""" | |
224 class A { | |
225 method({a}) => null; // testNotAllNamedParameters:9 | |
226 } | |
227 class Class extends A { | |
228 method() => null; // testNotAllNamedParameters:10 | |
229 } | |
230 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
231 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
232 | |
233 check(""" | |
234 class A { | |
235 method({a, b}) => null; // testNotAllNamedParameters:11 | |
236 } | |
237 class Class extends A { | |
238 method({b}) => null; // testNotAllNamedParameters:12 | |
239 } | |
240 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
241 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
242 | |
243 check(""" | |
244 class A { | |
245 method({a, b, c, d}) => null; // testNotAllNamedParameters:13 | |
246 } | |
247 class Class extends A { | |
248 method({a, e, d, c}) => null; // testNotAllNamedParameters:14 | |
249 } | |
250 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
251 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
252 } | |
253 | |
254 testNotSubtype() { | |
karlklose
2014/01/28 12:27:45
This method also tests the positive test. Consider
Johnni Winther
2014/01/31 12:29:30
Done.
| |
255 check(""" | |
256 class A { | |
257 method(int a) => null; // testNotSubtype:1 | |
258 } | |
259 class Class extends A { | |
260 method(int a) => null; // testNotSubtype:2 | |
261 } | |
262 """); | |
263 | |
264 check(""" | |
265 class A { | |
266 method(int a) => null; // testNotSubtype:3 | |
267 } | |
268 class Class extends A { | |
269 method(num a) => null; // testNotSubtype:4 | |
270 } | |
271 """); | |
272 | |
273 check(""" | |
274 class A { | |
275 void method() {} // testNotSubtype:5 | |
276 } | |
277 class Class extends A { | |
278 method() => null; // testNotSubtype:6 | |
279 } | |
280 """); | |
281 | |
282 check(""" | |
283 class A { | |
284 method() => null; // testNotSubtype:7 | |
285 } | |
286 class Class extends A { | |
287 void method() {} // testNotSubtype:8 | |
288 } | |
289 """); | |
290 | |
291 check(""" | |
292 class A { | |
293 void method() {} // testNotSubtype:9 | |
294 } | |
295 class Class extends A { | |
296 int method() => null; // testNotSubtype:10 | |
297 } | |
298 """); | |
299 | |
300 check(""" | |
301 class A { | |
302 int method() => null; // testNotSubtype:11 | |
303 } | |
304 class Class extends A { | |
305 void method() {} // testNotSubtype:12 | |
306 } | |
307 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
308 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
309 | |
310 check(""" | |
311 class A { | |
312 method(int a) => null; // testNotSubtype:13 | |
313 } | |
314 class B extends A { | |
315 method(num a) => null; // testNotSubtype:14 | |
316 } | |
317 class Class extends B { | |
318 method(double a) => null; // testNotSubtype:15 | |
319 } | |
320 """); | |
321 | |
322 check(""" | |
323 class A { | |
324 method(int a) => null; // testNotSubtype:16 | |
325 } | |
326 class B extends A { | |
327 method(a) => null; // testNotSubtype:17 | |
328 } | |
329 class Class extends B { | |
330 method(String a) => null; // testNotSubtype:18 | |
331 } | |
332 """); | |
333 | |
334 check(""" | |
335 class A { | |
336 method(int a) => null; // testNotSubtype:19 | |
337 } | |
338 class Class extends A { | |
339 method(String a) => null; // testNotSubtype:20 | |
340 } | |
341 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
342 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
343 | |
344 check(""" | |
karlklose
2014/01/28 12:27:45
I would argue that 'inherited(C, _)' contains 'met
Johnni Winther
2014/01/31 12:29:30
Done.
| |
345 class A { | |
346 method(int a) => null; // testNotSubtype:23 | |
347 } | |
348 class B { | |
349 method(num a) => null; // testNotSubtype:24 | |
350 } | |
351 abstract class C implements A, B { | |
352 } | |
353 class Class implements C { | |
354 method(double a) => null; // testNotSubtype:25 | |
355 } | |
356 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
357 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
358 | |
359 check(""" | |
karlklose
2014/01/28 12:27:45
Ditto.
Johnni Winther
2014/01/31 12:29:30
Done.
| |
360 class A { | |
361 method(int a) => null; // testNotSubtype:26 | |
362 } | |
363 class B { | |
364 method(num a) => null; // testNotSubtype:27 | |
365 } | |
366 abstract class C implements A, B { | |
367 } | |
368 class Class implements C { | |
369 method(String a) => null; // testNotSubtype:28 | |
370 } | |
371 """, warnings: [MessageKind.INVALID_OVERRIDE_METHOD, | |
372 MessageKind.INVALID_OVERRIDE_METHOD], | |
373 infos: [MessageKind.INVALID_OVERRIDDEN_METHOD, | |
374 MessageKind.INVALID_OVERRIDDEN_METHOD]); | |
375 | |
376 check(""" | |
karlklose
2014/01/28 12:27:45
Move this up after l. 357 (it is just testing a sy
Johnni Winther
2014/01/31 12:29:30
Done.
| |
377 class A { | |
378 method(num a) => null; // testNotSubtype:29 | |
379 } | |
380 class B { | |
381 method(int a) => null; // testNotSubtype:30 | |
382 } | |
383 abstract class C implements A, B { | |
384 } | |
385 class Class implements C { | |
386 method(double a) => null; // testNotSubtype:31 | |
387 } | |
388 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
389 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
390 } | |
391 | |
392 testGetterNotSubtype() { | |
393 check(""" | |
394 class A { | |
395 get getter => null; // testGetterNotSubtype:1 | |
396 } | |
397 class Class extends A { | |
398 get getter => null; // testGetterNotSubtype:2 | |
399 } | |
400 """); | |
401 | |
402 check(""" | |
403 class A { | |
404 num get getter => null; // testGetterNotSubtype:3 | |
405 } | |
406 class Class extends A { | |
407 num get getter => null; // testGetterNotSubtype:4 | |
408 } | |
409 """); | |
410 | |
411 check(""" | |
412 class A { | |
413 num get getter => null; // testGetterNotSubtype:5 | |
414 } | |
415 class Class extends A { | |
416 int get getter => null; // testGetterNotSubtype:6 | |
417 } | |
418 """); | |
419 | |
420 check(""" | |
421 class A { | |
422 int get getter => null; // testGetterNotSubtype:7 | |
423 } | |
424 class Class extends A { | |
425 num get getter => null; // testGetterNotSubtype:8 | |
426 } | |
427 """); | |
428 | |
429 check(""" | |
430 class A { | |
431 int get getter => null; // testGetterNotSubtype:9 | |
432 } | |
433 class Class extends A { | |
434 double get getter => null; // testGetterNotSubtype:10 | |
435 } | |
436 """, warnings: MessageKind.INVALID_OVERRIDE_GETTER, | |
437 infos: MessageKind.INVALID_OVERRIDDEN_GETTER); | |
438 | |
439 check(""" | |
440 class A { | |
441 int get getter => null; // testGetterNotSubtype:11 | |
442 } | |
443 class B extends A { | |
444 num get getter => null; // testGetterNotSubtype:12 | |
445 } | |
446 class Class extends B { | |
447 double get getter => null; // testGetterNotSubtype:13 | |
448 } | |
449 """); | |
450 | |
451 check(""" | |
452 class A { | |
453 int get getter => null; // testGetterNotSubtype:14 | |
454 } | |
455 class B { | |
456 num get getter => null; // testGetterNotSubtype:15 | |
457 } | |
458 class Class extends A implements B { | |
459 double get getter => null; // testGetterNotSubtype:16 | |
460 } | |
461 """, warnings: MessageKind.INVALID_OVERRIDE_GETTER, | |
462 infos: MessageKind.INVALID_OVERRIDDEN_GETTER); | |
463 | |
464 check(""" | |
465 class A { | |
466 int get getter => null; // testGetterNotSubtype:17 | |
467 } | |
468 class B { | |
469 String get getter => null; // testGetterNotSubtype:18 | |
470 } | |
471 class Class extends A implements B { | |
472 double get getter => null; // testGetterNotSubtype:19 | |
473 } | |
474 """, warnings: [MessageKind.INVALID_OVERRIDE_GETTER, | |
475 MessageKind.INVALID_OVERRIDE_GETTER], | |
476 infos: [MessageKind.INVALID_OVERRIDDEN_GETTER, | |
477 MessageKind.INVALID_OVERRIDDEN_GETTER]); | |
478 | |
479 check(""" | |
480 class A { | |
481 int get getter => null; // testGetterNotSubtype:20 | |
482 } | |
483 class B { | |
484 String get getter => null; // testGetterNotSubtype:21 | |
485 } | |
486 class Class implements A, B { | |
487 double get getter => null; // testGetterNotSubtype:22 | |
488 } | |
489 """, warnings: [MessageKind.INVALID_OVERRIDE_GETTER, | |
490 MessageKind.INVALID_OVERRIDE_GETTER], | |
491 infos: [MessageKind.INVALID_OVERRIDDEN_GETTER, | |
492 MessageKind.INVALID_OVERRIDDEN_GETTER]); | |
493 | |
494 check(""" | |
495 class A { | |
496 int get getter => null; // testGetterNotSubtype:23 | |
497 } | |
498 class B { | |
499 num get getter => null; // testGetterNotSubtype:24 | |
500 } | |
501 abstract class C implements A, B { | |
502 } | |
503 class Class implements C { | |
504 double get getter => null; // testGetterNotSubtype:25 | |
505 } | |
506 """, warnings: MessageKind.INVALID_OVERRIDE_GETTER, | |
507 infos: MessageKind.INVALID_OVERRIDDEN_GETTER); | |
508 | |
509 check(""" | |
karlklose
2014/01/28 12:27:45
Also add a TODO to wait for clarification from Gil
Johnni Winther
2014/01/31 12:29:30
Done.
| |
510 class A { | |
511 int get getter => null; // testGetterNotSubtype:26 | |
512 } | |
513 class B { | |
514 num get getter => null; // testGetterNotSubtype:27 | |
515 } | |
516 abstract class C implements A, B { | |
517 } | |
518 class Class implements C { | |
519 String get getter => null; // testGetterNotSubtype:28 | |
520 } | |
521 """, warnings: [MessageKind.INVALID_OVERRIDE_GETTER, | |
522 MessageKind.INVALID_OVERRIDE_GETTER], | |
523 infos: [MessageKind.INVALID_OVERRIDDEN_GETTER, | |
524 MessageKind.INVALID_OVERRIDDEN_GETTER]); | |
525 } | |
526 | |
527 testGenericNotSubtype() { | |
528 check(""" | |
529 class A<T> { | |
530 method(T t) => null; // testGenericNotSubtype:1 | |
531 } | |
532 class Class<S> extends A<S> { | |
533 method(S s) => null; // testGenericNotSubtype:2 | |
534 } | |
535 """); | |
536 | |
537 check(""" | |
538 class A<T> { | |
539 method(T t) => null; // testGenericNotSubtype:3 | |
540 } | |
541 class Class extends A<num> { | |
542 method(int i) => null; // testGenericNotSubtype:4 | |
543 } | |
544 """); | |
545 | |
546 check(""" | |
547 class A<T> { | |
548 method(T t) => null; // testGenericNotSubtype:5 | |
549 } | |
550 class B<S> { | |
551 method(S s) => null; // testGenericNotSubtype:6 | |
552 } | |
553 class Class extends A<double> implements B<int> { | |
554 method(num i) => null; // testGenericNotSubtype:7 | |
555 } | |
556 """); | |
557 | |
558 check(""" | |
559 class A<T> { | |
560 method(T t) => null; // testGenericNotSubtype:8 | |
561 } | |
562 class Class<S> extends A<S> { | |
563 method(int i) => null; // testGenericNotSubtype:9 | |
564 } | |
565 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
566 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
567 | |
568 check(""" | |
569 class A<T> { | |
570 method(T t) => null; // testGenericNotSubtype:10 | |
571 } | |
572 class B<S> extends A<S> { | |
573 | |
574 } | |
575 class Class<U> extends B<U> { | |
576 method(U u) => null; // testGenericNotSubtype:11 | |
577 } | |
578 """); | |
579 | |
580 check(""" | |
581 class A<T> { | |
582 method(T t) => null; // testGenericNotSubtype:12 | |
583 } | |
584 class B<S> { | |
585 method(S s) => null; // testGenericNotSubtype:13 | |
586 } | |
587 class Class<U> extends A<U> implements B<num> { | |
588 method(int i) => null; // testGenericNotSubtype:14 | |
589 } | |
590 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
591 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
592 | |
593 check(""" | |
594 class A<T> { | |
595 method(T t) => null; // testGenericNotSubtype:15 | |
596 } | |
597 class B<S> { | |
598 method(S s) => null; // testGenericNotSubtype:16 | |
599 } | |
600 class Class extends A<int> implements B<String> { | |
601 method(double d) => null; // testGenericNotSubtype:17 | |
602 } | |
603 """, warnings: [MessageKind.INVALID_OVERRIDE_METHOD, | |
604 MessageKind.INVALID_OVERRIDE_METHOD], | |
605 infos: [MessageKind.INVALID_OVERRIDDEN_METHOD, | |
606 MessageKind.INVALID_OVERRIDDEN_METHOD]); | |
607 | |
608 check(""" | |
609 class A<T> { | |
610 method(T t) => null; // testGenericNotSubtype:18 | |
611 } | |
612 class B<S> { | |
613 method(S s) => null; // testGenericNotSubtype:19 | |
614 } | |
615 class Class implements A<int>, B<String> { | |
616 method(double d) => null; // testGenericNotSubtype:20 | |
617 } | |
618 """, warnings: [MessageKind.INVALID_OVERRIDE_METHOD, | |
619 MessageKind.INVALID_OVERRIDE_METHOD], | |
620 infos: [MessageKind.INVALID_OVERRIDDEN_METHOD, | |
621 MessageKind.INVALID_OVERRIDDEN_METHOD]); | |
622 | |
623 check(""" | |
624 class A<T> { | |
625 method(T t) => null; // testGenericNotSubtype:21 | |
626 } | |
627 class B<S> { | |
628 method(S s) => null; // testGenericNotSubtype:22 | |
629 } | |
630 abstract class C implements A<int>, B<num> { | |
631 } | |
632 class Class implements C { | |
633 method(double d) => null; // testGenericNotSubtype:23 | |
634 } | |
635 """, warnings: MessageKind.INVALID_OVERRIDE_METHOD, | |
636 infos: MessageKind.INVALID_OVERRIDDEN_METHOD); | |
637 | |
638 check(""" | |
639 class A<T> { | |
640 method(T t) => null; // testGenericNotSubtype:24 | |
641 } | |
642 class B<S> { | |
643 method(S s) => null; // testGenericNotSubtype:25 | |
644 } | |
645 abstract class C implements A<int>, B<num> { | |
646 } | |
647 class Class implements C { | |
648 method(String s) => null; // testGenericNotSubtype:26 | |
649 } | |
650 """, warnings: [MessageKind.INVALID_OVERRIDE_METHOD, | |
651 MessageKind.INVALID_OVERRIDE_METHOD], | |
652 infos: [MessageKind.INVALID_OVERRIDDEN_METHOD, | |
653 MessageKind.INVALID_OVERRIDDEN_METHOD]); | |
654 } | |
655 | |
656 testSetterNotSubtype() { | |
657 check(""" | |
658 class A { | |
659 set setter(_) => null; // testSetterNotSubtype:1 | |
660 } | |
661 class Class extends A { | |
662 set setter(_) => null; // testSetterNotSubtype:2 | |
663 } | |
664 """); | |
665 | |
666 check(""" | |
667 class A { | |
668 void set setter(_) {} // testSetterNotSubtype:3 | |
669 } | |
670 class Class extends A { | |
671 set setter(_) => null; // testSetterNotSubtype:4 | |
672 } | |
673 """); | |
674 | |
675 check(""" | |
676 class A { | |
677 set setter(_) => null; // testSetterNotSubtype:5 | |
678 } | |
679 class Class extends A { | |
680 void set setter(_) {} // testSetterNotSubtype:6 | |
681 } | |
682 """); | |
683 | |
684 check(""" | |
685 class A { | |
686 set setter(_) => null; // testSetterNotSubtype:7 | |
687 } | |
688 class Class extends A { | |
689 void set setter(_) {} // testSetterNotSubtype:8 | |
690 } | |
691 """); | |
692 | |
693 check(""" | |
694 class A { | |
695 set setter(num _) => null; // testSetterNotSubtype:9 | |
696 } | |
697 class Class extends A { | |
698 set setter(num _) => null; // testSetterNotSubtype:10 | |
699 } | |
700 """); | |
701 | |
702 check(""" | |
703 class A { | |
704 set setter(num _) => null; // testSetterNotSubtype:11 | |
705 } | |
706 class Class extends A { | |
707 set setter(int _) => null; // testSetterNotSubtype:12 | |
708 } | |
709 """); | |
710 | |
711 check(""" | |
712 class A { | |
713 set setter(int _) => null; // testSetterNotSubtype:13 | |
714 } | |
715 class Class extends A { | |
716 set setter(num _) => null; // testSetterNotSubtype:14 | |
717 } | |
718 """); | |
719 | |
720 check(""" | |
721 class A { | |
722 set setter(int _) => null; // testSetterNotSubtype:15 | |
723 } | |
724 class Class extends A { | |
725 set setter(double _) => null; // testSetterNotSubtype:16 | |
726 } | |
727 """, warnings: MessageKind.INVALID_OVERRIDE_SETTER, | |
728 infos: MessageKind.INVALID_OVERRIDDEN_SETTER); | |
729 | |
730 check(""" | |
731 class A { | |
732 set setter(int _) => null; // testSetterNotSubtype:17 | |
733 } | |
734 class B extends A { | |
735 set setter(num _) => null; // testSetterNotSubtype:18 | |
736 } | |
737 class Class extends B { | |
738 set setter(double _) => null; // testSetterNotSubtype:19 | |
739 } | |
740 """); | |
741 | |
742 check(""" | |
743 class A { | |
744 set setter(int _) => null; // testSetterNotSubtype:20 | |
745 } | |
746 class B { | |
747 set setter(num _) => null; // testSetterNotSubtype:21 | |
748 } | |
749 class Class extends A implements B { | |
750 set setter(double _) => null; // testSetterNotSubtype:22 | |
751 } | |
752 """, warnings: MessageKind.INVALID_OVERRIDE_SETTER, | |
753 infos: MessageKind.INVALID_OVERRIDDEN_SETTER); | |
754 | |
755 check(""" | |
756 class A { | |
757 set setter(int _) => null; // testSetterNotSubtype:23 | |
758 } | |
759 class B { | |
760 set setter(String _) => null; // testSetterNotSubtype:24 | |
761 } | |
762 class Class extends A implements B { | |
763 set setter(double _) => null; // testSetterNotSubtype:25 | |
764 } | |
765 """, warnings: [MessageKind.INVALID_OVERRIDE_SETTER, | |
766 MessageKind.INVALID_OVERRIDE_SETTER], | |
767 infos: [MessageKind.INVALID_OVERRIDDEN_SETTER, | |
768 MessageKind.INVALID_OVERRIDDEN_SETTER]); | |
769 | |
770 check(""" | |
771 class A { | |
772 set setter(int _) => null; // testSetterNotSubtype:26 | |
773 } | |
774 class B { | |
775 set setter(String _) => null; // testSetterNotSubtype:27 | |
776 } | |
777 class Class implements A, B { | |
778 set setter(double _) => null; // testSetterNotSubtype:28 | |
779 } | |
780 """, warnings: [MessageKind.INVALID_OVERRIDE_SETTER, | |
781 MessageKind.INVALID_OVERRIDE_SETTER], | |
782 infos: [MessageKind.INVALID_OVERRIDDEN_SETTER, | |
783 MessageKind.INVALID_OVERRIDDEN_SETTER]); | |
784 | |
785 check(""" | |
786 class A { | |
787 set setter(int _) => null; // testSetterNotSubtype:29 | |
788 } | |
789 class B { | |
790 set setter(num _) => null; // testSetterNotSubtype:30 | |
791 } | |
792 abstract class C implements A, B { | |
793 } | |
794 class Class implements C { | |
795 set setter(double _) => null; // testSetterNotSubtype:31 | |
796 } | |
797 """, warnings: MessageKind.INVALID_OVERRIDE_SETTER, | |
798 infos: MessageKind.INVALID_OVERRIDDEN_SETTER); | |
799 | |
800 check(""" | |
801 class A { | |
802 set setter(int _) => null; // testSetterNotSubtype:32 | |
803 } | |
804 class B { | |
805 set setter(num _) => null; // testSetterNotSubtype:33 | |
806 } | |
807 abstract class C implements A, B { | |
808 } | |
809 class Class implements C { | |
810 set setter(String _) => null; // testSetterNotSubtype:34 | |
811 } | |
812 """, warnings: [MessageKind.INVALID_OVERRIDE_SETTER, | |
813 MessageKind.INVALID_OVERRIDE_SETTER], | |
814 infos: [MessageKind.INVALID_OVERRIDDEN_SETTER, | |
815 MessageKind.INVALID_OVERRIDDEN_SETTER]); | |
816 } | |
817 | |
818 testFieldNotSubtype() { | |
819 check(""" | |
820 class A { | |
821 int field; // testFieldNotSubtype:1 | |
822 } | |
823 class Class extends A { | |
824 int field; // testFieldNotSubtype:2 | |
825 } | |
826 """); | |
827 | |
828 check(""" | |
829 class A { | |
830 num field; // testFieldNotSubtype:3 | |
831 } | |
832 class Class extends A { | |
833 int field; // testFieldNotSubtype:4 | |
834 } | |
835 """); | |
836 | |
837 check(""" | |
838 class A { | |
839 int field; // testFieldNotSubtype:5 | |
840 } | |
841 class Class extends A { | |
842 num field; // testFieldNotSubtype:6 | |
843 } | |
844 """); | |
845 | |
846 check(""" | |
847 class A { | |
848 int field; // testFieldNotSubtype:7 | |
849 } | |
850 class Class extends A { | |
851 double field; // testFieldNotSubtype:8 | |
852 } | |
853 """, warnings: MessageKind.INVALID_OVERRIDE_FIELD, | |
854 infos: MessageKind.INVALID_OVERRIDDEN_FIELD); | |
855 | |
856 check(""" | |
857 class A { | |
858 int field; // testFieldNotSubtype:9 | |
859 } | |
860 class B extends A { | |
861 num field; // testFieldNotSubtype:10 | |
862 } | |
863 class Class extends B { | |
864 double field; // testFieldNotSubtype:11 | |
865 } | |
866 """); | |
867 | |
868 check(""" | |
869 class A { | |
870 num field; // testFieldNotSubtype:12 | |
871 } | |
872 class Class extends A { | |
873 int get field => null; // testFieldNotSubtype:13 | |
874 } | |
875 """); | |
876 | |
877 check(""" | |
878 class A { | |
879 num field; // testFieldNotSubtype:14 | |
880 } | |
881 class Class extends A { | |
882 String get field => null; // testFieldNotSubtype:15 | |
883 } | |
884 """, warnings: MessageKind.INVALID_OVERRIDE_FIELD_WITH_GETTER, | |
885 infos: MessageKind.INVALID_OVERRIDDEN_FIELD); | |
886 | |
887 check(""" | |
888 class A { | |
889 num get field => null; // testFieldNotSubtype:16 | |
890 } | |
891 class Class extends A { | |
892 String field; // testFieldNotSubtype:17 | |
893 } | |
894 """, warnings: MessageKind.INVALID_OVERRIDE_GETTER_WITH_FIELD, | |
895 infos: MessageKind.INVALID_OVERRIDDEN_GETTER); | |
896 | |
897 check(""" | |
898 class A { | |
899 num field; // testFieldNotSubtype:18 | |
900 } | |
901 class Class extends A { | |
902 set field(int _) {} // testFieldNotSubtype:19 | |
903 } | |
904 """); | |
905 | |
906 check(""" | |
907 class A { | |
908 num field; // testFieldNotSubtype:19 | |
909 } | |
910 class Class extends A { | |
911 void set field(int _) {} // testFieldNotSubtype:20 | |
912 } | |
913 """); | |
914 | |
915 check(""" | |
916 class A { | |
917 set field(int _) {} // testFieldNotSubtype:21 | |
918 } | |
919 class Class extends A { | |
920 num field; // testFieldNotSubtype:22 | |
921 } | |
922 """); | |
923 | |
924 check(""" | |
925 class A { | |
926 void set field(int _) {} // testFieldNotSubtype:23 | |
927 } | |
928 class Class extends A { | |
929 num field; // testFieldNotSubtype:24 | |
930 } | |
931 """); | |
932 | |
933 check(""" | |
934 class A { | |
935 num field; // testFieldNotSubtype:25 | |
936 } | |
937 class Class extends A { | |
938 set field(String _) {} // testFieldNotSubtype:26 | |
939 } | |
940 """, warnings: MessageKind.INVALID_OVERRIDE_FIELD_WITH_SETTER, | |
941 infos: MessageKind.INVALID_OVERRIDDEN_FIELD); | |
942 | |
943 check(""" | |
944 class A { | |
945 set field(num _) {} // testFieldNotSubtype:27 | |
946 } | |
947 class Class extends A { | |
948 String field; // testFieldNotSubtype:28 | |
949 } | |
950 """, warnings: MessageKind.INVALID_OVERRIDE_SETTER_WITH_FIELD, | |
951 infos: MessageKind.INVALID_OVERRIDDEN_SETTER); | |
952 | |
953 check(""" | |
954 class A { | |
955 int field; // testFieldNotSubtype:29 | |
956 } | |
957 class Class implements A { | |
958 String get field => null; // testFieldNotSubtype:30 | |
959 void set field(String s) {} // testFieldNotSubtype:31 | |
960 } | |
961 """, warnings: [MessageKind.INVALID_OVERRIDE_FIELD_WITH_GETTER, | |
962 MessageKind.INVALID_OVERRIDE_FIELD_WITH_SETTER], | |
963 infos: [MessageKind.INVALID_OVERRIDDEN_FIELD, | |
964 MessageKind.INVALID_OVERRIDDEN_FIELD]); | |
965 | |
966 | |
967 check(""" | |
968 class A { | |
969 String get field => null; // testFieldNotSubtype:32 | |
970 void set field(String s) {} // testFieldNotSubtype:33 | |
971 } | |
972 class Class implements A { | |
973 int field; // testFieldNotSubtype:34 | |
974 } | |
975 """, warnings: [MessageKind.INVALID_OVERRIDE_GETTER_WITH_FIELD, | |
976 MessageKind.INVALID_OVERRIDE_SETTER_WITH_FIELD], | |
977 infos: [MessageKind.INVALID_OVERRIDDEN_GETTER, | |
978 MessageKind.INVALID_OVERRIDDEN_SETTER]); | |
979 } | |
980 | |
981 testMixedOverride() { | |
982 check(""" | |
983 class A { | |
984 var member; // testMixedOverride:1 | |
985 } | |
986 class Class extends A { | |
987 member() {} // testMixedOverride:2 | |
988 } | |
989 """, errors: MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD, | |
990 infos: MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT); | |
991 | |
992 check(""" | |
993 class A { | |
994 member() {} // testMixedOverride:3 | |
995 } | |
996 class Class extends A { | |
997 var member; // testMixedOverride:4 | |
998 } | |
999 """, errors: MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD, | |
1000 infos: MessageKind.CANNOT_OVERRIDE_METHOD_WITH_FIELD_CONT); | |
1001 | |
1002 check(""" | |
1003 class A { | |
1004 get member => null; // testMixedOverride:5 | |
1005 } | |
1006 class Class extends A { | |
1007 member() {} // testMixedOverride:6 | |
1008 } | |
1009 """, errors: MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD, | |
1010 infos: MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT); | |
1011 | |
1012 check(""" | |
1013 class A { | |
1014 member() {} // testMixedOverride:7 | |
1015 } | |
1016 class Class extends A { | |
1017 get member => null; // testMixedOverride:8 | |
1018 } | |
1019 """, errors: MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER, | |
1020 infos: MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT); | |
1021 | |
1022 check(""" | |
1023 abstract class A { | |
1024 var member; // testMixedOverride:9 | |
1025 } | |
1026 abstract class B { | |
1027 get member; // testMixedOverride:10 | |
1028 } | |
1029 abstract class Class implements A, B { | |
1030 } | |
1031 """); | |
1032 | |
1033 check(""" | |
1034 abstract class A { | |
1035 var member; // testMixedOverride:11 | |
1036 } | |
1037 abstract class B { | |
1038 member() {} // testMixedOverride:12 | |
1039 } | |
1040 abstract class Class implements A, B { | |
1041 } | |
1042 """, warnings: MessageKind.INHERIT_GETTER_AND_METHOD, | |
1043 infos: [MessageKind.INHERITED_METHOD, | |
1044 MessageKind.INHERITED_IMPLICIT_GETTER]); | |
1045 | |
1046 check(""" | |
1047 abstract class A { | |
1048 get member; // testMixedOverride:13 | |
1049 } | |
1050 abstract class B { | |
1051 member() {} // testMixedOverride:14 | |
1052 } | |
1053 abstract class Class implements A, B { | |
1054 } | |
1055 """, warnings: MessageKind.INHERIT_GETTER_AND_METHOD, | |
1056 infos: [MessageKind.INHERITED_METHOD, | |
1057 MessageKind.INHERITED_EXPLICIT_GETTER]); | |
1058 | |
1059 check(""" | |
1060 abstract class A { | |
1061 get member; // testMixedOverride:15 | |
1062 } | |
1063 abstract class B { | |
1064 member() {} // testMixedOverride:16 | |
1065 } | |
1066 abstract class C { | |
1067 var member; // testMixedOverride:17 | |
1068 } | |
1069 abstract class D { | |
1070 member() {} // testMixedOverride:18 | |
1071 } | |
1072 abstract class E { | |
1073 get member; // testMixedOverride:19 | |
1074 } | |
1075 abstract class Class implements A, B, C, D, E { | |
1076 } | |
1077 """, warnings: MessageKind.INHERIT_GETTER_AND_METHOD, | |
1078 infos: [MessageKind.INHERITED_EXPLICIT_GETTER, | |
1079 MessageKind.INHERITED_METHOD, | |
1080 MessageKind.INHERITED_IMPLICIT_GETTER, | |
1081 MessageKind.INHERITED_METHOD, | |
1082 MessageKind.INHERITED_EXPLICIT_GETTER]); | |
1083 | |
1084 check(""" | |
1085 abstract class A { | |
1086 get member; // testMixedOverride:20 | |
1087 } | |
1088 abstract class B { | |
1089 member() {} // testMixedOverride:21 | |
1090 } | |
1091 abstract class C implements A, B { | |
1092 } | |
1093 class Class extends C { | |
1094 member() {} // testMixedOverride:22 | |
1095 } | |
1096 """, errors: MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD, | |
1097 warnings: MessageKind.INHERIT_GETTER_AND_METHOD, | |
1098 infos: [MessageKind.INHERITED_METHOD, | |
1099 MessageKind.INHERITED_EXPLICIT_GETTER, | |
1100 MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT]); | |
1101 | |
1102 check(""" | |
1103 abstract class A { | |
1104 get member; // testMixedOverride:23 | |
1105 } | |
1106 abstract class B { | |
1107 member() {} // testMixedOverride:24 | |
1108 } | |
1109 abstract class C implements A, B { | |
1110 } | |
1111 class Class extends C { | |
1112 get member => null; // testMixedOverride:25 | |
1113 } | |
1114 """, errors: MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER, | |
1115 warnings: MessageKind.INHERIT_GETTER_AND_METHOD, | |
1116 infos: [MessageKind.INHERITED_METHOD, | |
1117 MessageKind.INHERITED_EXPLICIT_GETTER, | |
1118 MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT]); | |
1119 } | |
1120 | |
1121 testAbstractMethods() { | |
1122 check(""" | |
1123 abstract class Class { | |
1124 method(); // testAbstractMethod:1 | |
1125 } | |
1126 """); | |
1127 | |
1128 check(""" | |
1129 class Class { | |
1130 method(); // testAbstractMethod:2 | |
1131 } | |
1132 """, warnings: MessageKind.ABSTRACT_METHOD, | |
1133 infos: []); | |
1134 | |
1135 check(""" | |
1136 class Class { | |
1137 get getter; // testAbstractMethod:3 | |
1138 } | |
1139 """, warnings: MessageKind.ABSTRACT_GETTER, | |
1140 infos: []); | |
1141 | |
1142 check(""" | |
1143 class Class { | |
1144 set setter(_); // testAbstractMethod:4 | |
1145 } | |
1146 """, warnings: MessageKind.ABSTRACT_SETTER, | |
1147 infos: []); | |
1148 | |
1149 check(""" | |
1150 abstract class A { | |
1151 method(); // testAbstractMethod:5 | |
1152 } | |
1153 class Class extends A { | |
1154 method() {} // testAbstractMethod:6 | |
1155 } | |
1156 """); | |
1157 | |
1158 check(""" | |
1159 abstract class A { | |
1160 method(); // testAbstractMethod:7 | |
1161 } | |
1162 class Class extends A { | |
1163 method([a]) {} // testAbstractMethod:8 | |
1164 } | |
1165 """); | |
1166 | |
1167 check(""" | |
1168 abstract class A { | |
1169 method(); // testAbstractMethod:9 | |
1170 } | |
1171 class Class extends A { | |
1172 } | |
1173 """, warnings: MessageKind.UNIMPLEMENTED_METHOD_ONE, | |
1174 infos: MessageKind.UNIMPLEMENTED_METHOD_CONT); | |
1175 | |
1176 check(""" | |
1177 abstract class A { | |
1178 get getter; // testAbstractMethod:10 | |
1179 } | |
1180 class Class extends A { | |
1181 } | |
1182 """, warnings: MessageKind.UNIMPLEMENTED_GETTER_ONE, | |
1183 infos: MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER); | |
1184 | |
1185 check(""" | |
1186 abstract class A { | |
1187 set setter(_); // testAbstractMethod:11 | |
1188 } | |
1189 class Class extends A { | |
1190 } | |
1191 """, warnings: MessageKind.UNIMPLEMENTED_SETTER_ONE, | |
1192 infos: MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER); | |
1193 | |
1194 check(""" | |
1195 abstract class A { | |
1196 method(); // testAbstractMethod:12 | |
1197 } | |
1198 class B { | |
1199 method() {} // testAbstractMethod:13 | |
1200 } | |
1201 class Class extends A implements B { | |
1202 } | |
1203 """, warnings: MessageKind.UNIMPLEMENTED_METHOD, | |
1204 infos: [MessageKind.UNIMPLEMENTED_METHOD_CONT, | |
1205 MessageKind.UNIMPLEMENTED_METHOD_CONT]); | |
1206 | |
1207 check(""" | |
1208 abstract class A { | |
1209 get getter; // testAbstractMethod:14 | |
1210 } | |
1211 class B { | |
1212 get getter => 0; // testAbstractMethod:15 | |
1213 } | |
1214 class Class extends A implements B { | |
1215 } | |
1216 """, warnings: MessageKind.UNIMPLEMENTED_GETTER, | |
1217 infos: [MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER, | |
1218 MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER]); | |
1219 | |
1220 check(""" | |
1221 abstract class A { | |
1222 set setter(_); // testAbstractMethod:16 | |
1223 } | |
1224 class B { | |
1225 set setter(_) {} // testAbstractMethod:17 | |
1226 } | |
1227 class Class extends A implements B { | |
1228 } | |
1229 """, warnings: MessageKind.UNIMPLEMENTED_SETTER, | |
1230 infos: [MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER, | |
1231 MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER]); | |
1232 | |
1233 check(""" | |
1234 abstract class A { | |
1235 get field; // testAbstractMethod:18 | |
1236 } | |
1237 class B { | |
1238 var field; // testAbstractMethod:19 | |
1239 } | |
1240 class Class extends A implements B { | |
1241 set field(_) {} // testAbstractMethod:20 | |
1242 } | |
1243 """, warnings: MessageKind.UNIMPLEMENTED_GETTER, | |
1244 infos: [MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER, | |
1245 MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER]); | |
1246 | |
1247 check(""" | |
1248 abstract class A { | |
1249 set field(_); // testAbstractMethod:21 | |
1250 } | |
1251 class B { | |
1252 var field; // testAbstractMethod:22 | |
1253 } | |
1254 class Class extends A implements B { | |
1255 get field => 0; // testAbstractMethod:23 | |
1256 } | |
1257 """, warnings: MessageKind.UNIMPLEMENTED_SETTER, | |
1258 infos: [MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER, | |
1259 MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER]); | |
1260 | |
1261 check(""" | |
1262 class A { | |
1263 method() {} // testAbstractMethod:24 | |
1264 } | |
1265 class Class implements A { | |
1266 method() {} // testAbstractMethod:25 | |
1267 } | |
1268 """); | |
1269 | |
1270 check(""" | |
1271 class A { | |
1272 method() {} // testAbstractMethod:26 | |
1273 } | |
1274 class Class implements A { | |
1275 method([a]) {} // testAbstractMethod:27 | |
1276 } | |
1277 """); | |
1278 | |
1279 check(""" | |
1280 class A { | |
1281 method() {} // testAbstractMethod:28 | |
1282 } | |
1283 class Class implements A { | |
1284 } | |
1285 """, warnings: MessageKind.UNIMPLEMENTED_METHOD_ONE, | |
1286 infos: MessageKind.UNIMPLEMENTED_METHOD_CONT); | |
1287 | |
1288 check(""" | |
1289 class A { | |
1290 method() {} // testAbstractMethod:29 | |
1291 } | |
1292 class B { | |
1293 method() {} // testAbstractMethod:30 | |
1294 } | |
1295 class Class extends A implements B { | |
1296 } | |
1297 """); | |
1298 | |
1299 check(""" | |
1300 class A { | |
1301 var member; // testAbstractMethod:31 | |
1302 } | |
1303 class Class implements A { | |
1304 } | |
1305 """, warnings: [MessageKind.UNIMPLEMENTED_GETTER_ONE, | |
1306 MessageKind.UNIMPLEMENTED_SETTER_ONE], | |
1307 infos: [MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER, | |
1308 MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER]); | |
1309 | |
1310 check(""" | |
1311 class A { | |
1312 var member; // testAbstractMethod:32 | |
1313 } | |
1314 class B { | |
1315 get member => null; // testAbstractMethod:33 | |
1316 set member(_) {} // testAbstractMethod:34 | |
1317 } | |
1318 class Class implements A, B { | |
1319 } | |
1320 """, warnings: [MessageKind.UNIMPLEMENTED_GETTER, | |
1321 MessageKind.UNIMPLEMENTED_SETTER], | |
1322 infos: [MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER, | |
1323 MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER, | |
1324 MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER, | |
1325 MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER]); | |
1326 | |
1327 check(""" | |
1328 class A { | |
1329 var member; // testAbstractMethod:35 | |
1330 } | |
1331 class B { | |
1332 var member; // testAbstractMethod:36 | |
1333 } | |
1334 class Class implements A, B { | |
1335 } | |
1336 """, warnings: [MessageKind.UNIMPLEMENTED_GETTER, | |
1337 MessageKind.UNIMPLEMENTED_SETTER], | |
1338 infos: [MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER, | |
1339 MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER, | |
1340 MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER, | |
1341 MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER]); | |
1342 | |
1343 check(""" | |
1344 class A { | |
1345 get member => 0; // testAbstractMethod:37 | |
1346 } | |
1347 class Class implements A { | |
1348 } | |
1349 """, warnings: MessageKind.UNIMPLEMENTED_GETTER_ONE, | |
1350 infos: MessageKind.UNIMPLEMENTED_EXPLICIT_GETTER); | |
1351 | |
1352 check(""" | |
1353 class A { | |
1354 set member(_) {} // testAbstractMethod:38 | |
1355 } | |
1356 class Class implements A { | |
1357 } | |
1358 """, warnings: MessageKind.UNIMPLEMENTED_SETTER_ONE, | |
1359 infos: MessageKind.UNIMPLEMENTED_EXPLICIT_SETTER); | |
1360 | |
1361 check(""" | |
1362 class A { | |
1363 var member; // testAbstractMethod:39 | |
1364 } | |
1365 class Class implements A { | |
1366 get member => 0; | |
1367 } | |
1368 """, warnings: MessageKind.UNIMPLEMENTED_SETTER_ONE, | |
1369 infos: MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER); | |
1370 | |
1371 check(""" | |
1372 class A { | |
1373 var field; // testAbstractMethod:40 | |
1374 } | |
1375 class Class implements A { | |
1376 final field = 0; // testAbstractMethod:41 | |
1377 } | |
1378 """, warnings: MessageKind.UNIMPLEMENTED_SETTER_ONE, | |
1379 infos: MessageKind.UNIMPLEMENTED_IMPLICIT_SETTER); | |
1380 | |
1381 check(""" | |
1382 class A { | |
1383 var member; // testAbstractMethod:42 | |
1384 } | |
1385 class Class implements A { | |
1386 set member(_) {} | |
1387 } | |
1388 """, warnings: MessageKind.UNIMPLEMENTED_GETTER_ONE, | |
1389 infos: MessageKind.UNIMPLEMENTED_IMPLICIT_GETTER); | |
1390 | |
1391 check(""" | |
1392 abstract class A { | |
1393 method() {} // testAbstractMethod:43 | |
1394 } | |
1395 class Class extends A { | |
1396 method(); | |
1397 } | |
1398 """); | |
1399 } | |
1400 | |
1401 testNoSuchMethod() { | |
1402 check(""" | |
1403 class Class { | |
1404 method(); // testNoSuchMethod:1 | |
1405 } | |
1406 """, warnings: MessageKind.ABSTRACT_METHOD, | |
1407 infos: []); | |
1408 | |
1409 check(""" | |
1410 @proxy | |
1411 class Class { | |
1412 method(); // testNoSuchMethod:2 | |
1413 } | |
1414 """); | |
1415 | |
1416 check(""" | |
1417 class Class { | |
1418 noSuchMethod(_) => null; | |
1419 method(); // testNoSuchMethod:3 | |
1420 } | |
1421 """); | |
1422 | |
1423 check(""" | |
1424 class Class { | |
1425 noSuchMethod(_, [__]) => null; | |
1426 method(); // testNoSuchMethod:4 | |
1427 } | |
1428 """); | |
1429 | |
1430 check(""" | |
1431 class Class { | |
1432 noSuchMethod(_); | |
1433 method(); // testNoSuchMethod:5 | |
1434 } | |
1435 """); | |
1436 | |
1437 check(""" | |
1438 abstract class A { | |
1439 method(); // testNoSuchMethod:6 | |
1440 } | |
1441 class Class extends A { | |
1442 } | |
1443 """, warnings: MessageKind.UNIMPLEMENTED_METHOD_ONE, | |
1444 infos: MessageKind.UNIMPLEMENTED_METHOD_CONT); | |
1445 | |
1446 check(""" | |
1447 abstract class A { | |
1448 method(); // testNoSuchMethod:7 | |
1449 } | |
1450 @proxy | |
1451 class Class extends A { | |
1452 } | |
1453 """); | |
1454 | |
1455 check(""" | |
1456 abstract class A { | |
1457 method(); // testNoSuchMethod:8 | |
1458 } | |
1459 class Class extends A { | |
1460 noSuchMethod(_) => null; | |
1461 } | |
1462 """); | |
1463 | |
1464 check(""" | |
1465 class A { | |
1466 method() {} // testNoSuchMethod:9 | |
1467 } | |
1468 class Class implements A { | |
1469 } | |
1470 """, warnings: MessageKind.UNIMPLEMENTED_METHOD_ONE, | |
1471 infos: MessageKind.UNIMPLEMENTED_METHOD_CONT); | |
1472 | |
1473 check(""" | |
1474 class A { | |
1475 method() {} // testNoSuchMethod:10 | |
1476 } | |
1477 class Class implements A { | |
1478 } | |
1479 """, warnings: MessageKind.UNIMPLEMENTED_METHOD_ONE, | |
1480 infos: MessageKind.UNIMPLEMENTED_METHOD_CONT); | |
1481 | |
1482 check(""" | |
karlklose
2014/01/28 12:27:45
I am not sure about this test. Please double check
Johnni Winther
2014/01/31 12:29:30
The spec has changed. Filed a bug with co19.
| |
1483 class A { | |
1484 method() {} // testNoSuchMethod:11 | |
1485 } | |
1486 @proxy | |
1487 class Class implements A { | |
1488 } | |
1489 """); | |
1490 | |
1491 check(""" | |
1492 class A { | |
1493 method() {} // testNoSuchMethod:12 | |
1494 } | |
1495 class Class implements A { | |
1496 noSuchMethod(_) => null; | |
1497 } | |
1498 """); | |
1499 | |
1500 check(""" | |
1501 @proxy | |
1502 class A { | |
1503 method(); // testNoSuchMethod:13 | |
1504 } | |
1505 class Class extends A { | |
1506 } | |
1507 """, warnings: MessageKind.UNIMPLEMENTED_METHOD_ONE, | |
1508 infos: MessageKind.UNIMPLEMENTED_METHOD_CONT); | |
1509 | |
1510 check(""" | |
1511 class A { | |
1512 noSuchMethod(_) => null; | |
1513 method(); // testNoSuchMethod:14 | |
1514 } | |
1515 class Class extends A { | |
1516 } | |
1517 """, warnings: MessageKind.UNIMPLEMENTED_METHOD_ONE, | |
1518 infos: MessageKind.UNIMPLEMENTED_METHOD_CONT); | |
1519 } | |
OLD | NEW |