library test;
//
// Problems in library:
//
// pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart:26:55: Error: A value of type 'A' can't be assigned to a variable of type 'int'.
//  - 'A' is from 'pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart'.
// Try changing the type of the variable.
//   for (i /*@error=ForInLoopElementTypeNotAssignable*/ in iterable) {}
//                                                       ^
//
// pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart:27:61: Error: A value of type 'A' can't be assigned to a variable of type 'int'.
//  - 'A' is from 'pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart'.
// Try changing the type of the variable.
//   await for (i /*@error=ForInLoopElementTypeNotAssignable*/ in stream) {}
//                                                             ^
//
import self as self;
import "dart:core" as core;
import "dart:async" as asy;

import "dart:async";

class A extends core::Object {
  synthetic constructor •() → self::A
    : super core::Object::•()
    ;
}
class B extends self::A {
  synthetic constructor •() → self::B
    : super self::A::•()
    ;
}
static method f<T extends core::Object = dynamic>() → self::f::T
  return null;
static method test() → dynamic async {
  core::Iterable<self::A> iterable;
  asy::Stream<self::A> stream;
  self::A a;
  self::B b;
  core::int i;
  for (final self::A #t1 in iterable) {
    a = #t1;
  }
  await for (final self::A #t2 in stream) {
    a = #t2;
  }
  for (final self::A #t3 in iterable) {
    b = #t3 as{TypeError} self::B;
  }
  await for (final self::A #t4 in stream) {
    b = #t4 as{TypeError} self::B;
  }
  for (final self::A #t5 in iterable) {
    i = let final<BottomType> #t6 = invalid-expression "pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart:26:55: Error: A value of type 'A' can't be assigned to a variable of type 'int'.
 - 'A' is from 'pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart'.
Try changing the type of the variable.
  for (i /*@error=ForInLoopElementTypeNotAssignable*/ in iterable) {}
                                                      ^" in #t5 as{TypeError} core::int;
  }
  await for (final self::A #t7 in stream) {
    i = let final<BottomType> #t8 = invalid-expression "pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart:27:61: Error: A value of type 'A' can't be assigned to a variable of type 'int'.
 - 'A' is from 'pkg/front_end/testcases/inference_new/for_each_outer_var_type.dart'.
Try changing the type of the variable.
  await for (i /*@error=ForInLoopElementTypeNotAssignable*/ in stream) {}
                                                            ^" in #t7 as{TypeError} core::int;
  }
  for (final self::A #t9 in self::f<core::Iterable<self::A>>()) {
    a = #t9;
  }
  await for (final self::A #t10 in self::f<asy::Stream<self::A>>()) {
    a = #t10;
  }
}
static method main() → dynamic {}
