OLD | NEW |
1 // Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2016, 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 // GENERATED - DON'T EDIT. | 5 // GENERATED - DON'T EDIT. |
6 // GENERATED - DON'T EDIT. | 6 // GENERATED - DON'T EDIT. |
7 // GENERATED - DON'T EDIT. | 7 // GENERATED - DON'T EDIT. |
8 // GENERATED - DON'T EDIT. | 8 // GENERATED - DON'T EDIT. |
9 // GENERATED - DON'T EDIT. | 9 // GENERATED - DON'T EDIT. |
10 // GENERATED - DON'T EDIT. | 10 // GENERATED - DON'T EDIT. |
11 // GENERATED - DON'T EDIT. | 11 // GENERATED - DON'T EDIT. |
12 // GENERATED - DON'T EDIT. | 12 // GENERATED - DON'T EDIT. |
13 | 13 |
14 import 'dart:core'; | 14 import 'dart:core'; |
15 import 'dart:core' as core; | 15 import 'dart:core' as core; |
16 import 'package:expect/expect.dart'; | 16 import 'package:expect/expect.dart'; |
17 | 17 |
18 @NoInline() | 18 @NoInline() |
19 @AssumeDynamic() | 19 @AssumeDynamic() |
20 confuse(f) => f; | 20 confuse(f) => f; |
21 | 21 |
22 final bool inCheckedMode = | 22 final bool inCheckedMode = (() { |
23 (() { bool result = false; assert(result = true); return result; })(); | 23 bool result = false; |
| 24 assert(result = true); |
| 25 return result; |
| 26 })(); |
24 | 27 |
25 | 28 typedef F0<T> |
26 typedef F0<T> = int Function(int x, [List<T> x2]); | 29 = int Function(int x, [List<T> x2]); |
27 typedef F1<T> = List<Function> Function(int x1, [core.List<core.int> x2]); | 30 typedef F1<T> |
28 typedef F2<T> = List<T> Function([List<Function> x1]); | 31 = List<Function> Function(int x1, [core.List<core.int> x2]); |
29 typedef F3<T> = void Function(Function x0); | 32 typedef F2<T> |
30 typedef F4<T> = List<A> Function<A>(core.List<core.int> x); | 33 = List<T> Function([List<Function> x1]); |
31 typedef F5<T> = int Function(int y, {Function x}) Function<B extends core.int>(i
nt x); | 34 typedef F3<T> |
32 typedef F6<T> = int Function(int x1, [List<T> x]) Function<B extends core.int>(i
nt x); | 35 = void Function(Function x0); |
33 typedef F7<T> = Function Function(Function x1) Function<B extends core.int>(int
x); | 36 typedef F4<T> |
34 typedef F8<T> = Function Function(int x, [core.List<core.int> x1]) Function<B ex
tends core.int>(int x); | 37 = List<A> Function<A>(core.List<core.int> x); |
35 typedef F9<T> = List<Function> Function(int x1, {int x}) Function<B extends core
.int>(int x); | 38 typedef F5<T> |
36 typedef F10<T> = List<Function> Function([core.List<core.int> x]) Function<B ext
ends core.int>(int x); | 39 = int Function(int y, {Function x}) Function<B extends core.int>(int x); |
37 typedef F11<T> = core.List<core.int> Function(int y, [int x]) Function<B extends
core.int>(int x); | 40 typedef F6<T> |
38 typedef F12<T> = core.List<core.int> Function(int x2, [List<Function> x3]) Funct
ion<B extends core.int>(int x); | 41 = int Function(int x1, [List<T> x]) Function<B extends core.int>(int x); |
39 typedef F13<T> = core.List<core.int> Function(int x1, {List<T> x}) Function<B ex
tends core.int>(int x); | 42 typedef F7<T> |
40 typedef F14<T> = List<T> Function(List<Function> x) Function<B extends core.int>
(int x); | 43 = Function Function(Function x1) Function<B extends core.int>(int x); |
41 typedef F15<T> = List<T> Function(int y, [List<T> x]) Function<B extends core.in
t>(int x); | 44 typedef F8<T> |
42 typedef F16<T> = Function([Function x1]) Function<B extends core.int>(int x); | 45 = Function Function(int x, |
43 typedef F17<T> = Function({core.List<core.int> x}) Function<B extends core.int>(
int x); | 46 [core.List<core.int> x1]) Function<B extends core.int>(int x); |
44 typedef F18<T> = void Function(int y, {int x}) Function<B extends core.int>(int
x); | 47 typedef F9<T> |
45 typedef F19<T> = void Function(int x1, [core.List<core.int> x]) Function<B exten
ds core.int>(int x); | 48 = List<Function> Function(int x1, {int x}) Function<B extends core.int>( |
46 typedef F20<T> = int Function<A>(List<T> x) Function<B extends core.int>(int x); | 49 int x); |
47 typedef F21<T> = core.List<core.int> Function<A>() Function<B extends core.int>(
int x); | 50 typedef F10<T> |
48 typedef F22<T> = A Function<A>(A x) Function<B extends core.int>(int x); | 51 = List<Function> Function( |
49 | 52 [core.List<core.int> x]) Function<B extends core.int>(int x); |
| 53 typedef F11<T> |
| 54 = core.List<core.int> Function(int y, [int x]) Function<B extends core.int>( |
| 55 int x); |
| 56 typedef F12<T> |
| 57 = core.List<core.int> Function(int x2, |
| 58 [List<Function> x3]) Function<B extends core.int>(int x); |
| 59 typedef F13<T> |
| 60 = core.List<core.int> Function(int x1, |
| 61 {List<T> x}) Function<B extends core.int>(int x); |
| 62 typedef F14<T> |
| 63 = List<T> Function(List<Function> x) Function<B extends core.int>(int x); |
| 64 typedef F15<T> |
| 65 = List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x); |
| 66 typedef F16<T> |
| 67 = Function([Function x1]) Function<B extends core.int>(int x); |
| 68 typedef F17<T> |
| 69 = Function({core.List<core.int> x}) Function<B extends core.int>(int x); |
| 70 typedef F18<T> |
| 71 = void Function(int y, {int x}) Function<B extends core.int>(int x); |
| 72 typedef F19<T> |
| 73 = void Function(int x1, |
| 74 [core.List<core.int> x]) Function<B extends core.int>(int x); |
| 75 typedef F20<T> |
| 76 = int Function<A>(List<T> x) Function<B extends core.int>(int x); |
| 77 typedef F21<T> |
| 78 = core.List<core.int> Function<A>() Function<B extends core.int>(int x); |
| 79 typedef F22<T> |
| 80 = A Function<A>(A x) Function<B extends core.int>(int x); |
50 | 81 |
51 int f0(int x, [List<int> x0]) => null; | 82 int f0(int x, [List<int> x0]) => null; |
52 List<Function> f1(int x0, [core.List<core.int> x1]) => null; | 83 List<Function> f1(int x0, [core.List<core.int> x1]) => null; |
53 List<int> f2([List<Function> x0]) => null; | 84 List<int> f2([List<Function> x0]) => null; |
54 void f3(Function x0) => null; | 85 void f3(Function x0) => null; |
55 List<A> f4<A>(core.List<core.int> x) => null; | 86 List<A> f4<A>(core.List<core.int> x) => null; |
56 int Function(int y, {Function x}) f5<B extends core.int>(int x) => null; | 87 int Function(int y, {Function x}) f5<B extends core.int>(int x) => null; |
57 int Function(int x0, [List<int> x]) f6<B extends core.int>(int x) => null; | 88 int Function(int x0, [List<int> x]) f6<B extends core.int>(int x) => null; |
58 Function Function(Function x0) f7<B extends core.int>(int x) => null; | 89 Function Function(Function x0) f7<B extends core.int>(int x) => null; |
59 Function Function(int x, [core.List<core.int> x0]) f8<B extends core.int>(int x)
=> null; | 90 Function Function(int x, [core.List<core.int> x0]) f8<B extends core.int>( |
| 91 int x) => |
| 92 null; |
60 List<Function> Function(int x0, {int x}) f9<B extends core.int>(int x) => null; | 93 List<Function> Function(int x0, {int x}) f9<B extends core.int>(int x) => null; |
61 List<Function> Function([core.List<core.int> x]) f10<B extends core.int>(int x)
=> null; | 94 List<Function> Function([core.List<core.int> x]) f10<B extends core.int>( |
62 core.List<core.int> Function(int y, [int x]) f11<B extends core.int>(int x) => n
ull; | 95 int x) => |
63 core.List<core.int> Function(int x0, [List<Function> x1]) f12<B extends core.int
>(int x) => null; | 96 null; |
64 core.List<core.int> Function(int x0, {List<int> x}) f13<B extends core.int>(int
x) => null; | 97 core.List<core.int> Function(int y, [int x]) f11<B extends core.int>(int x) => |
| 98 null; |
| 99 core.List<core.int> Function(int x0, [List<Function> x1]) |
| 100 f12<B extends core.int>(int x) => null; |
| 101 core.List<core.int> Function(int x0, {List<int> x}) f13<B extends core.int>( |
| 102 int x) => |
| 103 null; |
65 List<int> Function(List<Function> x) f14<B extends core.int>(int x) => null; | 104 List<int> Function(List<Function> x) f14<B extends core.int>(int x) => null; |
66 List<int> Function(int y, [List<int> x]) f15<B extends core.int>(int x) => null; | 105 List<int> Function(int y, [List<int> x]) f15<B extends core.int>(int x) => null; |
67 Function([Function x0]) f16<B extends core.int>(int x) => null; | 106 Function([Function x0]) f16<B extends core.int>(int x) => null; |
68 Function({core.List<core.int> x}) f17<B extends core.int>(int x) => null; | 107 Function({core.List<core.int> x}) f17<B extends core.int>(int x) => null; |
69 void Function(int y, {int x}) f18<B extends core.int>(int x) => null; | 108 void Function(int y, {int x}) f18<B extends core.int>(int x) => null; |
70 void Function(int x0, [core.List<core.int> x]) f19<B extends core.int>(int x) =>
null; | 109 void Function(int x0, [core.List<core.int> x]) f19<B extends core.int>(int x) => |
| 110 null; |
71 int Function<A>(List<int> x) f20<B extends core.int>(int x) => null; | 111 int Function<A>(List<int> x) f20<B extends core.int>(int x) => null; |
72 core.List<core.int> Function<A>() f21<B extends core.int>(int x) => null; | 112 core.List<core.int> Function<A>() f21<B extends core.int>(int x) => null; |
73 A Function<A>(A x) f22<B extends core.int>(int x) => null; | 113 A Function<A>(A x) f22<B extends core.int>(int x) => null; |
74 | 114 |
75 | |
76 class U51<T> { | 115 class U51<T> { |
77 final bool tIsBool; | 116 final bool tIsBool; |
78 final bool tIsInt; | 117 final bool tIsInt; |
79 final bool tIsDynamic; | 118 final bool tIsDynamic; |
80 | 119 |
81 int Function(int x, [List<T> x2]) x0; | 120 int Function(int x, [List<T> x2]) x0; |
82 List<Function> Function(int x1, [core.List<core.int> x2]) x1; | 121 List<Function> Function(int x1, [core.List<core.int> x2]) x1; |
83 List<T> Function([List<Function> x1]) x2; | 122 List<T> Function([List<Function> x1]) x2; |
84 void Function(Function x0) x3; | 123 void Function(Function x0) x3; |
85 List<A> Function<A>(core.List<core.int> x) x4; | 124 List<A> Function<A>(core.List<core.int> x) x4; |
86 int Function(int y, {Function x}) Function<B extends core.int>(int x) x5; | 125 int Function(int y, {Function x}) Function<B extends core.int>(int x) x5; |
87 int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) x6; | 126 int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) x6; |
88 Function Function(Function x1) Function<B extends core.int>(int x) x7; | 127 Function Function(Function x1) Function<B extends core.int>(int x) x7; |
89 Function Function(int x, [core.List<core.int> x1]) Function<B extends core.int
>(int x) x8; | 128 Function Function(int x, |
90 List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x) x
9; | 129 [core.List<core.int> x1]) Function<B extends core.int>(int x) x8; |
91 List<Function> Function([core.List<core.int> x]) Function<B extends core.int>(
int x) x10; | 130 List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x) |
92 core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(int
x) x11; | 131 x9; |
93 core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends c
ore.int>(int x) x12; | 132 List<Function> Function([core.List<core.int> x]) Function<B extends core.int>( |
94 core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.int>
(int x) x13; | 133 int x) x10; |
| 134 core.List<core.int> Function(int y, [int x]) Function<B extends core.int>( |
| 135 int x) x11; |
| 136 core.List<core.int> Function(int x2, |
| 137 [List<Function> x3]) Function<B extends core.int>(int x) x12; |
| 138 core.List<core.int> Function(int x1, |
| 139 {List<T> x}) Function<B extends core.int>(int x) x13; |
95 List<T> Function(List<Function> x) Function<B extends core.int>(int x) x14; | 140 List<T> Function(List<Function> x) Function<B extends core.int>(int x) x14; |
96 List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) x15; | 141 List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) x15; |
97 Function([Function x1]) Function<B extends core.int>(int x) x16; | 142 Function([Function x1]) Function<B extends core.int>(int x) x16; |
98 Function({core.List<core.int> x}) Function<B extends core.int>(int x) x17; | 143 Function({core.List<core.int> x}) Function<B extends core.int>(int x) x17; |
99 void Function(int y, {int x}) Function<B extends core.int>(int x) x18; | 144 void Function(int y, {int x}) Function<B extends core.int>(int x) x18; |
100 void Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(in
t x) x19; | 145 void Function(int x1, [core.List<core.int> x]) Function<B extends core.int>( |
| 146 int x) x19; |
101 int Function<A>(List<T> x) Function<B extends core.int>(int x) x20; | 147 int Function<A>(List<T> x) Function<B extends core.int>(int x) x20; |
102 core.List<core.int> Function<A>() Function<B extends core.int>(int x) x21; | 148 core.List<core.int> Function<A>() Function<B extends core.int>(int x) x21; |
103 A Function<A>(A x) Function<B extends core.int>(int x) x22; | 149 A Function<A>(A x) Function<B extends core.int>(int x) x22; |
104 | 150 |
105 | |
106 U51({this.tIsBool: false, this.tIsInt: false}) | 151 U51({this.tIsBool: false, this.tIsInt: false}) |
107 : tIsDynamic = !tIsBool && !tIsInt; | 152 : tIsDynamic = !tIsBool && !tIsInt; |
108 | 153 |
109 int m0(int x, [List<T> x0]) => null; | 154 int m0(int x, [List<T> x0]) => null; |
110 List<Function> m1(int x0, [core.List<core.int> x1]) => null; | 155 List<Function> m1(int x0, [core.List<core.int> x1]) => null; |
111 List<T> m2([List<Function> x0]) => null; | 156 List<T> m2([List<Function> x0]) => null; |
112 void m3(Function x0) => null; | 157 void m3(Function x0) => null; |
113 List<A> m4<A>(core.List<core.int> x) => null; | 158 List<A> m4<A>(core.List<core.int> x) => null; |
114 int Function(int y, {Function x}) m5<B extends core.int>(int x) => null; | 159 int Function(int y, {Function x}) m5<B extends core.int>(int x) => null; |
115 int Function(int x0, [List<T> x]) m6<B extends core.int>(int x) => null; | 160 int Function(int x0, [List<T> x]) m6<B extends core.int>(int x) => null; |
116 Function Function(Function x0) m7<B extends core.int>(int x) => null; | 161 Function Function(Function x0) m7<B extends core.int>(int x) => null; |
117 Function Function(int x, [core.List<core.int> x0]) m8<B extends core.int>(int
x) => null; | 162 Function Function(int x, [core.List<core.int> x0]) m8<B extends core.int>( |
118 List<Function> Function(int x0, {int x}) m9<B extends core.int>(int x) => null
; | 163 int x) => |
119 List<Function> Function([core.List<core.int> x]) m10<B extends core.int>(int x
) => null; | 164 null; |
120 core.List<core.int> Function(int y, [int x]) m11<B extends core.int>(int x) =>
null; | 165 List<Function> Function(int x0, {int x}) m9<B extends core.int>(int x) => |
121 core.List<core.int> Function(int x0, [List<Function> x1]) m12<B extends core.i
nt>(int x) => null; | 166 null; |
122 core.List<core.int> Function(int x0, {List<T> x}) m13<B extends core.int>(int
x) => null; | 167 List<Function> Function([core.List<core.int> x]) m10<B extends core.int>( |
| 168 int x) => |
| 169 null; |
| 170 core.List<core.int> Function(int y, [int x]) m11<B extends core.int>(int x) => |
| 171 null; |
| 172 core.List<core.int> Function(int x0, [List<Function> x1]) |
| 173 m12<B extends core.int>(int x) => null; |
| 174 core.List<core.int> Function(int x0, {List<T> x}) m13<B extends core.int>( |
| 175 int x) => |
| 176 null; |
123 List<T> Function(List<Function> x) m14<B extends core.int>(int x) => null; | 177 List<T> Function(List<Function> x) m14<B extends core.int>(int x) => null; |
124 List<T> Function(int y, [List<T> x]) m15<B extends core.int>(int x) => null; | 178 List<T> Function(int y, [List<T> x]) m15<B extends core.int>(int x) => null; |
125 Function([Function x0]) m16<B extends core.int>(int x) => null; | 179 Function([Function x0]) m16<B extends core.int>(int x) => null; |
126 Function({core.List<core.int> x}) m17<B extends core.int>(int x) => null; | 180 Function({core.List<core.int> x}) m17<B extends core.int>(int x) => null; |
127 void Function(int y, {int x}) m18<B extends core.int>(int x) => null; | 181 void Function(int y, {int x}) m18<B extends core.int>(int x) => null; |
128 void Function(int x0, [core.List<core.int> x]) m19<B extends core.int>(int x)
=> null; | 182 void Function(int x0, [core.List<core.int> x]) m19<B extends core.int>( |
| 183 int x) => |
| 184 null; |
129 int Function<A>(List<T> x) m20<B extends core.int>(int x) => null; | 185 int Function<A>(List<T> x) m20<B extends core.int>(int x) => null; |
130 core.List<core.int> Function<A>() m21<B extends core.int>(int x) => null; | 186 core.List<core.int> Function<A>() m21<B extends core.int>(int x) => null; |
131 A Function<A>(A x) m22<B extends core.int>(int x) => null; | 187 A Function<A>(A x) m22<B extends core.int>(int x) => null; |
132 | 188 |
133 | |
134 runTests() { | 189 runTests() { |
135 testF0(); | 190 testF0(); |
136 testF1(); | 191 testF1(); |
137 testF2(); | 192 testF2(); |
138 testF3(); | 193 testF3(); |
139 testF4(); | 194 testF4(); |
140 testF5(); | 195 testF5(); |
141 testF6(); | 196 testF6(); |
142 testF7(); | 197 testF7(); |
143 testF8(); | 198 testF8(); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
181 l0 = confuse(m0); | 236 l0 = confuse(m0); |
182 if (!tIsBool) { | 237 if (!tIsBool) { |
183 Expect.isTrue(f0 is F0<int>); | 238 Expect.isTrue(f0 is F0<int>); |
184 Expect.isFalse(f0 is F0<bool>); | 239 Expect.isFalse(f0 is F0<bool>); |
185 Expect.isTrue(confuse(f0) is F0<int>); | 240 Expect.isTrue(confuse(f0) is F0<int>); |
186 Expect.isFalse(confuse(f0) is F0<bool>); | 241 Expect.isFalse(confuse(f0) is F0<bool>); |
187 Expect.equals(tIsDynamic, m0 is F0<bool>); | 242 Expect.equals(tIsDynamic, m0 is F0<bool>); |
188 Expect.equals(tIsDynamic, confuse(m0) is F0<bool>); | 243 Expect.equals(tIsDynamic, confuse(m0) is F0<bool>); |
189 } else { | 244 } else { |
190 if (inCheckedMode) { | 245 if (inCheckedMode) { |
191 Expect.throws(() { x0 = (f0 as dynamic); }); | 246 Expect.throws(() { |
192 Expect.throws(() { x0 = confuse(f0); }); | 247 x0 = (f0 as dynamic); |
| 248 }); |
| 249 Expect.throws(() { |
| 250 x0 = confuse(f0); |
| 251 }); |
193 int Function(int x, [List<T> x2]) l0; | 252 int Function(int x, [List<T> x2]) l0; |
194 Expect.throws(() { l0 = (f0 as dynamic); }); | 253 Expect.throws(() { |
195 Expect.throws(() { l0 = confuse(f0); }); | 254 l0 = (f0 as dynamic); |
| 255 }); |
| 256 Expect.throws(() { |
| 257 l0 = confuse(f0); |
| 258 }); |
196 } | 259 } |
197 int Function(int x, [List<T> x2]) l0 = m0; | 260 int Function(int x, [List<T> x2]) l0 = m0; |
198 // In checked mode, verifies the type. | 261 // In checked mode, verifies the type. |
199 x0 = m0; | 262 x0 = m0; |
200 x0 = confuse(m0); | 263 x0 = confuse(m0); |
201 } | 264 } |
202 } | 265 } |
203 | 266 |
204 /// List<Function> Function(int x1, [core.List<core.int> x2]) | 267 /// List<Function> Function(int x1, [core.List<core.int> x2]) |
205 void testF1() { | 268 void testF1() { |
206 Expect.isTrue(f1 is F1); | 269 Expect.isTrue(f1 is F1); |
207 Expect.isTrue(confuse(f1) is F1); | 270 Expect.isTrue(confuse(f1) is F1); |
208 // In checked mode, verifies the type. | 271 // In checked mode, verifies the type. |
209 List<Function> Function(int x1, [core.List<core.int> x2]) l1; | 272 List<Function> Function(int x1, [core.List<core.int> x2]) l1; |
210 // The static function f1 sets `T` to `int`. | 273 // The static function f1 sets `T` to `int`. |
211 if (!tIsBool) { | 274 if (!tIsBool) { |
212 x1 = f1 as dynamic; | 275 x1 = f1 as dynamic; |
213 l1 = f1 as dynamic; | 276 l1 = f1 as dynamic; |
214 x1 = confuse(f1); | 277 x1 = confuse(f1); |
215 l1 = confuse(f1); | 278 l1 = confuse(f1); |
216 } | 279 } |
217 | 280 |
218 Expect.isTrue(m1 is F1); | 281 Expect.isTrue(m1 is F1); |
219 Expect.isTrue(m1 is List<Function> Function(int x1, [core.List<core.int> x2]
)); | 282 Expect.isTrue( |
| 283 m1 is List<Function> Function(int x1, [core.List<core.int> x2])); |
220 Expect.isTrue(confuse(m1) is F1); | 284 Expect.isTrue(confuse(m1) is F1); |
221 // In checked mode, verifies the type. | 285 // In checked mode, verifies the type. |
222 x1 = m1; | 286 x1 = m1; |
223 l1 = m1; | 287 l1 = m1; |
224 x1 = confuse(m1); | 288 x1 = confuse(m1); |
225 l1 = confuse(m1); | 289 l1 = confuse(m1); |
226 | |
227 } | 290 } |
228 | 291 |
229 /// List<T> Function([List<Function> x1]) | 292 /// List<T> Function([List<Function> x1]) |
230 void testF2() { | 293 void testF2() { |
231 Expect.isTrue(f2 is F2); | 294 Expect.isTrue(f2 is F2); |
232 Expect.isTrue(confuse(f2) is F2); | 295 Expect.isTrue(confuse(f2) is F2); |
233 // In checked mode, verifies the type. | 296 // In checked mode, verifies the type. |
234 List<T> Function([List<Function> x1]) l2; | 297 List<T> Function([List<Function> x1]) l2; |
235 // The static function f2 sets `T` to `int`. | 298 // The static function f2 sets `T` to `int`. |
236 if (!tIsBool) { | 299 if (!tIsBool) { |
(...skipping 13 matching lines...) Expand all Loading... |
250 l2 = confuse(m2); | 313 l2 = confuse(m2); |
251 if (!tIsBool) { | 314 if (!tIsBool) { |
252 Expect.isTrue(f2 is F2<int>); | 315 Expect.isTrue(f2 is F2<int>); |
253 Expect.isFalse(f2 is F2<bool>); | 316 Expect.isFalse(f2 is F2<bool>); |
254 Expect.isTrue(confuse(f2) is F2<int>); | 317 Expect.isTrue(confuse(f2) is F2<int>); |
255 Expect.isFalse(confuse(f2) is F2<bool>); | 318 Expect.isFalse(confuse(f2) is F2<bool>); |
256 Expect.equals(tIsDynamic, m2 is F2<bool>); | 319 Expect.equals(tIsDynamic, m2 is F2<bool>); |
257 Expect.equals(tIsDynamic, confuse(m2) is F2<bool>); | 320 Expect.equals(tIsDynamic, confuse(m2) is F2<bool>); |
258 } else { | 321 } else { |
259 if (inCheckedMode) { | 322 if (inCheckedMode) { |
260 Expect.throws(() { x2 = (f2 as dynamic); }); | 323 Expect.throws(() { |
261 Expect.throws(() { x2 = confuse(f2); }); | 324 x2 = (f2 as dynamic); |
| 325 }); |
| 326 Expect.throws(() { |
| 327 x2 = confuse(f2); |
| 328 }); |
262 List<T> Function([List<Function> x1]) l2; | 329 List<T> Function([List<Function> x1]) l2; |
263 Expect.throws(() { l2 = (f2 as dynamic); }); | 330 Expect.throws(() { |
264 Expect.throws(() { l2 = confuse(f2); }); | 331 l2 = (f2 as dynamic); |
| 332 }); |
| 333 Expect.throws(() { |
| 334 l2 = confuse(f2); |
| 335 }); |
265 } | 336 } |
266 List<T> Function([List<Function> x1]) l2 = m2; | 337 List<T> Function([List<Function> x1]) l2 = m2; |
267 // In checked mode, verifies the type. | 338 // In checked mode, verifies the type. |
268 x2 = m2; | 339 x2 = m2; |
269 x2 = confuse(m2); | 340 x2 = confuse(m2); |
270 } | 341 } |
271 } | 342 } |
272 | 343 |
273 /// void Function(Function x0) | 344 /// void Function(Function x0) |
274 void testF3() { | 345 void testF3() { |
(...skipping 10 matching lines...) Expand all Loading... |
285 } | 356 } |
286 | 357 |
287 Expect.isTrue(m3 is F3); | 358 Expect.isTrue(m3 is F3); |
288 Expect.isTrue(m3 is void Function(Function x0)); | 359 Expect.isTrue(m3 is void Function(Function x0)); |
289 Expect.isTrue(confuse(m3) is F3); | 360 Expect.isTrue(confuse(m3) is F3); |
290 // In checked mode, verifies the type. | 361 // In checked mode, verifies the type. |
291 x3 = m3; | 362 x3 = m3; |
292 l3 = m3; | 363 l3 = m3; |
293 x3 = confuse(m3); | 364 x3 = confuse(m3); |
294 l3 = confuse(m3); | 365 l3 = confuse(m3); |
295 | |
296 } | 366 } |
297 | 367 |
298 /// List<A> Function<A>(core.List<core.int> x) | 368 /// List<A> Function<A>(core.List<core.int> x) |
299 void testF4() { | 369 void testF4() { |
300 Expect.isTrue(f4 is F4); | 370 Expect.isTrue(f4 is F4); |
301 Expect.isTrue(confuse(f4) is F4); | 371 Expect.isTrue(confuse(f4) is F4); |
302 // In checked mode, verifies the type. | 372 // In checked mode, verifies the type. |
303 List<A> Function<A>(core.List<core.int> x) l4; | 373 List<A> Function<A>(core.List<core.int> x) l4; |
304 // The static function f4 sets `T` to `int`. | 374 // The static function f4 sets `T` to `int`. |
305 if (!tIsBool) { | 375 if (!tIsBool) { |
306 x4 = f4 as dynamic; | 376 x4 = f4 as dynamic; |
307 l4 = f4 as dynamic; | 377 l4 = f4 as dynamic; |
308 x4 = confuse(f4); | 378 x4 = confuse(f4); |
309 l4 = confuse(f4); | 379 l4 = confuse(f4); |
310 } | 380 } |
311 | 381 |
312 Expect.isTrue(m4 is F4); | 382 Expect.isTrue(m4 is F4); |
313 Expect.isTrue(m4 is List<A> Function<A>(core.List<core.int> x)); | 383 Expect.isTrue(m4 is List<A> Function<A>(core.List<core.int> x)); |
314 Expect.isTrue(confuse(m4) is F4); | 384 Expect.isTrue(confuse(m4) is F4); |
315 // In checked mode, verifies the type. | 385 // In checked mode, verifies the type. |
316 x4 = m4; | 386 x4 = m4; |
317 l4 = m4; | 387 l4 = m4; |
318 x4 = confuse(m4); | 388 x4 = confuse(m4); |
319 l4 = confuse(m4); | 389 l4 = confuse(m4); |
320 | |
321 } | 390 } |
322 | 391 |
323 /// int Function(int y, {Function x}) Function<B extends core.int>(int x) | 392 /// int Function(int y, {Function x}) Function<B extends core.int>(int x) |
324 void testF5() { | 393 void testF5() { |
325 Expect.isTrue(f5 is F5); | 394 Expect.isTrue(f5 is F5); |
326 Expect.isTrue(confuse(f5) is F5); | 395 Expect.isTrue(confuse(f5) is F5); |
327 // In checked mode, verifies the type. | 396 // In checked mode, verifies the type. |
328 int Function(int y, {Function x}) Function<B extends core.int>(int x) l5; | 397 int Function(int y, {Function x}) Function<B extends core.int>(int x) l5; |
329 // The static function f5 sets `T` to `int`. | 398 // The static function f5 sets `T` to `int`. |
330 if (!tIsBool) { | 399 if (!tIsBool) { |
331 x5 = f5 as dynamic; | 400 x5 = f5 as dynamic; |
332 l5 = f5 as dynamic; | 401 l5 = f5 as dynamic; |
333 x5 = confuse(f5); | 402 x5 = confuse(f5); |
334 l5 = confuse(f5); | 403 l5 = confuse(f5); |
335 } | 404 } |
336 | 405 |
337 Expect.isTrue(m5 is F5); | 406 Expect.isTrue(m5 is F5); |
338 Expect.isTrue(m5 is int Function(int y, {Function x}) Function<B extends cor
e.int>(int x)); | 407 Expect.isTrue(m5 is int Function(int y, |
| 408 {Function x}) Function<B extends core.int>(int x)); |
339 Expect.isTrue(confuse(m5) is F5); | 409 Expect.isTrue(confuse(m5) is F5); |
340 // In checked mode, verifies the type. | 410 // In checked mode, verifies the type. |
341 x5 = m5; | 411 x5 = m5; |
342 l5 = m5; | 412 l5 = m5; |
343 x5 = confuse(m5); | 413 x5 = confuse(m5); |
344 l5 = confuse(m5); | 414 l5 = confuse(m5); |
345 | |
346 } | 415 } |
347 | 416 |
348 /// int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) | 417 /// int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) |
349 void testF6() { | 418 void testF6() { |
350 Expect.isTrue(f6 is F6); | 419 Expect.isTrue(f6 is F6); |
351 Expect.isTrue(confuse(f6) is F6); | 420 Expect.isTrue(confuse(f6) is F6); |
352 // In checked mode, verifies the type. | 421 // In checked mode, verifies the type. |
353 int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l6; | 422 int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l6; |
354 // The static function f6 sets `T` to `int`. | 423 // The static function f6 sets `T` to `int`. |
355 if (!tIsBool) { | 424 if (!tIsBool) { |
356 x6 = f6 as dynamic; | 425 x6 = f6 as dynamic; |
357 l6 = f6 as dynamic; | 426 l6 = f6 as dynamic; |
358 x6 = confuse(f6); | 427 x6 = confuse(f6); |
359 l6 = confuse(f6); | 428 l6 = confuse(f6); |
360 } | 429 } |
361 | 430 |
362 Expect.isTrue(m6 is F6); | 431 Expect.isTrue(m6 is F6); |
363 Expect.isTrue(m6 is int Function(int x1, [List<T> x]) Function<B extends cor
e.int>(int x)); | 432 Expect.isTrue(m6 is int Function(int x1, |
| 433 [List<T> x]) Function<B extends core.int>(int x)); |
364 Expect.isTrue(confuse(m6) is F6); | 434 Expect.isTrue(confuse(m6) is F6); |
365 // In checked mode, verifies the type. | 435 // In checked mode, verifies the type. |
366 x6 = m6; | 436 x6 = m6; |
367 l6 = m6; | 437 l6 = m6; |
368 x6 = confuse(m6); | 438 x6 = confuse(m6); |
369 l6 = confuse(m6); | 439 l6 = confuse(m6); |
370 if (!tIsBool) { | 440 if (!tIsBool) { |
371 Expect.isTrue(f6 is F6<int>); | 441 Expect.isTrue(f6 is F6<int>); |
372 Expect.isFalse(f6 is F6<bool>); | 442 Expect.isFalse(f6 is F6<bool>); |
373 Expect.isTrue(confuse(f6) is F6<int>); | 443 Expect.isTrue(confuse(f6) is F6<int>); |
374 Expect.isFalse(confuse(f6) is F6<bool>); | 444 Expect.isFalse(confuse(f6) is F6<bool>); |
375 Expect.equals(tIsDynamic, m6 is F6<bool>); | 445 Expect.equals(tIsDynamic, m6 is F6<bool>); |
376 Expect.equals(tIsDynamic, confuse(m6) is F6<bool>); | 446 Expect.equals(tIsDynamic, confuse(m6) is F6<bool>); |
377 } else { | 447 } else { |
378 if (inCheckedMode) { | 448 if (inCheckedMode) { |
379 Expect.throws(() { x6 = (f6 as dynamic); }); | 449 Expect.throws(() { |
380 Expect.throws(() { x6 = confuse(f6); }); | 450 x6 = (f6 as dynamic); |
381 int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l6
; | 451 }); |
382 Expect.throws(() { l6 = (f6 as dynamic); }); | 452 Expect.throws(() { |
383 Expect.throws(() { l6 = confuse(f6); }); | 453 x6 = confuse(f6); |
| 454 }); |
| 455 int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) |
| 456 l6; |
| 457 Expect.throws(() { |
| 458 l6 = (f6 as dynamic); |
| 459 }); |
| 460 Expect.throws(() { |
| 461 l6 = confuse(f6); |
| 462 }); |
384 } | 463 } |
385 int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l6 =
m6; | 464 int Function(int x1, [List<T> x]) Function<B extends core.int>(int x) l6 = |
| 465 m6; |
386 // In checked mode, verifies the type. | 466 // In checked mode, verifies the type. |
387 x6 = m6; | 467 x6 = m6; |
388 x6 = confuse(m6); | 468 x6 = confuse(m6); |
389 } | 469 } |
390 } | 470 } |
391 | 471 |
392 /// Function Function(Function x1) Function<B extends core.int>(int x) | 472 /// Function Function(Function x1) Function<B extends core.int>(int x) |
393 void testF7() { | 473 void testF7() { |
394 Expect.isTrue(f7 is F7); | 474 Expect.isTrue(f7 is F7); |
395 Expect.isTrue(confuse(f7) is F7); | 475 Expect.isTrue(confuse(f7) is F7); |
396 // In checked mode, verifies the type. | 476 // In checked mode, verifies the type. |
397 Function Function(Function x1) Function<B extends core.int>(int x) l7; | 477 Function Function(Function x1) Function<B extends core.int>(int x) l7; |
398 // The static function f7 sets `T` to `int`. | 478 // The static function f7 sets `T` to `int`. |
399 if (!tIsBool) { | 479 if (!tIsBool) { |
400 x7 = f7 as dynamic; | 480 x7 = f7 as dynamic; |
401 l7 = f7 as dynamic; | 481 l7 = f7 as dynamic; |
402 x7 = confuse(f7); | 482 x7 = confuse(f7); |
403 l7 = confuse(f7); | 483 l7 = confuse(f7); |
404 } | 484 } |
405 | 485 |
406 Expect.isTrue(m7 is F7); | 486 Expect.isTrue(m7 is F7); |
407 Expect.isTrue(m7 is Function Function(Function x1) Function<B extends core.i
nt>(int x)); | 487 Expect.isTrue(m7 is Function Function( |
| 488 Function x1) Function<B extends core.int>(int x)); |
408 Expect.isTrue(confuse(m7) is F7); | 489 Expect.isTrue(confuse(m7) is F7); |
409 // In checked mode, verifies the type. | 490 // In checked mode, verifies the type. |
410 x7 = m7; | 491 x7 = m7; |
411 l7 = m7; | 492 l7 = m7; |
412 x7 = confuse(m7); | 493 x7 = confuse(m7); |
413 l7 = confuse(m7); | 494 l7 = confuse(m7); |
414 | |
415 } | 495 } |
416 | 496 |
417 /// Function Function(int x, [core.List<core.int> x1]) Function<B extends core
.int>(int x) | 497 /// Function Function(int x, [core.List<core.int> x1]) Function<B extends core
.int>(int x) |
418 void testF8() { | 498 void testF8() { |
419 Expect.isTrue(f8 is F8); | 499 Expect.isTrue(f8 is F8); |
420 Expect.isTrue(confuse(f8) is F8); | 500 Expect.isTrue(confuse(f8) is F8); |
421 // In checked mode, verifies the type. | 501 // In checked mode, verifies the type. |
422 Function Function(int x, [core.List<core.int> x1]) Function<B extends core.i
nt>(int x) l8; | 502 Function Function(int x, |
| 503 [core.List<core.int> x1]) Function<B extends core.int>(int x) l8; |
423 // The static function f8 sets `T` to `int`. | 504 // The static function f8 sets `T` to `int`. |
424 if (!tIsBool) { | 505 if (!tIsBool) { |
425 x8 = f8 as dynamic; | 506 x8 = f8 as dynamic; |
426 l8 = f8 as dynamic; | 507 l8 = f8 as dynamic; |
427 x8 = confuse(f8); | 508 x8 = confuse(f8); |
428 l8 = confuse(f8); | 509 l8 = confuse(f8); |
429 } | 510 } |
430 | 511 |
431 Expect.isTrue(m8 is F8); | 512 Expect.isTrue(m8 is F8); |
432 Expect.isTrue(m8 is Function Function(int x, [core.List<core.int> x1]) Funct
ion<B extends core.int>(int x)); | 513 Expect.isTrue(m8 is Function Function(int x, |
| 514 [core.List<core.int> x1]) Function<B extends core.int>(int x)); |
433 Expect.isTrue(confuse(m8) is F8); | 515 Expect.isTrue(confuse(m8) is F8); |
434 // In checked mode, verifies the type. | 516 // In checked mode, verifies the type. |
435 x8 = m8; | 517 x8 = m8; |
436 l8 = m8; | 518 l8 = m8; |
437 x8 = confuse(m8); | 519 x8 = confuse(m8); |
438 l8 = confuse(m8); | 520 l8 = confuse(m8); |
439 | |
440 } | 521 } |
441 | 522 |
442 /// List<Function> Function(int x1, {int x}) Function<B extends core.int>(int
x) | 523 /// List<Function> Function(int x1, {int x}) Function<B extends core.int>(int
x) |
443 void testF9() { | 524 void testF9() { |
444 Expect.isTrue(f9 is F9); | 525 Expect.isTrue(f9 is F9); |
445 Expect.isTrue(confuse(f9) is F9); | 526 Expect.isTrue(confuse(f9) is F9); |
446 // In checked mode, verifies the type. | 527 // In checked mode, verifies the type. |
447 List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x)
l9; | 528 List<Function> Function(int x1, {int x}) Function<B extends core.int>(int x) |
| 529 l9; |
448 // The static function f9 sets `T` to `int`. | 530 // The static function f9 sets `T` to `int`. |
449 if (!tIsBool) { | 531 if (!tIsBool) { |
450 x9 = f9 as dynamic; | 532 x9 = f9 as dynamic; |
451 l9 = f9 as dynamic; | 533 l9 = f9 as dynamic; |
452 x9 = confuse(f9); | 534 x9 = confuse(f9); |
453 l9 = confuse(f9); | 535 l9 = confuse(f9); |
454 } | 536 } |
455 | 537 |
456 Expect.isTrue(m9 is F9); | 538 Expect.isTrue(m9 is F9); |
457 Expect.isTrue(m9 is List<Function> Function(int x1, {int x}) Function<B exte
nds core.int>(int x)); | 539 Expect.isTrue(m9 is List<Function> Function(int x1, |
| 540 {int x}) Function<B extends core.int>(int x)); |
458 Expect.isTrue(confuse(m9) is F9); | 541 Expect.isTrue(confuse(m9) is F9); |
459 // In checked mode, verifies the type. | 542 // In checked mode, verifies the type. |
460 x9 = m9; | 543 x9 = m9; |
461 l9 = m9; | 544 l9 = m9; |
462 x9 = confuse(m9); | 545 x9 = confuse(m9); |
463 l9 = confuse(m9); | 546 l9 = confuse(m9); |
464 | |
465 } | 547 } |
466 | 548 |
467 /// List<Function> Function([core.List<core.int> x]) Function<B extends core.i
nt>(int x) | 549 /// List<Function> Function([core.List<core.int> x]) Function<B extends core.i
nt>(int x) |
468 void testF10() { | 550 void testF10() { |
469 Expect.isTrue(f10 is F10); | 551 Expect.isTrue(f10 is F10); |
470 Expect.isTrue(confuse(f10) is F10); | 552 Expect.isTrue(confuse(f10) is F10); |
471 // In checked mode, verifies the type. | 553 // In checked mode, verifies the type. |
472 List<Function> Function([core.List<core.int> x]) Function<B extends core.int
>(int x) l10; | 554 List<Function> Function( |
| 555 [core.List<core.int> x]) Function<B extends core.int>(int x) l10; |
473 // The static function f10 sets `T` to `int`. | 556 // The static function f10 sets `T` to `int`. |
474 if (!tIsBool) { | 557 if (!tIsBool) { |
475 x10 = f10 as dynamic; | 558 x10 = f10 as dynamic; |
476 l10 = f10 as dynamic; | 559 l10 = f10 as dynamic; |
477 x10 = confuse(f10); | 560 x10 = confuse(f10); |
478 l10 = confuse(f10); | 561 l10 = confuse(f10); |
479 } | 562 } |
480 | 563 |
481 Expect.isTrue(m10 is F10); | 564 Expect.isTrue(m10 is F10); |
482 Expect.isTrue(m10 is List<Function> Function([core.List<core.int> x]) Functi
on<B extends core.int>(int x)); | 565 Expect.isTrue(m10 is List<Function> Function( |
| 566 [core.List<core.int> x]) Function<B extends core.int>(int x)); |
483 Expect.isTrue(confuse(m10) is F10); | 567 Expect.isTrue(confuse(m10) is F10); |
484 // In checked mode, verifies the type. | 568 // In checked mode, verifies the type. |
485 x10 = m10; | 569 x10 = m10; |
486 l10 = m10; | 570 l10 = m10; |
487 x10 = confuse(m10); | 571 x10 = confuse(m10); |
488 l10 = confuse(m10); | 572 l10 = confuse(m10); |
489 | |
490 } | 573 } |
491 | 574 |
492 /// core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(
int x) | 575 /// core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(
int x) |
493 void testF11() { | 576 void testF11() { |
494 Expect.isTrue(f11 is F11); | 577 Expect.isTrue(f11 is F11); |
495 Expect.isTrue(confuse(f11) is F11); | 578 Expect.isTrue(confuse(f11) is F11); |
496 // In checked mode, verifies the type. | 579 // In checked mode, verifies the type. |
497 core.List<core.int> Function(int y, [int x]) Function<B extends core.int>(in
t x) l11; | 580 core.List<core.int> Function(int y, [int x]) Function<B extends core.int>( |
| 581 int x) l11; |
498 // The static function f11 sets `T` to `int`. | 582 // The static function f11 sets `T` to `int`. |
499 if (!tIsBool) { | 583 if (!tIsBool) { |
500 x11 = f11 as dynamic; | 584 x11 = f11 as dynamic; |
501 l11 = f11 as dynamic; | 585 l11 = f11 as dynamic; |
502 x11 = confuse(f11); | 586 x11 = confuse(f11); |
503 l11 = confuse(f11); | 587 l11 = confuse(f11); |
504 } | 588 } |
505 | 589 |
506 Expect.isTrue(m11 is F11); | 590 Expect.isTrue(m11 is F11); |
507 Expect.isTrue(m11 is core.List<core.int> Function(int y, [int x]) Function<B
extends core.int>(int x)); | 591 Expect.isTrue(m11 is core.List<core.int> Function(int y, |
| 592 [int x]) Function<B extends core.int>(int x)); |
508 Expect.isTrue(confuse(m11) is F11); | 593 Expect.isTrue(confuse(m11) is F11); |
509 // In checked mode, verifies the type. | 594 // In checked mode, verifies the type. |
510 x11 = m11; | 595 x11 = m11; |
511 l11 = m11; | 596 l11 = m11; |
512 x11 = confuse(m11); | 597 x11 = confuse(m11); |
513 l11 = confuse(m11); | 598 l11 = confuse(m11); |
514 | |
515 } | 599 } |
516 | 600 |
517 /// core.List<core.int> Function(int x2, [List<Function> x3]) Function<B exten
ds core.int>(int x) | 601 /// core.List<core.int> Function(int x2, [List<Function> x3]) Function<B exten
ds core.int>(int x) |
518 void testF12() { | 602 void testF12() { |
519 Expect.isTrue(f12 is F12); | 603 Expect.isTrue(f12 is F12); |
520 Expect.isTrue(confuse(f12) is F12); | 604 Expect.isTrue(confuse(f12) is F12); |
521 // In checked mode, verifies the type. | 605 // In checked mode, verifies the type. |
522 core.List<core.int> Function(int x2, [List<Function> x3]) Function<B extends
core.int>(int x) l12; | 606 core.List<core.int> Function(int x2, |
| 607 [List<Function> x3]) Function<B extends core.int>(int x) l12; |
523 // The static function f12 sets `T` to `int`. | 608 // The static function f12 sets `T` to `int`. |
524 if (!tIsBool) { | 609 if (!tIsBool) { |
525 x12 = f12 as dynamic; | 610 x12 = f12 as dynamic; |
526 l12 = f12 as dynamic; | 611 l12 = f12 as dynamic; |
527 x12 = confuse(f12); | 612 x12 = confuse(f12); |
528 l12 = confuse(f12); | 613 l12 = confuse(f12); |
529 } | 614 } |
530 | 615 |
531 Expect.isTrue(m12 is F12); | 616 Expect.isTrue(m12 is F12); |
532 Expect.isTrue(m12 is core.List<core.int> Function(int x2, [List<Function> x3
]) Function<B extends core.int>(int x)); | 617 Expect.isTrue(m12 is core.List<core.int> Function(int x2, |
| 618 [List<Function> x3]) Function<B extends core.int>(int x)); |
533 Expect.isTrue(confuse(m12) is F12); | 619 Expect.isTrue(confuse(m12) is F12); |
534 // In checked mode, verifies the type. | 620 // In checked mode, verifies the type. |
535 x12 = m12; | 621 x12 = m12; |
536 l12 = m12; | 622 l12 = m12; |
537 x12 = confuse(m12); | 623 x12 = confuse(m12); |
538 l12 = confuse(m12); | 624 l12 = confuse(m12); |
539 | |
540 } | 625 } |
541 | 626 |
542 /// core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.
int>(int x) | 627 /// core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.
int>(int x) |
543 void testF13() { | 628 void testF13() { |
544 Expect.isTrue(f13 is F13); | 629 Expect.isTrue(f13 is F13); |
545 Expect.isTrue(confuse(f13) is F13); | 630 Expect.isTrue(confuse(f13) is F13); |
546 // In checked mode, verifies the type. | 631 // In checked mode, verifies the type. |
547 core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.in
t>(int x) l13; | 632 core.List<core.int> Function(int x1, |
| 633 {List<T> x}) Function<B extends core.int>(int x) l13; |
548 // The static function f13 sets `T` to `int`. | 634 // The static function f13 sets `T` to `int`. |
549 if (!tIsBool) { | 635 if (!tIsBool) { |
550 x13 = f13 as dynamic; | 636 x13 = f13 as dynamic; |
551 l13 = f13 as dynamic; | 637 l13 = f13 as dynamic; |
552 x13 = confuse(f13); | 638 x13 = confuse(f13); |
553 l13 = confuse(f13); | 639 l13 = confuse(f13); |
554 } | 640 } |
555 | 641 |
556 Expect.isTrue(m13 is F13); | 642 Expect.isTrue(m13 is F13); |
557 Expect.isTrue(m13 is core.List<core.int> Function(int x1, {List<T> x}) Funct
ion<B extends core.int>(int x)); | 643 Expect.isTrue(m13 is core.List<core.int> Function(int x1, |
| 644 {List<T> x}) Function<B extends core.int>(int x)); |
558 Expect.isTrue(confuse(m13) is F13); | 645 Expect.isTrue(confuse(m13) is F13); |
559 // In checked mode, verifies the type. | 646 // In checked mode, verifies the type. |
560 x13 = m13; | 647 x13 = m13; |
561 l13 = m13; | 648 l13 = m13; |
562 x13 = confuse(m13); | 649 x13 = confuse(m13); |
563 l13 = confuse(m13); | 650 l13 = confuse(m13); |
564 if (!tIsBool) { | 651 if (!tIsBool) { |
565 Expect.isTrue(f13 is F13<int>); | 652 Expect.isTrue(f13 is F13<int>); |
566 Expect.isFalse(f13 is F13<bool>); | 653 Expect.isFalse(f13 is F13<bool>); |
567 Expect.isTrue(confuse(f13) is F13<int>); | 654 Expect.isTrue(confuse(f13) is F13<int>); |
568 Expect.isFalse(confuse(f13) is F13<bool>); | 655 Expect.isFalse(confuse(f13) is F13<bool>); |
569 Expect.equals(tIsDynamic, m13 is F13<bool>); | 656 Expect.equals(tIsDynamic, m13 is F13<bool>); |
570 Expect.equals(tIsDynamic, confuse(m13) is F13<bool>); | 657 Expect.equals(tIsDynamic, confuse(m13) is F13<bool>); |
571 } else { | 658 } else { |
572 if (inCheckedMode) { | 659 if (inCheckedMode) { |
573 Expect.throws(() { x13 = (f13 as dynamic); }); | 660 Expect.throws(() { |
574 Expect.throws(() { x13 = confuse(f13); }); | 661 x13 = (f13 as dynamic); |
575 core.List<core.int> Function(int x1, {List<T> x}) Function<B extends cor
e.int>(int x) l13; | 662 }); |
576 Expect.throws(() { l13 = (f13 as dynamic); }); | 663 Expect.throws(() { |
577 Expect.throws(() { l13 = confuse(f13); }); | 664 x13 = confuse(f13); |
| 665 }); |
| 666 core.List<core.int> Function(int x1, |
| 667 {List<T> x}) Function<B extends core.int>(int x) l13; |
| 668 Expect.throws(() { |
| 669 l13 = (f13 as dynamic); |
| 670 }); |
| 671 Expect.throws(() { |
| 672 l13 = confuse(f13); |
| 673 }); |
578 } | 674 } |
579 core.List<core.int> Function(int x1, {List<T> x}) Function<B extends core.
int>(int x) l13 = m13; | 675 core.List<core.int> Function(int x1, |
| 676 {List<T> x}) Function<B extends core.int>(int x) l13 = m13; |
580 // In checked mode, verifies the type. | 677 // In checked mode, verifies the type. |
581 x13 = m13; | 678 x13 = m13; |
582 x13 = confuse(m13); | 679 x13 = confuse(m13); |
583 } | 680 } |
584 } | 681 } |
585 | 682 |
586 /// List<T> Function(List<Function> x) Function<B extends core.int>(int x) | 683 /// List<T> Function(List<Function> x) Function<B extends core.int>(int x) |
587 void testF14() { | 684 void testF14() { |
588 Expect.isTrue(f14 is F14); | 685 Expect.isTrue(f14 is F14); |
589 Expect.isTrue(confuse(f14) is F14); | 686 Expect.isTrue(confuse(f14) is F14); |
590 // In checked mode, verifies the type. | 687 // In checked mode, verifies the type. |
591 List<T> Function(List<Function> x) Function<B extends core.int>(int x) l14; | 688 List<T> Function(List<Function> x) Function<B extends core.int>(int x) l14; |
592 // The static function f14 sets `T` to `int`. | 689 // The static function f14 sets `T` to `int`. |
593 if (!tIsBool) { | 690 if (!tIsBool) { |
594 x14 = f14 as dynamic; | 691 x14 = f14 as dynamic; |
595 l14 = f14 as dynamic; | 692 l14 = f14 as dynamic; |
596 x14 = confuse(f14); | 693 x14 = confuse(f14); |
597 l14 = confuse(f14); | 694 l14 = confuse(f14); |
598 } | 695 } |
599 | 696 |
600 Expect.isTrue(m14 is F14); | 697 Expect.isTrue(m14 is F14); |
601 Expect.isTrue(m14 is List<T> Function(List<Function> x) Function<B extends c
ore.int>(int x)); | 698 Expect.isTrue(m14 is List<T> Function( |
| 699 List<Function> x) Function<B extends core.int>(int x)); |
602 Expect.isTrue(confuse(m14) is F14); | 700 Expect.isTrue(confuse(m14) is F14); |
603 // In checked mode, verifies the type. | 701 // In checked mode, verifies the type. |
604 x14 = m14; | 702 x14 = m14; |
605 l14 = m14; | 703 l14 = m14; |
606 x14 = confuse(m14); | 704 x14 = confuse(m14); |
607 l14 = confuse(m14); | 705 l14 = confuse(m14); |
608 if (!tIsBool) { | 706 if (!tIsBool) { |
609 Expect.isTrue(f14 is F14<int>); | 707 Expect.isTrue(f14 is F14<int>); |
610 Expect.isFalse(f14 is F14<bool>); | 708 Expect.isFalse(f14 is F14<bool>); |
611 Expect.isTrue(confuse(f14) is F14<int>); | 709 Expect.isTrue(confuse(f14) is F14<int>); |
612 Expect.isFalse(confuse(f14) is F14<bool>); | 710 Expect.isFalse(confuse(f14) is F14<bool>); |
613 Expect.equals(tIsDynamic, m14 is F14<bool>); | 711 Expect.equals(tIsDynamic, m14 is F14<bool>); |
614 Expect.equals(tIsDynamic, confuse(m14) is F14<bool>); | 712 Expect.equals(tIsDynamic, confuse(m14) is F14<bool>); |
615 } else { | 713 } else { |
616 if (inCheckedMode) { | 714 if (inCheckedMode) { |
617 Expect.throws(() { x14 = (f14 as dynamic); }); | 715 Expect.throws(() { |
618 Expect.throws(() { x14 = confuse(f14); }); | 716 x14 = (f14 as dynamic); |
619 List<T> Function(List<Function> x) Function<B extends core.int>(int x) l
14; | 717 }); |
620 Expect.throws(() { l14 = (f14 as dynamic); }); | 718 Expect.throws(() { |
621 Expect.throws(() { l14 = confuse(f14); }); | 719 x14 = confuse(f14); |
| 720 }); |
| 721 List<T> Function(List<Function> x) Function<B extends core.int>(int x) |
| 722 l14; |
| 723 Expect.throws(() { |
| 724 l14 = (f14 as dynamic); |
| 725 }); |
| 726 Expect.throws(() { |
| 727 l14 = confuse(f14); |
| 728 }); |
622 } | 729 } |
623 List<T> Function(List<Function> x) Function<B extends core.int>(int x) l14
= m14; | 730 List<T> Function(List<Function> x) Function<B extends core.int>(int x) |
| 731 l14 = m14; |
624 // In checked mode, verifies the type. | 732 // In checked mode, verifies the type. |
625 x14 = m14; | 733 x14 = m14; |
626 x14 = confuse(m14); | 734 x14 = confuse(m14); |
627 } | 735 } |
628 } | 736 } |
629 | 737 |
630 /// List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) | 738 /// List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) |
631 void testF15() { | 739 void testF15() { |
632 Expect.isTrue(f15 is F15); | 740 Expect.isTrue(f15 is F15); |
633 Expect.isTrue(confuse(f15) is F15); | 741 Expect.isTrue(confuse(f15) is F15); |
634 // In checked mode, verifies the type. | 742 // In checked mode, verifies the type. |
635 List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l15
; | 743 List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) |
| 744 l15; |
636 // The static function f15 sets `T` to `int`. | 745 // The static function f15 sets `T` to `int`. |
637 if (!tIsBool) { | 746 if (!tIsBool) { |
638 x15 = f15 as dynamic; | 747 x15 = f15 as dynamic; |
639 l15 = f15 as dynamic; | 748 l15 = f15 as dynamic; |
640 x15 = confuse(f15); | 749 x15 = confuse(f15); |
641 l15 = confuse(f15); | 750 l15 = confuse(f15); |
642 } | 751 } |
643 | 752 |
644 Expect.isTrue(m15 is F15); | 753 Expect.isTrue(m15 is F15); |
645 Expect.isTrue(m15 is List<T> Function(int y, [List<T> x]) Function<B extends
core.int>(int x)); | 754 Expect.isTrue(m15 is List<T> Function(int y, |
| 755 [List<T> x]) Function<B extends core.int>(int x)); |
646 Expect.isTrue(confuse(m15) is F15); | 756 Expect.isTrue(confuse(m15) is F15); |
647 // In checked mode, verifies the type. | 757 // In checked mode, verifies the type. |
648 x15 = m15; | 758 x15 = m15; |
649 l15 = m15; | 759 l15 = m15; |
650 x15 = confuse(m15); | 760 x15 = confuse(m15); |
651 l15 = confuse(m15); | 761 l15 = confuse(m15); |
652 if (!tIsBool) { | 762 if (!tIsBool) { |
653 Expect.isTrue(f15 is F15<int>); | 763 Expect.isTrue(f15 is F15<int>); |
654 Expect.isFalse(f15 is F15<bool>); | 764 Expect.isFalse(f15 is F15<bool>); |
655 Expect.isTrue(confuse(f15) is F15<int>); | 765 Expect.isTrue(confuse(f15) is F15<int>); |
656 Expect.isFalse(confuse(f15) is F15<bool>); | 766 Expect.isFalse(confuse(f15) is F15<bool>); |
657 Expect.equals(tIsDynamic, m15 is F15<bool>); | 767 Expect.equals(tIsDynamic, m15 is F15<bool>); |
658 Expect.equals(tIsDynamic, confuse(m15) is F15<bool>); | 768 Expect.equals(tIsDynamic, confuse(m15) is F15<bool>); |
659 } else { | 769 } else { |
660 if (inCheckedMode) { | 770 if (inCheckedMode) { |
661 Expect.throws(() { x15 = (f15 as dynamic); }); | 771 Expect.throws(() { |
662 Expect.throws(() { x15 = confuse(f15); }); | 772 x15 = (f15 as dynamic); |
663 List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x)
l15; | 773 }); |
664 Expect.throws(() { l15 = (f15 as dynamic); }); | 774 Expect.throws(() { |
665 Expect.throws(() { l15 = confuse(f15); }); | 775 x15 = confuse(f15); |
| 776 }); |
| 777 List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) |
| 778 l15; |
| 779 Expect.throws(() { |
| 780 l15 = (f15 as dynamic); |
| 781 }); |
| 782 Expect.throws(() { |
| 783 l15 = confuse(f15); |
| 784 }); |
666 } | 785 } |
667 List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) l
15 = m15; | 786 List<T> Function(int y, [List<T> x]) Function<B extends core.int>(int x) |
| 787 l15 = m15; |
668 // In checked mode, verifies the type. | 788 // In checked mode, verifies the type. |
669 x15 = m15; | 789 x15 = m15; |
670 x15 = confuse(m15); | 790 x15 = confuse(m15); |
671 } | 791 } |
672 } | 792 } |
673 | 793 |
674 /// Function([Function x1]) Function<B extends core.int>(int x) | 794 /// Function([Function x1]) Function<B extends core.int>(int x) |
675 void testF16() { | 795 void testF16() { |
676 Expect.isTrue(f16 is F16); | 796 Expect.isTrue(f16 is F16); |
677 Expect.isTrue(confuse(f16) is F16); | 797 Expect.isTrue(confuse(f16) is F16); |
678 // In checked mode, verifies the type. | 798 // In checked mode, verifies the type. |
679 Function([Function x1]) Function<B extends core.int>(int x) l16; | 799 Function([Function x1]) Function<B extends core.int>(int x) l16; |
680 // The static function f16 sets `T` to `int`. | 800 // The static function f16 sets `T` to `int`. |
681 if (!tIsBool) { | 801 if (!tIsBool) { |
682 x16 = f16 as dynamic; | 802 x16 = f16 as dynamic; |
683 l16 = f16 as dynamic; | 803 l16 = f16 as dynamic; |
684 x16 = confuse(f16); | 804 x16 = confuse(f16); |
685 l16 = confuse(f16); | 805 l16 = confuse(f16); |
686 } | 806 } |
687 | 807 |
688 Expect.isTrue(m16 is F16); | 808 Expect.isTrue(m16 is F16); |
689 Expect.isTrue(m16 is Function([Function x1]) Function<B extends core.int>(in
t x)); | 809 Expect.isTrue( |
| 810 m16 is Function([Function x1]) Function<B extends core.int>(int x)); |
690 Expect.isTrue(confuse(m16) is F16); | 811 Expect.isTrue(confuse(m16) is F16); |
691 // In checked mode, verifies the type. | 812 // In checked mode, verifies the type. |
692 x16 = m16; | 813 x16 = m16; |
693 l16 = m16; | 814 l16 = m16; |
694 x16 = confuse(m16); | 815 x16 = confuse(m16); |
695 l16 = confuse(m16); | 816 l16 = confuse(m16); |
696 | |
697 } | 817 } |
698 | 818 |
699 /// Function({core.List<core.int> x}) Function<B extends core.int>(int x) | 819 /// Function({core.List<core.int> x}) Function<B extends core.int>(int x) |
700 void testF17() { | 820 void testF17() { |
701 Expect.isTrue(f17 is F17); | 821 Expect.isTrue(f17 is F17); |
702 Expect.isTrue(confuse(f17) is F17); | 822 Expect.isTrue(confuse(f17) is F17); |
703 // In checked mode, verifies the type. | 823 // In checked mode, verifies the type. |
704 Function({core.List<core.int> x}) Function<B extends core.int>(int x) l17; | 824 Function({core.List<core.int> x}) Function<B extends core.int>(int x) l17; |
705 // The static function f17 sets `T` to `int`. | 825 // The static function f17 sets `T` to `int`. |
706 if (!tIsBool) { | 826 if (!tIsBool) { |
707 x17 = f17 as dynamic; | 827 x17 = f17 as dynamic; |
708 l17 = f17 as dynamic; | 828 l17 = f17 as dynamic; |
709 x17 = confuse(f17); | 829 x17 = confuse(f17); |
710 l17 = confuse(f17); | 830 l17 = confuse(f17); |
711 } | 831 } |
712 | 832 |
713 Expect.isTrue(m17 is F17); | 833 Expect.isTrue(m17 is F17); |
714 Expect.isTrue(m17 is Function({core.List<core.int> x}) Function<B extends co
re.int>(int x)); | 834 Expect.isTrue(m17 is Function( |
| 835 {core.List<core.int> x}) Function<B extends core.int>(int x)); |
715 Expect.isTrue(confuse(m17) is F17); | 836 Expect.isTrue(confuse(m17) is F17); |
716 // In checked mode, verifies the type. | 837 // In checked mode, verifies the type. |
717 x17 = m17; | 838 x17 = m17; |
718 l17 = m17; | 839 l17 = m17; |
719 x17 = confuse(m17); | 840 x17 = confuse(m17); |
720 l17 = confuse(m17); | 841 l17 = confuse(m17); |
721 | |
722 } | 842 } |
723 | 843 |
724 /// void Function(int y, {int x}) Function<B extends core.int>(int x) | 844 /// void Function(int y, {int x}) Function<B extends core.int>(int x) |
725 void testF18() { | 845 void testF18() { |
726 Expect.isTrue(f18 is F18); | 846 Expect.isTrue(f18 is F18); |
727 Expect.isTrue(confuse(f18) is F18); | 847 Expect.isTrue(confuse(f18) is F18); |
728 // In checked mode, verifies the type. | 848 // In checked mode, verifies the type. |
729 void Function(int y, {int x}) Function<B extends core.int>(int x) l18; | 849 void Function(int y, {int x}) Function<B extends core.int>(int x) l18; |
730 // The static function f18 sets `T` to `int`. | 850 // The static function f18 sets `T` to `int`. |
731 if (!tIsBool) { | 851 if (!tIsBool) { |
732 x18 = f18 as dynamic; | 852 x18 = f18 as dynamic; |
733 l18 = f18 as dynamic; | 853 l18 = f18 as dynamic; |
734 x18 = confuse(f18); | 854 x18 = confuse(f18); |
735 l18 = confuse(f18); | 855 l18 = confuse(f18); |
736 } | 856 } |
737 | 857 |
738 Expect.isTrue(m18 is F18); | 858 Expect.isTrue(m18 is F18); |
739 Expect.isTrue(m18 is void Function(int y, {int x}) Function<B extends core.i
nt>(int x)); | 859 Expect.isTrue(m18 is void Function(int y, |
| 860 {int x}) Function<B extends core.int>(int x)); |
740 Expect.isTrue(confuse(m18) is F18); | 861 Expect.isTrue(confuse(m18) is F18); |
741 // In checked mode, verifies the type. | 862 // In checked mode, verifies the type. |
742 x18 = m18; | 863 x18 = m18; |
743 l18 = m18; | 864 l18 = m18; |
744 x18 = confuse(m18); | 865 x18 = confuse(m18); |
745 l18 = confuse(m18); | 866 l18 = confuse(m18); |
746 | |
747 } | 867 } |
748 | 868 |
749 /// void Function(int x1, [core.List<core.int> x]) Function<B extends core.int
>(int x) | 869 /// void Function(int x1, [core.List<core.int> x]) Function<B extends core.int
>(int x) |
750 void testF19() { | 870 void testF19() { |
751 Expect.isTrue(f19 is F19); | 871 Expect.isTrue(f19 is F19); |
752 Expect.isTrue(confuse(f19) is F19); | 872 Expect.isTrue(confuse(f19) is F19); |
753 // In checked mode, verifies the type. | 873 // In checked mode, verifies the type. |
754 void Function(int x1, [core.List<core.int> x]) Function<B extends core.int>(
int x) l19; | 874 void Function(int x1, [core.List<core.int> x]) Function<B extends core.int>( |
| 875 int x) l19; |
755 // The static function f19 sets `T` to `int`. | 876 // The static function f19 sets `T` to `int`. |
756 if (!tIsBool) { | 877 if (!tIsBool) { |
757 x19 = f19 as dynamic; | 878 x19 = f19 as dynamic; |
758 l19 = f19 as dynamic; | 879 l19 = f19 as dynamic; |
759 x19 = confuse(f19); | 880 x19 = confuse(f19); |
760 l19 = confuse(f19); | 881 l19 = confuse(f19); |
761 } | 882 } |
762 | 883 |
763 Expect.isTrue(m19 is F19); | 884 Expect.isTrue(m19 is F19); |
764 Expect.isTrue(m19 is void Function(int x1, [core.List<core.int> x]) Function
<B extends core.int>(int x)); | 885 Expect.isTrue(m19 is void Function(int x1, |
| 886 [core.List<core.int> x]) Function<B extends core.int>(int x)); |
765 Expect.isTrue(confuse(m19) is F19); | 887 Expect.isTrue(confuse(m19) is F19); |
766 // In checked mode, verifies the type. | 888 // In checked mode, verifies the type. |
767 x19 = m19; | 889 x19 = m19; |
768 l19 = m19; | 890 l19 = m19; |
769 x19 = confuse(m19); | 891 x19 = confuse(m19); |
770 l19 = confuse(m19); | 892 l19 = confuse(m19); |
771 | |
772 } | 893 } |
773 | 894 |
774 /// int Function<A>(List<T> x) Function<B extends core.int>(int x) | 895 /// int Function<A>(List<T> x) Function<B extends core.int>(int x) |
775 void testF20() { | 896 void testF20() { |
776 Expect.isTrue(f20 is F20); | 897 Expect.isTrue(f20 is F20); |
777 Expect.isTrue(confuse(f20) is F20); | 898 Expect.isTrue(confuse(f20) is F20); |
778 // In checked mode, verifies the type. | 899 // In checked mode, verifies the type. |
779 int Function<A>(List<T> x) Function<B extends core.int>(int x) l20; | 900 int Function<A>(List<T> x) Function<B extends core.int>(int x) l20; |
780 // The static function f20 sets `T` to `int`. | 901 // The static function f20 sets `T` to `int`. |
781 if (!tIsBool) { | 902 if (!tIsBool) { |
782 x20 = f20 as dynamic; | 903 x20 = f20 as dynamic; |
783 l20 = f20 as dynamic; | 904 l20 = f20 as dynamic; |
784 x20 = confuse(f20); | 905 x20 = confuse(f20); |
785 l20 = confuse(f20); | 906 l20 = confuse(f20); |
786 } | 907 } |
787 | 908 |
788 Expect.isTrue(m20 is F20); | 909 Expect.isTrue(m20 is F20); |
789 Expect.isTrue(m20 is int Function<A>(List<T> x) Function<B extends core.int>
(int x)); | 910 Expect.isTrue( |
| 911 m20 is int Function<A>(List<T> x) Function<B extends core.int>(int x)); |
790 Expect.isTrue(confuse(m20) is F20); | 912 Expect.isTrue(confuse(m20) is F20); |
791 // In checked mode, verifies the type. | 913 // In checked mode, verifies the type. |
792 x20 = m20; | 914 x20 = m20; |
793 l20 = m20; | 915 l20 = m20; |
794 x20 = confuse(m20); | 916 x20 = confuse(m20); |
795 l20 = confuse(m20); | 917 l20 = confuse(m20); |
796 if (!tIsBool) { | 918 if (!tIsBool) { |
797 Expect.isTrue(f20 is F20<int>); | 919 Expect.isTrue(f20 is F20<int>); |
798 Expect.isFalse(f20 is F20<bool>); | 920 Expect.isFalse(f20 is F20<bool>); |
799 Expect.isTrue(confuse(f20) is F20<int>); | 921 Expect.isTrue(confuse(f20) is F20<int>); |
800 Expect.isFalse(confuse(f20) is F20<bool>); | 922 Expect.isFalse(confuse(f20) is F20<bool>); |
801 Expect.equals(tIsDynamic, m20 is F20<bool>); | 923 Expect.equals(tIsDynamic, m20 is F20<bool>); |
802 Expect.equals(tIsDynamic, confuse(m20) is F20<bool>); | 924 Expect.equals(tIsDynamic, confuse(m20) is F20<bool>); |
803 } else { | 925 } else { |
804 if (inCheckedMode) { | 926 if (inCheckedMode) { |
805 Expect.throws(() { x20 = (f20 as dynamic); }); | 927 Expect.throws(() { |
806 Expect.throws(() { x20 = confuse(f20); }); | 928 x20 = (f20 as dynamic); |
| 929 }); |
| 930 Expect.throws(() { |
| 931 x20 = confuse(f20); |
| 932 }); |
807 int Function<A>(List<T> x) Function<B extends core.int>(int x) l20; | 933 int Function<A>(List<T> x) Function<B extends core.int>(int x) l20; |
808 Expect.throws(() { l20 = (f20 as dynamic); }); | 934 Expect.throws(() { |
809 Expect.throws(() { l20 = confuse(f20); }); | 935 l20 = (f20 as dynamic); |
| 936 }); |
| 937 Expect.throws(() { |
| 938 l20 = confuse(f20); |
| 939 }); |
810 } | 940 } |
811 int Function<A>(List<T> x) Function<B extends core.int>(int x) l20 = m20; | 941 int Function<A>(List<T> x) Function<B extends core.int>(int x) l20 = m20; |
812 // In checked mode, verifies the type. | 942 // In checked mode, verifies the type. |
813 x20 = m20; | 943 x20 = m20; |
814 x20 = confuse(m20); | 944 x20 = confuse(m20); |
815 } | 945 } |
816 } | 946 } |
817 | 947 |
818 /// core.List<core.int> Function<A>() Function<B extends core.int>(int x) | 948 /// core.List<core.int> Function<A>() Function<B extends core.int>(int x) |
819 void testF21() { | 949 void testF21() { |
820 Expect.isTrue(f21 is F21); | 950 Expect.isTrue(f21 is F21); |
821 Expect.isTrue(confuse(f21) is F21); | 951 Expect.isTrue(confuse(f21) is F21); |
822 // In checked mode, verifies the type. | 952 // In checked mode, verifies the type. |
823 core.List<core.int> Function<A>() Function<B extends core.int>(int x) l21; | 953 core.List<core.int> Function<A>() Function<B extends core.int>(int x) l21; |
824 // The static function f21 sets `T` to `int`. | 954 // The static function f21 sets `T` to `int`. |
825 if (!tIsBool) { | 955 if (!tIsBool) { |
826 x21 = f21 as dynamic; | 956 x21 = f21 as dynamic; |
827 l21 = f21 as dynamic; | 957 l21 = f21 as dynamic; |
828 x21 = confuse(f21); | 958 x21 = confuse(f21); |
829 l21 = confuse(f21); | 959 l21 = confuse(f21); |
830 } | 960 } |
831 | 961 |
832 Expect.isTrue(m21 is F21); | 962 Expect.isTrue(m21 is F21); |
833 Expect.isTrue(m21 is core.List<core.int> Function<A>() Function<B extends co
re.int>(int x)); | 963 Expect.isTrue(m21 is core |
| 964 .List<core.int> Function<A>() Function<B extends core.int>(int x)); |
834 Expect.isTrue(confuse(m21) is F21); | 965 Expect.isTrue(confuse(m21) is F21); |
835 // In checked mode, verifies the type. | 966 // In checked mode, verifies the type. |
836 x21 = m21; | 967 x21 = m21; |
837 l21 = m21; | 968 l21 = m21; |
838 x21 = confuse(m21); | 969 x21 = confuse(m21); |
839 l21 = confuse(m21); | 970 l21 = confuse(m21); |
840 | |
841 } | 971 } |
842 | 972 |
843 /// A Function<A>(A x) Function<B extends core.int>(int x) | 973 /// A Function<A>(A x) Function<B extends core.int>(int x) |
844 void testF22() { | 974 void testF22() { |
845 Expect.isTrue(f22 is F22); | 975 Expect.isTrue(f22 is F22); |
846 Expect.isTrue(confuse(f22) is F22); | 976 Expect.isTrue(confuse(f22) is F22); |
847 // In checked mode, verifies the type. | 977 // In checked mode, verifies the type. |
848 A Function<A>(A x) Function<B extends core.int>(int x) l22; | 978 A Function<A>(A x) Function<B extends core.int>(int x) l22; |
849 // The static function f22 sets `T` to `int`. | 979 // The static function f22 sets `T` to `int`. |
850 if (!tIsBool) { | 980 if (!tIsBool) { |
851 x22 = f22 as dynamic; | 981 x22 = f22 as dynamic; |
852 l22 = f22 as dynamic; | 982 l22 = f22 as dynamic; |
853 x22 = confuse(f22); | 983 x22 = confuse(f22); |
854 l22 = confuse(f22); | 984 l22 = confuse(f22); |
855 } | 985 } |
856 | 986 |
857 Expect.isTrue(m22 is F22); | 987 Expect.isTrue(m22 is F22); |
858 Expect.isTrue(m22 is A Function<A>(A x) Function<B extends core.int>(int x))
; | 988 Expect |
| 989 .isTrue(m22 is A Function<A>(A x) Function<B extends core.int>(int x)); |
859 Expect.isTrue(confuse(m22) is F22); | 990 Expect.isTrue(confuse(m22) is F22); |
860 // In checked mode, verifies the type. | 991 // In checked mode, verifies the type. |
861 x22 = m22; | 992 x22 = m22; |
862 l22 = m22; | 993 l22 = m22; |
863 x22 = confuse(m22); | 994 x22 = confuse(m22); |
864 l22 = confuse(m22); | 995 l22 = confuse(m22); |
865 | |
866 } | 996 } |
867 | |
868 | |
869 } | 997 } |
870 | 998 |
871 void main() { | 999 void main() { |
872 new U51().runTests(); | 1000 new U51().runTests(); |
873 new U51<int>(tIsInt: true).runTests(); | 1001 new U51<int>(tIsInt: true).runTests(); |
874 new U51<bool>(tIsBool: true).runTests(); | 1002 new U51<bool>(tIsBool: true).runTests(); |
875 } | 1003 } |
876 | |
OLD | NEW |