| library /*isNonNullableByDefault*/; |
| // |
| // Problems in library: |
| // |
| // pkg/front_end/testcases/general/await_complex.dart:120:12: Error: A value of type 'FutureOr<bool>' can't be assigned to a variable of type 'bool'. |
| // assert(id(true), await func("message")); |
| // ^ |
| // |
| import self as self; |
| import "dart:core" as core; |
| import "dart:async" as asy; |
| import "dart:_internal" as _in; |
| |
| import "dart:async"; |
| |
| class C extends core::Object { |
| static field core::int staticField = 1; |
| field core::int field = 1; |
| synthetic constructor •() → self::C |
| : super core::Object::•() |
| ; |
| static get staticGetter() → core::int |
| return self::C::staticField; |
| static set staticSetter(dynamic val) → void { |
| self::C::staticField = val as{TypeError,ForDynamic,ForNonNullableByDefault} core::int; |
| } |
| static method staticFoo(core::int param) → core::int |
| return param; |
| get getter() → core::int |
| return this.{self::C::field}{core::int}; |
| set setter(dynamic val) → void { |
| this.{self::C::field} = val as{TypeError,ForDynamic,ForNonNullableByDefault} core::int; |
| } |
| method foo(core::int param) → core::int |
| return param; |
| } |
| static field core::int globalVariable = 1; |
| static final field core::bool assertStatementsEnabled = (() → core::bool { |
| try { |
| assert(false); |
| return false; |
| } |
| on core::Object catch(final core::Object _) { |
| return true; |
| } |
| })(){() → core::bool}; |
| static method topLevelFoo(core::int param) → core::int |
| return 1; |
| static get topLevelGetter() → core::int |
| return self::globalVariable; |
| static set topLevelSetter(dynamic val) → void { |
| self::globalVariable = val as{TypeError,ForDynamic,ForNonNullableByDefault} core::int; |
| } |
| static method dummy() → dynamic |
| return 1; |
| static method staticMembers() → dynamic /* futureValueType= dynamic */ /* originally async */ { |
| final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>(); |
| core::bool* :is_sync = false; |
| dynamic :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| core::int :async_temporary_0; |
| core::int :async_temporary_1; |
| core::int :async_temporary_2; |
| core::int :async_temporary_3; |
| core::int :async_temporary_4; |
| core::int :async_temporary_5; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L1: |
| { |
| :async_temporary_0 = self::C::staticField; |
| [yield] let dynamic #t1 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num a = _in::unsafeCast<core::int>(:async_temporary_0).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, a); |
| :async_temporary_1 = self::C::staticField = 1; |
| [yield] let dynamic #t2 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num f = _in::unsafeCast<core::int>(:async_temporary_1).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, f); |
| :async_temporary_2 = self::C::staticGetter; |
| [yield] let dynamic #t3 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num b = _in::unsafeCast<core::int>(:async_temporary_2).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, b); |
| :async_temporary_3 = self::C::staticSetter = 1; |
| [yield] let dynamic #t4 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num c = _in::unsafeCast<core::int>(:async_temporary_3).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, c); |
| :async_temporary_4 = self::C::staticFoo(2); |
| [yield] let dynamic #t5 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num d = _in::unsafeCast<core::int>(:async_temporary_4).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(3, d); |
| :async_temporary_5 = self::C::staticField.{core::num::+}(self::C::staticGetter){(core::num) → core::int}.{core::num::+}(self::C::staticSetter = 1){(core::num) → core::int}.{core::num::+}(self::C::staticFoo(1)){(core::num) → core::int}; |
| [yield] let dynamic #t6 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num e = _in::unsafeCast<core::int>(:async_temporary_5).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(5, e); |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method topLevelMembers() → dynamic /* futureValueType= dynamic */ /* originally async */ { |
| final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>(); |
| core::bool* :is_sync = false; |
| dynamic :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| core::int :async_temporary_0; |
| core::int :async_temporary_1; |
| core::int :async_temporary_2; |
| core::int :async_temporary_3; |
| core::int :async_temporary_4; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L2: |
| { |
| :async_temporary_0 = self::globalVariable; |
| [yield] let dynamic #t7 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num a = _in::unsafeCast<core::int>(:async_temporary_0).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, a); |
| :async_temporary_1 = self::topLevelGetter; |
| [yield] let dynamic #t8 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num b = _in::unsafeCast<core::int>(:async_temporary_1).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, b); |
| :async_temporary_2 = self::topLevelSetter = 1; |
| [yield] let dynamic #t9 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num c = _in::unsafeCast<core::int>(:async_temporary_2).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, c); |
| :async_temporary_3 = self::topLevelFoo(1); |
| [yield] let dynamic #t10 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num d = _in::unsafeCast<core::int>(:async_temporary_3).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, d); |
| :async_temporary_4 = self::globalVariable.{core::num::+}(self::topLevelGetter){(core::num) → core::int}.{core::num::+}(self::topLevelSetter = 1){(core::num) → core::int}.{core::num::+}(self::topLevelFoo(1)){(core::num) → core::int}; |
| [yield] let dynamic #t11 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num e = _in::unsafeCast<core::int>(:async_temporary_4).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(5, e); |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method instanceMembers() → dynamic /* futureValueType= dynamic */ /* originally async */ { |
| final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>(); |
| core::bool* :is_sync = false; |
| dynamic :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| core::int :async_temporary_0; |
| core::int :async_temporary_1; |
| core::int :async_temporary_2; |
| core::int :async_temporary_3; |
| core::int :async_temporary_4; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L3: |
| { |
| self::C inst = new self::C::•(); |
| :async_temporary_0 = inst.{self::C::field}{core::int}; |
| [yield] let dynamic #t12 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num a = _in::unsafeCast<core::int>(:async_temporary_0).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, a); |
| :async_temporary_1 = inst.{self::C::getter}{core::int}; |
| [yield] let dynamic #t13 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num b = _in::unsafeCast<core::int>(:async_temporary_1).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, b); |
| :async_temporary_2 = inst.{self::C::setter} = 1; |
| [yield] let dynamic #t14 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num c = _in::unsafeCast<core::int>(:async_temporary_2).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, c); |
| :async_temporary_3 = inst.{self::C::foo}(1){(core::int) → core::int}; |
| [yield] let dynamic #t15 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num d = _in::unsafeCast<core::int>(:async_temporary_3).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, d); |
| :async_temporary_4 = inst.{self::C::field}{core::int}.{core::num::+}(inst.{self::C::getter}{core::int}){(core::num) → core::int}.{core::num::+}(inst.{self::C::setter} = 1){(core::num) → core::int}.{core::num::+}(inst.{self::C::foo}(1){(core::int) → core::int}){(core::num) → core::int}; |
| [yield] let dynamic #t16 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num e = _in::unsafeCast<core::int>(:async_temporary_4).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(5, e); |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method others() → dynamic /* futureValueType= dynamic */ /* originally async */ { |
| final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>(); |
| core::bool* :is_sync = false; |
| dynamic :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| dynamic :async_temporary_0; |
| core::int :async_temporary_1; |
| core::int :async_temporary_2; |
| core::List<core::int> :async_temporary_3; |
| core::int :async_temporary_4; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L4: |
| { |
| :async_temporary_0 = self::globalVariable; |
| [yield] let dynamic #t17 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| :async_temporary_0 = "${_in::unsafeCast<core::int>(:async_temporary_0)} ${:result_or_exception} "; |
| [yield] let dynamic #t18 = asy::_awaitHelper("someString", :async_op_then, :async_op_error) in null; |
| core::String a = _in::unsafeCast<core::String>(:async_temporary_0).{core::String::+}(_in::unsafeCast<core::String>(:result_or_exception)){(core::String) → core::String}; |
| self::expect("1 1 someString", a); |
| self::C c = new self::C::•(); |
| :async_temporary_1 = c.{self::C::field}{core::int}; |
| [yield] let dynamic #t19 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num d = _in::unsafeCast<core::int>(:async_temporary_1).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| core::int cnt = 2; |
| core::List<core::int> b = core::_GrowableList::_literal3<core::int>(1, 2, 3); |
| :async_temporary_3 = b; |
| :async_temporary_2 = cnt; |
| [yield] let dynamic #t20 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| _in::unsafeCast<core::List<core::int>>(:async_temporary_3).{core::List::[]=}(_in::unsafeCast<core::int>(:async_temporary_2), :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::int){(core::int, core::int) → void}; |
| self::expect(1, b.{core::List::[]}(cnt){(core::int) → core::int}); |
| :async_temporary_4 = b.{core::List::[]}(0){(core::int) → core::int}; |
| [yield] let dynamic #t21 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| core::num e = _in::unsafeCast<core::int>(:async_temporary_4).{core::num::+}(:result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::num){(core::num) → core::num}; |
| self::expect(2, e); |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method conditionals() → dynamic /* futureValueType= dynamic */ /* originally async */ { |
| final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>(); |
| core::bool* :is_sync = false; |
| dynamic :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| dynamic :saved_try_context_var1; |
| core::bool :async_temporary_0; |
| dynamic :async_temporary_1; |
| dynamic :async_temporary_2; |
| dynamic :async_temporary_3; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L5: |
| { |
| core::bool a = false; |
| core::bool b = true; |
| :async_temporary_0 = (a || b) =={core::Object::==}{(core::Object) → core::bool} true; |
| if(_in::unsafeCast<core::bool>(:async_temporary_0)) |
| ; |
| else { |
| [yield] let dynamic #t22 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| :async_temporary_0 = :result_or_exception as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool =={core::Object::==}{(core::Object) → core::bool} true; |
| } |
| core::bool c = _in::unsafeCast<core::bool>(:async_temporary_0); |
| self::expect(true, c); |
| if(a || b) { |
| :async_temporary_1 = a; |
| } |
| else { |
| [yield] let dynamic #t23 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| :async_temporary_1 = :result_or_exception; |
| } |
| dynamic d = :async_temporary_1; |
| self::expect(false, d); |
| if(a is{ForNonNullableByDefault} core::int) { |
| [yield] let dynamic #t24 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| :async_temporary_2 = :result_or_exception; |
| } |
| else { |
| :async_temporary_2 = 2; |
| } |
| dynamic e = :async_temporary_2; |
| self::expect(2, e); |
| try { |
| if(a is{ForNonNullableByDefault} core::int) { |
| [yield] let dynamic #t25 = asy::_awaitHelper(self::dummy(), :async_op_then, :async_op_error) in null; |
| :async_temporary_3 = :result_or_exception; |
| } |
| else { |
| :async_temporary_3 = 2; |
| } |
| dynamic f = :async_temporary_3; |
| } |
| on core::Object catch(final core::Object e) { |
| } |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method asserts() → dynamic /* futureValueType= dynamic */ /* originally async */ { |
| final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>(); |
| core::bool* :is_sync = false; |
| dynamic :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| dynamic :saved_try_context_var1; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L6: |
| { |
| { |
| core::Iterator<<T extends core::Object? = dynamic>(T%) → FutureOr<T%>> :sync-for-iterator = core::_GrowableList::_literal2<<T extends core::Object? = dynamic>(T%) → FutureOr<T%>>(#C1, #C2).{core::Iterable::iterator}{core::Iterator<<T extends core::Object? = dynamic>(T%) → FutureOr<T%>>}; |
| for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) { |
| final <T extends core::Object? = dynamic>(T%) → FutureOr<T%>func = :sync-for-iterator.{core::Iterator::current}{<T extends core::Object? = dynamic>(T%) → FutureOr<T%>}; |
| { |
| assert { |
| [yield] let dynamic #t26 = asy::_awaitHelper(func<core::bool>(true){(core::bool) → FutureOr<core::bool>}, :async_op_then, :async_op_error) in null; |
| assert(_in::unsafeCast<core::bool>(:result_or_exception)); |
| } |
| assert { |
| if(invalid-expression "pkg/front_end/testcases/general/await_complex.dart:120:12: Error: A value of type 'FutureOr<bool>' can't be assigned to a variable of type 'bool'. |
| assert(id(true), await func(\"message\")); |
| ^" in self::id<core::bool>(true) as{TypeError,ForNonNullableByDefault} core::bool) |
| ; |
| else { |
| [yield] let dynamic #t27 = asy::_awaitHelper(func<core::String>("message"){(core::String) → FutureOr<core::String>}, :async_op_then, :async_op_error) in null; |
| assert(false, _in::unsafeCast<core::String>(:result_or_exception)); |
| } |
| } |
| assert { |
| [yield] let dynamic #t28 = asy::_awaitHelper(func<core::bool>(true){(core::bool) → FutureOr<core::bool>}, :async_op_then, :async_op_error) in null; |
| if(_in::unsafeCast<core::bool>(:result_or_exception)) |
| ; |
| else { |
| [yield] let dynamic #t29 = asy::_awaitHelper(func<core::String>("message"){(core::String) → FutureOr<core::String>}, :async_op_then, :async_op_error) in null; |
| assert(false, _in::unsafeCast<core::String>(:result_or_exception)); |
| } |
| } |
| try { |
| assert { |
| [yield] let dynamic #t30 = asy::_awaitHelper(func<core::bool>(false){(core::bool) → FutureOr<core::bool>}, :async_op_then, :async_op_error) in null; |
| if(_in::unsafeCast<core::bool>(:result_or_exception)) |
| ; |
| else { |
| [yield] let dynamic #t31 = asy::_awaitHelper(func<core::String>("message"){(core::String) → FutureOr<core::String>}, :async_op_then, :async_op_error) in null; |
| assert(false, _in::unsafeCast<core::String>(:result_or_exception)); |
| } |
| } |
| if(self::assertStatementsEnabled) |
| throw "Didn't throw"; |
| } |
| on core::AssertionError catch(final core::AssertionError e) { |
| self::expect("message", e.{core::AssertionError::message}{core::Object?}); |
| } |
| } |
| } |
| } |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method controlFlow() → dynamic /* futureValueType= dynamic */ /* originally async */ { |
| final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>(); |
| core::bool* :is_sync = false; |
| dynamic :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| dynamic :saved_try_context_var1; |
| dynamic :saved_try_context_var2; |
| dynamic :saved_try_context_var3; |
| dynamic :exception0; |
| dynamic :stack_trace0; |
| core::List<dynamic> :async_temporary_0; |
| core::List<dynamic> :async_temporary_1; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L7: |
| { |
| { |
| core::Iterator<<T extends core::Object? = dynamic>(T%) → FutureOr<T%>> :sync-for-iterator = core::_GrowableList::_literal2<<T extends core::Object? = dynamic>(T%) → FutureOr<T%>>(#C1, #C2).{core::Iterable::iterator}{core::Iterator<<T extends core::Object? = dynamic>(T%) → FutureOr<T%>>}; |
| for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) { |
| final <T extends core::Object? = dynamic>(T%) → FutureOr<T%>func = :sync-for-iterator.{core::Iterator::current}{<T extends core::Object? = dynamic>(T%) → FutureOr<T%>}; |
| { |
| core::int c = 0; |
| { |
| dynamic #t32 = true; |
| core::int #t33; |
| #L8: |
| while (true) { |
| core::int i; |
| if(#t32) { |
| #t32 = false; |
| [yield] let dynamic #t34 = asy::_awaitHelper(func<core::int>(0){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| i = _in::unsafeCast<core::int>(:result_or_exception); |
| } |
| else { |
| i = #t33; |
| [yield] let dynamic #t35 = asy::_awaitHelper(func<core::int>(let final core::int #t36 = i in let final core::int #t37 = i = #t36.{core::num::+}(1){(core::num) → core::int} in #t36){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| _in::unsafeCast<core::int>(:result_or_exception); |
| } |
| [yield] let dynamic #t38 = asy::_awaitHelper(func<core::bool>(i.{core::num::<}(5){(core::num) → core::bool}){(core::bool) → FutureOr<core::bool>}, :async_op_then, :async_op_error) in null; |
| if(_in::unsafeCast<core::bool>(:result_or_exception)) { |
| { |
| c = c.{core::num::+}(1){(core::num) → core::int}; |
| } |
| #t33 = i; |
| } |
| else |
| break #L8; |
| } |
| } |
| self::expect(5, c); |
| c = 0; |
| #L9: |
| while (true) { |
| [yield] let dynamic #t39 = asy::_awaitHelper(func<core::bool>(c.{core::num::<}(5){(core::num) → core::bool}){(core::bool) → FutureOr<core::bool>}, :async_op_then, :async_op_error) in null; |
| if(_in::unsafeCast<core::bool>(:result_or_exception)) |
| c = c.{core::num::+}(1){(core::num) → core::int}; |
| else |
| break #L9; |
| } |
| self::expect(5, c); |
| c = 0; |
| do { |
| c = c.{core::num::+}(1){(core::num) → core::int}; |
| [yield] let dynamic #t40 = asy::_awaitHelper(func<core::bool>(c.{core::num::<}(5){(core::num) → core::bool}){(core::bool) → FutureOr<core::bool>}, :async_op_then, :async_op_error) in null; |
| } |
| while (_in::unsafeCast<core::bool>(:result_or_exception)) |
| self::expect(5, c); |
| [yield] let dynamic #t41 = asy::_awaitHelper(func<core::bool>(c =={core::num::==}{(core::Object) → core::bool} 5){(core::bool) → FutureOr<core::bool>}, :async_op_then, :async_op_error) in null; |
| if(_in::unsafeCast<core::bool>(:result_or_exception)) { |
| self::expect(5, c); |
| } |
| else { |
| throw "unreachable"; |
| } |
| try { |
| [yield] let dynamic #t42 = asy::_awaitHelper(func<core::String>("string"){(core::String) → FutureOr<core::String>}, :async_op_then, :async_op_error) in null; |
| throw _in::unsafeCast<core::String>(:result_or_exception); |
| } |
| on core::String catch(no-exception-var) { |
| } |
| try { |
| [yield] let dynamic #t43 = asy::_awaitHelper(throw "string", :async_op_then, :async_op_error) in null; |
| let final Never #t44 = _in::unsafeCast<Never>(:result_or_exception) in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."); |
| } |
| on core::String catch(no-exception-var) { |
| } |
| try |
| try { |
| try |
| try { |
| throw "string"; |
| } |
| on core::Object catch(final core::Object e) { |
| self::expect("string", e); |
| [yield] let dynamic #t45 = asy::_awaitHelper(func<core::int>(0){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| self::expect(0, _in::unsafeCast<core::int>(:result_or_exception)); |
| rethrow; |
| } |
| finally { |
| [yield] let dynamic #t46 = asy::_awaitHelper(func<core::int>(0){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| self::expect(0, _in::unsafeCast<core::int>(:result_or_exception)); |
| } |
| } |
| on core::Object catch(final core::Object e) { |
| [yield] let dynamic #t47 = asy::_awaitHelper(func<core::int>(0){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| self::expect(0, _in::unsafeCast<core::int>(:result_or_exception)); |
| self::expect("string", e); |
| } |
| finally { |
| [yield] let dynamic #t48 = asy::_awaitHelper(func<core::int>(0){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| self::expect(0, _in::unsafeCast<core::int>(:result_or_exception)); |
| } |
| #L10: |
| { |
| [yield] let dynamic #t49 = asy::_awaitHelper(func<core::int>(2){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| switch(_in::unsafeCast<core::int>(:result_or_exception)) { |
| #L11: |
| case #C3: |
| { |
| break #L10; |
| } |
| #L12: |
| default: |
| { |
| throw "unreachable"; |
| } |
| } |
| } |
| [yield] let dynamic #t50 = asy::_awaitHelper((() → asy::Future<core::int> /* futureValueType= core::int */ /* originally async */ { |
| final asy::_Future<core::int> :async_future = new asy::_Future::•<core::int>(); |
| core::bool* :is_sync = false; |
| core::int? :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L13: |
| { |
| [yield] let dynamic #t51 = asy::_awaitHelper(func<core::int>(42){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| :return_value = _in::unsafeCast<core::int>(:result_or_exception); |
| break #L13; |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| })(){() → asy::Future<core::int>}, :async_op_then, :async_op_error) in null; |
| self::expect(42, _in::unsafeCast<core::int>(:result_or_exception)); |
| [yield] let dynamic #t52 = asy::_awaitHelper((() → asy::Future<core::int> /* futureValueType= core::int */ /* originally async */ { |
| final asy::_Future<core::int> :async_future = new asy::_Future::•<core::int>(); |
| core::bool* :is_sync = false; |
| FutureOr<core::int>? :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L14: |
| { |
| :return_value = func<core::int>(42){(core::int) → FutureOr<core::int>}; |
| break #L14; |
| } |
| asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| })(){() → asy::Future<core::int>}, :async_op_then, :async_op_error) in null; |
| self::expect(42, _in::unsafeCast<core::int>(:result_or_exception)); |
| function testStream1() → asy::Stream<core::int> /* originally async* */ { |
| asy::_AsyncStarStreamController<core::int>? :controller; |
| dynamic :controller_stream; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| dynamic :saved_try_context_var1; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try |
| try { |
| #L15: |
| { |
| [yield] let dynamic #t53 = asy::_awaitHelper(func<core::int>(42){(core::int) → FutureOr<core::int>}, :async_op_then, :async_op_error) in null; |
| if(:controller.{asy::_AsyncStarStreamController::add}(_in::unsafeCast<core::int>(:result_or_exception)){(core::int) → core::bool}) |
| return null; |
| else |
| [yield] null; |
| } |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| :controller.{asy::_AsyncStarStreamController::addError}(exception, stack_trace){(core::Object, core::StackTrace) → void}; |
| } |
| finally { |
| :controller.{asy::_AsyncStarStreamController::close}(){() → dynamic}; |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :controller = new asy::_AsyncStarStreamController::•<core::int>(:async_op); |
| :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<core::int>}; |
| return :controller_stream; |
| } |
| :async_temporary_0 = core::_GrowableList::_literal1<dynamic>(42); |
| [yield] let dynamic #t54 = asy::_awaitHelper(testStream1(){() → asy::Stream<core::int>}.{asy::Stream::toList}(){() → asy::Future<core::List<core::int>>}, :async_op_then, :async_op_error) in null; |
| self::expectList(_in::unsafeCast<core::List<dynamic>>(:async_temporary_0), _in::unsafeCast<core::List<core::int>>(:result_or_exception)); |
| function testStream2() → asy::Stream<core::int> /* originally async* */ { |
| asy::_AsyncStarStreamController<core::int>? :controller; |
| dynamic :controller_stream; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| dynamic :saved_try_context_var1; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try |
| try { |
| #L16: |
| { |
| [yield] let dynamic #t55 = asy::_awaitHelper(func<asy::Stream<core::int>>(self::intStream()){(asy::Stream<core::int>) → FutureOr<asy::Stream<core::int>>}, :async_op_then, :async_op_error) in null; |
| if(:controller.{asy::_AsyncStarStreamController::addStream}(_in::unsafeCast<asy::Stream<core::int>>(:result_or_exception)){(asy::Stream<core::int>) → core::bool}) |
| return null; |
| else |
| [yield] null; |
| } |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| :controller.{asy::_AsyncStarStreamController::addError}(exception, stack_trace){(core::Object, core::StackTrace) → void}; |
| } |
| finally { |
| :controller.{asy::_AsyncStarStreamController::close}(){() → dynamic}; |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :controller = new asy::_AsyncStarStreamController::•<core::int>(:async_op); |
| :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<core::int>}; |
| return :controller_stream; |
| } |
| :async_temporary_1 = core::_GrowableList::_literal1<dynamic>(42); |
| [yield] let dynamic #t56 = asy::_awaitHelper(testStream2(){() → asy::Stream<core::int>}.{asy::Stream::toList}(){() → asy::Future<core::List<core::int>>}, :async_op_then, :async_op_error) in null; |
| self::expectList(_in::unsafeCast<core::List<dynamic>>(:async_temporary_1), _in::unsafeCast<core::List<core::int>>(:result_or_exception)); |
| } |
| } |
| } |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method future<T extends core::Object? = dynamic>(self::future::T% value) → FutureOr<self::future::T%> /* futureValueType= self::future::T% */ /* originally async */ { |
| final asy::_Future<self::future::T%> :async_future = new asy::_Future::•<self::future::T%>(); |
| core::bool* :is_sync = false; |
| FutureOr<self::future::T%>? :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L17: |
| { |
| :return_value = value; |
| break #L17; |
| } |
| asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method id<T extends core::Object? = dynamic>(self::id::T% value) → FutureOr<self::id::T%> |
| return value; |
| static method intStream() → asy::Stream<core::int> /* originally async* */ { |
| asy::_AsyncStarStreamController<core::int>? :controller; |
| dynamic :controller_stream; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| dynamic :saved_try_context_var1; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try |
| try { |
| #L18: |
| { |
| if(:controller.{asy::_AsyncStarStreamController::add}(42){(core::int) → core::bool}) |
| return null; |
| else |
| [yield] null; |
| } |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| :controller.{asy::_AsyncStarStreamController::addError}(exception, stack_trace){(core::Object, core::StackTrace) → void}; |
| } |
| finally { |
| :controller.{asy::_AsyncStarStreamController::close}(){() → dynamic}; |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :controller = new asy::_AsyncStarStreamController::•<core::int>(:async_op); |
| :controller_stream = :controller.{asy::_AsyncStarStreamController::stream}{asy::Stream<core::int>}; |
| return :controller_stream; |
| } |
| static method main() → dynamic /* futureValueType= dynamic */ /* originally async */ { |
| final asy::_Future<dynamic> :async_future = new asy::_Future::•<dynamic>(); |
| core::bool* :is_sync = false; |
| dynamic :return_value; |
| (dynamic) → dynamic :async_op_then; |
| (core::Object, core::StackTrace) → dynamic :async_op_error; |
| core::int :await_jump_var = 0; |
| dynamic :await_ctx_var; |
| dynamic :saved_try_context_var0; |
| function :async_op(dynamic :result_or_exception, dynamic :stack_trace) → dynamic yielding |
| try { |
| #L19: |
| { |
| for (core::int i = 0; i.{core::num::<}(11){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int}) { |
| [yield] let dynamic #t57 = asy::_awaitHelper(self::staticMembers(), :async_op_then, :async_op_error) in null; |
| :result_or_exception; |
| [yield] let dynamic #t58 = asy::_awaitHelper(self::topLevelMembers(), :async_op_then, :async_op_error) in null; |
| :result_or_exception; |
| [yield] let dynamic #t59 = asy::_awaitHelper(self::instanceMembers(), :async_op_then, :async_op_error) in null; |
| :result_or_exception; |
| [yield] let dynamic #t60 = asy::_awaitHelper(self::conditionals(), :async_op_then, :async_op_error) in null; |
| :result_or_exception; |
| [yield] let dynamic #t61 = asy::_awaitHelper(self::others(), :async_op_then, :async_op_error) in null; |
| :result_or_exception; |
| [yield] let dynamic #t62 = asy::_awaitHelper(self::asserts(), :async_op_then, :async_op_error) in null; |
| :result_or_exception; |
| [yield] let dynamic #t63 = asy::_awaitHelper(self::controlFlow(), :async_op_then, :async_op_error) in null; |
| :result_or_exception; |
| } |
| } |
| asy::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync); |
| return; |
| } |
| on dynamic catch(dynamic exception, core::StackTrace stack_trace) { |
| asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync); |
| } |
| :async_op_then = asy::_asyncThenWrapperHelper(:async_op); |
| :async_op_error = asy::_asyncErrorWrapperHelper(:async_op); |
| :async_op(null, null){() → dynamic}; |
| :is_sync = true; |
| return :async_future; |
| } |
| static method expect(dynamic expected, dynamic actual) → dynamic { |
| if(!(expected =={core::Object::==}{(core::Object) → core::bool} actual)) |
| throw "Expected ${expected}, actual ${actual}"; |
| } |
| static method expectList(core::List<dynamic> expected, core::List<dynamic> actual) → dynamic { |
| if(!(expected.{core::List::length}{core::int} =={core::num::==}{(core::Object) → core::bool} actual.{core::List::length}{core::int})) { |
| throw "Expected ${expected}, actual ${actual}"; |
| } |
| for (core::int i = 0; i.{core::num::<}(expected.{core::List::length}{core::int}){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int}) { |
| self::expect(expected.{core::List::[]}(i){(core::int) → dynamic}, actual.{core::List::[]}(i){(core::int) → dynamic}); |
| } |
| } |
| |
| constants { |
| #C1 = static-tearoff self::id |
| #C2 = static-tearoff self::future |
| #C3 = 2 |
| } |