| // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file | |
| // for details. All rights reserved. Use of this source code is governed by a | |
| // BSD-style license that can be found in the LICENSE file. | |
| /*element: main:[null]*/ | |
| main() { | |
| simpleWhile(); | |
| whileNull(); | |
| whileNotNull(); | |
| whileNullUnreachable(); | |
| whileNotNullUnreachable(); | |
| whileUnion1(); | |
| whileUnion2(); | |
| whileUnion3(); | |
| whileIs(); | |
| whileIsNot(); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// Simple int based while loop. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: simpleWhile:[null]*/ | |
| simpleWhile() { | |
| var i = 0; | |
| while (i /*invoke: [subclass=JSPositiveInt]*/ < 10) { | |
| i = i /*invoke: [subclass=JSPositiveInt]*/ + 1; | |
| } | |
| i. /*invoke: [subclass=JSPositiveInt]*/ abs(); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with null test. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: whileNull:Value([null|exact=JSString], value: "null")*/ | |
| whileNull() { | |
| var o; | |
| while (o == null) { | |
| o = o. /*invoke: [null]*/ toString(); | |
| } | |
| return o; | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with not-null test. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: whileNotNull:[exact=JSString]*/ | |
| whileNotNull() { | |
| var o = ''; | |
| while (o != null) { | |
| o = o. /*invoke: [exact=JSString]*/ toString(); | |
| } | |
| return o; | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with null test with an unreachable body. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: whileNullUnreachable:[exact=JSString]*/ | |
| whileNullUnreachable() { | |
| var o = ''; | |
| while (o == null) { | |
| o = o. /*invoke: [null]*/ toString(); | |
| } | |
| return o; | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with not-null test with an unreachable body. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: whileNotNullUnreachable:[null]*/ | |
| whileNotNullUnreachable() { | |
| var o = null; | |
| while (o != null) { | |
| o = o. /*invoke: [empty]*/ toString(); | |
| } | |
| return o; | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with not-null test that mixes field accesses, passing the first | |
| /// object to the [_whileUnion1] method. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: Class1.:[exact=Class1]*/ | |
| class Class1 { | |
| /*element: Class1.field:[null|exact=Class2]*/ | |
| var field; | |
| } | |
| /*element: Class2.:[exact=Class2]*/ | |
| class Class2 { | |
| /*element: Class2.field:[null|exact=Class1]*/ | |
| var field; | |
| } | |
| /*element: _whileUnion1:Union([exact=Class1], [null|exact=Class2])*/ | |
| _whileUnion1(/*[exact=Class1]*/ o) { | |
| while (o != null) { | |
| o = o. /*Union([exact=Class1], [exact=Class2])*/ field; | |
| } | |
| return o; | |
| } | |
| /*element: whileUnion1:[null]*/ | |
| whileUnion1() { | |
| var c1 = new Class1(); | |
| var c2 = new Class2(); | |
| c1. /*update: [exact=Class1]*/ field = c2; | |
| c2. /*update: [exact=Class2]*/ field = c1; | |
| _whileUnion1(c1); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with not-null test that mixes field accesses, passing the second | |
| /// object to the [_whileUnion2] method. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: Class3.:[exact=Class3]*/ | |
| class Class3 { | |
| /*element: Class3.field:[null|exact=Class4]*/ | |
| var field; | |
| } | |
| /*element: Class4.:[exact=Class4]*/ | |
| class Class4 { | |
| /*element: Class4.field:[null|exact=Class3]*/ | |
| var field; | |
| } | |
| /*element: _whileUnion2:Union([exact=Class4], [null|exact=Class3])*/ | |
| _whileUnion2(/*[exact=Class4]*/ o) { | |
| while (o != null) { | |
| o = o. /*Union([exact=Class3], [exact=Class4])*/ field; | |
| } | |
| return o; | |
| } | |
| /*element: whileUnion2:[null]*/ | |
| whileUnion2() { | |
| var c1 = new Class3(); | |
| var c2 = new Class4(); | |
| c1. /*update: [exact=Class3]*/ field = c2; | |
| c2. /*update: [exact=Class4]*/ field = c1; | |
| _whileUnion2(c2); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with not-null test that mixes field accesses, passing both | |
| /// objects to the [_whileUnion3] method. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: Class5.:[exact=Class5]*/ | |
| class Class5 { | |
| /*element: Class5.field:[null|exact=Class6]*/ | |
| var field; | |
| } | |
| /*element: Class6.:[exact=Class6]*/ | |
| class Class6 { | |
| /*element: Class6.field:[null|exact=Class5]*/ | |
| var field; | |
| } | |
| /*element: _whileUnion3:Union([null|exact=Class5], [null|exact=Class6])*/ | |
| _whileUnion3(/*Union([exact=Class5], [exact=Class6])*/ o) { | |
| while (o != null) { | |
| o = o. /*Union([exact=Class5], [exact=Class6])*/ field; | |
| } | |
| return o; | |
| } | |
| /*element: whileUnion3:[null]*/ | |
| whileUnion3() { | |
| var c1 = new Class5(); | |
| var c2 = new Class6(); | |
| c1. /*update: [exact=Class5]*/ field = c2; | |
| c2. /*update: [exact=Class6]*/ field = c1; | |
| _whileUnion3(c1); | |
| _whileUnion3(c2); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with is test that mixes field accesses. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: Class7.:[exact=Class7]*/ | |
| class Class7 { | |
| /*element: Class7.field:[null|exact=Class8]*/ | |
| var field; | |
| } | |
| /*element: Class8.:[exact=Class8]*/ | |
| class Class8 { | |
| /*element: Class8.field:[null|exact=Class7]*/ | |
| var field; | |
| } | |
| /*element: _whileIs:Union([exact=Class7], [null|exact=Class8])*/ | |
| _whileIs(/*[exact=Class7]*/ o) { | |
| while (o is Class7) { | |
| o = o. /*[exact=Class7]*/ field; | |
| } | |
| return o; | |
| } | |
| /*element: whileIs:[null]*/ | |
| whileIs() { | |
| var c1 = new Class7(); | |
| var c2 = new Class8(); | |
| c1. /*update: [exact=Class7]*/ field = c2; | |
| c2. /*update: [exact=Class8]*/ field = c1; | |
| _whileIs(c1); | |
| } | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /// While loop with is-not test that mixes field accesses. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| /*element: Class9.:[exact=Class9]*/ | |
| class Class9 { | |
| /*element: Class9.field:[null|exact=Class10]*/ | |
| var field; | |
| } | |
| /*element: Class10.:[exact=Class10]*/ | |
| class Class10 { | |
| /*element: Class10.field:[null|exact=Class9]*/ | |
| var field; | |
| } | |
| /*element: _whileIsNot:Union([exact=Class9], [null|exact=Class10])*/ | |
| _whileIsNot(/*[exact=Class9]*/ o) { | |
| while (o is! Class10) { | |
| o = o. /*Union([exact=Class9], [null|exact=Class10])*/ field; | |
| } | |
| return o; | |
| } | |
| /*element: whileIsNot:[null]*/ | |
| whileIsNot() { | |
| var c1 = new Class9(); | |
| var c2 = new Class10(); | |
| c1. /*update: [exact=Class9]*/ field = c2; | |
| c2. /*update: [exact=Class10]*/ field = c1; | |
| _whileIsNot(c1); | |
| } |