OLD | NEW |
1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 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. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 library analyzer.test.src.task.strong.checker_test; | 5 library analyzer.test.src.task.strong.checker_test; |
6 | 6 |
7 import '../../../reflective_tests.dart'; | 7 import '../../../reflective_tests.dart'; |
8 import 'strong_test_helper.dart'; | 8 import 'strong_test_helper.dart'; |
9 | 9 |
10 void main() { | 10 void main() { |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
157 checkFile(''' | 157 checkFile(''' |
158 class A {} | 158 class A {} |
159 class B {} | 159 class B {} |
160 | 160 |
161 abstract class I1 { | 161 abstract class I1 { |
162 m(A a); | 162 m(A a); |
163 } | 163 } |
164 abstract class Base implements I1 {} | 164 abstract class Base implements I1 {} |
165 | 165 |
166 class T1 extends Base { | 166 class T1 extends Base { |
167 /*error:INVALID_METHOD_OVERRIDE*/m( | 167 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
168 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
169 } | 168 } |
170 '''); | 169 '''); |
171 } | 170 } |
172 | 171 |
173 void test_classOverrideOfGrandInterface_interfaceOfConcreteSuperclass() { | 172 void test_classOverrideOfGrandInterface_interfaceOfConcreteSuperclass() { |
174 checkFile(''' | 173 checkFile(''' |
175 class A {} | 174 class A {} |
176 class B {} | 175 class B {} |
177 | 176 |
178 abstract class I1 { | 177 abstract class I1 { |
179 m(A a); | 178 m(A a); |
180 } | 179 } |
181 | 180 |
182 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base | 181 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base |
183 implements I1 {} | 182 implements I1 {} |
184 | 183 |
185 class T1 extends Base { | 184 class T1 extends Base { |
186 // not reported technically because if the class is concrete, | 185 // not reported technically because if the class is concrete, |
187 // it should implement all its interfaces and hence it is | 186 // it should implement all its interfaces and hence it is |
188 // sufficient to check overrides against it. | 187 // sufficient to check overrides against it. |
189 m(/*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | 188 m(B a) {} |
190 } | 189 } |
191 '''); | 190 '''); |
192 } | 191 } |
193 | 192 |
194 void test_classOverrideOfGrandInterface_interfaceOfInterfaceOfChild() { | 193 void test_classOverrideOfGrandInterface_interfaceOfInterfaceOfChild() { |
195 checkFile(''' | 194 checkFile(''' |
196 class A {} | 195 class A {} |
197 class B {} | 196 class B {} |
198 | 197 |
199 abstract class I1 { | 198 abstract class I1 { |
200 m(A a); | 199 m(A a); |
201 } | 200 } |
202 abstract class I2 implements I1 {} | 201 abstract class I2 implements I1 {} |
203 | 202 |
204 class T1 implements I2 { | 203 class T1 implements I2 { |
205 /*error:INVALID_METHOD_OVERRIDE*/m( | 204 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
206 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
207 } | 205 } |
208 '''); | 206 '''); |
209 } | 207 } |
210 | 208 |
211 void test_classOverrideOfGrandInterface_mixinOfInterfaceOfChild() { | 209 void test_classOverrideOfGrandInterface_mixinOfInterfaceOfChild() { |
212 checkFile(''' | 210 checkFile(''' |
213 class A {} | 211 class A {} |
214 class B {} | 212 class B {} |
215 | 213 |
216 abstract class M1 { | 214 abstract class M1 { |
217 m(A a); | 215 m(A a); |
218 } | 216 } |
219 abstract class I2 extends Object with M1 {} | 217 abstract class I2 extends Object with M1 {} |
220 | 218 |
221 class T1 implements I2 { | 219 class T1 implements I2 { |
222 /*error:INVALID_METHOD_OVERRIDE*/m( | 220 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
223 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
224 } | 221 } |
225 '''); | 222 '''); |
226 } | 223 } |
227 | 224 |
228 void test_classOverrideOfGrandInterface_superclassOfInterfaceOfChild() { | 225 void test_classOverrideOfGrandInterface_superclassOfInterfaceOfChild() { |
229 checkFile(''' | 226 checkFile(''' |
230 class A {} | 227 class A {} |
231 class B {} | 228 class B {} |
232 | 229 |
233 abstract class I1 { | 230 abstract class I1 { |
234 m(A a); | 231 m(A a); |
235 } | 232 } |
236 abstract class I2 extends I1 {} | 233 abstract class I2 extends I1 {} |
237 | 234 |
238 class T1 implements I2 { | 235 class T1 implements I2 { |
239 /*error:INVALID_METHOD_OVERRIDE*/m( | 236 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
240 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
241 } | 237 } |
242 '''); | 238 '''); |
243 } | 239 } |
244 | 240 |
245 void test_compoundAssignments() { | 241 void test_compoundAssignments() { |
246 checkFile(''' | 242 checkFile(''' |
247 class A { | 243 class A { |
248 A operator *(B b) => null; | 244 A operator *(B b) => null; |
249 A operator /(B b) => null; | 245 A operator /(B b) => null; |
250 A operator ~/(B b) => null; | 246 A operator ~/(B b) => null; |
(...skipping 1529 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1780 void test_genericClassMethodOverride() { | 1776 void test_genericClassMethodOverride() { |
1781 checkFile(''' | 1777 checkFile(''' |
1782 class A {} | 1778 class A {} |
1783 class B extends A {} | 1779 class B extends A {} |
1784 | 1780 |
1785 class Base<T extends B> { | 1781 class Base<T extends B> { |
1786 T foo() => null; | 1782 T foo() => null; |
1787 } | 1783 } |
1788 | 1784 |
1789 class Derived<S extends A> extends Base<B> { | 1785 class Derived<S extends A> extends Base<B> { |
1790 /*error:INVALID_METHOD_OVERRIDE*/S | 1786 /*error:INVALID_METHOD_OVERRIDE*/S foo() => null; |
1791 /*error:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/foo() => null; | |
1792 } | 1787 } |
1793 | 1788 |
1794 class Derived2<S extends B> extends Base<B> { | 1789 class Derived2<S extends B> extends Base<B> { |
1795 S foo() => null; | 1790 S foo() => null; |
1796 } | 1791 } |
1797 '''); | 1792 '''); |
1798 } | 1793 } |
1799 | 1794 |
1800 void test_genericFunctionWrongNumberOfArguments() { | 1795 void test_genericFunctionWrongNumberOfArguments() { |
1801 checkFile(r''' | 1796 checkFile(r''' |
(...skipping 444 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2246 void test_invalidOverrides_childOverride() { | 2241 void test_invalidOverrides_childOverride() { |
2247 checkFile(''' | 2242 checkFile(''' |
2248 class A {} | 2243 class A {} |
2249 class B {} | 2244 class B {} |
2250 | 2245 |
2251 class Base { | 2246 class Base { |
2252 A f; | 2247 A f; |
2253 } | 2248 } |
2254 | 2249 |
2255 class T1 extends Base { | 2250 class T1 extends Base { |
2256 /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIE
LD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B get | 2251 /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIE
LD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B get f => null; |
2257 /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null; | |
2258 } | 2252 } |
2259 | 2253 |
2260 class T2 extends Base { | 2254 class T2 extends Base { |
2261 /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIE
LD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/set f( | 2255 /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIE
LD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/set f( |
2262 /*error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null; | 2256 B b) => null; |
2263 } | 2257 } |
2264 | 2258 |
2265 class T3 extends Base { | 2259 class T3 extends Base { |
2266 /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/final B | 2260 /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/final B |
2267 /*warning:FINAL_NOT_INITIALIZED, error:INVALID_GETTER_OVERRIDE_RETURN_TYPE
*/f; | 2261 /*warning:FINAL_NOT_INITIALIZED*/f; |
2268 } | 2262 } |
2269 class T4 extends Base { | 2263 class T4 extends Base { |
2270 // two: one for the getter one for the setter. | 2264 // two: one for the getter one for the setter. |
2271 /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE, error:INVALID_M
ETHOD_OVERRIDE*/B | 2265 /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE, error:INVALID_M
ETHOD_OVERRIDE*/B f; |
2272 /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE, error:INVALID_SETTER_OVERRIDE
_NORMAL_PARAM_TYPE*/f; | |
2273 } | 2266 } |
2274 | 2267 |
2275 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T5 implements Bas
e { | 2268 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T5 implements Bas
e { |
2276 /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_MET
HOD_OVERRIDE*/B get | 2269 /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_MET
HOD_OVERRIDE*/B get f => null; |
2277 /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null; | |
2278 } | 2270 } |
2279 | 2271 |
2280 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T6 implements Bas
e { | 2272 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T6 implements Bas
e { |
2281 /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_MET
HOD_OVERRIDE*/set f( | 2273 /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_MET
HOD_OVERRIDE*/set f(B b) => null; |
2282 /*error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null; | |
2283 } | 2274 } |
2284 | 2275 |
2285 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T7 implements Bas
e { | 2276 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T7 implements Bas
e { |
2286 /*error:INVALID_METHOD_OVERRIDE*/final B | 2277 /*error:INVALID_METHOD_OVERRIDE*/final B f = null; |
2287 /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f = null; | |
2288 } | 2278 } |
2289 class T8 implements Base { | 2279 class T8 implements Base { |
2290 // two: one for the getter one for the setter. | 2280 // two: one for the getter one for the setter. |
2291 /*error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B | 2281 /*error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B f; |
2292 /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE, error:INVALID_SETTER_OVERRIDE
_NORMAL_PARAM_TYPE*/f; | |
2293 } | 2282 } |
2294 '''); | 2283 '''); |
2295 } | 2284 } |
2296 | 2285 |
2297 void test_invalidOverrides_childOverride2() { | 2286 void test_invalidOverrides_childOverride2() { |
2298 checkFile(''' | 2287 checkFile(''' |
2299 class A {} | 2288 class A {} |
2300 class B {} | 2289 class B {} |
2301 | 2290 |
2302 class Base { | 2291 class Base { |
2303 m(A a) {} | 2292 m(A a) {} |
2304 } | 2293 } |
2305 | 2294 |
2306 class Test extends Base { | 2295 class Test extends Base { |
2307 /*error:INVALID_METHOD_OVERRIDE*/m( | 2296 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
2308 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
2309 } | 2297 } |
2310 '''); | 2298 '''); |
2311 } | 2299 } |
2312 | 2300 |
2313 void test_invalidOverrides_classOverrideOfInterface() { | 2301 void test_invalidOverrides_classOverrideOfInterface() { |
2314 checkFile(''' | 2302 checkFile(''' |
2315 class A {} | 2303 class A {} |
2316 class B {} | 2304 class B {} |
2317 | 2305 |
2318 abstract class I { | 2306 abstract class I { |
2319 m(A a); | 2307 m(A a); |
2320 } | 2308 } |
2321 | 2309 |
2322 class T1 implements I { | 2310 class T1 implements I { |
2323 /*error:INVALID_METHOD_OVERRIDE*/m( | 2311 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
2324 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
2325 } | 2312 } |
2326 '''); | 2313 '''); |
2327 } | 2314 } |
2328 | 2315 |
2329 void test_invalidOverrides_doubleOverride() { | 2316 void test_invalidOverrides_doubleOverride() { |
2330 checkFile(''' | 2317 checkFile(''' |
2331 class A {} | 2318 class A {} |
2332 class B {} | 2319 class B {} |
2333 | 2320 |
2334 class Grandparent { | 2321 class Grandparent { |
2335 m(A a) {} | 2322 m(A a) {} |
2336 } | 2323 } |
2337 class Parent extends Grandparent { | 2324 class Parent extends Grandparent { |
2338 m(A a) {} | 2325 m(A a) {} |
2339 } | 2326 } |
2340 | 2327 |
2341 class Test extends Parent { | 2328 class Test extends Parent { |
2342 // Reported only once | 2329 // Reported only once |
2343 /*error:INVALID_METHOD_OVERRIDE*/m( | 2330 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
2344 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
2345 } | 2331 } |
2346 '''); | 2332 '''); |
2347 } | 2333 } |
2348 | 2334 |
2349 void test_invalidOverrides_doubleOverride2() { | 2335 void test_invalidOverrides_doubleOverride2() { |
2350 checkFile(''' | 2336 checkFile(''' |
2351 class A {} | 2337 class A {} |
2352 class B {} | 2338 class B {} |
2353 | 2339 |
2354 class Grandparent { | 2340 class Grandparent { |
2355 m(A a) {} | 2341 m(A a) {} |
2356 } | 2342 } |
2357 class Parent extends Grandparent { | 2343 class Parent extends Grandparent { |
2358 /*error:INVALID_METHOD_OVERRIDE*/m( | 2344 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
2359 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
2360 } | 2345 } |
2361 | 2346 |
2362 class Test extends Parent { | 2347 class Test extends Parent { |
2363 m(B a) {} | 2348 m(B a) {} |
2364 } | 2349 } |
2365 '''); | 2350 '''); |
2366 } | 2351 } |
2367 | 2352 |
2368 void test_invalidOverrides_grandChildOverride() { | 2353 void test_invalidOverrides_grandChildOverride() { |
2369 checkFile(''' | 2354 checkFile(''' |
2370 class A {} | 2355 class A {} |
2371 class B {} | 2356 class B {} |
2372 | 2357 |
2373 class Grandparent { | 2358 class Grandparent { |
2374 m(A a) {} | 2359 m(A a) {} |
2375 int x; | 2360 int x; |
2376 } | 2361 } |
2377 class Parent extends Grandparent { | 2362 class Parent extends Grandparent { |
2378 } | 2363 } |
2379 | 2364 |
2380 class Test extends Parent { | 2365 class Test extends Parent { |
2381 /*error:INVALID_METHOD_OVERRIDE*/m( | 2366 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
2382 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
2383 /*error:INVALID_FIELD_OVERRIDE*/int x; | 2367 /*error:INVALID_FIELD_OVERRIDE*/int x; |
2384 } | 2368 } |
2385 '''); | 2369 '''); |
2386 } | 2370 } |
2387 | 2371 |
2388 void test_invalidOverrides_mixinOverrideOfInterface() { | 2372 void test_invalidOverrides_mixinOverrideOfInterface() { |
2389 checkFile(''' | 2373 checkFile(''' |
2390 class A {} | 2374 class A {} |
2391 class B {} | 2375 class B {} |
2392 | 2376 |
(...skipping 510 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2903 m(A a); | 2887 m(A a); |
2904 } | 2888 } |
2905 | 2889 |
2906 class Base { | 2890 class Base { |
2907 m(B a) {} | 2891 m(B a) {} |
2908 } | 2892 } |
2909 | 2893 |
2910 // Note: no error reported in `extends Base` to avoid duplicating | 2894 // Note: no error reported in `extends Base` to avoid duplicating |
2911 // the error in T1. | 2895 // the error in T1. |
2912 class T1 extends Base implements I1 { | 2896 class T1 extends Base implements I1 { |
2913 /*error:INVALID_METHOD_OVERRIDE*/m( | 2897 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
2914 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
2915 } | 2898 } |
2916 | 2899 |
2917 // If there is no error in the class, we do report the error at | 2900 // If there is no error in the class, we do report the error at |
2918 // the base class: | 2901 // the base class: |
2919 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2 | 2902 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2 |
2920 /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base | 2903 /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base |
2921 implements I1 {} | 2904 implements I1 {} |
2922 '''); | 2905 '''); |
2923 } | 2906 } |
2924 | 2907 |
2925 void | 2908 void |
2926 test_noDuplicateReportsFromOverridingInterfaces_typeAndMixinOverrideSameMe
thodInInterface() { | 2909 test_noDuplicateReportsFromOverridingInterfaces_typeAndMixinOverrideSameMe
thodInInterface() { |
2927 checkFile(''' | 2910 checkFile(''' |
2928 class A {} | 2911 class A {} |
2929 class B {} | 2912 class B {} |
2930 | 2913 |
2931 abstract class I1 { | 2914 abstract class I1 { |
2932 m(A a); | 2915 m(A a); |
2933 } | 2916 } |
2934 | 2917 |
2935 class M { | 2918 class M { |
2936 m(B a) {} | 2919 m(B a) {} |
2937 } | 2920 } |
2938 | 2921 |
2939 class T1 extends Object with M implements I1 { | 2922 class T1 extends Object with M implements I1 { |
2940 /*error:INVALID_METHOD_OVERRIDE*/m( | 2923 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
2941 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
2942 } | 2924 } |
2943 | 2925 |
2944 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2 | 2926 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2 |
2945 extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M | 2927 extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M |
2946 implements I1 {} | 2928 implements I1 {} |
2947 '''); | 2929 '''); |
2948 } | 2930 } |
2949 | 2931 |
2950 void | 2932 void |
2951 test_noDuplicateReportsFromOverridingInterfaces_typeOverridesSomeMethodInM
ultipleInterfaces() { | 2933 test_noDuplicateReportsFromOverridingInterfaces_typeOverridesSomeMethodInM
ultipleInterfaces() { |
2952 checkFile(''' | 2934 checkFile(''' |
2953 class A {} | 2935 class A {} |
2954 class B {} | 2936 class B {} |
2955 | 2937 |
2956 abstract class I1 { | 2938 abstract class I1 { |
2957 m(A a); | 2939 m(A a); |
2958 } | 2940 } |
2959 abstract class I2 implements I1 { | 2941 abstract class I2 implements I1 { |
2960 m(A a); | 2942 m(A a); |
2961 } | 2943 } |
2962 | 2944 |
2963 class Base {} | 2945 class Base {} |
2964 | 2946 |
2965 class T1 implements I2 { | 2947 class T1 implements I2 { |
2966 /*error:INVALID_METHOD_OVERRIDE*/m( | 2948 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
2967 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
2968 } | 2949 } |
2969 '''); | 2950 '''); |
2970 } | 2951 } |
2971 | 2952 |
2972 void test_nullCoalescingOperator() { | 2953 void test_nullCoalescingOperator() { |
2973 checkFile(''' | 2954 checkFile(''' |
2974 class A {} | 2955 class A {} |
2975 class C<T> {} | 2956 class C<T> {} |
2976 main() { | 2957 main() { |
2977 A a, b; | 2958 A a, b; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3012 void test_overrideNarrowsType() { | 2993 void test_overrideNarrowsType() { |
3013 addFile(r''' | 2994 addFile(r''' |
3014 class A {} | 2995 class A {} |
3015 class B extends A {} | 2996 class B extends A {} |
3016 | 2997 |
3017 abstract class C { | 2998 abstract class C { |
3018 m(A a); | 2999 m(A a); |
3019 n(B b); | 3000 n(B b); |
3020 } | 3001 } |
3021 abstract class D extends C { | 3002 abstract class D extends C { |
3022 /*error:INVALID_METHOD_OVERRIDE*/m(/*error:INVALID_METHOD_OVERRIDE_NORMAL_PARA
M_TYPE*/B b); | 3003 /*error:INVALID_METHOD_OVERRIDE*/m(B b); |
3023 n(A a); | 3004 n(A a); |
3024 } | 3005 } |
3025 '''); | 3006 '''); |
3026 check(implicitCasts: false); | 3007 check(implicitCasts: false); |
3027 } | 3008 } |
3028 | 3009 |
3029 void test_privateOverride() { | 3010 void test_privateOverride() { |
3030 addFile( | 3011 addFile( |
3031 ''' | 3012 ''' |
3032 import 'main.dart' as main; | 3013 import 'main.dart' as main; |
3033 | 3014 |
3034 class Base { | 3015 class Base { |
3035 var f1; | 3016 var f1; |
3036 var _f2; | 3017 var _f2; |
3037 var _f3; | 3018 var _f3; |
3038 get _f4 => null; | 3019 get _f4 => null; |
3039 | 3020 |
3040 int _m1() => null; | 3021 int _m1() => null; |
3041 } | 3022 } |
3042 | 3023 |
3043 class GrandChild extends main.Child { | 3024 class GrandChild extends main.Child { |
3044 /*error:INVALID_FIELD_OVERRIDE*/var _f2; | 3025 /*error:INVALID_FIELD_OVERRIDE*/var _f2; |
3045 /*error:INVALID_FIELD_OVERRIDE*/var _f3; | 3026 /*error:INVALID_FIELD_OVERRIDE*/var _f3; |
3046 var _f4; | 3027 var _f4; |
3047 | 3028 |
3048 /*error:INVALID_METHOD_OVERRIDE*/String | 3029 /*error:INVALID_METHOD_OVERRIDE*/String _m1() => null; |
3049 /*error:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/_m1() => null; | |
3050 } | 3030 } |
3051 ''', | 3031 ''', |
3052 name: '/helper.dart'); | 3032 name: '/helper.dart'); |
3053 checkFile(''' | 3033 checkFile(''' |
3054 import 'helper.dart' as helper; | 3034 import 'helper.dart' as helper; |
3055 | 3035 |
3056 class Child extends helper.Base { | 3036 class Child extends helper.Base { |
3057 /*error:INVALID_FIELD_OVERRIDE*/var f1; | 3037 /*error:INVALID_FIELD_OVERRIDE*/var f1; |
3058 var _f2; | 3038 var _f2; |
3059 var _f4; | 3039 var _f4; |
(...skipping 237 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3297 void test_superclassOverrideOfGrandInterface_interfaceOfAbstractSuperclass() { | 3277 void test_superclassOverrideOfGrandInterface_interfaceOfAbstractSuperclass() { |
3298 checkFile(''' | 3278 checkFile(''' |
3299 class A {} | 3279 class A {} |
3300 class B {} | 3280 class B {} |
3301 | 3281 |
3302 abstract class I1 { | 3282 abstract class I1 { |
3303 m(A a); | 3283 m(A a); |
3304 } | 3284 } |
3305 | 3285 |
3306 abstract class Base implements I1 { | 3286 abstract class Base implements I1 { |
3307 /*error:INVALID_METHOD_OVERRIDE*/m( | 3287 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
3308 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
3309 } | 3288 } |
3310 | 3289 |
3311 class T1 extends Base { | 3290 class T1 extends Base { |
3312 // we consider the base class incomplete because it is | 3291 // we consider the base class incomplete because it is |
3313 // abstract, so we report the error here too. | 3292 // abstract, so we report the error here too. |
3314 // TODO(sigmund): consider tracking overrides in a fine-grain | 3293 // TODO(sigmund): consider tracking overrides in a fine-grain |
3315 // manner, then this and the double-overrides would not be | 3294 // manner, then this and the double-overrides would not be |
3316 // reported. | 3295 // reported. |
3317 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} | 3296 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
3318 } | 3297 } |
3319 '''); | 3298 '''); |
3320 } | 3299 } |
3321 | 3300 |
3322 void test_superclassOverrideOfGrandInterface_interfaceOfConcreteSuperclass() { | 3301 void test_superclassOverrideOfGrandInterface_interfaceOfConcreteSuperclass() { |
3323 checkFile(''' | 3302 checkFile(''' |
3324 class A {} | 3303 class A {} |
3325 class B {} | 3304 class B {} |
3326 | 3305 |
3327 abstract class I1 { | 3306 abstract class I1 { |
3328 m(A a); | 3307 m(A a); |
3329 } | 3308 } |
3330 | 3309 |
3331 class Base implements I1 { | 3310 class Base implements I1 { |
3332 /*error:INVALID_METHOD_OVERRIDE*/m( | 3311 /*error:INVALID_METHOD_OVERRIDE*/m(B a) {} |
3333 /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {} | |
3334 } | 3312 } |
3335 | 3313 |
3336 class T1 extends Base { | 3314 class T1 extends Base { |
3337 m(B a) {} | 3315 m(B a) {} |
3338 } | 3316 } |
3339 '''); | 3317 '''); |
3340 } | 3318 } |
3341 | 3319 |
3342 void test_superclassOverrideOfGrandInterface_interfaceOfInterfaceOfChild() { | 3320 void test_superclassOverrideOfGrandInterface_interfaceOfInterfaceOfChild() { |
3343 checkFile(''' | 3321 checkFile(''' |
(...skipping 403 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3747 // Regression test for https://github.com/dart-lang/sdk/issues/25069 | 3725 // Regression test for https://github.com/dart-lang/sdk/issues/25069 |
3748 checkFile(''' | 3726 checkFile(''' |
3749 typedef int Foo(); | 3727 typedef int Foo(); |
3750 void foo() {} | 3728 void foo() {} |
3751 void main () { | 3729 void main () { |
3752 Foo x = /*error:INVALID_ASSIGNMENT,info:USE_OF_VOID_RESULT*/foo(); | 3730 Foo x = /*error:INVALID_ASSIGNMENT,info:USE_OF_VOID_RESULT*/foo(); |
3753 } | 3731 } |
3754 '''); | 3732 '''); |
3755 } | 3733 } |
3756 } | 3734 } |
OLD | NEW |