Chromium Code Reviews Chromium Code Reviews
Issue 52263003:
Implement least upper bound. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart| OLD | NEW |
|---|---|
| (Empty) | |
| 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 library subtype_test; | |
| 6 | |
| 7 import 'package:expect/expect.dart'; | |
| 8 import 'package:async_helper/async_helper.dart'; | |
| 9 import 'type_test_helper.dart'; | |
| 10 import '../../../sdk/lib/_internal/compiler/implementation/dart_types.dart'; | |
| 11 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dar t" | |
| 12 show Element, ClassElement; | |
| 13 import '../../../sdk/lib/_internal/compiler/implementation/util/util.dart' | |
| 14 show Link; | |
| 15 | |
| 16 void main() { | |
| 17 testInterface1(); | |
| 18 testInterface2(); | |
| 19 testGeneric(); | |
| 20 testMixin(); | |
| 21 testFunction(); | |
| 22 testTypeVariable(); | |
| 23 } | |
| 24 | |
| 25 void testInterface1() { | |
| 26 asyncTest(() => TypeEnvironment.create(r""" | |
| 27 class A {} // A and B have equal depth. | |
| 28 class B {} | |
| 29 class I implements A, B {} | |
| 30 class J implements A, B {} | |
| 31 """).then((var env) { | |
| 32 | |
| 33 DartType Object_ = env['Object']; | |
| 34 DartType A = env['A']; | |
| 35 DartType B = env['B']; | |
| 36 DartType I = env['I']; | |
| 37 DartType J = env['J']; | |
| 38 | |
| 39 checkLub(DartType a, DartType b, DartType expect) { | |
| 40 DartType lub = env.computeLeastUpperBound(a, b); | |
| 41 Expect.equals(expect, lub, | |
| 42 'Unexpected lub($a,$b) = $lub, expected $expect.'); | |
| 43 } | |
| 44 | |
| 45 checkLub(Object_, Object_, Object_); | |
| 46 checkLub(Object_, A, Object_); | |
| 47 checkLub(Object_, B, Object_); | |
| 48 checkLub(Object_, I, Object_); | |
| 49 checkLub(Object_, J, Object_); | |
| 50 | |
| 51 checkLub(A, Object_, Object_); | |
| 52 checkLub(A, A, A); | |
| 53 checkLub(A, B, Object_); | |
| 54 checkLub(A, I, A); | |
| 55 checkLub(A, J, A); | |
| 56 | |
| 57 checkLub(B, Object_, Object_); | |
| 58 checkLub(B, A, Object_); | |
| 59 checkLub(B, B, B); | |
| 60 checkLub(B, I, B); | |
| 61 checkLub(B, J, B); | |
| 62 | |
| 63 checkLub(I, Object_, Object_); | |
| 64 checkLub(I, A, A); | |
| 65 checkLub(I, B, B); | |
| 66 checkLub(I, I, I); | |
| 67 checkLub(I, J, Object_); | |
| 68 | |
| 69 checkLub(J, Object_, Object_); | |
| 70 checkLub(J, A, A); | |
| 71 checkLub(J, B, B); | |
| 72 checkLub(J, I, Object_); | |
| 73 checkLub(J, J, J); | |
| 74 })); | |
| 75 } | |
| 76 | |
| 77 void testInterface2() { | |
| 78 asyncTest(() => TypeEnvironment.create(r""" | |
| 79 class A {} | |
| 80 class B {} | |
| 81 class C extends B {} // This makes C have higher depth than A. | |
| 82 class I implements A, C {} | |
| 83 class J implements A, C {} | |
| 84 """).then((var env) { | |
| 85 | |
| 86 DartType Object_ = env['Object']; | |
| 87 DartType A = env['A']; | |
| 88 DartType B = env['B']; | |
| 89 DartType C = env['C']; | |
| 90 DartType I = env['I']; | |
| 91 DartType J = env['J']; | |
| 92 | |
| 93 checkLub(DartType a, DartType b, DartType expectedLub) { | |
| 94 DartType lub = env.computeLeastUpperBound(a, b); | |
| 95 Expect.equals(expectedLub, lub, | |
| 96 'Unexpected lub($a,$b) = $lub, expected $expectedLub'); | |
| 97 } | |
| 98 | |
| 99 checkLub(Object_, Object_, Object_); | |
| 100 checkLub(Object_, A, Object_); | |
| 101 checkLub(Object_, B, Object_); | |
| 102 checkLub(Object_, C, Object_); | |
| 103 checkLub(Object_, I, Object_); | |
| 104 checkLub(Object_, J, Object_); | |
| 105 | |
| 106 checkLub(A, Object_, Object_); | |
| 107 checkLub(A, A, A); | |
| 108 checkLub(A, B, Object_); | |
| 109 checkLub(A, C, Object_); | |
| 110 checkLub(A, I, A); | |
| 111 checkLub(A, J, A); | |
| 112 | |
| 113 checkLub(B, Object_, Object_); | |
| 114 checkLub(B, A, Object_); | |
| 115 checkLub(B, B, B); | |
| 116 checkLub(B, C, B); | |
| 117 checkLub(B, I, B); | |
| 118 checkLub(B, J, B); | |
| 119 | |
| 120 checkLub(C, Object_, Object_); | |
| 121 checkLub(C, A, Object_); | |
| 122 checkLub(C, B, B); | |
| 123 checkLub(C, C, C); | |
| 124 checkLub(C, I, C); | |
| 125 checkLub(C, J, C); | |
| 126 | |
| 127 checkLub(I, Object_, Object_); | |
| 128 checkLub(I, A, A); | |
| 129 checkLub(I, B, B); | |
| 130 checkLub(I, C, C); | |
| 131 checkLub(I, I, I); | |
| 132 checkLub(I, J, C); | |
| 133 | |
| 134 checkLub(J, Object_, Object_); | |
| 135 checkLub(J, A, A); | |
| 136 checkLub(J, B, B); | |
| 137 checkLub(J, C, C); | |
| 138 checkLub(J, I, C); | |
| 139 checkLub(J, J, J); | |
| 140 })); | |
| 141 } | |
| 142 | |
| 143 void testGeneric() { | |
| 144 asyncTest(() => TypeEnvironment.create(r""" | |
| 145 class A {} | |
| 146 class B {} | |
| 147 class C extends B {} | |
| 148 class I<T> {} | |
| 149 """).then((var env) { | |
|
karlklose
2013/11/21 13:29:10
Remove 'var' (also in the other tests).
Johnni Winther
2013/11/25 13:58:27
Done.
| |
| 150 | |
| 151 DartType Object_ = env['Object']; | |
| 152 DartType A = env['A']; | |
| 153 DartType B = env['B']; | |
| 154 DartType C = env['C']; | |
| 155 ClassElement I = env.getElement('I'); | |
| 156 DartType I_A = instantiate(I, [A]); | |
| 157 DartType I_B = instantiate(I, [B]); | |
| 158 DartType I_C = instantiate(I, [C]); | |
| 159 | |
| 160 checkLub(DartType a, DartType b, DartType expectedLub) { | |
| 161 DartType lub = env.computeLeastUpperBound(a, b); | |
| 162 Expect.equals(expectedLub, lub, | |
| 163 'Unexpected lub($a,$b) = $lub, expected $expectedLub'); | |
| 164 } | |
| 165 | |
| 166 checkLub(Object_, Object_, Object_); | |
| 167 checkLub(Object_, A, Object_); | |
| 168 checkLub(Object_, B, Object_); | |
| 169 checkLub(Object_, C, Object_); | |
| 170 checkLub(Object_, I_A, Object_); | |
| 171 checkLub(Object_, I_B, Object_); | |
| 172 checkLub(Object_, I_C, Object_); | |
| 173 | |
| 174 checkLub(A, Object_, Object_); | |
| 175 checkLub(A, A, A); | |
| 176 checkLub(A, B, Object_); | |
| 177 checkLub(A, C, Object_); | |
| 178 checkLub(A, I_A, Object_); | |
| 179 checkLub(A, I_B, Object_); | |
| 180 checkLub(A, I_C, Object_); | |
| 181 | |
| 182 checkLub(B, Object_, Object_); | |
| 183 checkLub(B, A, Object_); | |
| 184 checkLub(B, B, B); | |
| 185 checkLub(B, C, B); | |
| 186 checkLub(B, I_A, Object_); | |
| 187 checkLub(B, I_B, Object_); | |
| 188 checkLub(B, I_C, Object_); | |
| 189 | |
| 190 checkLub(C, Object_, Object_); | |
| 191 checkLub(C, A, Object_); | |
| 192 checkLub(C, B, B); | |
| 193 checkLub(C, C, C); | |
| 194 checkLub(C, I_A, Object_); | |
| 195 checkLub(C, I_B, Object_); | |
| 196 checkLub(C, I_C, Object_); | |
| 197 | |
| 198 checkLub(I_A, Object_, Object_); | |
| 199 checkLub(I_A, A, Object_); | |
| 200 checkLub(I_A, B, Object_); | |
| 201 checkLub(I_A, C, Object_); | |
| 202 checkLub(I_A, I_A, I_A); | |
| 203 checkLub(I_A, I_B, Object_); | |
| 204 checkLub(I_A, I_C, Object_); | |
| 205 | |
| 206 checkLub(I_B, Object_, Object_); | |
| 207 checkLub(I_B, A, Object_); | |
| 208 checkLub(I_B, B, Object_); | |
| 209 checkLub(I_B, C, Object_); | |
| 210 checkLub(I_B, I_A, Object_); | |
| 211 checkLub(I_B, I_B, I_B); | |
| 212 checkLub(I_B, I_C, Object_); | |
| 213 | |
| 214 checkLub(I_C, Object_, Object_); | |
| 215 checkLub(I_C, A, Object_); | |
| 216 checkLub(I_C, B, Object_); | |
| 217 checkLub(I_C, C, Object_); | |
| 218 checkLub(I_C, I_A, Object_); | |
| 219 checkLub(I_C, I_B, Object_); | |
| 220 checkLub(I_C, I_C, I_C); | |
| 221 })); | |
| 222 } | |
| 223 | |
| 224 void testMixin() { | |
| 225 asyncTest(() => TypeEnvironment.create(r""" | |
| 226 class A {} | |
| 227 class B {} | |
| 228 class C extends B {} | |
| 229 class D extends C {} // This makes D have higher depth than Object+A. | |
| 230 class I extends Object with A, B implements A, D {} | |
| 231 class I2 extends Object with A, B implements A, D {} | |
| 232 class J extends Object with B, A implements A, D {} | |
| 233 """).then((var env) { | |
| 234 | |
| 235 DartType Object_ = env['Object']; | |
| 236 DartType A = env['A']; | |
| 237 DartType B = env['B']; | |
| 238 DartType C = env['C']; | |
| 239 DartType D = env['D']; | |
| 240 DartType I = env['I']; | |
| 241 DartType I2 = env['I2']; | |
| 242 DartType J = env['J']; | |
| 243 | |
| 244 checkLub(DartType a, DartType b, DartType expectedLub) { | |
| 245 DartType lub = env.computeLeastUpperBound(a, b); | |
| 246 Expect.equals(expectedLub, lub, | |
| 247 'Unexpected lub($a,$b) = $lub, expected $expectedLub'); | |
| 248 } | |
| 249 | |
| 250 checkLub(Object_, Object_, Object_); | |
| 251 checkLub(Object_, A, Object_); | |
| 252 checkLub(Object_, B, Object_); | |
| 253 checkLub(Object_, C, Object_); | |
| 254 checkLub(Object_, D, Object_); | |
| 255 checkLub(Object_, I, Object_); | |
| 256 checkLub(Object_, I2, Object_); | |
| 257 checkLub(Object_, J, Object_); | |
| 258 | |
| 259 checkLub(A, Object_, Object_); | |
| 260 checkLub(A, A, A); | |
| 261 checkLub(A, B, Object_); | |
| 262 checkLub(A, C, Object_); | |
| 263 checkLub(A, D, Object_); | |
| 264 checkLub(A, I, A); | |
| 265 checkLub(A, I2, A); | |
| 266 checkLub(A, J, A); | |
| 267 | |
| 268 checkLub(B, Object_, Object_); | |
| 269 checkLub(B, A, Object_); | |
| 270 checkLub(B, B, B); | |
| 271 checkLub(B, C, B); | |
| 272 checkLub(B, D, B); | |
| 273 checkLub(B, I, B); | |
| 274 checkLub(B, I2, B); | |
| 275 checkLub(B, J, B); | |
| 276 | |
| 277 checkLub(C, Object_, Object_); | |
| 278 checkLub(C, A, Object_); | |
| 279 checkLub(C, B, B); | |
| 280 checkLub(C, C, C); | |
| 281 checkLub(C, D, C); | |
| 282 checkLub(C, I, C); | |
| 283 checkLub(C, I2, C); | |
| 284 checkLub(C, J, C); | |
| 285 | |
| 286 checkLub(D, Object_, Object_); | |
| 287 checkLub(D, A, Object_); | |
| 288 checkLub(D, B, B); | |
| 289 checkLub(D, C, C); | |
| 290 checkLub(D, D, D); | |
| 291 checkLub(D, I, D); | |
| 292 checkLub(D, I2, D); | |
| 293 checkLub(D, J, D); | |
| 294 | |
| 295 checkLub(I, Object_, Object_); | |
| 296 checkLub(I, A, A); | |
| 297 checkLub(I, B, B); | |
| 298 checkLub(I, C, C); | |
| 299 checkLub(I, D, D); | |
| 300 checkLub(I, I, I); | |
| 301 checkLub(I, I2, D); | |
| 302 checkLub(I, J, D); | |
| 303 | |
| 304 checkLub(I2, Object_, Object_); | |
| 305 checkLub(I2, A, A); | |
| 306 checkLub(I2, B, B); | |
| 307 checkLub(I2, C, C); | |
| 308 checkLub(I2, D, D); | |
| 309 checkLub(I2, I, D); | |
| 310 checkLub(I2, I2, I2); | |
| 311 checkLub(I2, J, D); | |
| 312 | |
| 313 checkLub(J, Object_, Object_); | |
| 314 checkLub(J, A, A); | |
| 315 checkLub(J, B, B); | |
| 316 checkLub(J, C, C); | |
| 317 checkLub(J, D, D); | |
| 318 checkLub(J, I, D); | |
| 319 checkLub(J, I2, D); | |
| 320 checkLub(J, J, J); | |
| 321 })); | |
| 322 } | |
| 323 | |
| 324 void testFunction() { | |
| 325 asyncTest(() => TypeEnvironment.create(r""" | |
| 326 class A {} | |
| 327 class B {} | |
| 328 class C extends B {} | |
| 329 | |
| 330 typedef dynamic__(); | |
| 331 typedef void void__(); | |
| 332 typedef A A__(); | |
| 333 typedef B B__(); | |
| 334 typedef C C__(); | |
| 335 | |
| 336 typedef void void__A_B(A a, B b); | |
| 337 typedef void void__A_C(A a, C b); | |
| 338 typedef void void__B_A(B a, A b); | |
| 339 typedef void void__B_C(B a, C b); | |
| 340 | |
| 341 typedef void void___B([B a]); | |
| 342 typedef void void___B_C([B a, C b]); | |
| 343 typedef void void___C_C([C a, C b]); | |
| 344 | |
| 345 typedef void void____B({B a}); | |
| 346 typedef void void____B_C({B a, C b}); | |
| 347 typedef void void____C_C({C a, C b}); | |
| 348 """).then((var env) { | |
| 349 | |
| 350 DartType Object_ = env['Object']; | |
| 351 DartType Function_ = env['Function']; | |
| 352 DartType dynamic__ = env['dynamic__']; | |
| 353 DartType void__ = env['void__']; | |
| 354 DartType A__ = env['A__']; | |
| 355 DartType B__ = env['B__']; | |
| 356 DartType C__ = env['C__']; | |
| 357 DartType void__A_B = env['void__A_B']; | |
| 358 DartType void__A_C = env['void__A_C']; | |
| 359 DartType void__B_A = env['void__B_A']; | |
| 360 DartType void__B_C = env['void__B_C']; | |
| 361 DartType void___B = env['void___B']; | |
| 362 DartType void___B_C = env['void___B_C']; | |
| 363 DartType void___C_C = env['void___C_C']; | |
| 364 DartType void____B = env['void____B']; | |
| 365 DartType void____B_C = env['void____B_C']; | |
| 366 DartType void____C_C = env['void____C_C']; | |
| 367 | |
| 368 // Types used only for checking results. | |
| 369 DartType void_ = env['void']; | |
| 370 DartType B = env['B']; | |
| 371 DartType C = env['C']; | |
| 372 FunctionType Object__ = env.functionType(Object_, []); | |
| 373 FunctionType void__Object_Object = | |
| 374 env.functionType(void_, [Object_, Object_]); | |
| 375 FunctionType void__Object_B = | |
| 376 env.functionType(void_, [Object_, B]); | |
| 377 FunctionType void__Object_C = | |
| 378 env.functionType(void_, [Object_, C]); | |
| 379 FunctionType void__B_Object = | |
| 380 env.functionType(void_, [B, Object_]); | |
| 381 | |
| 382 checkLub(DartType a, DartType b, DartType expectedLub) { | |
| 383 DartType lub = env.computeLeastUpperBound(a, b); | |
| 384 if (a != b) { | |
| 385 expectedLub = expectedLub.unalias(env.compiler); | |
| 386 lub = lub.unalias(env.compiler); | |
| 387 } | |
| 388 Expect.equals(expectedLub, lub, | |
| 389 'Unexpected lub(${a.unalias(env.compiler)},' | |
| 390 '${b.unalias(env.compiler)}) = ' | |
| 391 '${lub}, expected ${expectedLub}'); | |
| 392 } | |
| 393 | |
| 394 checkLub(Object_, Object_, Object_); | |
| 395 checkLub(Object_, Function_, Object_); | |
| 396 checkLub(Object_, dynamic__, Object_); | |
| 397 checkLub(Object_, void__, Object_); | |
| 398 checkLub(Object_, A__, Object_); | |
| 399 checkLub(Object_, B__, Object_); | |
| 400 checkLub(Object_, C__, Object_); | |
| 401 checkLub(Object_, void__A_B, Object_); | |
| 402 checkLub(Object_, void__A_C, Object_); | |
| 403 checkLub(Object_, void__B_A, Object_); | |
| 404 checkLub(Object_, void__B_C, Object_); | |
| 405 checkLub(Object_, void___B, Object_); | |
| 406 checkLub(Object_, void___B_C, Object_); | |
| 407 checkLub(Object_, void___C_C, Object_); | |
| 408 checkLub(Object_, void____B, Object_); | |
| 409 checkLub(Object_, void____B_C, Object_); | |
| 410 checkLub(Object_, void____C_C, Object_); | |
| 411 | |
| 412 checkLub(Function_, Object_, Object_); | |
| 413 checkLub(Function_, Function_, Function_); | |
| 414 checkLub(Function_, dynamic__, Function_); | |
| 415 checkLub(Function_, void__, Function_); | |
| 416 checkLub(Function_, A__, Function_); | |
| 417 checkLub(Function_, B__, Function_); | |
| 418 checkLub(Function_, C__, Function_); | |
| 419 checkLub(Function_, void__A_B, Function_); | |
| 420 checkLub(Function_, void__A_C, Function_); | |
| 421 checkLub(Function_, void__B_A, Function_); | |
| 422 checkLub(Function_, void__B_C, Function_); | |
| 423 checkLub(Function_, void___B, Function_); | |
| 424 checkLub(Function_, void___B_C, Function_); | |
| 425 checkLub(Function_, void___C_C, Function_); | |
| 426 checkLub(Function_, void____B, Function_); | |
| 427 checkLub(Function_, void____B_C, Function_); | |
| 428 checkLub(Function_, void____C_C, Function_); | |
| 429 | |
| 430 checkLub(dynamic__, Object_, Object_); | |
| 431 checkLub(dynamic__, Function_, Function_); | |
| 432 checkLub(dynamic__, dynamic__, dynamic__); | |
| 433 checkLub(dynamic__, void__, dynamic__); | |
| 434 checkLub(dynamic__, A__, dynamic__); | |
| 435 checkLub(dynamic__, B__, dynamic__); | |
| 436 checkLub(dynamic__, C__, dynamic__); | |
| 437 checkLub(dynamic__, void__A_B, Function_); | |
| 438 checkLub(dynamic__, void__A_C, Function_); | |
| 439 checkLub(dynamic__, void__B_A, Function_); | |
| 440 checkLub(dynamic__, void__B_C, Function_); | |
| 441 checkLub(dynamic__, void___B, dynamic__); | |
| 442 checkLub(dynamic__, void___B_C, dynamic__); | |
| 443 checkLub(dynamic__, void___C_C, dynamic__); | |
| 444 checkLub(dynamic__, void____B, dynamic__); | |
| 445 checkLub(dynamic__, void____B_C, dynamic__); | |
| 446 checkLub(dynamic__, void____C_C, dynamic__); | |
| 447 | |
| 448 checkLub(void__, Object_, Object_); | |
| 449 checkLub(void__, Function_, Function_); | |
| 450 checkLub(void__, dynamic__, dynamic__); | |
| 451 checkLub(void__, void__, void__); | |
| 452 checkLub(void__, A__, void__); | |
| 453 checkLub(void__, B__, void__); | |
| 454 checkLub(void__, C__, void__); | |
| 455 checkLub(void__, void__A_B, Function_); | |
| 456 checkLub(void__, void__A_C, Function_); | |
| 457 checkLub(void__, void__B_A, Function_); | |
| 458 checkLub(void__, void__B_C, Function_); | |
| 459 checkLub(void__, void___B, void__); | |
| 460 checkLub(void__, void___B_C, void__); | |
| 461 checkLub(void__, void___C_C, void__); | |
| 462 checkLub(void__, void____B, void__); | |
| 463 checkLub(void__, void____B_C, void__); | |
| 464 checkLub(void__, void____C_C, void__); | |
| 465 | |
| 466 checkLub(A__, Object_, Object_); | |
| 467 checkLub(A__, Function_, Function_); | |
| 468 checkLub(A__, dynamic__, dynamic__); | |
| 469 checkLub(A__, void__, void__); | |
| 470 checkLub(A__, A__, A__); | |
| 471 checkLub(A__, B__, Object__); | |
| 472 checkLub(A__, C__, Object__); | |
| 473 checkLub(A__, void__A_B, Function_); | |
| 474 checkLub(A__, void__A_C, Function_); | |
| 475 checkLub(A__, void__B_A, Function_); | |
| 476 checkLub(A__, void__B_C, Function_); | |
| 477 checkLub(A__, void___B, void__); | |
| 478 checkLub(A__, void___B_C, void__); | |
| 479 checkLub(A__, void___C_C, void__); | |
| 480 checkLub(A__, void____B, void__); | |
| 481 checkLub(A__, void____B_C, void__); | |
| 482 checkLub(A__, void____C_C, void__); | |
| 483 | |
| 484 checkLub(B__, Object_, Object_); | |
| 485 checkLub(B__, Function_, Function_); | |
| 486 checkLub(B__, dynamic__, dynamic__); | |
| 487 checkLub(B__, void__, void__); | |
| 488 checkLub(B__, A__, Object__); | |
| 489 checkLub(B__, B__, B__); | |
| 490 checkLub(B__, C__, B__); | |
| 491 checkLub(B__, void__A_B, Function_); | |
| 492 checkLub(B__, void__A_C, Function_); | |
| 493 checkLub(B__, void__B_A, Function_); | |
| 494 checkLub(B__, void__B_C, Function_); | |
| 495 checkLub(B__, void___B, void__); | |
| 496 checkLub(B__, void___B_C, void__); | |
| 497 checkLub(B__, void___C_C, void__); | |
| 498 checkLub(B__, void____B, void__); | |
| 499 checkLub(B__, void____B_C, void__); | |
| 500 checkLub(B__, void____C_C, void__); | |
| 501 | |
| 502 checkLub(C__, Object_, Object_); | |
| 503 checkLub(C__, Function_, Function_); | |
| 504 checkLub(C__, dynamic__, dynamic__); | |
| 505 checkLub(C__, void__, void__); | |
| 506 checkLub(C__, A__, Object__); | |
| 507 checkLub(C__, B__, B__); | |
| 508 checkLub(C__, C__, C__); | |
| 509 checkLub(C__, void__A_B, Function_); | |
| 510 checkLub(C__, void__A_C, Function_); | |
| 511 checkLub(C__, void__B_A, Function_); | |
| 512 checkLub(C__, void__B_C, Function_); | |
| 513 checkLub(C__, void___B, void__); | |
| 514 checkLub(C__, void___B_C, void__); | |
| 515 checkLub(C__, void___C_C, void__); | |
| 516 checkLub(C__, void____B, void__); | |
| 517 checkLub(C__, void____B_C, void__); | |
| 518 checkLub(C__, void____C_C, void__); | |
| 519 | |
| 520 checkLub(void__A_B, Object_, Object_); | |
| 521 checkLub(void__A_B, Function_, Function_); | |
| 522 checkLub(void__A_B, dynamic__, Function_); | |
| 523 checkLub(void__A_B, void__, Function_); | |
| 524 checkLub(void__A_B, A__, Function_); | |
| 525 checkLub(void__A_B, B__, Function_); | |
| 526 checkLub(void__A_B, C__, Function_); | |
| 527 checkLub(void__A_B, void__A_B, void__A_B); | |
| 528 checkLub(void__A_B, void__A_C, void__A_B); | |
| 529 checkLub(void__A_B, void__B_A, void__Object_Object); | |
| 530 checkLub(void__A_B, void__B_C, void__Object_B); | |
| 531 checkLub(void__A_B, void___B, Function_); | |
| 532 checkLub(void__A_B, void___B_C, Function_); | |
| 533 checkLub(void__A_B, void___C_C, Function_); | |
| 534 checkLub(void__A_B, void____B, Function_); | |
| 535 checkLub(void__A_B, void____B_C, Function_); | |
| 536 checkLub(void__A_B, void____C_C, Function_); | |
| 537 | |
| 538 checkLub(void__A_C, Object_, Object_); | |
| 539 checkLub(void__A_C, Function_, Function_); | |
| 540 checkLub(void__A_C, dynamic__, Function_); | |
| 541 checkLub(void__A_C, void__, Function_); | |
| 542 checkLub(void__A_C, A__, Function_); | |
| 543 checkLub(void__A_C, B__, Function_); | |
| 544 checkLub(void__A_C, C__, Function_); | |
| 545 checkLub(void__A_C, void__A_B, void__A_B); | |
| 546 checkLub(void__A_C, void__A_C, void__A_C); | |
| 547 checkLub(void__A_C, void__B_A, void__Object_Object); | |
| 548 checkLub(void__A_C, void__B_C, void__Object_C); | |
| 549 checkLub(void__A_C, void___B, Function_); | |
| 550 checkLub(void__A_C, void___B_C, Function_); | |
| 551 checkLub(void__A_C, void___C_C, Function_); | |
| 552 checkLub(void__A_C, void____B, Function_); | |
| 553 checkLub(void__A_C, void____B_C, Function_); | |
| 554 checkLub(void__A_C, void____C_C, Function_); | |
| 555 | |
| 556 checkLub(void__B_A, Object_, Object_); | |
| 557 checkLub(void__B_A, Function_, Function_); | |
| 558 checkLub(void__B_A, dynamic__, Function_); | |
| 559 checkLub(void__B_A, void__, Function_); | |
| 560 checkLub(void__B_A, A__, Function_); | |
| 561 checkLub(void__B_A, B__, Function_); | |
| 562 checkLub(void__B_A, C__, Function_); | |
| 563 checkLub(void__B_A, void__A_B, void__Object_Object); | |
| 564 checkLub(void__B_A, void__A_C, void__Object_Object); | |
| 565 checkLub(void__B_A, void__B_A, void__B_A); | |
| 566 checkLub(void__B_A, void__B_C, void__B_Object); | |
| 567 checkLub(void__B_A, void___B, Function_); | |
| 568 checkLub(void__B_A, void___B_C, Function_); | |
| 569 checkLub(void__B_A, void___C_C, Function_); | |
| 570 checkLub(void__B_A, void____B, Function_); | |
| 571 checkLub(void__B_A, void____B_C, Function_); | |
| 572 checkLub(void__B_A, void____C_C, Function_); | |
| 573 | |
| 574 checkLub(void__B_C, Object_, Object_); | |
| 575 checkLub(void__B_C, Function_, Function_); | |
| 576 checkLub(void__B_C, dynamic__, Function_); | |
| 577 checkLub(void__B_C, void__, Function_); | |
| 578 checkLub(void__B_C, A__, Function_); | |
| 579 checkLub(void__B_C, B__, Function_); | |
| 580 checkLub(void__B_C, C__, Function_); | |
| 581 checkLub(void__B_C, void__A_B, void__Object_B); | |
| 582 checkLub(void__B_C, void__A_C, void__Object_C); | |
| 583 checkLub(void__B_C, void__B_A, void__B_Object); | |
| 584 checkLub(void__B_C, void__B_C, void__B_C); | |
| 585 checkLub(void__B_C, void___B, Function_); | |
| 586 checkLub(void__B_C, void___B_C, Function_); | |
| 587 checkLub(void__B_C, void___C_C, Function_); | |
| 588 checkLub(void__B_C, void____B, Function_); | |
| 589 checkLub(void__B_C, void____B_C, Function_); | |
| 590 checkLub(void__B_C, void____C_C, Function_); | |
| 591 | |
| 592 checkLub(void___B, Object_, Object_); | |
| 593 checkLub(void___B, Function_, Function_); | |
| 594 checkLub(void___B, dynamic__, dynamic__); | |
| 595 checkLub(void___B, void__, void__); | |
| 596 checkLub(void___B, A__, void__); | |
| 597 checkLub(void___B, B__, void__); | |
| 598 checkLub(void___B, C__, void__); | |
| 599 checkLub(void___B, void__A_B, Function_); | |
| 600 checkLub(void___B, void__A_C, Function_); | |
| 601 checkLub(void___B, void__B_A, Function_); | |
| 602 checkLub(void___B, void__B_C, Function_); | |
| 603 checkLub(void___B, void___B, void___B); | |
| 604 checkLub(void___B, void___B_C, void___B); | |
| 605 checkLub(void___B, void___C_C, void___B); | |
| 606 checkLub(void___B, void____B, void__); | |
| 607 checkLub(void___B, void____B_C, void__); | |
| 608 checkLub(void___B, void____C_C, void__); | |
| 609 | |
| 610 checkLub(void___B_C, Object_, Object_); | |
| 611 checkLub(void___B_C, Function_, Function_); | |
| 612 checkLub(void___B_C, dynamic__, dynamic__); | |
| 613 checkLub(void___B_C, void__, void__); | |
| 614 checkLub(void___B_C, A__, void__); | |
| 615 checkLub(void___B_C, B__, void__); | |
| 616 checkLub(void___B_C, C__, void__); | |
| 617 checkLub(void___B_C, void__A_B, Function_); | |
| 618 checkLub(void___B_C, void__A_C, Function_); | |
| 619 checkLub(void___B_C, void__B_A, Function_); | |
| 620 checkLub(void___B_C, void__B_C, Function_); | |
| 621 checkLub(void___B_C, void___B, void___B); | |
| 622 checkLub(void___B_C, void___B_C, void___B_C); | |
| 623 checkLub(void___B_C, void___C_C, void___B_C); | |
| 624 checkLub(void___B_C, void____B, void__); | |
| 625 checkLub(void___B_C, void____B_C, void__); | |
| 626 checkLub(void___B_C, void____C_C, void__); | |
| 627 | |
| 628 checkLub(void___C_C, Object_, Object_); | |
| 629 checkLub(void___C_C, Function_, Function_); | |
| 630 checkLub(void___C_C, dynamic__, dynamic__); | |
| 631 checkLub(void___C_C, void__, void__); | |
| 632 checkLub(void___C_C, A__, void__); | |
| 633 checkLub(void___C_C, B__, void__); | |
| 634 checkLub(void___C_C, C__, void__); | |
| 635 checkLub(void___C_C, void__A_B, Function_); | |
| 636 checkLub(void___C_C, void__A_C, Function_); | |
| 637 checkLub(void___C_C, void__B_A, Function_); | |
| 638 checkLub(void___C_C, void__B_C, Function_); | |
| 639 checkLub(void___C_C, void___B, void___B); | |
| 640 checkLub(void___C_C, void___B_C, void___B_C); | |
| 641 checkLub(void___C_C, void___C_C, void___C_C); | |
| 642 checkLub(void___C_C, void____B, void__); | |
| 643 checkLub(void___C_C, void____B_C, void__); | |
| 644 checkLub(void___C_C, void____C_C, void__); | |
| 645 | |
| 646 checkLub(void____B, Object_, Object_); | |
| 647 checkLub(void____B, Function_, Function_); | |
| 648 checkLub(void____B, dynamic__, dynamic__); | |
| 649 checkLub(void____B, void__, void__); | |
| 650 checkLub(void____B, A__, void__); | |
| 651 checkLub(void____B, B__, void__); | |
| 652 checkLub(void____B, C__, void__); | |
| 653 checkLub(void____B, void__A_B, Function_); | |
| 654 checkLub(void____B, void__A_C, Function_); | |
| 655 checkLub(void____B, void__B_A, Function_); | |
| 656 checkLub(void____B, void__B_C, Function_); | |
| 657 checkLub(void____B, void___B, void__); | |
| 658 checkLub(void____B, void___B_C, void__); | |
| 659 checkLub(void____B, void___C_C, void__); | |
| 660 checkLub(void____B, void____B, void____B); | |
| 661 checkLub(void____B, void____B_C, void____B); | |
| 662 checkLub(void____B, void____C_C, void____B); | |
| 663 | |
| 664 checkLub(void____B_C, Object_, Object_); | |
| 665 checkLub(void____B_C, Function_, Function_); | |
| 666 checkLub(void____B_C, dynamic__, dynamic__); | |
| 667 checkLub(void____B_C, void__, void__); | |
| 668 checkLub(void____B_C, A__, void__); | |
| 669 checkLub(void____B_C, B__, void__); | |
| 670 checkLub(void____B_C, C__, void__); | |
| 671 checkLub(void____B_C, void__A_B, Function_); | |
| 672 checkLub(void____B_C, void__A_C, Function_); | |
| 673 checkLub(void____B_C, void__B_A, Function_); | |
| 674 checkLub(void____B_C, void__B_C, Function_); | |
| 675 checkLub(void____B_C, void___B, void__); | |
| 676 checkLub(void____B_C, void___B_C, void__); | |
| 677 checkLub(void____B_C, void___C_C, void__); | |
| 678 checkLub(void____B_C, void____B, void____B); | |
| 679 checkLub(void____B_C, void____B_C, void____B_C); | |
| 680 checkLub(void____B_C, void____C_C, void____B_C); | |
| 681 | |
| 682 checkLub(void____C_C, Object_, Object_); | |
| 683 checkLub(void____C_C, Function_, Function_); | |
| 684 checkLub(void____C_C, dynamic__, dynamic__); | |
| 685 checkLub(void____C_C, void__, void__); | |
| 686 checkLub(void____C_C, A__, void__); | |
| 687 checkLub(void____C_C, B__, void__); | |
| 688 checkLub(void____C_C, C__, void__); | |
| 689 checkLub(void____C_C, void__A_B, Function_); | |
| 690 checkLub(void____C_C, void__A_C, Function_); | |
| 691 checkLub(void____C_C, void__B_A, Function_); | |
| 692 checkLub(void____C_C, void__B_C, Function_); | |
| 693 checkLub(void____C_C, void___B, void__); | |
| 694 checkLub(void____C_C, void___B_C, void__); | |
| 695 checkLub(void____C_C, void___C_C, void__); | |
| 696 checkLub(void____C_C, void____B, void____B); | |
| 697 checkLub(void____C_C, void____B_C, void____B_C); | |
| 698 checkLub(void____C_C, void____C_C, void____C_C); | |
| 699 })); | |
| 700 } | |
| 701 | |
| 702 void testTypeVariable() { | |
| 703 asyncTest(() => TypeEnvironment.create(r""" | |
| 704 class A {} | |
| 705 class B {} | |
| 706 class C extends B {} | |
| 707 class I<S extends A, | |
| 708 T extends B, | |
| 709 U extends C, | |
| 710 V extends T, | |
| 711 W extends V, | |
| 712 X extends T> {} | |
| 713 """).then((var env) { | |
| 714 | |
| 715 // A B | |
| 716 // | / \ | |
| 717 // S T C | |
| 718 // / \ \ | |
| 719 // V X U | |
| 720 // / | |
| 721 // W | |
| 722 | |
| 723 DartType Object_ = env['Object']; | |
| 724 DartType A = env['A']; | |
| 725 DartType B = env['B']; | |
| 726 DartType C = env['C']; | |
| 727 ClassElement I = env.getElement('I'); | |
| 728 DartType S = I.typeVariables.head; | |
| 729 DartType T = I.typeVariables.tail.head; | |
| 730 DartType U = I.typeVariables.tail.tail.head; | |
| 731 DartType V = I.typeVariables.tail.tail.tail.head; | |
| 732 DartType W = I.typeVariables.tail.tail.tail.tail.head; | |
| 733 DartType X = I.typeVariables.tail.tail.tail.tail.tail.head; | |
| 734 | |
| 735 checkLub(DartType a, DartType b, DartType expectedLub) { | |
| 736 DartType lub = env.computeLeastUpperBound(a, b); | |
| 737 Expect.equals(expectedLub, lub, | |
| 738 'Unexpected lub($a,$b) = $lub, expected $expectedLub'); | |
| 739 } | |
| 740 | |
| 741 checkLub(Object_, Object_, Object_); | |
| 742 checkLub(Object_, A, Object_); | |
| 743 checkLub(Object_, B, Object_); | |
| 744 checkLub(Object_, C, Object_); | |
| 745 checkLub(Object_, S, Object_); | |
| 746 checkLub(Object_, T, Object_); | |
| 747 checkLub(Object_, U, Object_); | |
| 748 checkLub(Object_, V, Object_); | |
| 749 checkLub(Object_, W, Object_); | |
| 750 checkLub(Object_, X, Object_); | |
| 751 | |
| 752 checkLub(A, Object_, Object_); | |
| 753 checkLub(A, A, A); | |
| 754 checkLub(A, B, Object_); | |
| 755 checkLub(A, C, Object_); | |
| 756 checkLub(A, S, A); | |
| 757 checkLub(A, T, Object_); | |
| 758 checkLub(A, U, Object_); | |
| 759 checkLub(A, V, Object_); | |
| 760 checkLub(A, W, Object_); | |
| 761 checkLub(A, X, Object_); | |
| 762 | |
| 763 checkLub(B, Object_, Object_); | |
| 764 checkLub(B, A, Object_); | |
| 765 checkLub(B, B, B); | |
| 766 checkLub(B, C, B); | |
| 767 checkLub(B, S, Object_); | |
| 768 checkLub(B, T, B); | |
| 769 checkLub(B, U, B); | |
| 770 checkLub(B, V, B); | |
| 771 checkLub(B, W, B); | |
| 772 checkLub(B, X, B); | |
| 773 | |
| 774 checkLub(C, Object_, Object_); | |
| 775 checkLub(C, A, Object_); | |
| 776 checkLub(C, B, B); | |
| 777 checkLub(C, C, C); | |
| 778 checkLub(C, S, Object_); | |
| 779 checkLub(C, T, B); | |
| 780 checkLub(C, U, C); | |
| 781 checkLub(C, V, B); | |
| 782 checkLub(C, W, B); | |
| 783 checkLub(C, X, B); | |
| 784 | |
| 785 checkLub(S, Object_, Object_); | |
| 786 checkLub(S, A, A); | |
| 787 checkLub(S, B, Object_); | |
| 788 checkLub(S, C, Object_); | |
| 789 checkLub(S, S, S); | |
| 790 checkLub(S, T, Object_); | |
| 791 checkLub(S, U, Object_); | |
| 792 checkLub(S, V, Object_); | |
| 793 checkLub(S, W, Object_); | |
| 794 checkLub(S, X, Object_); | |
| 795 | |
| 796 checkLub(T, Object_, Object_); | |
| 797 checkLub(T, A, Object_); | |
| 798 checkLub(T, B, B); | |
| 799 checkLub(T, C, B); | |
| 800 checkLub(T, S, Object_); | |
| 801 checkLub(T, T, T); | |
| 802 checkLub(T, U, B); | |
| 803 checkLub(T, V, T); | |
| 804 checkLub(T, W, T); | |
| 805 checkLub(T, X, T); | |
| 806 | |
| 807 checkLub(U, Object_, Object_); | |
| 808 checkLub(U, A, Object_); | |
| 809 checkLub(U, B, B); | |
| 810 checkLub(U, C, C); | |
| 811 checkLub(U, S, Object_); | |
| 812 checkLub(U, T, B); | |
| 813 checkLub(U, U, U); | |
| 814 checkLub(U, V, B); | |
| 815 checkLub(U, W, B); | |
| 816 checkLub(U, X, B); | |
| 817 | |
| 818 checkLub(V, Object_, Object_); | |
| 819 checkLub(V, A, Object_); | |
| 820 checkLub(V, B, B); | |
| 821 checkLub(V, C, B); | |
| 822 checkLub(V, S, Object_); | |
| 823 checkLub(V, T, T); | |
| 824 checkLub(V, U, B); | |
| 825 checkLub(V, V, V); | |
| 826 checkLub(V, W, V); | |
| 827 checkLub(V, X, T); | |
| 828 | |
| 829 checkLub(W, Object_, Object_); | |
| 830 checkLub(W, A, Object_); | |
| 831 checkLub(W, B, B); | |
| 832 checkLub(W, C, B); | |
| 833 checkLub(W, S, Object_); | |
| 834 checkLub(W, T, T); | |
| 835 checkLub(W, U, B); | |
| 836 checkLub(W, V, V); | |
| 837 checkLub(W, W, W); | |
| 838 checkLub(W, X, T); | |
| 839 | |
| 840 checkLub(X, Object_, Object_); | |
| 841 checkLub(X, A, Object_); | |
| 842 checkLub(X, B, B); | |
| 843 checkLub(X, C, B); | |
| 844 checkLub(X, S, Object_); | |
| 845 checkLub(X, T, T); | |
| 846 checkLub(X, U, B); | |
| 847 checkLub(X, V, T); | |
| 848 checkLub(X, W, T); | |
| 849 checkLub(X, X, X); | |
| 850 })); | |
| 851 } | |
| 852 | |
| 853 | |
| OLD | NEW |
