pkg/front_end/testcases/unified_collections/set_add_all_nnbd.dart.weak.modular.expect

library /*isNonNullableByDefault*/;
import self as self;
import "dart:core" as core;
import "dart:collection" as col;
import "dart:_internal" as _in;

static method useAddAll() → void {
  dynamic dynamicSet1 = block {
    final core::Set<core::int> #t1 = col::LinkedHashSet::•<core::int>();
    #t1.{core::Set::add}{Invariant}(0){(core::int) → core::bool};
    #t1.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
    #t1.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
  } =>#t1;
  dynamic dynamicSet2 = block {
    final core::Set<core::num> #t2 = col::LinkedHashSet::•<core::num>();
    #t2.{core::Set::add}{Invariant}(3){(core::num) → core::bool};
    #t2.{core::Set::add}{Invariant}(4){(core::num) → core::bool};
    #t2.{core::Set::add}{Invariant}(5){(core::num) → core::bool};
  } =>#t2;
  dynamic dynamicSet3 = block {
    final core::Set<core::int?> #t3 = col::LinkedHashSet::•<core::int?>();
    #t3.{core::Set::add}{Invariant}(6){(core::int?) → core::bool};
    #t3.{core::Set::add}{Invariant}(7){(core::int?) → core::bool};
    #t3.{core::Set::add}{Invariant}(8){(core::int?) → core::bool};
  } =>#t3;
  core::Iterable<core::int> iterableIntSet = block {
    final core::Set<core::int> #t4 = col::LinkedHashSet::•<core::int>();
    #t4.{core::Set::add}{Invariant}(9){(core::int) → core::bool};
    #t4.{core::Set::add}{Invariant}(10){(core::int) → core::bool};
    #t4.{core::Set::add}{Invariant}(11){(core::int) → core::bool};
  } =>#t4;
  core::Set<core::int> intSet = block {
    final core::Set<core::int> #t5 = col::LinkedHashSet::•<core::int>();
    #t5.{core::Set::add}{Invariant}(12){(core::int) → core::bool};
    #t5.{core::Set::add}{Invariant}(13){(core::int) → core::bool};
    #t5.{core::Set::add}{Invariant}(14){(core::int) → core::bool};
  } =>#t5;
  core::Set<core::int> set1 = block {
    final core::Set<core::int> #t6 = col::LinkedHashSet::•<core::int>();
    for (final has-declared-initializer dynamic #t7 in dynamicSet1 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::int #t8 = #t7 as{TypeError,ForNonNullableByDefault} core::int;
      #t6.{core::Set::add}{Invariant}(#t8){(core::int) → core::bool};
    }
    for (final has-declared-initializer dynamic #t9 in dynamicSet2 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::int #t10 = #t9 as{TypeError,ForNonNullableByDefault} core::int;
      #t6.{core::Set::add}{Invariant}(#t10){(core::int) → core::bool};
    }
    for (final has-declared-initializer dynamic #t11 in dynamicSet3 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::int #t12 = #t11 as{TypeError,ForNonNullableByDefault} core::int;
      #t6.{core::Set::add}{Invariant}(#t12){(core::int) → core::bool};
    }
    #t6.{core::Set::addAll}{Invariant}(iterableIntSet){(core::Iterable<core::int>) → void};
    #t6.{core::Set::addAll}{Invariant}(intSet){(core::Iterable<core::int>) → void};
  } =>#t6;
  self::expect(core::List::generate<core::int>(15, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<core::int>}, set1);
  core::Set<core::num> set2 = block {
    final core::Set<core::num> #t13 = col::LinkedHashSet::•<core::num>();
    for (final has-declared-initializer dynamic #t14 in dynamicSet1 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::num #t15 = #t14 as{TypeError,ForNonNullableByDefault} core::num;
      #t13.{core::Set::add}{Invariant}(#t15){(core::num) → core::bool};
    }
    for (final has-declared-initializer dynamic #t16 in dynamicSet2 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::num #t17 = #t16 as{TypeError,ForNonNullableByDefault} core::num;
      #t13.{core::Set::add}{Invariant}(#t17){(core::num) → core::bool};
    }
    for (final has-declared-initializer dynamic #t18 in dynamicSet3 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::num #t19 = #t18 as{TypeError,ForNonNullableByDefault} core::num;
      #t13.{core::Set::add}{Invariant}(#t19){(core::num) → core::bool};
    }
    #t13.{core::Set::addAll}{Invariant}(iterableIntSet){(core::Iterable<core::num>) → void};
    #t13.{core::Set::addAll}{Invariant}(intSet){(core::Iterable<core::num>) → void};
  } =>#t13;
  self::expect(core::List::generate<core::num>(15, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<core::num>}, set2);
  core::Set<core::int> set3 = block {
    final core::Set<core::int> #t20 = col::LinkedHashSet::•<core::int>();
    for (final has-declared-initializer dynamic #t21 in dynamicSet1 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::int #t22 = #t21 as{TypeError,ForNonNullableByDefault} core::int;
      #t20.{core::Set::add}{Invariant}(#t22){(core::int) → core::bool};
    }
    for (final has-declared-initializer dynamic #t23 in dynamicSet2 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::int #t24 = #t23 as{TypeError,ForNonNullableByDefault} core::int;
      #t20.{core::Set::add}{Invariant}(#t24){(core::int) → core::bool};
    }
    for (final has-declared-initializer dynamic #t25 in dynamicSet3 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
      final core::int #t26 = #t25 as{TypeError,ForNonNullableByDefault} core::int;
      #t20.{core::Set::add}{Invariant}(#t26){(core::int) → core::bool};
    }
    #t20.{core::Set::addAll}{Invariant}(iterableIntSet){(core::Iterable<core::int>) → void};
    #t20.{core::Set::addAll}{Invariant}(intSet){(core::Iterable<core::int>) → void};
  } =>#t20;
  self::expect(core::List::generate<core::int>(15, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<core::int>}, set3);
  core::Set<dynamic> set4 = block {
    final core::Set<dynamic> #t27 = col::LinkedHashSet::of<dynamic>(dynamicSet1 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>);
    #t27.{core::Set::addAll}{Invariant}(dynamicSet2 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
    #t27.{core::Set::addAll}{Invariant}(dynamicSet3 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
    #t27.{core::Set::addAll}{Invariant}(iterableIntSet){(core::Iterable<dynamic>) → void};
    #t27.{core::Set::addAll}{Invariant}(intSet){(core::Iterable<dynamic>) → void};
  } =>#t27;
  self::expect(core::List::generate<dynamic>(15, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<dynamic>}, set4);
  {
    core::Set<core::int> intSet1 = block {
      final core::Set<core::int> #t28 = col::LinkedHashSet::•<core::int>();
      #t28.{core::Set::add}{Invariant}(0){(core::int) → core::bool};
      #t28.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
      #t28.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
    } =>#t28;
    core::Set<core::int> intSet2 = block {
      final core::Set<core::int> #t29 = col::LinkedHashSet::•<core::int>();
      #t29.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
      #t29.{core::Set::add}{Invariant}(4){(core::int) → core::bool};
      #t29.{core::Set::add}{Invariant}(5){(core::int) → core::bool};
    } =>#t29;
    core::Set<core::int> set = block {
      final core::Set<core::int> #t30 = col::LinkedHashSet::of<core::int>(intSet1);
      #t30.{core::Set::addAll}{Invariant}(intSet2){(core::Iterable<core::int>) → void};
    } =>#t30;
    self::expect(core::List::generate<core::int>(6, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<core::int>}, set);
  }
}
static method useAddAllNullable() → void {
  dynamic dynamicSet1 = block {
    final core::Set<core::int> #t31 = col::LinkedHashSet::•<core::int>();
    #t31.{core::Set::add}{Invariant}(0){(core::int) → core::bool};
    #t31.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
    #t31.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
  } =>#t31;
  dynamic dynamicSet2 = block {
    final core::Set<core::num> #t32 = col::LinkedHashSet::•<core::num>();
    #t32.{core::Set::add}{Invariant}(3){(core::num) → core::bool};
    #t32.{core::Set::add}{Invariant}(4){(core::num) → core::bool};
    #t32.{core::Set::add}{Invariant}(5){(core::num) → core::bool};
  } =>#t32;
  dynamic dynamicSet3 = block {
    final core::Set<core::int?> #t33 = col::LinkedHashSet::•<core::int?>();
    #t33.{core::Set::add}{Invariant}(6){(core::int?) → core::bool};
    #t33.{core::Set::add}{Invariant}(7){(core::int?) → core::bool};
    #t33.{core::Set::add}{Invariant}(8){(core::int?) → core::bool};
  } =>#t33;
  core::Iterable<core::int>? iterableIntSet = true ?{core::Set<core::int>?} block {
    final core::Set<core::int> #t34 = col::LinkedHashSet::•<core::int>();
    #t34.{core::Set::add}{Invariant}(9){(core::int) → core::bool};
    #t34.{core::Set::add}{Invariant}(10){(core::int) → core::bool};
    #t34.{core::Set::add}{Invariant}(11){(core::int) → core::bool};
  } =>#t34 : null;
  core::Set<core::int>? intSet = true ?{core::Set<core::int>?} block {
    final core::Set<core::int> #t35 = col::LinkedHashSet::•<core::int>();
    #t35.{core::Set::add}{Invariant}(12){(core::int) → core::bool};
    #t35.{core::Set::add}{Invariant}(13){(core::int) → core::bool};
    #t35.{core::Set::add}{Invariant}(14){(core::int) → core::bool};
  } =>#t35 : null;
  core::Set<core::int> set1 = block {
    final core::Set<core::int> #t36 = col::LinkedHashSet::•<core::int>();
    final core::Iterable<dynamic>? #t37 = dynamicSet1 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t37 == null))
      for (final has-declared-initializer dynamic #t38 in #t37{core::Iterable<dynamic>}) {
        final core::int #t39 = #t38 as{TypeError,ForNonNullableByDefault} core::int;
        #t36.{core::Set::add}{Invariant}(#t39){(core::int) → core::bool};
      }
    final core::Iterable<dynamic>? #t40 = dynamicSet2 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t40 == null))
      for (final has-declared-initializer dynamic #t41 in #t40{core::Iterable<dynamic>}) {
        final core::int #t42 = #t41 as{TypeError,ForNonNullableByDefault} core::int;
        #t36.{core::Set::add}{Invariant}(#t42){(core::int) → core::bool};
      }
    final core::Iterable<dynamic>? #t43 = dynamicSet3 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t43 == null))
      for (final has-declared-initializer dynamic #t44 in #t43{core::Iterable<dynamic>}) {
        final core::int #t45 = #t44 as{TypeError,ForNonNullableByDefault} core::int;
        #t36.{core::Set::add}{Invariant}(#t45){(core::int) → core::bool};
      }
    final core::Iterable<core::int>? #t46 = iterableIntSet;
    if(!(#t46 == null))
      #t36.{core::Set::addAll}{Invariant}(#t46{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
    final core::Iterable<core::int>? #t47 = intSet;
    if(!(#t47 == null))
      #t36.{core::Set::addAll}{Invariant}(#t47{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
  } =>#t36;
  self::expect(core::List::generate<core::int>(15, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<core::int>}, set1);
  core::Set<core::num> set2 = block {
    final core::Set<core::num> #t48 = col::LinkedHashSet::•<core::num>();
    final core::Iterable<dynamic>? #t49 = dynamicSet1 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t49 == null))
      for (final has-declared-initializer dynamic #t50 in #t49{core::Iterable<dynamic>}) {
        final core::num #t51 = #t50 as{TypeError,ForNonNullableByDefault} core::num;
        #t48.{core::Set::add}{Invariant}(#t51){(core::num) → core::bool};
      }
    final core::Iterable<dynamic>? #t52 = dynamicSet2 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t52 == null))
      for (final has-declared-initializer dynamic #t53 in #t52{core::Iterable<dynamic>}) {
        final core::num #t54 = #t53 as{TypeError,ForNonNullableByDefault} core::num;
        #t48.{core::Set::add}{Invariant}(#t54){(core::num) → core::bool};
      }
    final core::Iterable<dynamic>? #t55 = dynamicSet3 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t55 == null))
      for (final has-declared-initializer dynamic #t56 in #t55{core::Iterable<dynamic>}) {
        final core::num #t57 = #t56 as{TypeError,ForNonNullableByDefault} core::num;
        #t48.{core::Set::add}{Invariant}(#t57){(core::num) → core::bool};
      }
    final core::Iterable<core::num>? #t58 = iterableIntSet;
    if(!(#t58 == null))
      #t48.{core::Set::addAll}{Invariant}(#t58{core::Iterable<core::num>}){(core::Iterable<core::num>) → void};
    final core::Iterable<core::num>? #t59 = intSet;
    if(!(#t59 == null))
      #t48.{core::Set::addAll}{Invariant}(#t59{core::Iterable<core::num>}){(core::Iterable<core::num>) → void};
  } =>#t48;
  self::expect(core::List::generate<core::num>(15, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<core::num>}, set2);
  core::Set<core::int> set3 = block {
    final core::Set<core::int> #t60 = col::LinkedHashSet::•<core::int>();
    final core::Iterable<dynamic>? #t61 = dynamicSet1 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t61 == null))
      for (final has-declared-initializer dynamic #t62 in #t61{core::Iterable<dynamic>}) {
        final core::int #t63 = #t62 as{TypeError,ForNonNullableByDefault} core::int;
        #t60.{core::Set::add}{Invariant}(#t63){(core::int) → core::bool};
      }
    final core::Iterable<dynamic>? #t64 = dynamicSet2 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t64 == null))
      for (final has-declared-initializer dynamic #t65 in #t64{core::Iterable<dynamic>}) {
        final core::int #t66 = #t65 as{TypeError,ForNonNullableByDefault} core::int;
        #t60.{core::Set::add}{Invariant}(#t66){(core::int) → core::bool};
      }
    final core::Iterable<dynamic>? #t67 = dynamicSet3 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t67 == null))
      for (final has-declared-initializer dynamic #t68 in #t67{core::Iterable<dynamic>}) {
        final core::int #t69 = #t68 as{TypeError,ForNonNullableByDefault} core::int;
        #t60.{core::Set::add}{Invariant}(#t69){(core::int) → core::bool};
      }
    final core::Iterable<core::int>? #t70 = iterableIntSet;
    if(!(#t70 == null))
      #t60.{core::Set::addAll}{Invariant}(#t70{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
    final core::Iterable<core::int>? #t71 = intSet;
    if(!(#t71 == null))
      #t60.{core::Set::addAll}{Invariant}(#t71{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
  } =>#t60;
  self::expect(core::List::generate<core::int>(15, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<core::int>}, set3);
  core::Set<dynamic> set4 = block {
    final core::Set<dynamic> #t72 = col::LinkedHashSet::•<dynamic>();
    final core::Iterable<dynamic>? #t73 = dynamicSet1 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t73 == null))
      #t72.{core::Set::addAll}{Invariant}(#t73{core::Iterable<dynamic>}){(core::Iterable<dynamic>) → void};
    final core::Iterable<dynamic>? #t74 = dynamicSet2 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t74 == null))
      #t72.{core::Set::addAll}{Invariant}(#t74{core::Iterable<dynamic>}){(core::Iterable<dynamic>) → void};
    final core::Iterable<dynamic>? #t75 = dynamicSet3 as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>?;
    if(!(#t75 == null))
      #t72.{core::Set::addAll}{Invariant}(#t75{core::Iterable<dynamic>}){(core::Iterable<dynamic>) → void};
    final core::Iterable<dynamic>? #t76 = iterableIntSet;
    if(!(#t76 == null))
      #t72.{core::Set::addAll}{Invariant}(#t76{core::Iterable<dynamic>}){(core::Iterable<dynamic>) → void};
    final core::Iterable<dynamic>? #t77 = intSet;
    if(!(#t77 == null))
      #t72.{core::Set::addAll}{Invariant}(#t77{core::Iterable<dynamic>}){(core::Iterable<dynamic>) → void};
  } =>#t72;
  self::expect(core::List::generate<dynamic>(15, (core::int i) → core::int => i).{core::Iterable::toSet}(){() → core::Set<dynamic>}, set4);
}
static method main() → dynamic {
  self::useAddAll();
  self::useAddAllNullable();
}
static method expect(core::Set<dynamic> set1, core::Set<dynamic> set2) → void {
  if(!(set1.{_in::EfficientLengthIterable::length}{core::int} =={core::num::==}{(core::Object) → core::bool} set2.{_in::EfficientLengthIterable::length}{core::int})) {
    throw "Unexpected length. Expected ${set1.{_in::EfficientLengthIterable::length}{core::int}}, actual ${set2.{_in::EfficientLengthIterable::length}{core::int}}.";
  }
  for (dynamic element in set1) {
    if(!set2.{core::Set::contains}(element){(core::Object?) → core::bool}) {
      throw "Element ${element} not found. Expected ${set1}, actual ${set2}.";
    }
  }
  if(!(set1.{core::Object::runtimeType}{core::Type}.{core::Type::toString}(){() → core::String} =={core::String::==}{(core::Object) → core::bool} set2.{core::Object::runtimeType}{core::Type}.{core::Type::toString}(){() → core::String})) {
    throw "Runtime time difference: ${set1.{core::Object::runtimeType}{core::Type}.{core::Type::toString}(){() → core::String}} vs ${set2.{core::Object::runtimeType}{core::Type}.{core::Type::toString}(){() → core::String}}";
  }
}