main = <No Member>;
library from "org-dartlang-test:///lib.dart" as lib {

  abstract class TestMixin<T extends dart.core::Object? = dynamic> extends dart.core::Object /*isMixinDeclaration*/  {
    method test(covariant-by-class dart.async::Future<lib::TestMixin::T%> fetch) → dart.async::Future<lib::TestMixin::T%> /* futureValueType= lib::TestMixin::T% */ /* originally async */ {
      final dart.async::_Future<lib::TestMixin::T%> :async_future = new dart.async::_Future::•<lib::TestMixin::T%>();
      dart.core::bool* :is_sync = false;
      FutureOr<lib::TestMixin::T%>? :return_value;
      (dynamic) → dynamic :async_op_then;
      (dart.core::Object, dart.core::StackTrace) → dynamic :async_op_error;
      dart.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 {
          #L1:
          {
            [yield] let dynamic #t1 = dart.async::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
            final lib::TestMixin::T% response = dart._internal::unsafeCast<lib::TestMixin::T%>(:result_or_exception);
            :return_value = response;
            break #L1;
          }
          dart.async::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
          return;
        }
        on dynamic catch(dynamic exception, dart.core::StackTrace stack_trace) {
          dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
        }
      :async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
      :async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
      :async_op(null, null){() → dynamic};
      :is_sync = true;
      return :async_future;
    }
  }
}
library from "org-dartlang-test:///main.dart" as main {

  import "org-dartlang-test:///lib.dart";

  abstract class _Class2&Object&TestMixin extends dart.core::Object implements lib::TestMixin<dart.core::String> /*isAnonymousMixin,isEliminatedMixin,hasConstConstructor*/  {
    const synthetic constructor •() → main::_Class2&Object&TestMixin
      : super dart.core::Object::•()
      ;
    method /* from org-dartlang-test:///lib.dart */ test(covariant-by-class dart.async::Future<dart.core::String> fetch) → dart.async::Future<dart.core::String> /* futureValueType= dart.core::String */ /* originally async */ {
      final dart.async::_Future<dart.core::String> :async_future = new dart.async::_Future::•<dart.core::String>();
      dart.core::bool* :is_sync = false;
      dart.core::String? :return_value;
      (dynamic) → dynamic :async_op_then;
      (dart.core::Object, dart.core::StackTrace) → dynamic :async_op_error;
      dart.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 {
          #L2:
          {
            [yield] let dynamic #t2 = dart.async::_awaitHelper(fetch, :async_op_then, :async_op_error) in null;
            final dart.core::String response = dart._internal::unsafeCast<dart.core::String>(:result_or_exception);
            :return_value = response;
            break #L2;
          }
          dart.async::_completeWithNoFutureOnAsyncReturn(:async_future, :return_value, :is_sync);
          return;
        }
        on dynamic catch(dynamic exception, dart.core::StackTrace stack_trace) {
          dart.async::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
        }
      :async_op_then = dart.async::_asyncThenWrapperHelper(:async_op);
      :async_op_error = dart.async::_asyncErrorWrapperHelper(:async_op);
      :async_op(null, null){() → dynamic};
      :is_sync = true;
      return :async_future;
    }
  }
  class Class2 extends main::_Class2&Object&TestMixin {
    synthetic constructor •() → main::Class2
      : super main::_Class2&Object&TestMixin::•()
      ;
  }
}