Skip to content

Commit f1afb34

Browse files
srawlinscommit-bot@chromium.org
srawlins
authored and
[email protected]
committed
Move strict-raw-type tests; add tests for extensions
Bug: #38105 Change-Id: I50794f6c4fdfe6852b06adacb24a0620bd44b2f4 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/117642 Commit-Queue: Samuel Rawlins <[email protected]> Reviewed-by: Brian Wilkerson <[email protected]>
1 parent 4fcef04 commit f1afb34

File tree

3 files changed

+320
-203
lines changed

3 files changed

+320
-203
lines changed

‎pkg/analyzer/test/src/diagnostics/strict_raw_type_test.dart

Lines changed: 318 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,318 @@
1+
// Copyright (c) 2019, 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:analyzer/dart/analysis/features.dart';
6+
import 'package:analyzer/src/error/codes.dart';
7+
import 'package:analyzer/src/generated/engine.dart';
8+
import 'package:analyzer/src/test_utilities/package_mixin.dart';
9+
import 'package:test_reflective_loader/test_reflective_loader.dart';
10+
11+
import '../dart/resolution/driver_resolution.dart';
12+
13+
main() {
14+
defineReflectiveSuite(() {
15+
defineReflectiveTests(StrictRawTypeTest);
16+
defineReflectiveTests(StrictRawType_WithExtensionsTest);
17+
});
18+
}
19+
20+
@reflectiveTest
21+
class StrictRawType_WithExtensionsTest extends DriverResolutionTest
22+
with PackageMixin {
23+
@override
24+
AnalysisOptionsImpl get analysisOptions => AnalysisOptionsImpl()
25+
..contextFeatures = new FeatureSet.forTesting(
26+
sdkVersion: '2.3.0', additionalFeatures: [Feature.extension_methods])
27+
..strictRawTypes = true;
28+
29+
test_typeOnExtendedType_anonymous_missing() async {
30+
assertErrorsInCode(r'''
31+
extension on List {}
32+
''', [error(HintCode.STRICT_RAW_TYPE, 13, 4)]);
33+
}
34+
35+
test_typeOnExtendedType_missing() async {
36+
assertErrorsInCode(r'''
37+
extension E on List {}
38+
''', [error(HintCode.STRICT_RAW_TYPE, 15, 4)]);
39+
}
40+
41+
test_typeOnExtendedType_optionalTypeArgs() async {
42+
addMetaPackage();
43+
assertNoErrorsInCode(r'''
44+
import 'package:meta/meta.dart';
45+
@optionalTypeArgs
46+
class C<T> {}
47+
extension E on C {}
48+
extension on C {}
49+
''');
50+
}
51+
52+
test_typeOnExtendedType_present() async {
53+
assertNoErrorsInCode(r'''
54+
extension E<T> on List<T> {}
55+
extension F on List<int> {}
56+
''');
57+
}
58+
}
59+
60+
@reflectiveTest
61+
class StrictRawTypeTest extends DriverResolutionTest with PackageMixin {
62+
@override
63+
AnalysisOptionsImpl get analysisOptions =>
64+
AnalysisOptionsImpl()..strictRawTypes = true;
65+
66+
test_asExpression() async {
67+
await assertNoErrorsInCode(r'''
68+
void f(dynamic x) {
69+
print(x as List);
70+
print(x as List<dynamic>);
71+
print(x as List<List>);
72+
}
73+
''');
74+
}
75+
76+
test_functionParts_optionalTypeArg() async {
77+
addMetaPackage();
78+
await assertNoErrorsInCode(r'''
79+
import 'package:meta/meta.dart';
80+
@optionalTypeArgs
81+
class C<T> {}
82+
C f(int a) => null;
83+
void g(C a) => print(a);
84+
''');
85+
}
86+
87+
test_genericTypeArgument_missingTypeArg() async {
88+
await assertErrorsInCode(r'''
89+
void f() {
90+
var a = <List>[];
91+
}
92+
''', [
93+
error(HintCode.UNUSED_LOCAL_VARIABLE, 17, 1),
94+
error(HintCode.STRICT_RAW_TYPE, 22, 4),
95+
]);
96+
}
97+
98+
test_genericTypeArgument_withTypeArg() async {
99+
await assertNoErrorsInCode(r'''
100+
void f() {
101+
var a = <List<int>>[];
102+
}
103+
''');
104+
}
105+
106+
test_isExpression() async {
107+
await assertNoErrorsInCode(r'''
108+
void f(dynamic x) {
109+
print(x is List);
110+
print(x is List<dynamic>);
111+
print(x is List<List>);
112+
}
113+
''');
114+
}
115+
116+
test_localVariable_missingTypeArg() async {
117+
await assertErrorsInCode(r'''
118+
void f() {
119+
List a = [1, 2, 3];
120+
}
121+
''', [
122+
error(HintCode.STRICT_RAW_TYPE, 13, 4),
123+
error(HintCode.UNUSED_LOCAL_VARIABLE, 18, 1),
124+
]);
125+
}
126+
127+
test_localVariable_withTypeArg() async {
128+
await assertNoErrorsInCode(r'''
129+
void f() {
130+
List<Object> a = [1, 2, 3];
131+
print(a);
132+
}
133+
''');
134+
}
135+
136+
test_mixinApplication_missing() async {
137+
await assertErrorsInCode(r'''
138+
class C<T> {}
139+
class D = Object with C;
140+
''', [error(HintCode.STRICT_RAW_TYPE, 36, 1)]);
141+
}
142+
143+
test_mixinApplication_withTypeArg() async {
144+
await assertNoErrorsInCode(r'''
145+
class C<T> {}
146+
class D = Object with C<int>;
147+
''');
148+
}
149+
150+
test_parameter_missingTypeArg() async {
151+
await assertErrorsInCode(r'''
152+
void f(List a) {}
153+
''', [error(HintCode.STRICT_RAW_TYPE, 7, 4)]);
154+
}
155+
156+
test_returnType_missingTypeArg() async {
157+
await assertErrorsInCode(r'''
158+
List f(int a) => [1, 2, 3];
159+
''', [error(HintCode.STRICT_RAW_TYPE, 0, 4)]);
160+
}
161+
162+
test_superclassWith_missingTypeArg() async {
163+
await assertErrorsInCode(r'''
164+
class C<T> {}
165+
class D extends Object with C {}
166+
''', [error(HintCode.STRICT_RAW_TYPE, 42, 1)]);
167+
}
168+
169+
test_superclassWith_withTypeArg() async {
170+
await assertNoErrorsInCode(r'''
171+
class C<T> {}
172+
class D extends Object with C<int> {}
173+
''');
174+
}
175+
176+
test_topLevelField_missingTypeArg() async {
177+
await assertErrorsInCode(r'''
178+
List a;
179+
''', [error(HintCode.STRICT_RAW_TYPE, 0, 4)]);
180+
}
181+
182+
test_topLevelField_optionalTypeArg() async {
183+
addMetaPackage();
184+
await assertNoErrorsInCode(r'''
185+
import 'package:meta/meta.dart';
186+
@optionalTypeArgs
187+
class C<T> {}
188+
C a;
189+
C get g => null;
190+
void set s(C a) {}
191+
''');
192+
}
193+
194+
test_topLevelField_withTypeArg() async {
195+
await assertNoErrorsInCode(r'''
196+
List<int> a;
197+
List<num> get g => [];
198+
void set s(List<double> a) {}
199+
''');
200+
}
201+
202+
test_topLevelGetter_missingTypeArg() async {
203+
await assertErrorsInCode(r'''
204+
List get g => [];
205+
''', [error(HintCode.STRICT_RAW_TYPE, 0, 4)]);
206+
}
207+
208+
test_topLevelSetter_missingTypeArg() async {
209+
await assertErrorsInCode(r'''
210+
void set s(List a) {}
211+
''', [error(HintCode.STRICT_RAW_TYPE, 11, 4)]);
212+
}
213+
214+
test_typedef_classic_missingTypeArg() async {
215+
await assertErrorsInCode(r'''
216+
typedef T F1<T>(T _);
217+
F1 func;
218+
''', [error(HintCode.STRICT_RAW_TYPE, 22, 2)]);
219+
}
220+
221+
test_typedef_modern_missingTypeArg() async {
222+
await assertErrorsInCode(r'''
223+
typedef F1<T> = T Function(T);
224+
F1 func;
225+
''', [error(HintCode.STRICT_RAW_TYPE, 31, 2)]);
226+
}
227+
228+
test_typedef_modern_optionalTypeArgs() async {
229+
addMetaPackage();
230+
await assertNoErrorsInCode(r'''
231+
import 'package:meta/meta.dart';
232+
@optionalTypeArgs
233+
typedef T F1<T>(T _);
234+
@optionalTypeArgs
235+
typedef F2<T> = T Function(T);
236+
F1 f1;
237+
F2 f2;
238+
''');
239+
}
240+
241+
test_typedef_modern_withTypeArg() async {
242+
await assertNoErrorsInCode(r'''
243+
typedef T F1<T>(T _);
244+
typedef F2<T> = T Function(T);
245+
typedef F3 = T Function<T>(T);
246+
F1<int> f1;
247+
F2<int> f2;
248+
F3 f3;
249+
''');
250+
}
251+
252+
test_TypeOnClassDeclaration_optionalTypeArgs() async {
253+
addMetaPackage();
254+
await assertNoErrorsInCode(r'''
255+
import 'package:meta/meta.dart';
256+
@optionalTypeArgs
257+
class C<T> {}
258+
class D extends C {}
259+
class E extends Object with C {}
260+
class F = Object with C;
261+
class G implements C {}
262+
''');
263+
}
264+
265+
test_TypeOnConstructor() async {
266+
await assertNoErrorsInCode(r'''
267+
class C {
268+
C();
269+
C.named();
270+
}
271+
272+
var c = C();
273+
var d = C.named();
274+
''');
275+
}
276+
277+
test_TypeOnInterface_missing() async {
278+
await assertErrorsInCode(r'''
279+
class C<T> {}
280+
class D implements C {}
281+
''', [error(HintCode.STRICT_RAW_TYPE, 33, 1)]);
282+
}
283+
284+
test_TypeOnInterface_withTypeArg() async {
285+
await assertNoErrorsInCode(r'''
286+
class C<T> {}
287+
class D implements C<int> {}
288+
''');
289+
}
290+
291+
test_TypeOnSuperclass_missing() async {
292+
await assertErrorsInCode(r'''
293+
class C<T> {}
294+
class D extends C {}
295+
''', [error(HintCode.STRICT_RAW_TYPE, 30, 1)]);
296+
}
297+
298+
test_TypeOnSuperclass_withTypeArg() async {
299+
await assertNoErrorsInCode(r'''
300+
class C<T> {}
301+
class D extends C<int> {}
302+
''');
303+
}
304+
305+
test_typeParameterBound_missingTypeArg() async {
306+
await assertErrorsInCode(r'''
307+
class C<T> {}
308+
class D<T extends C> {}
309+
''', [error(HintCode.STRICT_RAW_TYPE, 32, 1)]);
310+
}
311+
312+
test_typeParameterBound_withTypeArg() async {
313+
await assertNoErrorsInCode(r'''
314+
class C<T> {}
315+
class D<S, T extends C<S>> {}
316+
''');
317+
}
318+
}

‎pkg/analyzer/test/src/diagnostics/test_all.dart

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -269,6 +269,7 @@ import 'spread_expression_from_deferred_library_test.dart'
269269
as spread_expression_from_deferred_library;
270270
import 'static_access_to_instance_member_test.dart'
271271
as static_access_to_instance_member;
272+
import 'strict_raw_type_test.dart' as strict_raw_type;
272273
import 'subtype_of_sealed_class_test.dart' as subtype_of_sealed_class;
273274
import 'super_in_extension_test.dart' as super_in_extension;
274275
import 'switch_expression_not_assignable_test.dart'
@@ -508,6 +509,7 @@ main() {
508509
set_element_type_not_assignable.main();
509510
spread_expression_from_deferred_library.main();
510511
static_access_to_instance_member.main();
512+
strict_raw_type.main();
511513
subtype_of_sealed_class.main();
512514
super_in_extension.main();
513515
switch_expression_not_assignable.main();

0 commit comments

Comments
 (0)