Version 2.18.0-265.0.dev

Merge commit '6b9bc2f575fe489587937eb2974dda84267fdf4f' into 'dev'
diff --git a/pkg/front_end/lib/src/fasta/kernel/collections.dart b/pkg/front_end/lib/src/fasta/kernel/collections.dart
index a11bbc7..ec4c2ff 100644
--- a/pkg/front_end/lib/src/fasta/kernel/collections.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/collections.dart
@@ -782,10 +782,15 @@
 /// [onConvertMapEntry] is called when a [ForMapEntry], [ForInMapEntry], or
 /// [IfMapEntry] is converted to a [ForElement], [ForInElement], or [IfElement],
 /// respectively.
-Expression convertToElement(MapLiteralEntry entry, InferenceHelper? helper,
-    void onConvertMapEntry(TreeNode from, TreeNode to)) {
+Expression convertToElement(
+  MapLiteralEntry entry,
+  InferenceHelper? helper,
+  void onConvertMapEntry(TreeNode from, TreeNode to), {
+  DartType? actualType,
+}) {
   if (entry is SpreadMapEntry) {
     return new SpreadElement(entry.expression, isNullAware: entry.isNullAware)
+      ..elementType = actualType
       ..fileOffset = entry.expression.fileOffset;
   }
   if (entry is IfMapEntry) {
diff --git a/pkg/front_end/lib/src/fasta/kernel/transform_collections.dart b/pkg/front_end/lib/src/fasta/kernel/transform_collections.dart
index ed6516b..d055140 100644
--- a/pkg/front_end/lib/src/fasta/kernel/transform_collections.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/transform_collections.dart
@@ -35,23 +35,30 @@
 class CollectionTransformer extends Transformer {
   final SourceLoader _loader;
   final TypeEnvironment _typeEnvironment;
+
   final Procedure _listAdd;
   late final FunctionType _listAddFunctionType;
   final Procedure _listAddAll;
   late final FunctionType _listAddAllFunctionType;
   final Procedure _listOf;
+
   final Procedure _setFactory;
   final Procedure _setAdd;
   late final FunctionType _setAddFunctionType;
   final Procedure _setAddAll;
   late final FunctionType _setAddAllFunctionType;
   final Procedure _setOf;
+
   final Procedure _mapEntries;
   final Procedure _mapPut;
   late final FunctionType _mapPutFunctionType;
   final Class _mapEntryClass;
   final Field _mapEntryKey;
   final Field _mapEntryValue;
+  final Procedure _mapAddAll;
+  late final FunctionType _mapAddAllFunctionType;
+  final Procedure _mapOf;
+
   final SourceLoaderDataForTesting? _dataForTesting;
 
   /// Library that contains the transformed nodes.
@@ -67,6 +74,13 @@
     return body.target as Procedure;
   }
 
+  static Procedure _findMapFactory(CoreTypes coreTypes, String name) {
+    Procedure factory = coreTypes.index.getProcedure('dart:core', 'Map', name);
+    RedirectingFactoryBody body =
+        factory.function.body as RedirectingFactoryBody;
+    return body.target as Procedure;
+  }
+
   CollectionTransformer(this._loader)
       : _typeEnvironment = _loader.typeInferenceEngine.typeSchemaEnvironment,
         _listAdd =
@@ -91,11 +105,15 @@
             _loader.coreTypes.index.getField('dart:core', 'MapEntry', 'key'),
         _mapEntryValue =
             _loader.coreTypes.index.getField('dart:core', 'MapEntry', 'value'),
+        _mapAddAll =
+            _loader.coreTypes.index.getProcedure('dart:core', 'Map', 'addAll'),
+        _mapOf = _findMapFactory(_loader.coreTypes, 'of'),
         _dataForTesting = _loader.dataForTesting {
     _listAddFunctionType = _listAdd.getterType as FunctionType;
     _listAddAllFunctionType = _listAddAll.getterType as FunctionType;
     _setAddFunctionType = _setAdd.getterType as FunctionType;
     _setAddAllFunctionType = _setAddAll.getterType as FunctionType;
+    _mapAddAllFunctionType = _mapAddAll.getterType as FunctionType;
     _mapPutFunctionType = _mapPut.getterType as FunctionType;
   }
 
@@ -424,28 +442,62 @@
     }
 
     // Translate entries in place up to the first control-flow entry, if any.
-    int i = 0;
-    for (; i < node.entries.length; ++i) {
-      if (node.entries[i] is ControlFlowMapEntry) break;
-      node.entries[i] = transform(node.entries[i])..parent = node;
+    int index = 0;
+    for (; index < node.entries.length; ++index) {
+      if (node.entries[index] is ControlFlowMapEntry) break;
+      node.entries[index] = transform(node.entries[index])..parent = node;
     }
 
     // If there were no control-flow entries we are done.
-    if (i == node.entries.length) return node;
+    if (index == node.entries.length) return node;
 
     // Build a block expression and create an empty map.
     InterfaceType receiverType = _typeEnvironment.mapType(
         node.keyType, node.valueType, _currentLibrary!.nonNullable);
-    VariableDeclaration result = _createVariable(
-        _createMapLiteral(node.fileOffset, node.keyType, node.valueType, []),
-        receiverType);
-    List<Statement> body = [result];
-    // Add all the entries up to the first control-flow entry.
-    for (int j = 0; j < i; ++j) {
-      _addNormalEntry(node.entries[j], receiverType, result, body);
+    VariableDeclaration? result;
+
+    if (index == 0 && node.entries[index] is SpreadMapEntry) {
+      SpreadMapEntry initialSpread = node.entries[index] as SpreadMapEntry;
+      final InterfaceType entryType = new InterfaceType(
+          _mapEntryClass,
+          _currentLibrary!.nonNullable,
+          <DartType>[node.keyType, node.valueType]);
+      final bool typeMatches = initialSpread.entryType != null &&
+          _typeEnvironment.isSubtypeOf(initialSpread.entryType!, entryType,
+              SubtypeCheckMode.withNullabilities);
+      if (typeMatches && !initialSpread.isNullAware) {
+        {
+          // Create a map of the initial spread element.
+          Expression value = transform(initialSpread.expression);
+          index++;
+          result = _createVariable(
+              new StaticInvocation(
+                  _mapOf,
+                  new Arguments([value], types: [node.keyType, node.valueType])
+                    ..fileOffset = node.fileOffset)
+                ..fileOffset = node.fileOffset,
+              receiverType);
+        }
+      }
     }
-    for (; i < node.entries.length; ++i) {
-      _translateEntry(node.entries[i], receiverType, node.keyType,
+
+    List<Statement>? body;
+    if (result == null) {
+      result = _createVariable(
+          _createMapLiteral(node.fileOffset, node.keyType, node.valueType, []),
+          receiverType);
+      body = [result];
+      // Add all the entries up to the first control-flow entry.
+      for (int j = 0; j < index; ++j) {
+        _addNormalEntry(node.entries[j], receiverType, result, body);
+      }
+    }
+
+    body ??= [result];
+
+    // Translate the elements starting with the first non-expression.
+    for (; index < node.entries.length; ++index) {
+      _translateEntry(node.entries[index], receiverType, node.keyType,
           node.valueType, result, body);
     }
 
@@ -574,27 +626,53 @@
         _typeEnvironment.isSubtypeOf(
             entry.entryType!, entryType, SubtypeCheckMode.withNullabilities);
 
-    // Null-aware spreads require testing the subexpression's value.
-    VariableDeclaration? temp;
-    if (entry.isNullAware) {
-      temp = _createVariable(
-          value,
-          _typeEnvironment.mapType(
-              typeMatches ? keyType : const DynamicType(),
-              typeMatches ? valueType : const DynamicType(),
-              _currentLibrary!.nullable));
-      body.add(temp);
-      value = _createNullCheckedVariableGet(temp);
-    }
+    if (typeMatches) {
+      // If the type guarantees that all elements are of the required type, use
+      // a single 'addAll' call instead of a for-loop with calls to '[]='.
 
-    VariableDeclaration variable;
-    Statement loopBody;
-    if (!typeMatches) {
+      // Null-aware spreads require testing the subexpression's value.
+      VariableDeclaration? temp;
+      if (entry.isNullAware) {
+        temp = _createVariable(
+            value,
+            _typeEnvironment.mapType(
+                typeMatches ? keyType : const DynamicType(),
+                typeMatches ? valueType : const DynamicType(),
+                _currentLibrary!.nullable));
+        body.add(temp);
+        value = _createNullCheckedVariableGet(temp);
+      }
+
+      Statement statement = _createExpressionStatement(
+          _createMapAddAll(_createVariableGet(result), receiverType, value));
+
+      if (entry.isNullAware) {
+        statement = _createIf(
+            temp!.fileOffset,
+            _createEqualsNull(_createVariableGet(temp), notEquals: true),
+            statement);
+      }
+      body.add(statement);
+    } else {
+      // Null-aware spreads require testing the subexpression's value.
+      VariableDeclaration? temp;
+      if (entry.isNullAware) {
+        temp = _createVariable(
+            value,
+            _typeEnvironment.mapType(
+                typeMatches ? keyType : const DynamicType(),
+                typeMatches ? valueType : const DynamicType(),
+                _currentLibrary!.nullable));
+        body.add(temp);
+        value = _createNullCheckedVariableGet(temp);
+      }
+
       final InterfaceType variableType = new InterfaceType(
           _mapEntryClass,
           _currentLibrary!.nonNullable,
           <DartType>[const DynamicType(), const DynamicType()]);
-      variable = _createForInVariable(entry.fileOffset, variableType);
+      VariableDeclaration variable =
+          _createForInVariable(entry.fileOffset, variableType);
       VariableDeclaration keyVar = _createVariable(
           _createImplicitAs(
               entry.expression.fileOffset,
@@ -609,7 +687,7 @@
                   _createVariableGet(variable), variableType),
               valueType),
           valueType);
-      loopBody = _createBlock(<Statement>[
+      Statement loopBody = _createBlock(<Statement>[
         keyVar,
         valueVar,
         _createExpressionStatement(_createIndexSet(
@@ -619,27 +697,17 @@
             _createVariableGet(keyVar),
             _createVariableGet(valueVar)))
       ]);
-    } else {
-      variable = _createForInVariable(entry.fileOffset, entryType);
-      loopBody = _createExpressionStatement(_createIndexSet(
-          entry.expression.fileOffset,
-          _createVariableGet(result),
-          receiverType,
-          _createGetKey(entry.expression.fileOffset,
-              _createVariableGet(variable), entryType),
-          _createGetValue(entry.expression.fileOffset,
-              _createVariableGet(variable), entryType)));
-    }
-    Statement statement = _createForInStatement(entry.fileOffset, variable,
-        _createGetEntries(entry.fileOffset, value, receiverType), loopBody);
+      Statement statement = _createForInStatement(entry.fileOffset, variable,
+          _createGetEntries(entry.fileOffset, value, receiverType), loopBody);
 
-    if (entry.isNullAware) {
-      statement = _createIf(
-          temp!.fileOffset,
-          _createEqualsNull(_createVariableGet(temp), notEquals: true),
-          statement);
+      if (entry.isNullAware) {
+        statement = _createIf(
+            temp!.fileOffset,
+            _createEqualsNull(_createVariableGet(temp), notEquals: true),
+            statement);
+      }
+      body.add(statement);
     }
-    body.add(statement);
   }
 
   TreeNode _translateConstListOrSet(
@@ -937,6 +1005,26 @@
       ..isInvariant = true;
   }
 
+  Expression _createMapAddAll(
+      Expression receiver, InterfaceType receiverType, Expression argument) {
+    // ignore: unnecessary_null_comparison
+    assert(receiver != null);
+    // ignore: unnecessary_null_comparison
+    assert(argument != null);
+    assert(argument.fileOffset != TreeNode.noOffset,
+        "No fileOffset on ${argument}.");
+    DartType functionType = Substitution.fromInterfaceType(receiverType)
+        .substituteType(_mapAddAllFunctionType);
+    if (!_currentLibrary!.isNonNullableByDefault) {
+      functionType = legacyErasure(functionType);
+    }
+    return new InstanceInvocation(InstanceAccessKind.Instance, receiver,
+        new Name('addAll'), new Arguments([argument]),
+        functionType: functionType as FunctionType, interfaceTarget: _mapAddAll)
+      ..fileOffset = argument.fileOffset
+      ..isInvariant = true;
+  }
+
   Expression _createEqualsNull(Expression expression, {bool notEquals: false}) {
     // ignore: unnecessary_null_comparison
     assert(expression != null);
diff --git a/pkg/front_end/lib/src/fasta/source/source_loader.dart b/pkg/front_end/lib/src/fasta/source/source_loader.dart
index 6e7c3fe..4f62e70 100644
--- a/pkg/front_end/lib/src/fasta/source/source_loader.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_loader.dart
@@ -2666,8 +2666,11 @@
 
 abstract class Map<K, V> extends Iterable {
   factory Map.unmodifiable(other) => null;
+  factory Map.of(o) = Map<E>._of;
+  external factory Map._of(o);
   Iterable<MapEntry<K, V>> get entries;
   void operator []=(K key, V value) {}
+  void addAll(Map<K, V> other) {}
 }
 
 abstract class pragma {
diff --git a/pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart b/pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart
index 275c3ba..8b82433 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart
@@ -2884,8 +2884,12 @@
         InterfaceType setType = coreTypes.thisInterfaceType(
             coreTypes.setClass, libraryBuilder.nonNullable);
         for (int i = 0; i < node.entries.length; ++i) {
-          setElements.add(convertToElement(node.entries[i],
-              isTopLevel ? null : helper, assignedVariables.reassignInfo));
+          setElements.add(convertToElement(
+            node.entries[i],
+            isTopLevel ? null : helper,
+            assignedVariables.reassignInfo,
+            actualType: actualTypesForSet![i],
+          ));
           formalTypesForSet.add(setType.typeArguments[0]);
         }
 
diff --git a/pkg/front_end/test/static_types/data/null_aware_spread.dart b/pkg/front_end/test/static_types/data/null_aware_spread.dart
index 0eec790..ee76152 100644
--- a/pkg/front_end/test/static_types/data/null_aware_spread.dart
+++ b/pkg/front_end/test/static_types/data/null_aware_spread.dart
@@ -53,11 +53,8 @@
         /*cfe:nnbd.String!*/
         'foo',
     ...?
-    /*cfe.Map<int,String>|Iterable<MapEntry<int,String>!>!|int|String*/
-    /*cfe:nnbd.Map<int!,String!>!|Iterable<MapEntry<int!,String!>!>!|int!|String!*/
-    /*cfe.current: MapEntry<int,String>!*/
-    /*cfe:nnbd.current: MapEntry<int!,String!>!*/
-    /*update: void*/
-    map
+    /*cfe.Map<int,String>*/
+    /*cfe:nnbd.Map<int!,String!>!*/
+    /*invoke: void*/ map
   };
 }
diff --git a/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.expect b/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.expect
index 7bea2cf..ea911ec 100644
--- a/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.expect
+++ b/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.expect
@@ -516,501 +516,486 @@
   core::Map<core::String*, core::int*>* map20 = block {
     final core::Map<core::String*, core::int*>* #t12 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t13 in <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t12.{core::Map::[]=}{Invariant}(#t13.{core::MapEntry::key}{core::String*}, #t13.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+      #t12.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
     #t12.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
   } =>#t12;
   core::List<dynamic>* list21 = block {
-    final core::List<dynamic>* #t14 = <dynamic>[];
+    final core::List<dynamic>* #t13 = <dynamic>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t14.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-  } =>#t14;
+      #t13.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+  } =>#t13;
   core::Set<dynamic>* set21 = block {
-    final core::Set<dynamic>* #t15 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t14 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t15.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-    #t15.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t15;
+      #t14.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+    #t14.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t14;
   core::Map<core::String*, dynamic>* map21 = block {
-    final core::Map<core::String*, dynamic>* #t16 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t15 = <core::String*, dynamic>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, dynamic>* #t17 in <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>})
-        #t16.{core::Map::[]=}{Invariant}(#t17.{core::MapEntry::key}{core::String*}, #t17.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-    #t16.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t16;
+      #t15.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t15.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t15;
   core::List<core::List<core::int*>*>* list22 = block {
-    final core::List<core::List<core::int*>*>* #t18 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t16 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t18.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t18;
+      #t16.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t16;
   core::Set<core::List<core::int*>*>* set22 = block {
-    final core::Set<core::List<core::int*>*>* #t19 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t17 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t19.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t19.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t19;
+      #t17.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t17.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t17;
   core::Map<core::String*, core::List<core::int*>*>* map22 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t20 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t18 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t21 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t20.{core::Map::[]=}{Invariant}(#t21.{core::MapEntry::key}{core::String*}, #t21.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t20.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t20;
+      #t18.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t18.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t18;
   core::List<core::int*>* list30 = block {
-    final core::List<core::int*>* #t22 = <core::int*>[];
+    final core::List<core::int*>* #t19 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t22.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-  } =>#t22;
+        #t19.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+  } =>#t19;
   core::Set<core::int*>* set30 = block {
-    final core::Set<core::int*>* #t23 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t20 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t23.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-    #t23.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t23;
+        #t20.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+    #t20.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t20;
   core::Map<core::String*, core::int*>* map30 = block {
-    final core::Map<core::String*, core::int*>* #t24 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t21 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t25 in <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-          #t24.{core::Map::[]=}{Invariant}(#t25.{core::MapEntry::key}{core::String*}, #t25.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t24.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t24;
+        #t21.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t21.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t21;
   core::List<dynamic>* list31 = block {
-    final core::List<dynamic>* #t26 = <dynamic>[];
+    final core::List<dynamic>* #t22 = <dynamic>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t26.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-  } =>#t26;
+        #t22.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+  } =>#t22;
   core::Set<dynamic>* set31 = block {
-    final core::Set<dynamic>* #t27 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t23 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t27.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-    #t27.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t27;
+        #t23.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+    #t23.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t23;
   core::Map<core::String*, dynamic>* map31 = block {
-    final core::Map<core::String*, dynamic>* #t28 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t24 = <core::String*, dynamic>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, dynamic>* #t29 in <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>})
-          #t28.{core::Map::[]=}{Invariant}(#t29.{core::MapEntry::key}{core::String*}, #t29.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-    #t28.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t28;
+        #t24.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t24.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t24;
   core::List<core::List<core::int*>*>* list33 = block {
-    final core::List<core::List<core::int*>*>* #t30 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t25 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t30.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t30;
+        #t25.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t25;
   core::Set<core::List<core::int*>*>* set33 = block {
-    final core::Set<core::List<core::int*>*>* #t31 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t26 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t31.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t31.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t31;
+        #t26.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t26.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t26;
   core::Map<core::String*, core::List<core::int*>*>* map33 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t32 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t27 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t33 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t32.{core::Map::[]=}{Invariant}(#t33.{core::MapEntry::key}{core::String*}, #t33.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t32.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t32;
+        #t27.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t27.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t27;
   core::List<core::List<core::int*>*>* list40 = block {
-    final core::List<core::List<core::int*>*>* #t34 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t28 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t34.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t34;
+      #t28.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t28;
   core::Set<core::List<core::int*>*>* set40 = block {
-    final core::Set<core::List<core::int*>*>* #t35 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t29 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t35.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t35.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t35;
+      #t29.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t29.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t29;
   core::Map<core::String*, core::List<core::int*>*>* map40 = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:41:34: Error: Both Iterable and Map spread elements encountered in ambiguous literal.
   Map<String, List<int>> map40 = {if (oracle(\"foo\")) ...{\"bar\", []}, \"baz\": null};
                                  ^";
   core::List<core::List<core::int*>*>* list41 = block {
-    final core::List<core::List<core::int*>*>* #t36 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t30 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t36.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t37 = col::LinkedHashSet::•<core::List<core::int*>*>();
-        #t37.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-      } =>#t37){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t36;
+      #t30.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t31 = col::LinkedHashSet::•<core::List<core::int*>*>();
+        #t31.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+      } =>#t31){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t30;
   core::Set<core::List<core::int*>*>* set41 = block {
-    final core::Set<core::List<core::int*>*>* #t38 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t32 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t38.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t39 = col::LinkedHashSet::•<core::List<core::int*>*>();
-        #t39.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-      } =>#t39){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t38.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t38;
+      #t32.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t33 = col::LinkedHashSet::•<core::List<core::int*>*>();
+        #t33.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+      } =>#t33){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t32.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t32;
   core::List<core::List<core::int*>*>* list42 = block {
-    final core::List<core::List<core::int*>*>* #t40 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t34 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t40.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t40;
+        #t34.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t34;
   core::Set<core::List<core::int*>*>* set42 = block {
-    final core::Set<core::List<core::int*>*>* #t41 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t35 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t41.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t41.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t41;
+        #t35.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t35.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t35;
   core::Map<core::String*, core::List<core::int*>*>* map42 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t42 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t36 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t43 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t42.{core::Map::[]=}{Invariant}(#t43.{core::MapEntry::key}{core::String*}, #t43.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t42.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t42;
+        #t36.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t36.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t36;
   core::List<core::int*>* list50 = block {
+    final core::List<core::int*>* #t37 = <core::int*>[];
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t37.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+  } =>#t37;
+  core::Set<core::int*>* set50 = block {
+    final core::Set<core::int*>* #t38 = col::LinkedHashSet::•<core::int*>();
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t38.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+    #t38.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t38;
+  core::Map<core::String*, core::int*>* map50 = block {
+    final core::Map<core::String*, core::int*>* #t39 = <core::String*, core::int*>{};
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t39.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
+    #t39.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t39;
+  core::List<core::int*>* list51 = block {
+    final core::List<core::int*>* #t40 = <core::int*>[];
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t40.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t41 = col::LinkedHashSet::•<core::int*>();
+      } =>#t41){(core::Iterable<core::int*>*) →* void};
+  } =>#t40;
+  core::Set<core::int*>* set51 = block {
+    final core::Set<core::int*>* #t42 = col::LinkedHashSet::•<core::int*>();
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t42.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t43 = col::LinkedHashSet::•<core::int*>();
+      } =>#t43){(core::Iterable<core::int*>*) →* void};
+    #t42.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t42;
+  core::List<core::int*>* list52 = block {
     final core::List<core::int*>* #t44 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t44.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t44.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
   } =>#t44;
-  core::Set<core::int*>* set50 = block {
+  core::Set<core::int*>* set52 = block {
     final core::Set<core::int*>* #t45 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t45.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t45.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
     #t45.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
   } =>#t45;
-  core::Map<core::String*, core::int*>* map50 = block {
+  core::Map<core::String*, core::int*>* map52 = block {
     final core::Map<core::String*, core::int*>* #t46 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t47 in <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t46.{core::Map::[]=}{Invariant}(#t47.{core::MapEntry::key}{core::String*}, #t47.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t46.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
     #t46.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
   } =>#t46;
-  core::List<core::int*>* list51 = block {
-    final core::List<core::int*>* #t48 = <core::int*>[];
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t48.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t49 = col::LinkedHashSet::•<core::int*>();
-      } =>#t49){(core::Iterable<core::int*>*) →* void};
-  } =>#t48;
-  core::Set<core::int*>* set51 = block {
-    final core::Set<core::int*>* #t50 = col::LinkedHashSet::•<core::int*>();
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t50.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t51 = col::LinkedHashSet::•<core::int*>();
-      } =>#t51){(core::Iterable<core::int*>*) →* void};
-    #t50.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t50;
-  core::List<core::int*>* list52 = block {
-    final core::List<core::int*>* #t52 = <core::int*>[];
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t52.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-  } =>#t52;
-  core::Set<core::int*>* set52 = block {
-    final core::Set<core::int*>* #t53 = col::LinkedHashSet::•<core::int*>();
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t53.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-    #t53.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t53;
-  core::Map<core::String*, core::int*>* map52 = block {
-    final core::Map<core::String*, core::int*>* #t54 = <core::String*, core::int*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t55 in <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-          #t54.{core::Map::[]=}{Invariant}(#t55.{core::MapEntry::key}{core::String*}, #t55.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t54.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t54;
   core::List<core::List<core::int*>*>* list60 = block {
-    final core::List<core::List<core::int*>*>* #t56 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t47 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t56.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t56;
+      #t47.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t47;
   core::Set<core::List<core::int*>*>* set60 = block {
-    final core::Set<core::List<core::int*>*>* #t57 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t48 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t57.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t57.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t57;
+      #t48.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t48.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t48;
   core::Map<core::String*, core::List<core::int*>*>* map60 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t58 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t49 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t59 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t58.{core::Map::[]=}{Invariant}(#t59.{core::MapEntry::key}{core::String*}, #t59.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t58.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t58;
+      #t49.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t49.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t49;
   core::List<core::List<core::int*>*>* list61 = block {
-    final core::List<core::List<core::int*>*>* #t60 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t50 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t60.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t60;
+        #t50.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t50;
   core::Set<core::List<core::int*>*>* set61 = block {
-    final core::Set<core::List<core::int*>*>* #t61 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t51 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t61.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t61.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t61;
+        #t51.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t51.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t51;
   core::Map<core::String*, core::List<core::int*>*>* map61 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t62 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t52 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t63 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t62.{core::Map::[]=}{Invariant}(#t63.{core::MapEntry::key}{core::String*}, #t63.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t62.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t62;
+        #t52.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t52.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t52;
   core::List<core::List<core::int*>*>* list70 = block {
-    final core::List<core::List<core::int*>*>* #t64 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t53 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t64.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
-  } =>#t64;
+      #t53.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
+  } =>#t53;
   core::Set<core::List<core::int*>*>* set70 = block {
-    final core::Set<core::List<core::int*>*>* #t65 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t54 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t65.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-    #t65.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t65;
+      #t54.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+    #t54.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t54;
   core::List<core::List<core::int*>*>* list71 = block {
-    final core::List<core::List<core::int*>*>* #t66 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t55 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t66.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
-  } =>#t66;
+        #t55.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
+  } =>#t55;
   core::Set<core::List<core::int*>*>* set71 = block {
-    final core::Set<core::List<core::int*>*>* #t67 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t56 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t67.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-    #t67.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t67;
+        #t56.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+    #t56.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t56;
   core::List<core::num*>* list80 = block {
-    final core::List<core::num*>* #t68 = <core::num*>[];
+    final core::List<core::num*>* #t57 = <core::num*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t68.{core::List::add}{Invariant}(42){(core::num*) →* void};
+      #t57.{core::List::add}{Invariant}(42){(core::num*) →* void};
     else
-      #t68.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
-  } =>#t68;
+      #t57.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
+  } =>#t57;
   core::Set<core::num*>* set80 = block {
-    final core::Set<core::num*>* #t69 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t58 = col::LinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t69.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
+      #t58.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
     else
-      #t69.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t69.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t69;
+      #t58.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t58.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t58;
   core::Map<core::String*, core::num*>* map80 = block {
-    final core::Map<core::String*, core::num*>* #t70 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t59 = <core::String*, core::num*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t70.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
+      #t59.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
     else
-      #t70.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t70.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t70;
+      #t59.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t59.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t59;
   core::List<core::num*>* list81 = block {
-    final core::List<core::num*>* #t71 = <core::num*>[];
+    final core::List<core::num*>* #t60 = <core::num*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t71.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t60.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t71.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t71;
+      #t60.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t60;
   core::Set<core::num*>* set81 = block {
-    final core::Set<core::num*>* #t72 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t61 = col::LinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t72.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t61.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t72.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-    #t72.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t72;
+      #t61.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+    #t61.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t61;
   core::Map<core::String*, core::num*>* map81 = block {
-    final core::Map<core::String*, core::num*>* #t73 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t62 = <core::String*, core::num*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t74 in mapToInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-        #t73.{core::Map::[]=}{Invariant}(#t74.{core::MapEntry::key}{core::String*}, #t74.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
+      #t62.{core::Map::addAll}{Invariant}(mapToInt){(core::Map<core::String*, core::num*>*) →* void};
     else
-      for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t75 in mapToDouble.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-        #t73.{core::Map::[]=}{Invariant}(#t75.{core::MapEntry::key}{core::String*}, #t75.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-    #t73.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t73;
+      #t62.{core::Map::addAll}{Invariant}(mapToDouble){(core::Map<core::String*, core::num*>*) →* void};
+    #t62.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t62;
   core::List<dynamic>* list82 = block {
-    final core::List<dynamic>* #t76 = <dynamic>[];
+    final core::List<dynamic>* #t63 = <dynamic>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t76.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+      #t63.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
     else
-      #t76.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-  } =>#t76;
+      #t63.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+  } =>#t63;
   core::Set<dynamic>* set82 = block {
-    final core::Set<dynamic>* #t77 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t64 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t77.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+      #t64.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
     else
-      #t77.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t77.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t77;
+      #t64.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t64.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t64;
   core::Set<dynamic>* map82 = block {
-    final core::Set<dynamic>* #t78 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t65 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t78.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:73:38: Error: Unexpected type 'Map<String, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t65.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:73:38: Error: Unexpected type 'Map<String, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   var map82 = {if (oracle(\"foo\")) ...mapToInt else ...dynVar, null};
                                      ^"){(dynamic) →* core::bool*};
     else
-      #t78.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t78.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t78;
+      #t65.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t65.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t65;
   core::List<core::num*>* list83 = block {
-    final core::List<core::num*>* #t79 = <core::num*>[];
+    final core::List<core::num*>* #t66 = <core::num*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t79.{core::List::add}{Invariant}(42){(core::num*) →* void};
+      #t66.{core::List::add}{Invariant}(42){(core::num*) →* void};
     else
-      #t79.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t79;
+      #t66.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t66;
   core::Set<core::num*>* set83 = block {
-    final core::Set<core::num*>* #t80 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t67 = col::LinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t80.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t67.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t80.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t80.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t80;
+      #t67.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t67.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t67;
   core::Map<core::String*, core::num*>* map83 = block {
-    final core::Map<core::String*, core::num*>* #t81 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t68 = <core::String*, core::num*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t82 in mapToInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-        #t81.{core::Map::[]=}{Invariant}(#t82.{core::MapEntry::key}{core::String*}, #t82.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
+      #t68.{core::Map::addAll}{Invariant}(mapToInt){(core::Map<core::String*, core::num*>*) →* void};
     else
-      #t81.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t81.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t81;
+      #t68.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t68.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t68;
   core::List<core::int*>* list90 = block {
-    final core::List<core::int*>* #t83 = <core::int*>[];
+    final core::List<core::int*>* #t69 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t83.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
-  } =>#t83;
+      #t69.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+  } =>#t69;
   core::Set<core::int*>* set90 = block {
-    final core::Set<core::int*>* #t84 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t70 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t84.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
-    #t84.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t84;
+      #t70.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+    #t70.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t70;
   core::Map<core::String*, core::int*>* map90 = block {
-    final core::Map<core::String*, core::int*>* #t85 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t71 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t85.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
-    #t85.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t85;
+      #t71.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+    #t71.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t71;
   core::List<core::int*>* list91 = block {
-    final core::List<core::int*>* #t86 = <core::int*>[];
+    final core::List<core::int*>* #t72 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer dynamic #t87 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
-        final core::int* #t88 = #t87 as{TypeError} core::int*;
-        #t86.{core::List::add}{Invariant}(#t88){(core::int*) →* void};
+      for (final has-declared-initializer dynamic #t73 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
+        final core::int* #t74 = #t73 as{TypeError} core::int*;
+        #t72.{core::List::add}{Invariant}(#t74){(core::int*) →* void};
       }
-  } =>#t86;
+  } =>#t72;
   core::Set<core::int*>* set91 = block {
-    final core::Set<core::int*>* #t89 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t75 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer dynamic #t90 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
-        final core::int* #t91 = #t90 as{TypeError} core::int*;
-        #t89.{core::Set::add}{Invariant}(#t91){(core::int*) →* core::bool*};
+      for (final has-declared-initializer dynamic #t76 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
+        final core::int* #t77 = #t76 as{TypeError} core::int*;
+        #t75.{core::Set::add}{Invariant}(#t77){(core::int*) →* core::bool*};
       }
-    #t89.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t89;
+    #t75.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t75;
   core::Map<core::String*, core::int*>* map91 = block {
-    final core::Map<core::String*, core::int*>* #t92 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t78 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t93 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}) {
-        final core::String* #t94 = #t93.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
-        final core::int* #t95 = #t93.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-        #t92.{core::Map::[]=}{Invariant}(#t94, #t95){(core::String*, core::int*) →* void};
+      for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t79 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}) {
+        final core::String* #t80 = #t79.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
+        final core::int* #t81 = #t79.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
+        #t78.{core::Map::[]=}{Invariant}(#t80, #t81){(core::String*, core::int*) →* void};
       }
-    #t92.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t92;
+    #t78.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t78;
   core::List<core::int*>* list100 = block {
-    final core::List<core::int*>* #t96 = <core::int*>[];
+    final core::List<core::int*>* #t82 = <core::int*>[];
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t96.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t96;
+      #t82.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t82;
   core::Set<core::int*>* set100 = block {
-    final core::Set<core::int*>* #t97 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t83 = col::LinkedHashSet::•<core::int*>();
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t97.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t97;
+      #t83.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t83;
   core::Map<core::int*, core::int*>* map100 = block {
-    final core::Map<core::int*, core::int*>* #t98 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t84 = <core::int*, core::int*>{};
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t98.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
-  } =>#t98;
+      #t84.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
+  } =>#t84;
 }
 static method testIfElementErrors(core::Map<core::int*, core::int*>* map) → dynamic {
   block {
-    final core::List<core::int*>* #t99 = <core::int*>[];
+    final core::List<core::int*>* #t85 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t99.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:89:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t85.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:89:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[if (oracle(\"foo\")) \"bar\"];
                            ^" in "bar" as{TypeError} core::int*){(core::int*) →* void};
-  } =>#t99;
+  } =>#t85;
   block {
-    final core::Set<core::int*>* #t100 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t86 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t100.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:90:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t86.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:90:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{if (oracle(\"foo\")) \"bar\", null};
                            ^" in "bar" as{TypeError} core::int*){(core::int*) →* core::bool*};
-    #t100.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t100;
+    #t86.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t86;
   block {
-    final core::Map<core::String*, core::int*>* #t101 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t87 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t101.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:91:43: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t87.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:91:43: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <String, int>{if (oracle(\"foo\")) \"bar\": \"bar\", \"baz\": null};
                                           ^" in "bar" as{TypeError} core::int*){(core::String*, core::int*) →* void};
-    #t101.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t101;
+    #t87.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t87;
   block {
-    final core::List<core::int*>* #t102 = <core::int*>[];
+    final core::List<core::int*>* #t88 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t102.{core::List::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:92:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t88.{core::List::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:92:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[if (oracle(\"foo\")) ...[\"bar\"]];
                                ^" in "bar" as{TypeError} core::int*]){(core::Iterable<core::int*>*) →* void};
-  } =>#t102;
+  } =>#t88;
   block {
-    final core::Set<core::int*>* #t103 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t89 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t103.{core::Set::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:93:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t89.{core::Set::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:93:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{if (oracle(\"foo\")) ...[\"bar\"], null};
                                ^" in "bar" as{TypeError} core::int*]){(core::Iterable<core::int*>*) →* void};
-    #t103.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t103;
+    #t89.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t89;
   block {
-    final core::Map<core::String*, core::int*>* #t104 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t90 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t105 in <core::String*, core::int*>{"bar": invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:94:47: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t90.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:94:47: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <String, int>{if (oracle(\"foo\")) ...{\"bar\": \"bar\"}, \"baz\": null};
-                                              ^" in "bar" as{TypeError} core::int*}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t104.{core::Map::[]=}{Invariant}(#t105.{core::MapEntry::key}{core::String*}, #t105.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t104.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t104;
+                                              ^" in "bar" as{TypeError} core::int*}){(core::Map<core::String*, core::int*>*) →* void};
+    #t90.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t90;
   block {
-    final core::List<core::int*>* #t106 = <core::int*>[];
+    final core::List<core::int*>* #t91 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t106.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:95:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t91.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:95:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) ...map];
                               ^"){(core::int*) →* void};
-  } =>#t106;
+  } =>#t91;
   block {
-    final core::Set<core::int*>* #t107 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t92 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t107.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:96:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t92.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:96:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map, null};
                               ^"){(core::int*) →* core::bool*};
-    #t107.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t107;
+    #t92.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t92;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:97:39: Error: Unexpected type 'List<String>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) ...[\"bar\"], \"baz\": null};
@@ -1019,61 +1004,61 @@
   <String, int>{if (oracle(\"foo\")) ...[\"bar\"], \"baz\": null};
                                       ^": null};
   block {
-    final core::List<core::String*>* #t108 = <core::String*>[];
+    final core::List<core::String*>* #t93 = <core::String*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t108.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t93.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>[if (oracle(\"foo\")) 42 else 3.14];
                               ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
     else
-      #t108.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t93.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>[if (oracle(\"foo\")) 42 else 3.14];
                                       ^" in 3.14 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t108;
+  } =>#t93;
   block {
-    final core::Set<core::String*>* #t109 = col::LinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t94 = col::LinkedHashSet::•<core::String*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t109.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t94.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>{if (oracle(\"foo\")) 42 else 3.14, null};
                               ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
     else
-      #t109.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t94.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>{if (oracle(\"foo\")) 42 else 3.14, null};
                                       ^" in 3.14 as{TypeError} core::String*){(core::String*) →* core::bool*};
-    #t109.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
-  } =>#t109;
+    #t94.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
+  } =>#t94;
   block {
-    final core::Map<core::String*, core::String*>* #t110 = <core::String*, core::String*>{};
+    final core::Map<core::String*, core::String*>* #t95 = <core::String*, core::String*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t110.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:46: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t95.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:46: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String, String>{if (oracle(\"foo\")) \"bar\": 42 else \"baz\": 3.14, \"baz\": null};
                                              ^" in 42 as{TypeError} core::String*){(core::String*, core::String*) →* void};
     else
-      #t110.{core::Map::[]=}{Invariant}("baz", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:61: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t95.{core::Map::[]=}{Invariant}("baz", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:61: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String, String>{if (oracle(\"foo\")) \"bar\": 42 else \"baz\": 3.14, \"baz\": null};
                                                             ^" in 3.14 as{TypeError} core::String*){(core::String*, core::String*) →* void};
-    #t110.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
-  } =>#t110;
+    #t95.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
+  } =>#t95;
   block {
-    final core::List<core::int*>* #t111 = <core::int*>[];
+    final core::List<core::int*>* #t96 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t111.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:101:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t96.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:101:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) ...map else 42];
                               ^"){(core::int*) →* void};
     else
-      #t111.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t111;
+      #t96.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t96;
   block {
-    final core::Set<core::int*>* #t112 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t97 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t112.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:102:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t97.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:102:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map else 42, null};
                               ^"){(core::int*) →* core::bool*};
     else
-      #t112.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t112.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t112;
+      #t97.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t97.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t97;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:103:39: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) ...[42] else \"bar\": 42, \"baz\": null};
@@ -1082,26 +1067,26 @@
   <String, int>{if (oracle(\"foo\")) ...[42] else \"bar\": 42, \"baz\": null};
                                       ^": null};
   block {
-    final core::List<core::int*>* #t113 = <core::int*>[];
+    final core::List<core::int*>* #t98 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t113.{core::List::add}{Invariant}(42){(core::int*) →* void};
+      #t98.{core::List::add}{Invariant}(42){(core::int*) →* void};
     else
-      #t113.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:104:39: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t98.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:104:39: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) 42 else ...map];
                                       ^"){(core::int*) →* void};
-  } =>#t113;
+  } =>#t98;
   block {
-    final core::Set<core::int*>* #t114 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t99 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t114.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:105:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t99.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:105:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map else 42, null};
                               ^"){(core::int*) →* core::bool*};
     else
-      #t114.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t114.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t114;
+      #t99.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t99.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t99;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:106:54: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) \"bar\": 42 else ...[42], \"baz\": null};
@@ -1128,709 +1113,692 @@
   var map13 = {if (oracle(\"foo\")) \"bar\": 3.14 else 42};
                                                    ^": null};
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t115 = <core::int*>[];
+    final core::List<core::int*>* #t100 = <core::int*>[];
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:114:27: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   List<int> list20 = [if (42) 42];
                           ^" in 42 as{TypeError} core::bool*)
-      #t115.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t115;
+      #t100.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t100;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t116 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t101 = col::LinkedHashSet::•<core::int*>();
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:115:25: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   Set<int> set20 = {if (42) 42};
                         ^" in 42 as{TypeError} core::bool*)
-      #t116.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t116;
+      #t101.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t101;
   core::Map<core::int*, core::int*>* map30 = block {
-    final core::Map<core::int*, core::int*>* #t117 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t102 = <core::int*, core::int*>{};
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:116:30: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   Map<int, int> map30 = {if (42) 42: 42};
                              ^" in 42 as{TypeError} core::bool*)
-      #t117.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
-  } =>#t117;
+      #t102.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
+  } =>#t102;
   core::List<core::String*>* list40 = block {
-    final core::List<core::String*>* #t118 = <core::String*>[];
+    final core::List<core::String*>* #t103 = <core::String*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t118.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:53: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t103.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:53: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   List<String> list40 = <String>[if (oracle(\"foo\")) true else 42];
                                                     ^" in true as{TypeError} core::String*){(core::String*) →* void};
     else
-      #t118.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:63: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t103.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:63: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   List<String> list40 = <String>[if (oracle(\"foo\")) true else 42];
                                                               ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t118;
+  } =>#t103;
   core::Set<core::String*>* set40 = block {
-    final core::Set<core::String*>* #t119 = col::LinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t104 = col::LinkedHashSet::•<core::String*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t119.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:51: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t104.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:51: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Set<String> set40 = <String>{if (oracle(\"foo\")) true else 42};
                                                   ^" in true as{TypeError} core::String*){(core::String*) →* core::bool*};
     else
-      #t119.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:61: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t104.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:61: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Set<String> set40 = <String>{if (oracle(\"foo\")) true else 42};
                                                             ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
-  } =>#t119;
+  } =>#t104;
   core::Map<core::String*, core::int*>* map40 = block {
-    final core::Map<core::String*, core::int*>* #t120 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t105 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:61: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t105.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:61: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Map<String, int> map40 = <String, int>{if (oracle(\"foo\")) true: 42 else 42: 42};
                                                             ^" in true as{TypeError} core::String*, 42){(core::String*, core::int*) →* void};
     else
-      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:75: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t105.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:75: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Map<String, int> map40 = <String, int>{if (oracle(\"foo\")) true: 42 else 42: 42};
                                                                           ^" in 42 as{TypeError} core::String*, 42){(core::String*, core::int*) →* void};
-  } =>#t120;
+  } =>#t105;
   core::Map<core::int*, core::String*>* map41 = block {
-    final core::Map<core::int*, core::String*>* #t121 = <core::int*, core::String*>{};
+    final core::Map<core::int*, core::String*>* #t106 = <core::int*, core::String*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t121.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:65: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t106.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:65: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Map<int, String> map41 = <int, String>{if (oracle(\"foo\")) 42: true else 42: 42};
                                                                 ^" in true as{TypeError} core::String*){(core::int*, core::String*) →* void};
     else
-      #t121.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:79: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t106.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:79: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Map<int, String> map41 = <int, String>{if (oracle(\"foo\")) 42: true else 42: 42};
                                                                               ^" in 42 as{TypeError} core::String*){(core::int*, core::String*) →* void};
-  } =>#t121;
+  } =>#t106;
 }
 static method testForElement(dynamic dynVar, core::List<core::int*>* listInt, core::List<core::double*>* listDouble, core::int* index, core::Map<core::String*, core::int*>* mapStringInt, core::Map<core::String*, core::double*>* mapStringDouble) → dynamic {
   core::List<core::int*>* list10 = block {
-    final core::List<core::int*>* #t122 = <core::int*>[];
+    final core::List<core::int*>* #t107 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t122.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t122;
+      #t107.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t107;
   core::Set<core::int*>* set10 = block {
-    final core::Set<core::int*>* #t123 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t108 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t123.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t123.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t123;
+      #t108.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t108.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t108;
   core::Map<core::String*, core::int*>* map10 = block {
-    final core::Map<core::String*, core::int*>* #t124 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t109 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t124.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t124.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t124;
+      #t109.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t109.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t109;
   core::List<dynamic>* list11 = block {
-    final core::List<dynamic>* #t125 = <dynamic>[];
+    final core::List<dynamic>* #t110 = <dynamic>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t125.{core::List::add}{Invariant}(dynVar){(dynamic) →* void};
-  } =>#t125;
+      #t110.{core::List::add}{Invariant}(dynVar){(dynamic) →* void};
+  } =>#t110;
   core::Set<dynamic>* set11 = block {
-    final core::Set<dynamic>* #t126 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t111 = col::LinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t126.{core::Set::add}{Invariant}(dynVar){(dynamic) →* core::bool*};
-    #t126.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t126;
+      #t111.{core::Set::add}{Invariant}(dynVar){(dynamic) →* core::bool*};
+    #t111.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t111;
   core::Map<core::String*, dynamic>* map11 = block {
-    final core::Map<core::String*, dynamic>* #t127 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t112 = <core::String*, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t127.{core::Map::[]=}{Invariant}("bar", dynVar){(core::String*, dynamic) →* void};
-    #t127.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t127;
+      #t112.{core::Map::[]=}{Invariant}("bar", dynVar){(core::String*, dynamic) →* void};
+    #t112.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t112;
   core::List<core::List<core::int*>*>* list12 = block {
-    final core::List<core::List<core::int*>*>* #t128 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t113 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t128.{core::List::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* void};
-  } =>#t128;
+      #t113.{core::List::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* void};
+  } =>#t113;
   core::Set<core::List<core::int*>*>* set12 = block {
-    final core::Set<core::List<core::int*>*>* #t129 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t114 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t129.{core::Set::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* core::bool*};
-    #t129.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t129;
+      #t114.{core::Set::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* core::bool*};
+    #t114.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t114;
   core::Map<core::String*, core::List<core::int*>*>* map12 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t130 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t115 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t130.{core::Map::[]=}{Invariant}("bar", <core::int*>[42]){(core::String*, core::List<core::int*>*) →* void};
-    #t130.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t130;
+      #t115.{core::Map::[]=}{Invariant}("bar", <core::int*>[42]){(core::String*, core::List<core::int*>*) →* void};
+    #t115.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t115;
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t131 = <core::int*>[];
+    final core::List<core::int*>* #t116 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t131.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-  } =>#t131;
+      #t116.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+  } =>#t116;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t132 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t117 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t132.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-    #t132.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t132;
+      #t117.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+    #t117.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t117;
   core::Map<core::String*, core::int*>* map20 = block {
-    final core::Map<core::String*, core::int*>* #t133 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t118 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t134 in <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t133.{core::Map::[]=}{Invariant}(#t134.{core::MapEntry::key}{core::String*}, #t134.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t133.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t133;
+      #t118.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t118.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t118;
   core::List<dynamic>* list21 = block {
-    final core::List<dynamic>* #t135 = <dynamic>[];
+    final core::List<dynamic>* #t119 = <dynamic>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t135.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-  } =>#t135;
+      #t119.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+  } =>#t119;
   core::Set<dynamic>* set21 = block {
-    final core::Set<dynamic>* #t136 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t120 = col::LinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t136.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-    #t136.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t136;
+      #t120.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+    #t120.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t120;
   core::Map<core::String*, dynamic>* map21 = block {
-    final core::Map<core::String*, dynamic>* #t137 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t121 = <core::String*, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, dynamic>* #t138 in <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>})
-        #t137.{core::Map::[]=}{Invariant}(#t138.{core::MapEntry::key}{core::String*}, #t138.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-    #t137.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t137;
+      #t121.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t121.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t121;
   core::List<core::List<core::int*>*>* list22 = block {
-    final core::List<core::List<core::int*>*>* #t139 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t122 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t139.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t139;
+      #t122.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t122;
   core::Set<core::List<core::int*>*>* set22 = block {
-    final core::Set<core::List<core::int*>*>* #t140 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t123 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t140.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t140.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t140;
+      #t123.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t123.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t123;
   core::Map<core::String*, core::List<core::int*>*>* map22 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t141 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t124 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t142 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t141.{core::Map::[]=}{Invariant}(#t142.{core::MapEntry::key}{core::String*}, #t142.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t141.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t141;
+      #t124.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t124.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t124;
   core::List<core::int*>* list30 = block {
-    final core::List<core::int*>* #t143 = <core::int*>[];
+    final core::List<core::int*>* #t125 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t143.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-  } =>#t143;
+        #t125.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+  } =>#t125;
   core::Set<core::int*>* set30 = block {
-    final core::Set<core::int*>* #t144 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t126 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t144.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-    #t144.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t144;
+        #t126.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+    #t126.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t126;
   core::Map<core::String*, core::int*>* map30 = block {
-    final core::Map<core::String*, core::int*>* #t145 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t127 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t146 in <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-          #t145.{core::Map::[]=}{Invariant}(#t146.{core::MapEntry::key}{core::String*}, #t146.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t145.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t145;
+        #t127.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t127.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t127;
   core::List<dynamic>* list31 = block {
-    final core::List<dynamic>* #t147 = <dynamic>[];
+    final core::List<dynamic>* #t128 = <dynamic>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t147.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-  } =>#t147;
+        #t128.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+  } =>#t128;
   core::Set<dynamic>* set31 = block {
-    final core::Set<dynamic>* #t148 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t129 = col::LinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t148.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-    #t148.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t148;
+        #t129.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+    #t129.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t129;
   core::Map<core::String*, dynamic>* map31 = block {
-    final core::Map<core::String*, dynamic>* #t149 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t130 = <core::String*, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, dynamic>* #t150 in <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>})
-          #t149.{core::Map::[]=}{Invariant}(#t150.{core::MapEntry::key}{core::String*}, #t150.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-    #t149.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t149;
+        #t130.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t130.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t130;
   core::List<core::List<core::int*>*>* list33 = block {
-    final core::List<core::List<core::int*>*>* #t151 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t131 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t151.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t151;
+        #t131.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t131;
   core::Set<core::List<core::int*>*>* set33 = block {
-    final core::Set<core::List<core::int*>*>* #t152 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t132 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t152.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t152.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t152;
+        #t132.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t132.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t132;
   core::Map<core::String*, core::List<core::int*>*>* map33 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t153 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t133 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t154 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t153.{core::Map::[]=}{Invariant}(#t154.{core::MapEntry::key}{core::String*}, #t154.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t153.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t153;
+        #t133.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t133.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t133;
   core::List<core::List<core::int*>*>* list40 = block {
-    final core::List<core::List<core::int*>*>* #t155 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t134 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t155.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t155;
+      #t134.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t134;
   core::Set<core::List<core::int*>*>* set40 = block {
-    final core::Set<core::List<core::int*>*>* #t156 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t135 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t156.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t156.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t156;
+      #t135.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t135.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t135;
   core::Map<core::String*, core::List<core::int*>*>* map40 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t157 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t136 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t158 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t157.{core::Map::[]=}{Invariant}(#t158.{core::MapEntry::key}{core::String*}, #t158.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t157.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t157;
+      #t136.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t136.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t136;
   core::List<core::List<core::int*>*>* list41 = block {
+    final core::List<core::List<core::int*>*>* #t137 = <core::List<core::int*>*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t137.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t138 = col::LinkedHashSet::•<core::List<core::int*>*>();
+        #t138.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+      } =>#t138){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t137;
+  core::Set<core::List<core::int*>*>* set41 = block {
+    final core::Set<core::List<core::int*>*>* #t139 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t139.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t140 = col::LinkedHashSet::•<core::List<core::int*>*>();
+        #t140.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+      } =>#t140){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t139.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t139;
+  core::List<core::List<core::int*>*>* list42 = block {
+    final core::List<core::List<core::int*>*>* #t141 = <core::List<core::int*>*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t141.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t141;
+  core::Set<core::List<core::int*>*>* set42 = block {
+    final core::Set<core::List<core::int*>*>* #t142 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t142.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t142.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t142;
+  core::Map<core::String*, core::List<core::int*>*>* map42 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t143 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t143.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t143.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t143;
+  core::List<core::int*>* list50 = block {
+    final core::List<core::int*>* #t144 = <core::int*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t144.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+  } =>#t144;
+  core::Set<core::int*>* set50 = block {
+    final core::Set<core::int*>* #t145 = col::LinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t145.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+    #t145.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t145;
+  core::Map<core::String*, core::int*>* map50 = block {
+    final core::Map<core::String*, core::int*>* #t146 = <core::String*, core::int*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t146.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
+    #t146.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t146;
+  core::List<core::int*>* list51 = block {
+    final core::List<core::int*>* #t147 = <core::int*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t147.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t148 = col::LinkedHashSet::•<core::int*>();
+      } =>#t148){(core::Iterable<core::int*>*) →* void};
+  } =>#t147;
+  core::Set<core::int*>* set51 = block {
+    final core::Set<core::int*>* #t149 = col::LinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t149.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t150 = col::LinkedHashSet::•<core::int*>();
+      } =>#t150){(core::Iterable<core::int*>*) →* void};
+    #t149.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t149;
+  core::List<core::int*>* list52 = block {
+    final core::List<core::int*>* #t151 = <core::int*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t151.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+  } =>#t151;
+  core::Set<core::int*>* set52 = block {
+    final core::Set<core::int*>* #t152 = col::LinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t152.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+    #t152.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t152;
+  core::List<core::List<core::int*>*>* list60 = block {
+    final core::List<core::List<core::int*>*>* #t153 = <core::List<core::int*>*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t153.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t153;
+  core::Set<core::List<core::int*>*>* set60 = block {
+    final core::Set<core::List<core::int*>*>* #t154 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t154.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t154.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t154;
+  core::Map<core::String*, core::List<core::int*>*>* map60 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t155 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t155.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t155.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t155;
+  core::List<core::List<core::int*>*>* list61 = block {
+    final core::List<core::List<core::int*>*>* #t156 = <core::List<core::int*>*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t156.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t156;
+  core::Set<core::List<core::int*>*>* set61 = block {
+    final core::Set<core::List<core::int*>*>* #t157 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t157.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t157.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t157;
+  core::Map<core::String*, core::List<core::int*>*>* map61 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t158 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t158.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t158.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t158;
+  core::List<core::List<core::int*>*>* list70 = block {
     final core::List<core::List<core::int*>*>* #t159 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t159.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t160 = col::LinkedHashSet::•<core::List<core::int*>*>();
-        #t160.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-      } =>#t160){(core::Iterable<core::List<core::int*>*>*) →* void};
+      #t159.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
   } =>#t159;
-  core::Set<core::List<core::int*>*>* set41 = block {
-    final core::Set<core::List<core::int*>*>* #t161 = col::LinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t161.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t162 = col::LinkedHashSet::•<core::List<core::int*>*>();
-        #t162.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-      } =>#t162){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t161.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t161;
-  core::List<core::List<core::int*>*>* list42 = block {
-    final core::List<core::List<core::int*>*>* #t163 = <core::List<core::int*>*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t163.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t163;
-  core::Set<core::List<core::int*>*>* set42 = block {
-    final core::Set<core::List<core::int*>*>* #t164 = col::LinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t164.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t164.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t164;
-  core::Map<core::String*, core::List<core::int*>*>* map42 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t165 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t166 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t165.{core::Map::[]=}{Invariant}(#t166.{core::MapEntry::key}{core::String*}, #t166.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t165.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t165;
-  core::List<core::int*>* list50 = block {
-    final core::List<core::int*>* #t167 = <core::int*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t167.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-  } =>#t167;
-  core::Set<core::int*>* set50 = block {
-    final core::Set<core::int*>* #t168 = col::LinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t168.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-    #t168.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t168;
-  core::Map<core::String*, core::int*>* map50 = block {
-    final core::Map<core::String*, core::int*>* #t169 = <core::String*, core::int*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t170 in <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t169.{core::Map::[]=}{Invariant}(#t170.{core::MapEntry::key}{core::String*}, #t170.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t169.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t169;
-  core::List<core::int*>* list51 = block {
-    final core::List<core::int*>* #t171 = <core::int*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t171.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t172 = col::LinkedHashSet::•<core::int*>();
-      } =>#t172){(core::Iterable<core::int*>*) →* void};
-  } =>#t171;
-  core::Set<core::int*>* set51 = block {
-    final core::Set<core::int*>* #t173 = col::LinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t173.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t174 = col::LinkedHashSet::•<core::int*>();
-      } =>#t174){(core::Iterable<core::int*>*) →* void};
-    #t173.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t173;
-  core::List<core::int*>* list52 = block {
-    final core::List<core::int*>* #t175 = <core::int*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t175.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-  } =>#t175;
-  core::Set<core::int*>* set52 = block {
-    final core::Set<core::int*>* #t176 = col::LinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t176.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-    #t176.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t176;
-  core::List<core::List<core::int*>*>* list60 = block {
-    final core::List<core::List<core::int*>*>* #t177 = <core::List<core::int*>*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t177.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t177;
-  core::Set<core::List<core::int*>*>* set60 = block {
-    final core::Set<core::List<core::int*>*>* #t178 = col::LinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t178.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t178.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t178;
-  core::Map<core::String*, core::List<core::int*>*>* map60 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t179 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t180 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t179.{core::Map::[]=}{Invariant}(#t180.{core::MapEntry::key}{core::String*}, #t180.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t179.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t179;
-  core::List<core::List<core::int*>*>* list61 = block {
-    final core::List<core::List<core::int*>*>* #t181 = <core::List<core::int*>*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t181.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t181;
-  core::Set<core::List<core::int*>*>* set61 = block {
-    final core::Set<core::List<core::int*>*>* #t182 = col::LinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t182.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t182.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t182;
-  core::Map<core::String*, core::List<core::int*>*>* map61 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t183 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t184 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t183.{core::Map::[]=}{Invariant}(#t184.{core::MapEntry::key}{core::String*}, #t184.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t183.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t183;
-  core::List<core::List<core::int*>*>* list70 = block {
-    final core::List<core::List<core::int*>*>* #t185 = <core::List<core::int*>*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t185.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
-  } =>#t185;
   core::Set<core::List<core::int*>*>* set70 = block {
-    final core::Set<core::List<core::int*>*>* #t186 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t160 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t186.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-    #t186.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t186;
+      #t160.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+    #t160.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t160;
   core::Map<core::String*, core::List<core::int*>*>* map70 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t187 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t161 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t187.{core::Map::[]=}{Invariant}("bar", <core::int*>[]){(core::String*, core::List<core::int*>*) →* void};
-    #t187.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t187;
+      #t161.{core::Map::[]=}{Invariant}("bar", <core::int*>[]){(core::String*, core::List<core::int*>*) →* void};
+    #t161.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t161;
   core::List<core::List<core::int*>*>* list71 = block {
-    final core::List<core::List<core::int*>*>* #t188 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t162 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t188.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
-  } =>#t188;
+        #t162.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
+  } =>#t162;
   core::Set<core::List<core::int*>*>* set71 = block {
-    final core::Set<core::List<core::int*>*>* #t189 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t163 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t189.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-    #t189.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t189;
+        #t163.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+    #t163.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t163;
   core::Map<core::String*, core::List<core::int*>*>* map71 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t190 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t164 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t190.{core::Map::[]=}{Invariant}("bar", <core::int*>[]){(core::String*, core::List<core::int*>*) →* void};
-    #t190.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t190;
+        #t164.{core::Map::[]=}{Invariant}("bar", <core::int*>[]){(core::String*, core::List<core::int*>*) →* void};
+    #t164.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t164;
   core::List<core::num*>* list80 = block {
-    final core::List<core::num*>* #t191 = <core::num*>[];
+    final core::List<core::num*>* #t165 = <core::num*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t191.{core::List::add}{Invariant}(42){(core::num*) →* void};
+        #t165.{core::List::add}{Invariant}(42){(core::num*) →* void};
       else
-        #t191.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
-  } =>#t191;
+        #t165.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
+  } =>#t165;
   core::Set<core::num*>* set80 = block {
-    final core::Set<core::num*>* #t192 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t166 = col::LinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t192.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
+        #t166.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
       else
-        #t192.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t192.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t192;
+        #t166.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t166.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t166;
   core::Map<core::String*, core::num*>* map80 = block {
-    final core::Map<core::String*, core::num*>* #t193 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t167 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t193.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
+        #t167.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
       else
-        #t193.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t193.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t193;
+        #t167.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t167.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t167;
   core::List<core::num*>* list81 = block {
-    final core::List<core::num*>* #t194 = <core::num*>[];
+    final core::List<core::num*>* #t168 = <core::num*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t194.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t168.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t194.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t194;
+        #t168.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t168;
   core::Set<core::num*>* set81 = block {
-    final core::Set<core::num*>* #t195 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t169 = col::LinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t195.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t169.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t195.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-    #t195.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t195;
+        #t169.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+    #t169.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t169;
   core::Map<core::String*, core::num*>* map81 = block {
-    final core::Map<core::String*, core::num*>* #t196 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t170 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t197 in mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-          #t196.{core::Map::[]=}{Invariant}(#t197.{core::MapEntry::key}{core::String*}, #t197.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
+        #t170.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<core::String*, core::num*>*) →* void};
       else
-        for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t198 in mapStringDouble.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-          #t196.{core::Map::[]=}{Invariant}(#t198.{core::MapEntry::key}{core::String*}, #t198.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-    #t196.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t196;
+        #t170.{core::Map::addAll}{Invariant}(mapStringDouble){(core::Map<core::String*, core::num*>*) →* void};
+    #t170.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t170;
   core::List<dynamic>* list82 = block {
-    final core::List<dynamic>* #t199 = <dynamic>[];
+    final core::List<dynamic>* #t171 = <dynamic>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t199.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+        #t171.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
       else
-        #t199.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-  } =>#t199;
+        #t171.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+  } =>#t171;
   core::Set<dynamic>* set82 = block {
-    final core::Set<dynamic>* #t200 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t172 = col::LinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t200.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+        #t172.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
       else
-        #t200.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t200.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t200;
+        #t172.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t172.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t172;
   core::Map<dynamic, dynamic>* map82 = block {
-    final core::Map<dynamic, dynamic>* #t201 = <dynamic, dynamic>{};
+    final core::Map<dynamic, dynamic>* #t173 = <dynamic, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t202 in mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-          #t201.{core::Map::[]=}{Invariant}(#t202.{core::MapEntry::key}{dynamic}, #t202.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
+        #t173.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<dynamic, dynamic>*) →* void};
       else
-        for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t203 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-          #t201.{core::Map::[]=}{Invariant}(#t203.{core::MapEntry::key}{dynamic}, #t203.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
-    #t201.{core::Map::[]=}{Invariant}("baz", null){(dynamic, dynamic) →* void};
-  } =>#t201;
+        #t173.{core::Map::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*){(core::Map<dynamic, dynamic>*) →* void};
+    #t173.{core::Map::[]=}{Invariant}("baz", null){(dynamic, dynamic) →* void};
+  } =>#t173;
   core::List<core::num*>* list83 = block {
-    final core::List<core::num*>* #t204 = <core::num*>[];
+    final core::List<core::num*>* #t174 = <core::num*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t204.{core::List::add}{Invariant}(42){(core::num*) →* void};
+        #t174.{core::List::add}{Invariant}(42){(core::num*) →* void};
       else
-        #t204.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t204;
+        #t174.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t174;
   core::Set<core::num*>* set83 = block {
-    final core::Set<core::num*>* #t205 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t175 = col::LinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t205.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t175.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t205.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t205.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t205;
+        #t175.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t175.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t175;
   core::Map<core::String*, core::num*>* map83 = block {
-    final core::Map<core::String*, core::num*>* #t206 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t176 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t207 in mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-          #t206.{core::Map::[]=}{Invariant}(#t207.{core::MapEntry::key}{core::String*}, #t207.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
+        #t176.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<core::String*, core::num*>*) →* void};
       else
-        #t206.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t206.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t206;
+        #t176.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t176.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t176;
   core::List<core::int*>* list90 = block {
-    final core::List<core::int*>* #t208 = <core::int*>[];
+    final core::List<core::int*>* #t177 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t208.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
-  } =>#t208;
+      #t177.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+  } =>#t177;
   core::Set<core::int*>* set90 = block {
-    final core::Set<core::int*>* #t209 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t178 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t209.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
-    #t209.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t209;
+      #t178.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+    #t178.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t178;
   core::Map<core::String*, core::int*>* map90 = block {
-    final core::Map<core::String*, core::int*>* #t210 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t179 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t210.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
-    #t210.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t210;
+      #t179.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+    #t179.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t179;
   core::List<core::int*>* list91 = block {
-    final core::List<core::int*>* #t211 = <core::int*>[];
+    final core::List<core::int*>* #t180 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer dynamic #t212 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
-        final core::int* #t213 = #t212 as{TypeError} core::int*;
-        #t211.{core::List::add}{Invariant}(#t213){(core::int*) →* void};
+      for (final has-declared-initializer dynamic #t181 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
+        final core::int* #t182 = #t181 as{TypeError} core::int*;
+        #t180.{core::List::add}{Invariant}(#t182){(core::int*) →* void};
       }
-  } =>#t211;
+  } =>#t180;
   core::Set<core::int*>* set91 = block {
-    final core::Set<core::int*>* #t214 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t183 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer dynamic #t215 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
-        final core::int* #t216 = #t215 as{TypeError} core::int*;
-        #t214.{core::Set::add}{Invariant}(#t216){(core::int*) →* core::bool*};
+      for (final has-declared-initializer dynamic #t184 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
+        final core::int* #t185 = #t184 as{TypeError} core::int*;
+        #t183.{core::Set::add}{Invariant}(#t185){(core::int*) →* core::bool*};
       }
-    #t214.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t214;
+    #t183.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t183;
   core::Map<core::String*, core::int*>* map91 = block {
-    final core::Map<core::String*, core::int*>* #t217 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t186 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t218 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}) {
-        final core::String* #t219 = #t218.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
-        final core::int* #t220 = #t218.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-        #t217.{core::Map::[]=}{Invariant}(#t219, #t220){(core::String*, core::int*) →* void};
+      for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t187 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}) {
+        final core::String* #t188 = #t187.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
+        final core::int* #t189 = #t187.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
+        #t186.{core::Map::[]=}{Invariant}(#t188, #t189){(core::String*, core::int*) →* void};
       }
-    #t217.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t217;
+    #t186.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t186;
   core::List<core::int*>* list100 = block {
-    final core::List<core::int*>* #t221 = <core::int*>[];
-    for (final core::int* #t222 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t221.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t221;
+    final core::List<core::int*>* #t190 = <core::int*>[];
+    for (final core::int* #t191 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t190.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t190;
   core::Set<core::int*>* set100 = block {
-    final core::Set<core::int*>* #t223 = col::LinkedHashSet::•<core::int*>();
-    for (final core::int* #t224 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t223.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t223;
+    final core::Set<core::int*>* #t192 = col::LinkedHashSet::•<core::int*>();
+    for (final core::int* #t193 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t192.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t192;
   core::Map<core::String*, core::int*>* map100 = block {
-    final core::Map<core::String*, core::int*>* #t225 = <core::String*, core::int*>{};
-    for (final core::int* #t226 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t225.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-  } =>#t225;
+    final core::Map<core::String*, core::int*>* #t194 = <core::String*, core::int*>{};
+    for (final core::int* #t195 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t194.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+  } =>#t194;
   core::List<core::int*>* list110 = block {
-    final core::List<core::int*>* #t227 = <core::int*>[];
+    final core::List<core::int*>* #t196 = <core::int*>[];
     for (core::int* i in <core::int*>[1, 2, 3])
-      #t227.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t227;
+      #t196.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t196;
   core::Set<core::int*>* set110 = block {
-    final core::Set<core::int*>* #t228 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t197 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i in <core::int*>[1, 2, 3])
-      #t228.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-    #t228.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t228;
+      #t197.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+    #t197.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t197;
   core::Map<core::String*, core::int*>* map110 = block {
-    final core::Map<core::String*, core::int*>* #t229 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t198 = <core::String*, core::int*>{};
     for (core::int* i in <core::int*>[1, 2, 3])
-      #t229.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-    #t229.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t229;
+      #t198.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+    #t198.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t198;
   core::List<core::int*>* list120 = block {
-    final core::List<core::int*>* #t230 = <core::int*>[];
+    final core::List<core::int*>* #t199 = <core::int*>[];
     for (dynamic i in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*)
-      #t230.{core::List::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
-  } =>#t230;
+      #t199.{core::List::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+  } =>#t199;
   core::Set<core::int*>* set120 = block {
-    final core::Set<core::int*>* #t231 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t200 = col::LinkedHashSet::•<core::int*>();
     for (dynamic i in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*)
-      #t231.{core::Set::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
-    #t231.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t231;
+      #t200.{core::Set::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+    #t200.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t200;
   core::Map<core::String*, core::int*>* map120 = block {
-    final core::Map<core::String*, core::int*>* #t232 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t201 = <core::String*, core::int*>{};
     for (dynamic i in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*)
-      #t232.{core::Map::[]=}{Invariant}("bar", i as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
-    #t232.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t232;
+      #t201.{core::Map::[]=}{Invariant}("bar", i as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+    #t201.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t201;
   core::List<core::int*>* list130 = block {
-    final core::List<core::int*>* #t233 = <core::int*>[];
+    final core::List<core::int*>* #t202 = <core::int*>[];
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t233.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t233;
+      #t202.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t202;
   core::Set<core::int*>* set130 = block {
-    final core::Set<core::int*>* #t234 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t203 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t234.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-  } =>#t234;
+      #t203.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+  } =>#t203;
   core::Map<core::int*, core::int*>* map130 = block {
-    final core::Map<core::int*, core::int*>* #t235 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t204 = <core::int*, core::int*>{};
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t235.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
-  } =>#t235;
+      #t204.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
+  } =>#t204;
 }
 static method testForElementErrors(core::Map<core::int*, core::int*>* map, core::List<core::int*>* list) → dynamic async /* futureValueType= dynamic */ {
   block {
-    final core::List<core::int*>* #t236 = <core::int*>[];
+    final core::List<core::int*>* #t205 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t236.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:212:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t205.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:212:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) \"bar\"];
                                             ^" in "bar" as{TypeError} core::int*){(core::int*) →* void};
-  } =>#t236;
+  } =>#t205;
   block {
-    final core::Set<core::int*>* #t237 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t206 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t237.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:213:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t206.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:213:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\", null};
                                             ^" in "bar" as{TypeError} core::int*){(core::int*) →* core::bool*};
-    #t237.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t237;
+    #t206.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t206;
   block {
-    final core::Map<core::int*, core::int*>* #t238 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t207 = <core::int*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t238.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:50: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t207.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:50: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                  ^" in "bar" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                         ^" in "bar" as{TypeError} core::int*){(core::int*, core::int*) →* void};
-    #t238.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+    #t207.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                                ^" in "baz" as{TypeError} core::int*, null){(core::int*, core::int*) →* void};
-  } =>#t238;
+  } =>#t207;
   block {
-    final core::List<core::int*>* #t239 = <core::int*>[];
+    final core::List<core::int*>* #t208 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t239.{core::List::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:215:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t208.{core::List::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:215:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) ...[\"bar\"]];
                                                 ^" in "bar" as{TypeError} core::int*]){(core::Iterable<core::int*>*) →* void};
-  } =>#t239;
+  } =>#t208;
   block {
-    final core::Set<core::int*>* #t240 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t209 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t240.{core::Set::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:216:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t209.{core::Set::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:216:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) ...[\"bar\"], null};
                                                 ^" in "bar" as{TypeError} core::int*]){(core::Iterable<core::int*>*) →* void};
-    #t240.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t240;
+    #t209.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t209;
   block {
-    final core::Map<core::int*, core::int*>* #t241 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t210 = <core::int*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::int*, core::int*>* #t242 in <core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:54: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t210.{core::Map::addAll}{Invariant}(<core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:54: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
                                                      ^" in "bar" as{TypeError} core::int*: invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:61: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
-                                                            ^" in "bar" as{TypeError} core::int*}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int*, core::int*>>})
-        #t241.{core::Map::[]=}{Invariant}(#t242.{core::MapEntry::key}{core::int*}, #t242.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
-    #t241.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:69: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+                                                            ^" in "bar" as{TypeError} core::int*}){(core::Map<core::int*, core::int*>*) →* void};
+    #t210.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:69: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
                                                                     ^" in "baz" as{TypeError} core::int*, null){(core::int*, core::int*) →* void};
-  } =>#t241;
+  } =>#t210;
   block {
-    final core::List<core::int*>* #t243 = <core::int*>[];
+    final core::List<core::int*>* #t211 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t243.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:218:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t211.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:218:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) ...map];
                                                ^"){(core::int*) →* void};
-  } =>#t243;
+  } =>#t211;
   block {
-    final core::Set<core::int*>* #t244 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t212 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t244.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:219:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t212.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:219:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) ...map, null};
                                                ^"){(core::int*) →* core::bool*};
-    #t244.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t244;
+    #t212.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t212;
   <core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:220:53: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...list, 42: null};
@@ -1839,66 +1807,66 @@
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...list, 42: null};
                                                     ^": null};
   block {
-    final core::List<core::String*>* #t245 = <core::String*>[];
+    final core::List<core::String*>* #t213 = <core::String*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t245.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t213.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14];
                                                              ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
       else
-        #t245.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t213.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14];
                                                                      ^" in 3.14 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t245;
+  } =>#t213;
   block {
-    final core::Set<core::String*>* #t246 = col::LinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t214 = col::LinkedHashSet::•<core::String*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t246.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t214.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14, null};
                                                              ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
       else
-        #t246.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t214.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14, null};
                                                                      ^" in 3.14 as{TypeError} core::String*){(core::String*) →* core::bool*};
-    #t246.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
-  } =>#t246;
+    #t214.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
+  } =>#t214;
   block {
-    final core::Map<core::String*, core::String*>* #t247 = <core::String*, core::String*>{};
+    final core::Map<core::String*, core::String*>* #t215 = <core::String*, core::String*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t247.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:77: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t215.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:77: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String, String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else \"bar\": 3.14, \"baz\": null};
                                                                             ^" in 42 as{TypeError} core::String*){(core::String*, core::String*) →* void};
       else
-        #t247.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:92: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t215.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:92: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String, String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else \"bar\": 3.14, \"baz\": null};
                                                                                            ^" in 3.14 as{TypeError} core::String*){(core::String*, core::String*) →* void};
-    #t247.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
-  } =>#t247;
+    #t215.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
+  } =>#t215;
   block {
-    final core::List<core::int*>* #t248 = <core::int*>[];
+    final core::List<core::int*>* #t216 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t248.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:224:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t216.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:224:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...map else 42];
                                                              ^"){(core::int*) →* void};
       else
-        #t248.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t248;
+        #t216.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t216;
   block {
-    final core::Set<core::int*>* #t249 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t217 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t249.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:225:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t217.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:225:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...map else 42, null};
                                                              ^"){(core::int*) →* core::bool*};
       else
-        #t249.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t249.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t249;
+        #t217.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t217.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t217;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:226:70: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...list else \"bar\": 42, \"baz\": null};
@@ -1907,28 +1875,28 @@
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...list else \"bar\": 42, \"baz\": null};
                                                                      ^": null};
   block {
-    final core::List<core::int*>* #t250 = <core::int*>[];
+    final core::List<core::int*>* #t218 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t250.{core::List::add}{Invariant}(42){(core::int*) →* void};
+        #t218.{core::List::add}{Invariant}(42){(core::int*) →* void};
       else
-        #t250.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:227:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t218.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:227:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else ...map];
                                                                      ^"){(core::int*) →* void};
-  } =>#t250;
+  } =>#t218;
   block {
-    final core::Set<core::int*>* #t251 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t219 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t251.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+        #t219.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
       else
-        #t251.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:228:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t219.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:228:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else ...map, null};
                                                                      ^"){(core::int*) →* core::bool*};
-    #t251.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t251;
+    #t219.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t219;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:229:85: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else ...list, \"baz\": null};
@@ -1938,218 +1906,218 @@
                                                                                     ^": null};
   final core::int* i = 0;
   block {
-    final core::List<core::int*>* #t252 = <core::int*>[];
-    for (final core::int* #t253 in <core::int*>[1]) {
+    final core::List<core::int*>* #t220 = <core::int*>[];
+    for (final core::int* #t221 in <core::int*>[1]) {
       invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:232:14: Error: Can't assign to the final variable 'i'.
   <int>[for (i in <int>[1]) i];
              ^";
-      #t252.{core::List::add}{Invariant}(i){(core::int*) →* void};
+      #t220.{core::List::add}{Invariant}(i){(core::int*) →* void};
     }
-  } =>#t252;
+  } =>#t220;
   block {
-    final core::Set<core::int*>* #t254 = col::LinkedHashSet::•<core::int*>();
-    for (final core::int* #t255 in <core::int*>[1]) {
+    final core::Set<core::int*>* #t222 = col::LinkedHashSet::•<core::int*>();
+    for (final core::int* #t223 in <core::int*>[1]) {
       invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:233:14: Error: Can't assign to the final variable 'i'.
   <int>{for (i in <int>[1]) i, null};
              ^";
-      #t254.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+      #t222.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
     }
-    #t254.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t254;
+    #t222.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t222;
   block {
-    final core::Map<core::String*, core::int*>* #t256 = <core::String*, core::int*>{};
-    for (final core::int* #t257 in <core::int*>[1]) {
+    final core::Map<core::String*, core::int*>* #t224 = <core::String*, core::int*>{};
+    for (final core::int* #t225 in <core::int*>[1]) {
       invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:234:21: Error: Can't assign to the final variable 'i'.
 \t<String, int>{for (i in <int>[1]) \"bar\": i, \"baz\": null};
 \t                   ^";
-      #t256.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+      #t224.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
     }
-    #t256.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t256;
+    #t224.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t224;
   core::List<dynamic>* list10 = block {
-    final core::List<dynamic>* #t258 = <dynamic>[];
+    final core::List<dynamic>* #t226 = <dynamic>[];
     for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:236:31: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
   var list10 = [for (var i in \"not iterable\") i];
                               ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*)
-      #t258.{core::List::add}{Invariant}(i){(dynamic) →* void};
-  } =>#t258;
+      #t226.{core::List::add}{Invariant}(i){(dynamic) →* void};
+  } =>#t226;
   core::Set<dynamic>* set10 = block {
-    final core::Set<dynamic>* #t259 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t227 = col::LinkedHashSet::•<dynamic>();
     for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:237:30: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
   var set10 = {for (var i in \"not iterable\") i, null};
                              ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*)
-      #t259.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
-    #t259.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t259;
+      #t227.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
+    #t227.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t227;
   core::Map<core::String*, dynamic>* map10 = block {
-    final core::Map<core::String*, dynamic>* #t260 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t228 = <core::String*, dynamic>{};
     for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:238:30: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
   var map10 = {for (var i in \"not iterable\") \"bar\": i, \"baz\": null};
                              ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*)
-      #t260.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
-    #t260.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t260;
+      #t228.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
+    #t228.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t228;
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t261 = <core::int*>[];
+    final core::List<core::int*>* #t229 = <core::int*>[];
     for (core::int* i in <core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:239:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list20 = [for (int i in [\"not\", \"int\"]) i];
                                ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:239:39: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list20 = [for (int i in [\"not\", \"int\"]) i];
                                       ^" in "int" as{TypeError} core::int*])
-      #t261.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t261;
+      #t229.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t229;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t262 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t230 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i in <core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:240:31: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set20 = {for (int i in [\"not\", \"int\"]) i, null};
                               ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:240:38: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set20 = {for (int i in [\"not\", \"int\"]) i, null};
                                      ^" in "int" as{TypeError} core::int*])
-      #t262.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-    #t262.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t262;
+      #t230.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+    #t230.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t230;
   core::Map<core::String*, core::int*>* map20 = block {
-    final core::Map<core::String*, core::int*>* #t263 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t231 = <core::String*, core::int*>{};
     for (core::int* i in <core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:241:31: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map20 = {for (int i in [\"not\", \"int\"]) \"bar\": i, \"baz\": null};
                               ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:241:38: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map20 = {for (int i in [\"not\", \"int\"]) \"bar\": i, \"baz\": null};
                                      ^" in "int" as{TypeError} core::int*])
-      #t263.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-    #t263.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t263;
+      #t231.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+    #t231.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t231;
   core::List<dynamic>* list30 = block {
-    final core::List<dynamic>* #t264 = <dynamic>[];
+    final core::List<dynamic>* #t232 = <dynamic>[];
     await for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:242:37: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
   var list30 = [await for (var i in \"not stream\") i];
                                     ^" in "not stream" as{TypeError} asy::Stream<dynamic>*)
-      #t264.{core::List::add}{Invariant}(i){(dynamic) →* void};
-  } =>#t264;
+      #t232.{core::List::add}{Invariant}(i){(dynamic) →* void};
+  } =>#t232;
   core::Set<dynamic>* set30 = block {
-    final core::Set<dynamic>* #t265 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t233 = col::LinkedHashSet::•<dynamic>();
     await for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:243:36: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
   var set30 = {await for (var i in \"not stream\") i, null};
                                    ^" in "not stream" as{TypeError} asy::Stream<dynamic>*)
-      #t265.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
-    #t265.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t265;
+      #t233.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
+    #t233.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t233;
   core::Map<core::String*, dynamic>* map30 = block {
-    final core::Map<core::String*, dynamic>* #t266 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t234 = <core::String*, dynamic>{};
     await for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:244:36: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
   var map30 = {await for (var i in \"not stream\") \"bar\": i, \"baz\": null};
                                    ^" in "not stream" as{TypeError} asy::Stream<dynamic>*)
-      #t266.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
-    #t266.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t266;
+      #t234.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
+    #t234.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t234;
   core::List<core::int*>* list40 = block {
-    final core::List<core::int*>* #t267 = <core::int*>[];
+    final core::List<core::int*>* #t235 = <core::int*>[];
     await for (core::int* i in asy::Stream::fromIterable<core::int*>(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:245:58: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list40 = [await for (int i in Stream.fromIterable([\"not\", \"int\"])) i];
                                                          ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:245:65: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list40 = [await for (int i in Stream.fromIterable([\"not\", \"int\"])) i];
                                                                 ^" in "int" as{TypeError} core::int*]))
-      #t267.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t267;
+      #t235.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t235;
   core::Set<core::int*>* set40 = block {
-    final core::Set<core::int*>* #t268 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t236 = col::LinkedHashSet::•<core::int*>();
     await for (core::int* i in asy::Stream::fromIterable<core::int*>(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:246:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) i, null};
                                                         ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:246:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) i, null};
                                                                ^" in "int" as{TypeError} core::int*]))
-      #t268.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-    #t268.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t268;
+      #t236.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+    #t236.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t236;
   core::Map<core::String*, core::int*>* map40 = block {
-    final core::Map<core::String*, core::int*>* #t269 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t237 = <core::String*, core::int*>{};
     await for (core::int* i in asy::Stream::fromIterable<core::int*>(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:247:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) \"bar\": i, \"baz\": null};
                                                         ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:247:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) \"bar\": i, \"baz\": null};
                                                                ^" in "int" as{TypeError} core::int*]))
-      #t269.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-    #t269.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t269;
+      #t237.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+    #t237.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t237;
   core::List<core::int*>* list50 = block {
-    final core::List<core::int*>* #t270 = <core::int*>[];
+    final core::List<core::int*>* #t238 = <core::int*>[];
     for (; ; )
-      #t270.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t270;
+      #t238.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t238;
   core::Set<core::int*>* set50 = block {
-    final core::Set<core::int*>* #t271 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t239 = col::LinkedHashSet::•<core::int*>();
     for (; ; )
-      #t271.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t271.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t271;
+      #t239.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t239.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t239;
   core::Map<core::String*, core::int*>* map50 = block {
-    final core::Map<core::String*, core::int*>* #t272 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t240 = <core::String*, core::int*>{};
     for (; ; )
-      #t272.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t272.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t272;
+      #t240.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t240.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t240;
   core::List<core::int*>* list60 = block {
-    final core::List<core::int*>* #t273 = <core::int*>[];
+    final core::List<core::int*>* #t241 = <core::int*>[];
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:251:24: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var list60 = [for (; \"not bool\";) 42];
                        ^" in "not bool" as{TypeError} core::bool*; )
-      #t273.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t273;
+      #t241.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t241;
   core::Set<core::int*>* set60 = block {
-    final core::Set<core::int*>* #t274 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t242 = col::LinkedHashSet::•<core::int*>();
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:252:23: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var set60 = {for (; \"not bool\";) 42, null};
                       ^" in "not bool" as{TypeError} core::bool*; )
-      #t274.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t274.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t274;
+      #t242.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t242.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t242;
   core::Map<core::String*, core::int*>* map60 = block {
-    final core::Map<core::String*, core::int*>* #t275 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t243 = <core::String*, core::int*>{};
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:253:23: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var map60 = {for (; \"not bool\";) \"bar\": 42, \"baz\": null};
                       ^" in "not bool" as{TypeError} core::bool*; )
-      #t275.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t275.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t275;
+      #t243.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t243.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t243;
 }
 static method testForElementErrorsNotAsync(asy::Stream<core::int*>* stream) → dynamic {
   block {
-    final core::List<core::int*>* #t276 = <core::int*>[];
+    final core::List<core::int*>* #t244 = <core::int*>[];
     await for (core::int* i in stream)
-      #t276.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t276;
+      #t244.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t244;
   block {
-    final core::Set<core::int*>* #t277 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t245 = col::LinkedHashSet::•<core::int*>();
     await for (core::int* i in stream)
-      #t277.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-  } =>#t277;
+      #t245.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+  } =>#t245;
   block {
-    final core::Map<core::String*, core::int*>* #t278 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t246 = <core::String*, core::int*>{};
     await for (core::int* i in stream)
-      #t278.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-  } =>#t278;
+      #t246.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+  } =>#t246;
 }
 static method testPromotion(self::A* a) → dynamic {
   core::List<core::int*>* list10 = block {
-    final core::List<core::int*>* #t279 = <core::int*>[];
+    final core::List<core::int*>* #t247 = <core::int*>[];
     if(a is self::B*)
-      #t279.{core::List::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* void};
-  } =>#t279;
+      #t247.{core::List::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* void};
+  } =>#t247;
   core::Set<core::int*>* set10 = block {
-    final core::Set<core::int*>* #t280 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t248 = col::LinkedHashSet::•<core::int*>();
     if(a is self::B*)
-      #t280.{core::Set::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* core::bool*};
-  } =>#t280;
+      #t248.{core::Set::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* core::bool*};
+  } =>#t248;
   core::Map<core::int*, core::int*>* map10 = block {
-    final core::Map<core::int*, core::int*>* #t281 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t249 = <core::int*, core::int*>{};
     if(a is self::B*)
-      #t281.{core::Map::[]=}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}, a{self::B*}.{self::B::foo}{core::int*}){(core::int*, core::int*) →* void};
-  } =>#t281;
+      #t249.{core::Map::[]=}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}, a{self::B*}.{self::B::foo}{core::int*}){(core::int*, core::int*) →* void};
+  } =>#t249;
 }
 static method main() → dynamic {}
 
diff --git a/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.modular.expect b/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.modular.expect
index 7bea2cf..ea911ec 100644
--- a/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.modular.expect
@@ -516,501 +516,486 @@
   core::Map<core::String*, core::int*>* map20 = block {
     final core::Map<core::String*, core::int*>* #t12 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t13 in <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t12.{core::Map::[]=}{Invariant}(#t13.{core::MapEntry::key}{core::String*}, #t13.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+      #t12.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
     #t12.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
   } =>#t12;
   core::List<dynamic>* list21 = block {
-    final core::List<dynamic>* #t14 = <dynamic>[];
+    final core::List<dynamic>* #t13 = <dynamic>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t14.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-  } =>#t14;
+      #t13.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+  } =>#t13;
   core::Set<dynamic>* set21 = block {
-    final core::Set<dynamic>* #t15 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t14 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t15.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-    #t15.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t15;
+      #t14.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+    #t14.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t14;
   core::Map<core::String*, dynamic>* map21 = block {
-    final core::Map<core::String*, dynamic>* #t16 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t15 = <core::String*, dynamic>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, dynamic>* #t17 in <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>})
-        #t16.{core::Map::[]=}{Invariant}(#t17.{core::MapEntry::key}{core::String*}, #t17.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-    #t16.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t16;
+      #t15.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t15.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t15;
   core::List<core::List<core::int*>*>* list22 = block {
-    final core::List<core::List<core::int*>*>* #t18 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t16 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t18.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t18;
+      #t16.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t16;
   core::Set<core::List<core::int*>*>* set22 = block {
-    final core::Set<core::List<core::int*>*>* #t19 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t17 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t19.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t19.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t19;
+      #t17.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t17.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t17;
   core::Map<core::String*, core::List<core::int*>*>* map22 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t20 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t18 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t21 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t20.{core::Map::[]=}{Invariant}(#t21.{core::MapEntry::key}{core::String*}, #t21.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t20.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t20;
+      #t18.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t18.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t18;
   core::List<core::int*>* list30 = block {
-    final core::List<core::int*>* #t22 = <core::int*>[];
+    final core::List<core::int*>* #t19 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t22.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-  } =>#t22;
+        #t19.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+  } =>#t19;
   core::Set<core::int*>* set30 = block {
-    final core::Set<core::int*>* #t23 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t20 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t23.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-    #t23.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t23;
+        #t20.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+    #t20.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t20;
   core::Map<core::String*, core::int*>* map30 = block {
-    final core::Map<core::String*, core::int*>* #t24 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t21 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t25 in <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-          #t24.{core::Map::[]=}{Invariant}(#t25.{core::MapEntry::key}{core::String*}, #t25.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t24.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t24;
+        #t21.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t21.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t21;
   core::List<dynamic>* list31 = block {
-    final core::List<dynamic>* #t26 = <dynamic>[];
+    final core::List<dynamic>* #t22 = <dynamic>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t26.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-  } =>#t26;
+        #t22.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+  } =>#t22;
   core::Set<dynamic>* set31 = block {
-    final core::Set<dynamic>* #t27 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t23 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t27.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-    #t27.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t27;
+        #t23.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+    #t23.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t23;
   core::Map<core::String*, dynamic>* map31 = block {
-    final core::Map<core::String*, dynamic>* #t28 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t24 = <core::String*, dynamic>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, dynamic>* #t29 in <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>})
-          #t28.{core::Map::[]=}{Invariant}(#t29.{core::MapEntry::key}{core::String*}, #t29.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-    #t28.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t28;
+        #t24.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t24.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t24;
   core::List<core::List<core::int*>*>* list33 = block {
-    final core::List<core::List<core::int*>*>* #t30 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t25 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t30.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t30;
+        #t25.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t25;
   core::Set<core::List<core::int*>*>* set33 = block {
-    final core::Set<core::List<core::int*>*>* #t31 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t26 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t31.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t31.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t31;
+        #t26.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t26.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t26;
   core::Map<core::String*, core::List<core::int*>*>* map33 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t32 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t27 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t33 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t32.{core::Map::[]=}{Invariant}(#t33.{core::MapEntry::key}{core::String*}, #t33.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t32.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t32;
+        #t27.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t27.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t27;
   core::List<core::List<core::int*>*>* list40 = block {
-    final core::List<core::List<core::int*>*>* #t34 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t28 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t34.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t34;
+      #t28.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t28;
   core::Set<core::List<core::int*>*>* set40 = block {
-    final core::Set<core::List<core::int*>*>* #t35 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t29 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t35.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t35.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t35;
+      #t29.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t29.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t29;
   core::Map<core::String*, core::List<core::int*>*>* map40 = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:41:34: Error: Both Iterable and Map spread elements encountered in ambiguous literal.
   Map<String, List<int>> map40 = {if (oracle(\"foo\")) ...{\"bar\", []}, \"baz\": null};
                                  ^";
   core::List<core::List<core::int*>*>* list41 = block {
-    final core::List<core::List<core::int*>*>* #t36 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t30 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t36.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t37 = col::LinkedHashSet::•<core::List<core::int*>*>();
-        #t37.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-      } =>#t37){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t36;
+      #t30.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t31 = col::LinkedHashSet::•<core::List<core::int*>*>();
+        #t31.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+      } =>#t31){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t30;
   core::Set<core::List<core::int*>*>* set41 = block {
-    final core::Set<core::List<core::int*>*>* #t38 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t32 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t38.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t39 = col::LinkedHashSet::•<core::List<core::int*>*>();
-        #t39.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-      } =>#t39){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t38.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t38;
+      #t32.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t33 = col::LinkedHashSet::•<core::List<core::int*>*>();
+        #t33.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+      } =>#t33){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t32.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t32;
   core::List<core::List<core::int*>*>* list42 = block {
-    final core::List<core::List<core::int*>*>* #t40 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t34 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t40.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t40;
+        #t34.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t34;
   core::Set<core::List<core::int*>*>* set42 = block {
-    final core::Set<core::List<core::int*>*>* #t41 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t35 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t41.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t41.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t41;
+        #t35.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t35.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t35;
   core::Map<core::String*, core::List<core::int*>*>* map42 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t42 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t36 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t43 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t42.{core::Map::[]=}{Invariant}(#t43.{core::MapEntry::key}{core::String*}, #t43.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t42.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t42;
+        #t36.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t36.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t36;
   core::List<core::int*>* list50 = block {
+    final core::List<core::int*>* #t37 = <core::int*>[];
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t37.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+  } =>#t37;
+  core::Set<core::int*>* set50 = block {
+    final core::Set<core::int*>* #t38 = col::LinkedHashSet::•<core::int*>();
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t38.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+    #t38.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t38;
+  core::Map<core::String*, core::int*>* map50 = block {
+    final core::Map<core::String*, core::int*>* #t39 = <core::String*, core::int*>{};
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t39.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
+    #t39.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t39;
+  core::List<core::int*>* list51 = block {
+    final core::List<core::int*>* #t40 = <core::int*>[];
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t40.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t41 = col::LinkedHashSet::•<core::int*>();
+      } =>#t41){(core::Iterable<core::int*>*) →* void};
+  } =>#t40;
+  core::Set<core::int*>* set51 = block {
+    final core::Set<core::int*>* #t42 = col::LinkedHashSet::•<core::int*>();
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t42.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t43 = col::LinkedHashSet::•<core::int*>();
+      } =>#t43){(core::Iterable<core::int*>*) →* void};
+    #t42.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t42;
+  core::List<core::int*>* list52 = block {
     final core::List<core::int*>* #t44 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t44.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t44.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
   } =>#t44;
-  core::Set<core::int*>* set50 = block {
+  core::Set<core::int*>* set52 = block {
     final core::Set<core::int*>* #t45 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t45.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t45.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
     #t45.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
   } =>#t45;
-  core::Map<core::String*, core::int*>* map50 = block {
+  core::Map<core::String*, core::int*>* map52 = block {
     final core::Map<core::String*, core::int*>* #t46 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t47 in <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t46.{core::Map::[]=}{Invariant}(#t47.{core::MapEntry::key}{core::String*}, #t47.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t46.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
     #t46.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
   } =>#t46;
-  core::List<core::int*>* list51 = block {
-    final core::List<core::int*>* #t48 = <core::int*>[];
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t48.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t49 = col::LinkedHashSet::•<core::int*>();
-      } =>#t49){(core::Iterable<core::int*>*) →* void};
-  } =>#t48;
-  core::Set<core::int*>* set51 = block {
-    final core::Set<core::int*>* #t50 = col::LinkedHashSet::•<core::int*>();
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t50.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t51 = col::LinkedHashSet::•<core::int*>();
-      } =>#t51){(core::Iterable<core::int*>*) →* void};
-    #t50.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t50;
-  core::List<core::int*>* list52 = block {
-    final core::List<core::int*>* #t52 = <core::int*>[];
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t52.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-  } =>#t52;
-  core::Set<core::int*>* set52 = block {
-    final core::Set<core::int*>* #t53 = col::LinkedHashSet::•<core::int*>();
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t53.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-    #t53.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t53;
-  core::Map<core::String*, core::int*>* map52 = block {
-    final core::Map<core::String*, core::int*>* #t54 = <core::String*, core::int*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t55 in <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-          #t54.{core::Map::[]=}{Invariant}(#t55.{core::MapEntry::key}{core::String*}, #t55.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t54.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t54;
   core::List<core::List<core::int*>*>* list60 = block {
-    final core::List<core::List<core::int*>*>* #t56 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t47 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t56.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t56;
+      #t47.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t47;
   core::Set<core::List<core::int*>*>* set60 = block {
-    final core::Set<core::List<core::int*>*>* #t57 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t48 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t57.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t57.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t57;
+      #t48.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t48.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t48;
   core::Map<core::String*, core::List<core::int*>*>* map60 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t58 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t49 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t59 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t58.{core::Map::[]=}{Invariant}(#t59.{core::MapEntry::key}{core::String*}, #t59.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t58.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t58;
+      #t49.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t49.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t49;
   core::List<core::List<core::int*>*>* list61 = block {
-    final core::List<core::List<core::int*>*>* #t60 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t50 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t60.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t60;
+        #t50.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t50;
   core::Set<core::List<core::int*>*>* set61 = block {
-    final core::Set<core::List<core::int*>*>* #t61 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t51 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t61.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t61.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t61;
+        #t51.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t51.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t51;
   core::Map<core::String*, core::List<core::int*>*>* map61 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t62 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t52 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t63 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t62.{core::Map::[]=}{Invariant}(#t63.{core::MapEntry::key}{core::String*}, #t63.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t62.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t62;
+        #t52.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t52.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t52;
   core::List<core::List<core::int*>*>* list70 = block {
-    final core::List<core::List<core::int*>*>* #t64 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t53 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t64.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
-  } =>#t64;
+      #t53.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
+  } =>#t53;
   core::Set<core::List<core::int*>*>* set70 = block {
-    final core::Set<core::List<core::int*>*>* #t65 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t54 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t65.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-    #t65.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t65;
+      #t54.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+    #t54.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t54;
   core::List<core::List<core::int*>*>* list71 = block {
-    final core::List<core::List<core::int*>*>* #t66 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t55 = <core::List<core::int*>*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t66.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
-  } =>#t66;
+        #t55.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
+  } =>#t55;
   core::Set<core::List<core::int*>*>* set71 = block {
-    final core::Set<core::List<core::int*>*>* #t67 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t56 = col::LinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t67.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-    #t67.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t67;
+        #t56.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+    #t56.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t56;
   core::List<core::num*>* list80 = block {
-    final core::List<core::num*>* #t68 = <core::num*>[];
+    final core::List<core::num*>* #t57 = <core::num*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t68.{core::List::add}{Invariant}(42){(core::num*) →* void};
+      #t57.{core::List::add}{Invariant}(42){(core::num*) →* void};
     else
-      #t68.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
-  } =>#t68;
+      #t57.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
+  } =>#t57;
   core::Set<core::num*>* set80 = block {
-    final core::Set<core::num*>* #t69 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t58 = col::LinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t69.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
+      #t58.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
     else
-      #t69.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t69.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t69;
+      #t58.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t58.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t58;
   core::Map<core::String*, core::num*>* map80 = block {
-    final core::Map<core::String*, core::num*>* #t70 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t59 = <core::String*, core::num*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t70.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
+      #t59.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
     else
-      #t70.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t70.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t70;
+      #t59.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t59.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t59;
   core::List<core::num*>* list81 = block {
-    final core::List<core::num*>* #t71 = <core::num*>[];
+    final core::List<core::num*>* #t60 = <core::num*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t71.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t60.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t71.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t71;
+      #t60.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t60;
   core::Set<core::num*>* set81 = block {
-    final core::Set<core::num*>* #t72 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t61 = col::LinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t72.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t61.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t72.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-    #t72.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t72;
+      #t61.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+    #t61.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t61;
   core::Map<core::String*, core::num*>* map81 = block {
-    final core::Map<core::String*, core::num*>* #t73 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t62 = <core::String*, core::num*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t74 in mapToInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-        #t73.{core::Map::[]=}{Invariant}(#t74.{core::MapEntry::key}{core::String*}, #t74.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
+      #t62.{core::Map::addAll}{Invariant}(mapToInt){(core::Map<core::String*, core::num*>*) →* void};
     else
-      for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t75 in mapToDouble.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-        #t73.{core::Map::[]=}{Invariant}(#t75.{core::MapEntry::key}{core::String*}, #t75.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-    #t73.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t73;
+      #t62.{core::Map::addAll}{Invariant}(mapToDouble){(core::Map<core::String*, core::num*>*) →* void};
+    #t62.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t62;
   core::List<dynamic>* list82 = block {
-    final core::List<dynamic>* #t76 = <dynamic>[];
+    final core::List<dynamic>* #t63 = <dynamic>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t76.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+      #t63.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
     else
-      #t76.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-  } =>#t76;
+      #t63.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+  } =>#t63;
   core::Set<dynamic>* set82 = block {
-    final core::Set<dynamic>* #t77 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t64 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t77.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+      #t64.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
     else
-      #t77.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t77.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t77;
+      #t64.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t64.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t64;
   core::Set<dynamic>* map82 = block {
-    final core::Set<dynamic>* #t78 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t65 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t78.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:73:38: Error: Unexpected type 'Map<String, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t65.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:73:38: Error: Unexpected type 'Map<String, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   var map82 = {if (oracle(\"foo\")) ...mapToInt else ...dynVar, null};
                                      ^"){(dynamic) →* core::bool*};
     else
-      #t78.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t78.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t78;
+      #t65.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t65.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t65;
   core::List<core::num*>* list83 = block {
-    final core::List<core::num*>* #t79 = <core::num*>[];
+    final core::List<core::num*>* #t66 = <core::num*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t79.{core::List::add}{Invariant}(42){(core::num*) →* void};
+      #t66.{core::List::add}{Invariant}(42){(core::num*) →* void};
     else
-      #t79.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t79;
+      #t66.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t66;
   core::Set<core::num*>* set83 = block {
-    final core::Set<core::num*>* #t80 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t67 = col::LinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t80.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t67.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t80.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t80.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t80;
+      #t67.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t67.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t67;
   core::Map<core::String*, core::num*>* map83 = block {
-    final core::Map<core::String*, core::num*>* #t81 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t68 = <core::String*, core::num*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t82 in mapToInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-        #t81.{core::Map::[]=}{Invariant}(#t82.{core::MapEntry::key}{core::String*}, #t82.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
+      #t68.{core::Map::addAll}{Invariant}(mapToInt){(core::Map<core::String*, core::num*>*) →* void};
     else
-      #t81.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t81.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t81;
+      #t68.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t68.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t68;
   core::List<core::int*>* list90 = block {
-    final core::List<core::int*>* #t83 = <core::int*>[];
+    final core::List<core::int*>* #t69 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t83.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
-  } =>#t83;
+      #t69.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+  } =>#t69;
   core::Set<core::int*>* set90 = block {
-    final core::Set<core::int*>* #t84 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t70 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t84.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
-    #t84.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t84;
+      #t70.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+    #t70.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t70;
   core::Map<core::String*, core::int*>* map90 = block {
-    final core::Map<core::String*, core::int*>* #t85 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t71 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t85.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
-    #t85.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t85;
+      #t71.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+    #t71.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t71;
   core::List<core::int*>* list91 = block {
-    final core::List<core::int*>* #t86 = <core::int*>[];
+    final core::List<core::int*>* #t72 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer dynamic #t87 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
-        final core::int* #t88 = #t87 as{TypeError} core::int*;
-        #t86.{core::List::add}{Invariant}(#t88){(core::int*) →* void};
+      for (final has-declared-initializer dynamic #t73 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
+        final core::int* #t74 = #t73 as{TypeError} core::int*;
+        #t72.{core::List::add}{Invariant}(#t74){(core::int*) →* void};
       }
-  } =>#t86;
+  } =>#t72;
   core::Set<core::int*>* set91 = block {
-    final core::Set<core::int*>* #t89 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t75 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer dynamic #t90 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
-        final core::int* #t91 = #t90 as{TypeError} core::int*;
-        #t89.{core::Set::add}{Invariant}(#t91){(core::int*) →* core::bool*};
+      for (final has-declared-initializer dynamic #t76 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
+        final core::int* #t77 = #t76 as{TypeError} core::int*;
+        #t75.{core::Set::add}{Invariant}(#t77){(core::int*) →* core::bool*};
       }
-    #t89.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t89;
+    #t75.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t75;
   core::Map<core::String*, core::int*>* map91 = block {
-    final core::Map<core::String*, core::int*>* #t92 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t78 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t93 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}) {
-        final core::String* #t94 = #t93.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
-        final core::int* #t95 = #t93.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-        #t92.{core::Map::[]=}{Invariant}(#t94, #t95){(core::String*, core::int*) →* void};
+      for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t79 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}) {
+        final core::String* #t80 = #t79.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
+        final core::int* #t81 = #t79.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
+        #t78.{core::Map::[]=}{Invariant}(#t80, #t81){(core::String*, core::int*) →* void};
       }
-    #t92.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t92;
+    #t78.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t78;
   core::List<core::int*>* list100 = block {
-    final core::List<core::int*>* #t96 = <core::int*>[];
+    final core::List<core::int*>* #t82 = <core::int*>[];
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t96.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t96;
+      #t82.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t82;
   core::Set<core::int*>* set100 = block {
-    final core::Set<core::int*>* #t97 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t83 = col::LinkedHashSet::•<core::int*>();
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t97.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t97;
+      #t83.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t83;
   core::Map<core::int*, core::int*>* map100 = block {
-    final core::Map<core::int*, core::int*>* #t98 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t84 = <core::int*, core::int*>{};
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t98.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
-  } =>#t98;
+      #t84.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
+  } =>#t84;
 }
 static method testIfElementErrors(core::Map<core::int*, core::int*>* map) → dynamic {
   block {
-    final core::List<core::int*>* #t99 = <core::int*>[];
+    final core::List<core::int*>* #t85 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t99.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:89:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t85.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:89:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[if (oracle(\"foo\")) \"bar\"];
                            ^" in "bar" as{TypeError} core::int*){(core::int*) →* void};
-  } =>#t99;
+  } =>#t85;
   block {
-    final core::Set<core::int*>* #t100 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t86 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t100.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:90:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t86.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:90:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{if (oracle(\"foo\")) \"bar\", null};
                            ^" in "bar" as{TypeError} core::int*){(core::int*) →* core::bool*};
-    #t100.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t100;
+    #t86.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t86;
   block {
-    final core::Map<core::String*, core::int*>* #t101 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t87 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t101.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:91:43: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t87.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:91:43: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <String, int>{if (oracle(\"foo\")) \"bar\": \"bar\", \"baz\": null};
                                           ^" in "bar" as{TypeError} core::int*){(core::String*, core::int*) →* void};
-    #t101.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t101;
+    #t87.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t87;
   block {
-    final core::List<core::int*>* #t102 = <core::int*>[];
+    final core::List<core::int*>* #t88 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t102.{core::List::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:92:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t88.{core::List::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:92:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[if (oracle(\"foo\")) ...[\"bar\"]];
                                ^" in "bar" as{TypeError} core::int*]){(core::Iterable<core::int*>*) →* void};
-  } =>#t102;
+  } =>#t88;
   block {
-    final core::Set<core::int*>* #t103 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t89 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t103.{core::Set::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:93:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t89.{core::Set::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:93:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{if (oracle(\"foo\")) ...[\"bar\"], null};
                                ^" in "bar" as{TypeError} core::int*]){(core::Iterable<core::int*>*) →* void};
-    #t103.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t103;
+    #t89.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t89;
   block {
-    final core::Map<core::String*, core::int*>* #t104 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t90 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t105 in <core::String*, core::int*>{"bar": invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:94:47: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t90.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:94:47: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <String, int>{if (oracle(\"foo\")) ...{\"bar\": \"bar\"}, \"baz\": null};
-                                              ^" in "bar" as{TypeError} core::int*}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t104.{core::Map::[]=}{Invariant}(#t105.{core::MapEntry::key}{core::String*}, #t105.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t104.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t104;
+                                              ^" in "bar" as{TypeError} core::int*}){(core::Map<core::String*, core::int*>*) →* void};
+    #t90.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t90;
   block {
-    final core::List<core::int*>* #t106 = <core::int*>[];
+    final core::List<core::int*>* #t91 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t106.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:95:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t91.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:95:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) ...map];
                               ^"){(core::int*) →* void};
-  } =>#t106;
+  } =>#t91;
   block {
-    final core::Set<core::int*>* #t107 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t92 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t107.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:96:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t92.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:96:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map, null};
                               ^"){(core::int*) →* core::bool*};
-    #t107.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t107;
+    #t92.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t92;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:97:39: Error: Unexpected type 'List<String>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) ...[\"bar\"], \"baz\": null};
@@ -1019,61 +1004,61 @@
   <String, int>{if (oracle(\"foo\")) ...[\"bar\"], \"baz\": null};
                                       ^": null};
   block {
-    final core::List<core::String*>* #t108 = <core::String*>[];
+    final core::List<core::String*>* #t93 = <core::String*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t108.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t93.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>[if (oracle(\"foo\")) 42 else 3.14];
                               ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
     else
-      #t108.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t93.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>[if (oracle(\"foo\")) 42 else 3.14];
                                       ^" in 3.14 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t108;
+  } =>#t93;
   block {
-    final core::Set<core::String*>* #t109 = col::LinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t94 = col::LinkedHashSet::•<core::String*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t109.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t94.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>{if (oracle(\"foo\")) 42 else 3.14, null};
                               ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
     else
-      #t109.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t94.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>{if (oracle(\"foo\")) 42 else 3.14, null};
                                       ^" in 3.14 as{TypeError} core::String*){(core::String*) →* core::bool*};
-    #t109.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
-  } =>#t109;
+    #t94.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
+  } =>#t94;
   block {
-    final core::Map<core::String*, core::String*>* #t110 = <core::String*, core::String*>{};
+    final core::Map<core::String*, core::String*>* #t95 = <core::String*, core::String*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t110.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:46: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t95.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:46: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String, String>{if (oracle(\"foo\")) \"bar\": 42 else \"baz\": 3.14, \"baz\": null};
                                              ^" in 42 as{TypeError} core::String*){(core::String*, core::String*) →* void};
     else
-      #t110.{core::Map::[]=}{Invariant}("baz", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:61: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t95.{core::Map::[]=}{Invariant}("baz", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:61: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String, String>{if (oracle(\"foo\")) \"bar\": 42 else \"baz\": 3.14, \"baz\": null};
                                                             ^" in 3.14 as{TypeError} core::String*){(core::String*, core::String*) →* void};
-    #t110.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
-  } =>#t110;
+    #t95.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
+  } =>#t95;
   block {
-    final core::List<core::int*>* #t111 = <core::int*>[];
+    final core::List<core::int*>* #t96 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t111.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:101:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t96.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:101:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) ...map else 42];
                               ^"){(core::int*) →* void};
     else
-      #t111.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t111;
+      #t96.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t96;
   block {
-    final core::Set<core::int*>* #t112 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t97 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t112.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:102:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t97.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:102:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map else 42, null};
                               ^"){(core::int*) →* core::bool*};
     else
-      #t112.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t112.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t112;
+      #t97.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t97.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t97;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:103:39: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) ...[42] else \"bar\": 42, \"baz\": null};
@@ -1082,26 +1067,26 @@
   <String, int>{if (oracle(\"foo\")) ...[42] else \"bar\": 42, \"baz\": null};
                                       ^": null};
   block {
-    final core::List<core::int*>* #t113 = <core::int*>[];
+    final core::List<core::int*>* #t98 = <core::int*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t113.{core::List::add}{Invariant}(42){(core::int*) →* void};
+      #t98.{core::List::add}{Invariant}(42){(core::int*) →* void};
     else
-      #t113.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:104:39: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t98.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:104:39: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) 42 else ...map];
                                       ^"){(core::int*) →* void};
-  } =>#t113;
+  } =>#t98;
   block {
-    final core::Set<core::int*>* #t114 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t99 = col::LinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t114.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:105:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t99.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:105:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map else 42, null};
                               ^"){(core::int*) →* core::bool*};
     else
-      #t114.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t114.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t114;
+      #t99.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t99.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t99;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:106:54: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) \"bar\": 42 else ...[42], \"baz\": null};
@@ -1128,709 +1113,692 @@
   var map13 = {if (oracle(\"foo\")) \"bar\": 3.14 else 42};
                                                    ^": null};
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t115 = <core::int*>[];
+    final core::List<core::int*>* #t100 = <core::int*>[];
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:114:27: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   List<int> list20 = [if (42) 42];
                           ^" in 42 as{TypeError} core::bool*)
-      #t115.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t115;
+      #t100.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t100;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t116 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t101 = col::LinkedHashSet::•<core::int*>();
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:115:25: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   Set<int> set20 = {if (42) 42};
                         ^" in 42 as{TypeError} core::bool*)
-      #t116.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t116;
+      #t101.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t101;
   core::Map<core::int*, core::int*>* map30 = block {
-    final core::Map<core::int*, core::int*>* #t117 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t102 = <core::int*, core::int*>{};
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:116:30: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   Map<int, int> map30 = {if (42) 42: 42};
                              ^" in 42 as{TypeError} core::bool*)
-      #t117.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
-  } =>#t117;
+      #t102.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
+  } =>#t102;
   core::List<core::String*>* list40 = block {
-    final core::List<core::String*>* #t118 = <core::String*>[];
+    final core::List<core::String*>* #t103 = <core::String*>[];
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t118.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:53: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t103.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:53: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   List<String> list40 = <String>[if (oracle(\"foo\")) true else 42];
                                                     ^" in true as{TypeError} core::String*){(core::String*) →* void};
     else
-      #t118.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:63: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t103.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:63: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   List<String> list40 = <String>[if (oracle(\"foo\")) true else 42];
                                                               ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t118;
+  } =>#t103;
   core::Set<core::String*>* set40 = block {
-    final core::Set<core::String*>* #t119 = col::LinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t104 = col::LinkedHashSet::•<core::String*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t119.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:51: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t104.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:51: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Set<String> set40 = <String>{if (oracle(\"foo\")) true else 42};
                                                   ^" in true as{TypeError} core::String*){(core::String*) →* core::bool*};
     else
-      #t119.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:61: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t104.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:61: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Set<String> set40 = <String>{if (oracle(\"foo\")) true else 42};
                                                             ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
-  } =>#t119;
+  } =>#t104;
   core::Map<core::String*, core::int*>* map40 = block {
-    final core::Map<core::String*, core::int*>* #t120 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t105 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:61: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t105.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:61: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Map<String, int> map40 = <String, int>{if (oracle(\"foo\")) true: 42 else 42: 42};
                                                             ^" in true as{TypeError} core::String*, 42){(core::String*, core::int*) →* void};
     else
-      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:75: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t105.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:75: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Map<String, int> map40 = <String, int>{if (oracle(\"foo\")) true: 42 else 42: 42};
                                                                           ^" in 42 as{TypeError} core::String*, 42){(core::String*, core::int*) →* void};
-  } =>#t120;
+  } =>#t105;
   core::Map<core::int*, core::String*>* map41 = block {
-    final core::Map<core::int*, core::String*>* #t121 = <core::int*, core::String*>{};
+    final core::Map<core::int*, core::String*>* #t106 = <core::int*, core::String*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t121.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:65: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t106.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:65: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Map<int, String> map41 = <int, String>{if (oracle(\"foo\")) 42: true else 42: 42};
                                                                 ^" in true as{TypeError} core::String*){(core::int*, core::String*) →* void};
     else
-      #t121.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:79: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t106.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:79: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Map<int, String> map41 = <int, String>{if (oracle(\"foo\")) 42: true else 42: 42};
                                                                               ^" in 42 as{TypeError} core::String*){(core::int*, core::String*) →* void};
-  } =>#t121;
+  } =>#t106;
 }
 static method testForElement(dynamic dynVar, core::List<core::int*>* listInt, core::List<core::double*>* listDouble, core::int* index, core::Map<core::String*, core::int*>* mapStringInt, core::Map<core::String*, core::double*>* mapStringDouble) → dynamic {
   core::List<core::int*>* list10 = block {
-    final core::List<core::int*>* #t122 = <core::int*>[];
+    final core::List<core::int*>* #t107 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t122.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t122;
+      #t107.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t107;
   core::Set<core::int*>* set10 = block {
-    final core::Set<core::int*>* #t123 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t108 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t123.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t123.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t123;
+      #t108.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t108.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t108;
   core::Map<core::String*, core::int*>* map10 = block {
-    final core::Map<core::String*, core::int*>* #t124 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t109 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t124.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t124.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t124;
+      #t109.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t109.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t109;
   core::List<dynamic>* list11 = block {
-    final core::List<dynamic>* #t125 = <dynamic>[];
+    final core::List<dynamic>* #t110 = <dynamic>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t125.{core::List::add}{Invariant}(dynVar){(dynamic) →* void};
-  } =>#t125;
+      #t110.{core::List::add}{Invariant}(dynVar){(dynamic) →* void};
+  } =>#t110;
   core::Set<dynamic>* set11 = block {
-    final core::Set<dynamic>* #t126 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t111 = col::LinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t126.{core::Set::add}{Invariant}(dynVar){(dynamic) →* core::bool*};
-    #t126.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t126;
+      #t111.{core::Set::add}{Invariant}(dynVar){(dynamic) →* core::bool*};
+    #t111.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t111;
   core::Map<core::String*, dynamic>* map11 = block {
-    final core::Map<core::String*, dynamic>* #t127 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t112 = <core::String*, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t127.{core::Map::[]=}{Invariant}("bar", dynVar){(core::String*, dynamic) →* void};
-    #t127.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t127;
+      #t112.{core::Map::[]=}{Invariant}("bar", dynVar){(core::String*, dynamic) →* void};
+    #t112.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t112;
   core::List<core::List<core::int*>*>* list12 = block {
-    final core::List<core::List<core::int*>*>* #t128 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t113 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t128.{core::List::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* void};
-  } =>#t128;
+      #t113.{core::List::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* void};
+  } =>#t113;
   core::Set<core::List<core::int*>*>* set12 = block {
-    final core::Set<core::List<core::int*>*>* #t129 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t114 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t129.{core::Set::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* core::bool*};
-    #t129.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t129;
+      #t114.{core::Set::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* core::bool*};
+    #t114.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t114;
   core::Map<core::String*, core::List<core::int*>*>* map12 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t130 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t115 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t130.{core::Map::[]=}{Invariant}("bar", <core::int*>[42]){(core::String*, core::List<core::int*>*) →* void};
-    #t130.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t130;
+      #t115.{core::Map::[]=}{Invariant}("bar", <core::int*>[42]){(core::String*, core::List<core::int*>*) →* void};
+    #t115.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t115;
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t131 = <core::int*>[];
+    final core::List<core::int*>* #t116 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t131.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-  } =>#t131;
+      #t116.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+  } =>#t116;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t132 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t117 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t132.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-    #t132.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t132;
+      #t117.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+    #t117.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t117;
   core::Map<core::String*, core::int*>* map20 = block {
-    final core::Map<core::String*, core::int*>* #t133 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t118 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t134 in <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t133.{core::Map::[]=}{Invariant}(#t134.{core::MapEntry::key}{core::String*}, #t134.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t133.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t133;
+      #t118.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t118.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t118;
   core::List<dynamic>* list21 = block {
-    final core::List<dynamic>* #t135 = <dynamic>[];
+    final core::List<dynamic>* #t119 = <dynamic>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t135.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-  } =>#t135;
+      #t119.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+  } =>#t119;
   core::Set<dynamic>* set21 = block {
-    final core::Set<dynamic>* #t136 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t120 = col::LinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t136.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-    #t136.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t136;
+      #t120.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+    #t120.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t120;
   core::Map<core::String*, dynamic>* map21 = block {
-    final core::Map<core::String*, dynamic>* #t137 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t121 = <core::String*, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, dynamic>* #t138 in <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>})
-        #t137.{core::Map::[]=}{Invariant}(#t138.{core::MapEntry::key}{core::String*}, #t138.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-    #t137.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t137;
+      #t121.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t121.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t121;
   core::List<core::List<core::int*>*>* list22 = block {
-    final core::List<core::List<core::int*>*>* #t139 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t122 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t139.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t139;
+      #t122.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t122;
   core::Set<core::List<core::int*>*>* set22 = block {
-    final core::Set<core::List<core::int*>*>* #t140 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t123 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t140.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t140.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t140;
+      #t123.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t123.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t123;
   core::Map<core::String*, core::List<core::int*>*>* map22 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t141 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t124 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t142 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t141.{core::Map::[]=}{Invariant}(#t142.{core::MapEntry::key}{core::String*}, #t142.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t141.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t141;
+      #t124.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t124.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t124;
   core::List<core::int*>* list30 = block {
-    final core::List<core::int*>* #t143 = <core::int*>[];
+    final core::List<core::int*>* #t125 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t143.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-  } =>#t143;
+        #t125.{core::List::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+  } =>#t125;
   core::Set<core::int*>* set30 = block {
-    final core::Set<core::int*>* #t144 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t126 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t144.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
-    #t144.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t144;
+        #t126.{core::Set::addAll}{Invariant}(<core::int*>[42]){(core::Iterable<core::int*>*) →* void};
+    #t126.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t126;
   core::Map<core::String*, core::int*>* map30 = block {
-    final core::Map<core::String*, core::int*>* #t145 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t127 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t146 in <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-          #t145.{core::Map::[]=}{Invariant}(#t146.{core::MapEntry::key}{core::String*}, #t146.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t145.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t145;
+        #t127.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t127.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t127;
   core::List<dynamic>* list31 = block {
-    final core::List<dynamic>* #t147 = <dynamic>[];
+    final core::List<dynamic>* #t128 = <dynamic>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t147.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-  } =>#t147;
+        #t128.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+  } =>#t128;
   core::Set<dynamic>* set31 = block {
-    final core::Set<dynamic>* #t148 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t129 = col::LinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t148.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
-    #t148.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t148;
+        #t129.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>*) →* void};
+    #t129.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t129;
   core::Map<core::String*, dynamic>* map31 = block {
-    final core::Map<core::String*, dynamic>* #t149 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t130 = <core::String*, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, dynamic>* #t150 in <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>})
-          #t149.{core::Map::[]=}{Invariant}(#t150.{core::MapEntry::key}{core::String*}, #t150.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-    #t149.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t149;
+        #t130.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t130.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t130;
   core::List<core::List<core::int*>*>* list33 = block {
-    final core::List<core::List<core::int*>*>* #t151 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t131 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t151.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t151;
+        #t131.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t131;
   core::Set<core::List<core::int*>*>* set33 = block {
-    final core::Set<core::List<core::int*>*>* #t152 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t132 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t152.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t152.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t152;
+        #t132.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[42]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t132.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t132;
   core::Map<core::String*, core::List<core::int*>*>* map33 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t153 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t133 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t154 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t153.{core::Map::[]=}{Invariant}(#t154.{core::MapEntry::key}{core::String*}, #t154.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t153.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t153;
+        #t133.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[42]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t133.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t133;
   core::List<core::List<core::int*>*>* list40 = block {
-    final core::List<core::List<core::int*>*>* #t155 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t134 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t155.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t155;
+      #t134.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t134;
   core::Set<core::List<core::int*>*>* set40 = block {
-    final core::Set<core::List<core::int*>*>* #t156 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t135 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t156.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t156.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t156;
+      #t135.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t135.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t135;
   core::Map<core::String*, core::List<core::int*>*>* map40 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t157 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t136 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t158 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t157.{core::Map::[]=}{Invariant}(#t158.{core::MapEntry::key}{core::String*}, #t158.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t157.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t157;
+      #t136.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t136.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t136;
   core::List<core::List<core::int*>*>* list41 = block {
+    final core::List<core::List<core::int*>*>* #t137 = <core::List<core::int*>*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t137.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t138 = col::LinkedHashSet::•<core::List<core::int*>*>();
+        #t138.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+      } =>#t138){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t137;
+  core::Set<core::List<core::int*>*>* set41 = block {
+    final core::Set<core::List<core::int*>*>* #t139 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t139.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t140 = col::LinkedHashSet::•<core::List<core::int*>*>();
+        #t140.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+      } =>#t140){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t139.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t139;
+  core::List<core::List<core::int*>*>* list42 = block {
+    final core::List<core::List<core::int*>*>* #t141 = <core::List<core::int*>*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t141.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t141;
+  core::Set<core::List<core::int*>*>* set42 = block {
+    final core::Set<core::List<core::int*>*>* #t142 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t142.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t142.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t142;
+  core::Map<core::String*, core::List<core::int*>*>* map42 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t143 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t143.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t143.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t143;
+  core::List<core::int*>* list50 = block {
+    final core::List<core::int*>* #t144 = <core::int*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t144.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+  } =>#t144;
+  core::Set<core::int*>* set50 = block {
+    final core::Set<core::int*>* #t145 = col::LinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t145.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+    #t145.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t145;
+  core::Map<core::String*, core::int*>* map50 = block {
+    final core::Map<core::String*, core::int*>* #t146 = <core::String*, core::int*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t146.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
+    #t146.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t146;
+  core::List<core::int*>* list51 = block {
+    final core::List<core::int*>* #t147 = <core::int*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t147.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t148 = col::LinkedHashSet::•<core::int*>();
+      } =>#t148){(core::Iterable<core::int*>*) →* void};
+  } =>#t147;
+  core::Set<core::int*>* set51 = block {
+    final core::Set<core::int*>* #t149 = col::LinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t149.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t150 = col::LinkedHashSet::•<core::int*>();
+      } =>#t150){(core::Iterable<core::int*>*) →* void};
+    #t149.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t149;
+  core::List<core::int*>* list52 = block {
+    final core::List<core::int*>* #t151 = <core::int*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t151.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+  } =>#t151;
+  core::Set<core::int*>* set52 = block {
+    final core::Set<core::int*>* #t152 = col::LinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t152.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
+    #t152.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t152;
+  core::List<core::List<core::int*>*>* list60 = block {
+    final core::List<core::List<core::int*>*>* #t153 = <core::List<core::int*>*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t153.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t153;
+  core::Set<core::List<core::int*>*>* set60 = block {
+    final core::Set<core::List<core::int*>*>* #t154 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t154.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t154.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t154;
+  core::Map<core::String*, core::List<core::int*>*>* map60 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t155 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t155.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t155.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t155;
+  core::List<core::List<core::int*>*>* list61 = block {
+    final core::List<core::List<core::int*>*>* #t156 = <core::List<core::int*>*>[];
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t156.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t156;
+  core::Set<core::List<core::int*>*>* set61 = block {
+    final core::Set<core::List<core::int*>*>* #t157 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t157.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t157.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t157;
+  core::Map<core::String*, core::List<core::int*>*>* map61 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t158 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t158.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t158.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t158;
+  core::List<core::List<core::int*>*>* list70 = block {
     final core::List<core::List<core::int*>*>* #t159 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t159.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t160 = col::LinkedHashSet::•<core::List<core::int*>*>();
-        #t160.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-      } =>#t160){(core::Iterable<core::List<core::int*>*>*) →* void};
+      #t159.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
   } =>#t159;
-  core::Set<core::List<core::int*>*>* set41 = block {
-    final core::Set<core::List<core::int*>*>* #t161 = col::LinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t161.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t162 = col::LinkedHashSet::•<core::List<core::int*>*>();
-        #t162.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-      } =>#t162){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t161.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t161;
-  core::List<core::List<core::int*>*>* list42 = block {
-    final core::List<core::List<core::int*>*>* #t163 = <core::List<core::int*>*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t163.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t163;
-  core::Set<core::List<core::int*>*>* set42 = block {
-    final core::Set<core::List<core::int*>*>* #t164 = col::LinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t164.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t164.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t164;
-  core::Map<core::String*, core::List<core::int*>*>* map42 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t165 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t166 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t165.{core::Map::[]=}{Invariant}(#t166.{core::MapEntry::key}{core::String*}, #t166.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t165.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t165;
-  core::List<core::int*>* list50 = block {
-    final core::List<core::int*>* #t167 = <core::int*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t167.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-  } =>#t167;
-  core::Set<core::int*>* set50 = block {
-    final core::Set<core::int*>* #t168 = col::LinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t168.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-    #t168.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t168;
-  core::Map<core::String*, core::int*>* map50 = block {
-    final core::Map<core::String*, core::int*>* #t169 = <core::String*, core::int*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::int*>* #t170 in <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t169.{core::Map::[]=}{Invariant}(#t170.{core::MapEntry::key}{core::String*}, #t170.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t169.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t169;
-  core::List<core::int*>* list51 = block {
-    final core::List<core::int*>* #t171 = <core::int*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t171.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t172 = col::LinkedHashSet::•<core::int*>();
-      } =>#t172){(core::Iterable<core::int*>*) →* void};
-  } =>#t171;
-  core::Set<core::int*>* set51 = block {
-    final core::Set<core::int*>* #t173 = col::LinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t173.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t174 = col::LinkedHashSet::•<core::int*>();
-      } =>#t174){(core::Iterable<core::int*>*) →* void};
-    #t173.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t173;
-  core::List<core::int*>* list52 = block {
-    final core::List<core::int*>* #t175 = <core::int*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t175.{core::List::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-  } =>#t175;
-  core::Set<core::int*>* set52 = block {
-    final core::Set<core::int*>* #t176 = col::LinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t176.{core::Set::addAll}{Invariant}(<core::int*>[]){(core::Iterable<core::int*>*) →* void};
-    #t176.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t176;
-  core::List<core::List<core::int*>*>* list60 = block {
-    final core::List<core::List<core::int*>*>* #t177 = <core::List<core::int*>*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t177.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t177;
-  core::Set<core::List<core::int*>*>* set60 = block {
-    final core::Set<core::List<core::int*>*>* #t178 = col::LinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t178.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t178.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t178;
-  core::Map<core::String*, core::List<core::int*>*>* map60 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t179 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t180 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-        #t179.{core::Map::[]=}{Invariant}(#t180.{core::MapEntry::key}{core::String*}, #t180.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t179.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t179;
-  core::List<core::List<core::int*>*>* list61 = block {
-    final core::List<core::List<core::int*>*>* #t181 = <core::List<core::int*>*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t181.{core::List::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t181;
-  core::Set<core::List<core::int*>*>* set61 = block {
-    final core::Set<core::List<core::int*>*>* #t182 = col::LinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t182.{core::Set::addAll}{Invariant}(<core::List<core::int*>*>[<core::int*>[]]){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t182.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t182;
-  core::Map<core::String*, core::List<core::int*>*>* map61 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t183 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::List<core::int*>*>* #t184 in <core::String*, core::List<core::int*>*>{"bar": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-          #t183.{core::Map::[]=}{Invariant}(#t184.{core::MapEntry::key}{core::String*}, #t184.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-    #t183.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t183;
-  core::List<core::List<core::int*>*>* list70 = block {
-    final core::List<core::List<core::int*>*>* #t185 = <core::List<core::int*>*>[];
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t185.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
-  } =>#t185;
   core::Set<core::List<core::int*>*>* set70 = block {
-    final core::Set<core::List<core::int*>*>* #t186 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t160 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t186.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-    #t186.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t186;
+      #t160.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+    #t160.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t160;
   core::Map<core::String*, core::List<core::int*>*>* map70 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t187 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t161 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t187.{core::Map::[]=}{Invariant}("bar", <core::int*>[]){(core::String*, core::List<core::int*>*) →* void};
-    #t187.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t187;
+      #t161.{core::Map::[]=}{Invariant}("bar", <core::int*>[]){(core::String*, core::List<core::int*>*) →* void};
+    #t161.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t161;
   core::List<core::List<core::int*>*>* list71 = block {
-    final core::List<core::List<core::int*>*>* #t188 = <core::List<core::int*>*>[];
+    final core::List<core::List<core::int*>*>* #t162 = <core::List<core::int*>*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t188.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
-  } =>#t188;
+        #t162.{core::List::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* void};
+  } =>#t162;
   core::Set<core::List<core::int*>*>* set71 = block {
-    final core::Set<core::List<core::int*>*>* #t189 = col::LinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t163 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t189.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
-    #t189.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t189;
+        #t163.{core::Set::add}{Invariant}(<core::int*>[]){(core::List<core::int*>*) →* core::bool*};
+    #t163.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t163;
   core::Map<core::String*, core::List<core::int*>*>* map71 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t190 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t164 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t190.{core::Map::[]=}{Invariant}("bar", <core::int*>[]){(core::String*, core::List<core::int*>*) →* void};
-    #t190.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t190;
+        #t164.{core::Map::[]=}{Invariant}("bar", <core::int*>[]){(core::String*, core::List<core::int*>*) →* void};
+    #t164.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t164;
   core::List<core::num*>* list80 = block {
-    final core::List<core::num*>* #t191 = <core::num*>[];
+    final core::List<core::num*>* #t165 = <core::num*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t191.{core::List::add}{Invariant}(42){(core::num*) →* void};
+        #t165.{core::List::add}{Invariant}(42){(core::num*) →* void};
       else
-        #t191.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
-  } =>#t191;
+        #t165.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
+  } =>#t165;
   core::Set<core::num*>* set80 = block {
-    final core::Set<core::num*>* #t192 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t166 = col::LinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t192.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
+        #t166.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
       else
-        #t192.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t192.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t192;
+        #t166.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t166.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t166;
   core::Map<core::String*, core::num*>* map80 = block {
-    final core::Map<core::String*, core::num*>* #t193 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t167 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t193.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
+        #t167.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
       else
-        #t193.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t193.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t193;
+        #t167.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t167.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t167;
   core::List<core::num*>* list81 = block {
-    final core::List<core::num*>* #t194 = <core::num*>[];
+    final core::List<core::num*>* #t168 = <core::num*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t194.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t168.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t194.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t194;
+        #t168.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t168;
   core::Set<core::num*>* set81 = block {
-    final core::Set<core::num*>* #t195 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t169 = col::LinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t195.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t169.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t195.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-    #t195.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t195;
+        #t169.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+    #t169.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t169;
   core::Map<core::String*, core::num*>* map81 = block {
-    final core::Map<core::String*, core::num*>* #t196 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t170 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t197 in mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-          #t196.{core::Map::[]=}{Invariant}(#t197.{core::MapEntry::key}{core::String*}, #t197.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
+        #t170.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<core::String*, core::num*>*) →* void};
       else
-        for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t198 in mapStringDouble.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-          #t196.{core::Map::[]=}{Invariant}(#t198.{core::MapEntry::key}{core::String*}, #t198.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-    #t196.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t196;
+        #t170.{core::Map::addAll}{Invariant}(mapStringDouble){(core::Map<core::String*, core::num*>*) →* void};
+    #t170.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t170;
   core::List<dynamic>* list82 = block {
-    final core::List<dynamic>* #t199 = <dynamic>[];
+    final core::List<dynamic>* #t171 = <dynamic>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t199.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+        #t171.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
       else
-        #t199.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-  } =>#t199;
+        #t171.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+  } =>#t171;
   core::Set<dynamic>* set82 = block {
-    final core::Set<dynamic>* #t200 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t172 = col::LinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t200.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+        #t172.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
       else
-        #t200.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t200.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t200;
+        #t172.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t172.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t172;
   core::Map<dynamic, dynamic>* map82 = block {
-    final core::Map<dynamic, dynamic>* #t201 = <dynamic, dynamic>{};
+    final core::Map<dynamic, dynamic>* #t173 = <dynamic, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t202 in mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-          #t201.{core::Map::[]=}{Invariant}(#t202.{core::MapEntry::key}{dynamic}, #t202.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
+        #t173.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<dynamic, dynamic>*) →* void};
       else
-        for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t203 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-          #t201.{core::Map::[]=}{Invariant}(#t203.{core::MapEntry::key}{dynamic}, #t203.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
-    #t201.{core::Map::[]=}{Invariant}("baz", null){(dynamic, dynamic) →* void};
-  } =>#t201;
+        #t173.{core::Map::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*){(core::Map<dynamic, dynamic>*) →* void};
+    #t173.{core::Map::[]=}{Invariant}("baz", null){(dynamic, dynamic) →* void};
+  } =>#t173;
   core::List<core::num*>* list83 = block {
-    final core::List<core::num*>* #t204 = <core::num*>[];
+    final core::List<core::num*>* #t174 = <core::num*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t204.{core::List::add}{Invariant}(42){(core::num*) →* void};
+        #t174.{core::List::add}{Invariant}(42){(core::num*) →* void};
       else
-        #t204.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t204;
+        #t174.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t174;
   core::Set<core::num*>* set83 = block {
-    final core::Set<core::num*>* #t205 = col::LinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t175 = col::LinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t205.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t175.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t205.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t205.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t205;
+        #t175.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t175.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t175;
   core::Map<core::String*, core::num*>* map83 = block {
-    final core::Map<core::String*, core::num*>* #t206 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t176 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        for (final has-declared-initializer core::MapEntry<core::String*, core::num*>* #t207 in mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>})
-          #t206.{core::Map::[]=}{Invariant}(#t207.{core::MapEntry::key}{core::String*}, #t207.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
+        #t176.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<core::String*, core::num*>*) →* void};
       else
-        #t206.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t206.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t206;
+        #t176.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t176.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t176;
   core::List<core::int*>* list90 = block {
-    final core::List<core::int*>* #t208 = <core::int*>[];
+    final core::List<core::int*>* #t177 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t208.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
-  } =>#t208;
+      #t177.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+  } =>#t177;
   core::Set<core::int*>* set90 = block {
-    final core::Set<core::int*>* #t209 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t178 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t209.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
-    #t209.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t209;
+      #t178.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+    #t178.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t178;
   core::Map<core::String*, core::int*>* map90 = block {
-    final core::Map<core::String*, core::int*>* #t210 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t179 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t210.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
-    #t210.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t210;
+      #t179.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+    #t179.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t179;
   core::List<core::int*>* list91 = block {
-    final core::List<core::int*>* #t211 = <core::int*>[];
+    final core::List<core::int*>* #t180 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer dynamic #t212 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
-        final core::int* #t213 = #t212 as{TypeError} core::int*;
-        #t211.{core::List::add}{Invariant}(#t213){(core::int*) →* void};
+      for (final has-declared-initializer dynamic #t181 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
+        final core::int* #t182 = #t181 as{TypeError} core::int*;
+        #t180.{core::List::add}{Invariant}(#t182){(core::int*) →* void};
       }
-  } =>#t211;
+  } =>#t180;
   core::Set<core::int*>* set91 = block {
-    final core::Set<core::int*>* #t214 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t183 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer dynamic #t215 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
-        final core::int* #t216 = #t215 as{TypeError} core::int*;
-        #t214.{core::Set::add}{Invariant}(#t216){(core::int*) →* core::bool*};
+      for (final has-declared-initializer dynamic #t184 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
+        final core::int* #t185 = #t184 as{TypeError} core::int*;
+        #t183.{core::Set::add}{Invariant}(#t185){(core::int*) →* core::bool*};
       }
-    #t214.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t214;
+    #t183.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t183;
   core::Map<core::String*, core::int*>* map91 = block {
-    final core::Map<core::String*, core::int*>* #t217 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t186 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t218 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}) {
-        final core::String* #t219 = #t218.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
-        final core::int* #t220 = #t218.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-        #t217.{core::Map::[]=}{Invariant}(#t219, #t220){(core::String*, core::int*) →* void};
+      for (final has-declared-initializer core::MapEntry<dynamic, dynamic>* #t187 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}) {
+        final core::String* #t188 = #t187.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
+        final core::int* #t189 = #t187.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
+        #t186.{core::Map::[]=}{Invariant}(#t188, #t189){(core::String*, core::int*) →* void};
       }
-    #t217.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t217;
+    #t186.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t186;
   core::List<core::int*>* list100 = block {
-    final core::List<core::int*>* #t221 = <core::int*>[];
-    for (final core::int* #t222 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t221.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t221;
+    final core::List<core::int*>* #t190 = <core::int*>[];
+    for (final core::int* #t191 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t190.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t190;
   core::Set<core::int*>* set100 = block {
-    final core::Set<core::int*>* #t223 = col::LinkedHashSet::•<core::int*>();
-    for (final core::int* #t224 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t223.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t223;
+    final core::Set<core::int*>* #t192 = col::LinkedHashSet::•<core::int*>();
+    for (final core::int* #t193 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t192.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t192;
   core::Map<core::String*, core::int*>* map100 = block {
-    final core::Map<core::String*, core::int*>* #t225 = <core::String*, core::int*>{};
-    for (final core::int* #t226 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t225.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-  } =>#t225;
+    final core::Map<core::String*, core::int*>* #t194 = <core::String*, core::int*>{};
+    for (final core::int* #t195 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t194.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+  } =>#t194;
   core::List<core::int*>* list110 = block {
-    final core::List<core::int*>* #t227 = <core::int*>[];
+    final core::List<core::int*>* #t196 = <core::int*>[];
     for (core::int* i in <core::int*>[1, 2, 3])
-      #t227.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t227;
+      #t196.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t196;
   core::Set<core::int*>* set110 = block {
-    final core::Set<core::int*>* #t228 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t197 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i in <core::int*>[1, 2, 3])
-      #t228.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-    #t228.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t228;
+      #t197.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+    #t197.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t197;
   core::Map<core::String*, core::int*>* map110 = block {
-    final core::Map<core::String*, core::int*>* #t229 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t198 = <core::String*, core::int*>{};
     for (core::int* i in <core::int*>[1, 2, 3])
-      #t229.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-    #t229.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t229;
+      #t198.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+    #t198.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t198;
   core::List<core::int*>* list120 = block {
-    final core::List<core::int*>* #t230 = <core::int*>[];
+    final core::List<core::int*>* #t199 = <core::int*>[];
     for (dynamic i in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*)
-      #t230.{core::List::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
-  } =>#t230;
+      #t199.{core::List::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+  } =>#t199;
   core::Set<core::int*>* set120 = block {
-    final core::Set<core::int*>* #t231 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t200 = col::LinkedHashSet::•<core::int*>();
     for (dynamic i in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*)
-      #t231.{core::Set::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
-    #t231.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t231;
+      #t200.{core::Set::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+    #t200.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t200;
   core::Map<core::String*, core::int*>* map120 = block {
-    final core::Map<core::String*, core::int*>* #t232 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t201 = <core::String*, core::int*>{};
     for (dynamic i in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*)
-      #t232.{core::Map::[]=}{Invariant}("bar", i as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
-    #t232.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t232;
+      #t201.{core::Map::[]=}{Invariant}("bar", i as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+    #t201.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t201;
   core::List<core::int*>* list130 = block {
-    final core::List<core::int*>* #t233 = <core::int*>[];
+    final core::List<core::int*>* #t202 = <core::int*>[];
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t233.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t233;
+      #t202.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t202;
   core::Set<core::int*>* set130 = block {
-    final core::Set<core::int*>* #t234 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t203 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t234.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-  } =>#t234;
+      #t203.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+  } =>#t203;
   core::Map<core::int*, core::int*>* map130 = block {
-    final core::Map<core::int*, core::int*>* #t235 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t204 = <core::int*, core::int*>{};
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t235.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
-  } =>#t235;
+      #t204.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
+  } =>#t204;
 }
 static method testForElementErrors(core::Map<core::int*, core::int*>* map, core::List<core::int*>* list) → dynamic async /* futureValueType= dynamic */ {
   block {
-    final core::List<core::int*>* #t236 = <core::int*>[];
+    final core::List<core::int*>* #t205 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t236.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:212:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t205.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:212:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) \"bar\"];
                                             ^" in "bar" as{TypeError} core::int*){(core::int*) →* void};
-  } =>#t236;
+  } =>#t205;
   block {
-    final core::Set<core::int*>* #t237 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t206 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t237.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:213:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t206.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:213:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\", null};
                                             ^" in "bar" as{TypeError} core::int*){(core::int*) →* core::bool*};
-    #t237.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t237;
+    #t206.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t206;
   block {
-    final core::Map<core::int*, core::int*>* #t238 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t207 = <core::int*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t238.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:50: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t207.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:50: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                  ^" in "bar" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                         ^" in "bar" as{TypeError} core::int*){(core::int*, core::int*) →* void};
-    #t238.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+    #t207.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                                ^" in "baz" as{TypeError} core::int*, null){(core::int*, core::int*) →* void};
-  } =>#t238;
+  } =>#t207;
   block {
-    final core::List<core::int*>* #t239 = <core::int*>[];
+    final core::List<core::int*>* #t208 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t239.{core::List::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:215:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t208.{core::List::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:215:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) ...[\"bar\"]];
                                                 ^" in "bar" as{TypeError} core::int*]){(core::Iterable<core::int*>*) →* void};
-  } =>#t239;
+  } =>#t208;
   block {
-    final core::Set<core::int*>* #t240 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t209 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t240.{core::Set::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:216:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t209.{core::Set::addAll}{Invariant}(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:216:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) ...[\"bar\"], null};
                                                 ^" in "bar" as{TypeError} core::int*]){(core::Iterable<core::int*>*) →* void};
-    #t240.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t240;
+    #t209.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t209;
   block {
-    final core::Map<core::int*, core::int*>* #t241 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t210 = <core::int*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      for (final has-declared-initializer core::MapEntry<core::int*, core::int*>* #t242 in <core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:54: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t210.{core::Map::addAll}{Invariant}(<core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:54: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
                                                      ^" in "bar" as{TypeError} core::int*: invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:61: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
-                                                            ^" in "bar" as{TypeError} core::int*}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int*, core::int*>>})
-        #t241.{core::Map::[]=}{Invariant}(#t242.{core::MapEntry::key}{core::int*}, #t242.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
-    #t241.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:69: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+                                                            ^" in "bar" as{TypeError} core::int*}){(core::Map<core::int*, core::int*>*) →* void};
+    #t210.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:69: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
                                                                     ^" in "baz" as{TypeError} core::int*, null){(core::int*, core::int*) →* void};
-  } =>#t241;
+  } =>#t210;
   block {
-    final core::List<core::int*>* #t243 = <core::int*>[];
+    final core::List<core::int*>* #t211 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t243.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:218:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t211.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:218:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) ...map];
                                                ^"){(core::int*) →* void};
-  } =>#t243;
+  } =>#t211;
   block {
-    final core::Set<core::int*>* #t244 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t212 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t244.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:219:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t212.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:219:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) ...map, null};
                                                ^"){(core::int*) →* core::bool*};
-    #t244.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t244;
+    #t212.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t212;
   <core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:220:53: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...list, 42: null};
@@ -1839,66 +1807,66 @@
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...list, 42: null};
                                                     ^": null};
   block {
-    final core::List<core::String*>* #t245 = <core::String*>[];
+    final core::List<core::String*>* #t213 = <core::String*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t245.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t213.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14];
                                                              ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
       else
-        #t245.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t213.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14];
                                                                      ^" in 3.14 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t245;
+  } =>#t213;
   block {
-    final core::Set<core::String*>* #t246 = col::LinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t214 = col::LinkedHashSet::•<core::String*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t246.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t214.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14, null};
                                                              ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
       else
-        #t246.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t214.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14, null};
                                                                      ^" in 3.14 as{TypeError} core::String*){(core::String*) →* core::bool*};
-    #t246.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
-  } =>#t246;
+    #t214.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
+  } =>#t214;
   block {
-    final core::Map<core::String*, core::String*>* #t247 = <core::String*, core::String*>{};
+    final core::Map<core::String*, core::String*>* #t215 = <core::String*, core::String*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t247.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:77: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t215.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:77: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String, String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else \"bar\": 3.14, \"baz\": null};
                                                                             ^" in 42 as{TypeError} core::String*){(core::String*, core::String*) →* void};
       else
-        #t247.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:92: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t215.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:92: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String, String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else \"bar\": 3.14, \"baz\": null};
                                                                                            ^" in 3.14 as{TypeError} core::String*){(core::String*, core::String*) →* void};
-    #t247.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
-  } =>#t247;
+    #t215.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
+  } =>#t215;
   block {
-    final core::List<core::int*>* #t248 = <core::int*>[];
+    final core::List<core::int*>* #t216 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t248.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:224:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t216.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:224:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...map else 42];
                                                              ^"){(core::int*) →* void};
       else
-        #t248.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t248;
+        #t216.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t216;
   block {
-    final core::Set<core::int*>* #t249 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t217 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t249.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:225:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t217.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:225:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...map else 42, null};
                                                              ^"){(core::int*) →* core::bool*};
       else
-        #t249.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t249.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t249;
+        #t217.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t217.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t217;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:226:70: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...list else \"bar\": 42, \"baz\": null};
@@ -1907,28 +1875,28 @@
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...list else \"bar\": 42, \"baz\": null};
                                                                      ^": null};
   block {
-    final core::List<core::int*>* #t250 = <core::int*>[];
+    final core::List<core::int*>* #t218 = <core::int*>[];
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t250.{core::List::add}{Invariant}(42){(core::int*) →* void};
+        #t218.{core::List::add}{Invariant}(42){(core::int*) →* void};
       else
-        #t250.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:227:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t218.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:227:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else ...map];
                                                                      ^"){(core::int*) →* void};
-  } =>#t250;
+  } =>#t218;
   block {
-    final core::Set<core::int*>* #t251 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t219 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t251.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+        #t219.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
       else
-        #t251.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:228:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t219.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:228:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else ...map, null};
                                                                      ^"){(core::int*) →* core::bool*};
-    #t251.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t251;
+    #t219.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t219;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:229:85: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else ...list, \"baz\": null};
@@ -1938,218 +1906,218 @@
                                                                                     ^": null};
   final core::int* i = 0;
   block {
-    final core::List<core::int*>* #t252 = <core::int*>[];
-    for (final core::int* #t253 in <core::int*>[1]) {
+    final core::List<core::int*>* #t220 = <core::int*>[];
+    for (final core::int* #t221 in <core::int*>[1]) {
       invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:232:14: Error: Can't assign to the final variable 'i'.
   <int>[for (i in <int>[1]) i];
              ^";
-      #t252.{core::List::add}{Invariant}(i){(core::int*) →* void};
+      #t220.{core::List::add}{Invariant}(i){(core::int*) →* void};
     }
-  } =>#t252;
+  } =>#t220;
   block {
-    final core::Set<core::int*>* #t254 = col::LinkedHashSet::•<core::int*>();
-    for (final core::int* #t255 in <core::int*>[1]) {
+    final core::Set<core::int*>* #t222 = col::LinkedHashSet::•<core::int*>();
+    for (final core::int* #t223 in <core::int*>[1]) {
       invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:233:14: Error: Can't assign to the final variable 'i'.
   <int>{for (i in <int>[1]) i, null};
              ^";
-      #t254.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+      #t222.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
     }
-    #t254.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t254;
+    #t222.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t222;
   block {
-    final core::Map<core::String*, core::int*>* #t256 = <core::String*, core::int*>{};
-    for (final core::int* #t257 in <core::int*>[1]) {
+    final core::Map<core::String*, core::int*>* #t224 = <core::String*, core::int*>{};
+    for (final core::int* #t225 in <core::int*>[1]) {
       invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:234:21: Error: Can't assign to the final variable 'i'.
 \t<String, int>{for (i in <int>[1]) \"bar\": i, \"baz\": null};
 \t                   ^";
-      #t256.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+      #t224.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
     }
-    #t256.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t256;
+    #t224.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t224;
   core::List<dynamic>* list10 = block {
-    final core::List<dynamic>* #t258 = <dynamic>[];
+    final core::List<dynamic>* #t226 = <dynamic>[];
     for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:236:31: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
   var list10 = [for (var i in \"not iterable\") i];
                               ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*)
-      #t258.{core::List::add}{Invariant}(i){(dynamic) →* void};
-  } =>#t258;
+      #t226.{core::List::add}{Invariant}(i){(dynamic) →* void};
+  } =>#t226;
   core::Set<dynamic>* set10 = block {
-    final core::Set<dynamic>* #t259 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t227 = col::LinkedHashSet::•<dynamic>();
     for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:237:30: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
   var set10 = {for (var i in \"not iterable\") i, null};
                              ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*)
-      #t259.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
-    #t259.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t259;
+      #t227.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
+    #t227.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t227;
   core::Map<core::String*, dynamic>* map10 = block {
-    final core::Map<core::String*, dynamic>* #t260 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t228 = <core::String*, dynamic>{};
     for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:238:30: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
   var map10 = {for (var i in \"not iterable\") \"bar\": i, \"baz\": null};
                              ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*)
-      #t260.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
-    #t260.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t260;
+      #t228.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
+    #t228.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t228;
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t261 = <core::int*>[];
+    final core::List<core::int*>* #t229 = <core::int*>[];
     for (core::int* i in <core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:239:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list20 = [for (int i in [\"not\", \"int\"]) i];
                                ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:239:39: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list20 = [for (int i in [\"not\", \"int\"]) i];
                                       ^" in "int" as{TypeError} core::int*])
-      #t261.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t261;
+      #t229.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t229;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t262 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t230 = col::LinkedHashSet::•<core::int*>();
     for (core::int* i in <core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:240:31: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set20 = {for (int i in [\"not\", \"int\"]) i, null};
                               ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:240:38: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set20 = {for (int i in [\"not\", \"int\"]) i, null};
                                      ^" in "int" as{TypeError} core::int*])
-      #t262.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-    #t262.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t262;
+      #t230.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+    #t230.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t230;
   core::Map<core::String*, core::int*>* map20 = block {
-    final core::Map<core::String*, core::int*>* #t263 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t231 = <core::String*, core::int*>{};
     for (core::int* i in <core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:241:31: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map20 = {for (int i in [\"not\", \"int\"]) \"bar\": i, \"baz\": null};
                               ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:241:38: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map20 = {for (int i in [\"not\", \"int\"]) \"bar\": i, \"baz\": null};
                                      ^" in "int" as{TypeError} core::int*])
-      #t263.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-    #t263.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t263;
+      #t231.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+    #t231.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t231;
   core::List<dynamic>* list30 = block {
-    final core::List<dynamic>* #t264 = <dynamic>[];
+    final core::List<dynamic>* #t232 = <dynamic>[];
     await for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:242:37: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
   var list30 = [await for (var i in \"not stream\") i];
                                     ^" in "not stream" as{TypeError} asy::Stream<dynamic>*)
-      #t264.{core::List::add}{Invariant}(i){(dynamic) →* void};
-  } =>#t264;
+      #t232.{core::List::add}{Invariant}(i){(dynamic) →* void};
+  } =>#t232;
   core::Set<dynamic>* set30 = block {
-    final core::Set<dynamic>* #t265 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t233 = col::LinkedHashSet::•<dynamic>();
     await for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:243:36: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
   var set30 = {await for (var i in \"not stream\") i, null};
                                    ^" in "not stream" as{TypeError} asy::Stream<dynamic>*)
-      #t265.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
-    #t265.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t265;
+      #t233.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
+    #t233.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t233;
   core::Map<core::String*, dynamic>* map30 = block {
-    final core::Map<core::String*, dynamic>* #t266 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t234 = <core::String*, dynamic>{};
     await for (dynamic i in invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:244:36: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
   var map30 = {await for (var i in \"not stream\") \"bar\": i, \"baz\": null};
                                    ^" in "not stream" as{TypeError} asy::Stream<dynamic>*)
-      #t266.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
-    #t266.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t266;
+      #t234.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
+    #t234.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t234;
   core::List<core::int*>* list40 = block {
-    final core::List<core::int*>* #t267 = <core::int*>[];
+    final core::List<core::int*>* #t235 = <core::int*>[];
     await for (core::int* i in asy::Stream::fromIterable<core::int*>(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:245:58: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list40 = [await for (int i in Stream.fromIterable([\"not\", \"int\"])) i];
                                                          ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:245:65: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list40 = [await for (int i in Stream.fromIterable([\"not\", \"int\"])) i];
                                                                 ^" in "int" as{TypeError} core::int*]))
-      #t267.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t267;
+      #t235.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t235;
   core::Set<core::int*>* set40 = block {
-    final core::Set<core::int*>* #t268 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t236 = col::LinkedHashSet::•<core::int*>();
     await for (core::int* i in asy::Stream::fromIterable<core::int*>(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:246:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) i, null};
                                                         ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:246:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) i, null};
                                                                ^" in "int" as{TypeError} core::int*]))
-      #t268.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-    #t268.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t268;
+      #t236.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+    #t236.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t236;
   core::Map<core::String*, core::int*>* map40 = block {
-    final core::Map<core::String*, core::int*>* #t269 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t237 = <core::String*, core::int*>{};
     await for (core::int* i in asy::Stream::fromIterable<core::int*>(<core::int*>[invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:247:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) \"bar\": i, \"baz\": null};
                                                         ^" in "not" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:247:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) \"bar\": i, \"baz\": null};
                                                                ^" in "int" as{TypeError} core::int*]))
-      #t269.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-    #t269.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t269;
+      #t237.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+    #t237.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t237;
   core::List<core::int*>* list50 = block {
-    final core::List<core::int*>* #t270 = <core::int*>[];
+    final core::List<core::int*>* #t238 = <core::int*>[];
     for (; ; )
-      #t270.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t270;
+      #t238.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t238;
   core::Set<core::int*>* set50 = block {
-    final core::Set<core::int*>* #t271 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t239 = col::LinkedHashSet::•<core::int*>();
     for (; ; )
-      #t271.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t271.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t271;
+      #t239.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t239.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t239;
   core::Map<core::String*, core::int*>* map50 = block {
-    final core::Map<core::String*, core::int*>* #t272 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t240 = <core::String*, core::int*>{};
     for (; ; )
-      #t272.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t272.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t272;
+      #t240.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t240.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t240;
   core::List<core::int*>* list60 = block {
-    final core::List<core::int*>* #t273 = <core::int*>[];
+    final core::List<core::int*>* #t241 = <core::int*>[];
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:251:24: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var list60 = [for (; \"not bool\";) 42];
                        ^" in "not bool" as{TypeError} core::bool*; )
-      #t273.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t273;
+      #t241.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t241;
   core::Set<core::int*>* set60 = block {
-    final core::Set<core::int*>* #t274 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t242 = col::LinkedHashSet::•<core::int*>();
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:252:23: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var set60 = {for (; \"not bool\";) 42, null};
                       ^" in "not bool" as{TypeError} core::bool*; )
-      #t274.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t274.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t274;
+      #t242.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t242.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t242;
   core::Map<core::String*, core::int*>* map60 = block {
-    final core::Map<core::String*, core::int*>* #t275 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t243 = <core::String*, core::int*>{};
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:253:23: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var map60 = {for (; \"not bool\";) \"bar\": 42, \"baz\": null};
                       ^" in "not bool" as{TypeError} core::bool*; )
-      #t275.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t275.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t275;
+      #t243.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t243.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t243;
 }
 static method testForElementErrorsNotAsync(asy::Stream<core::int*>* stream) → dynamic {
   block {
-    final core::List<core::int*>* #t276 = <core::int*>[];
+    final core::List<core::int*>* #t244 = <core::int*>[];
     await for (core::int* i in stream)
-      #t276.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t276;
+      #t244.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t244;
   block {
-    final core::Set<core::int*>* #t277 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t245 = col::LinkedHashSet::•<core::int*>();
     await for (core::int* i in stream)
-      #t277.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-  } =>#t277;
+      #t245.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+  } =>#t245;
   block {
-    final core::Map<core::String*, core::int*>* #t278 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t246 = <core::String*, core::int*>{};
     await for (core::int* i in stream)
-      #t278.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-  } =>#t278;
+      #t246.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+  } =>#t246;
 }
 static method testPromotion(self::A* a) → dynamic {
   core::List<core::int*>* list10 = block {
-    final core::List<core::int*>* #t279 = <core::int*>[];
+    final core::List<core::int*>* #t247 = <core::int*>[];
     if(a is self::B*)
-      #t279.{core::List::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* void};
-  } =>#t279;
+      #t247.{core::List::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* void};
+  } =>#t247;
   core::Set<core::int*>* set10 = block {
-    final core::Set<core::int*>* #t280 = col::LinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t248 = col::LinkedHashSet::•<core::int*>();
     if(a is self::B*)
-      #t280.{core::Set::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* core::bool*};
-  } =>#t280;
+      #t248.{core::Set::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* core::bool*};
+  } =>#t248;
   core::Map<core::int*, core::int*>* map10 = block {
-    final core::Map<core::int*, core::int*>* #t281 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t249 = <core::int*, core::int*>{};
     if(a is self::B*)
-      #t281.{core::Map::[]=}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}, a{self::B*}.{self::B::foo}{core::int*}){(core::int*, core::int*) →* void};
-  } =>#t281;
+      #t249.{core::Map::[]=}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}, a{self::B*}.{self::B::foo}{core::int*}){(core::int*, core::int*) →* void};
+  } =>#t249;
 }
 static method main() → dynamic {}
 
diff --git a/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.transformed.expect b/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.transformed.expect
index ef6dd9c..5316e10 100644
--- a/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/control_flow_collection_inference.dart.weak.transformed.expect
@@ -515,577 +515,502 @@
   } =>#t11;
   core::Map<core::String*, core::int*>* map20 = block {
     final core::Map<core::String*, core::int*>* #t12 = <core::String*, core::int*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
-      core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::int*>* #t13 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t12.{core::Map::[]=}{Invariant}(#t13.{core::MapEntry::key}{core::String*}, #t13.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-      }
-    }
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t12.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
     #t12.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
   } =>#t12;
   core::List<dynamic>* list21 = block {
-    final core::List<dynamic>* #t14 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t13 = core::_GrowableList::•<dynamic>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t14.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
-  } =>#t14;
+      #t13.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
+  } =>#t13;
   core::Set<dynamic>* set21 = block {
-    final core::Set<dynamic>* #t15 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t14 = new col::_CompactLinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t15.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
-    #t15.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t15;
+      #t14.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
+    #t14.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t14;
   core::Map<core::String*, dynamic>* map21 = block {
-    final core::Map<core::String*, dynamic>* #t16 = <core::String*, dynamic>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
-      core::Iterator<core::MapEntry<core::String*, dynamic>>* :sync-for-iterator = <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, dynamic>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, dynamic>* #t17 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, dynamic>};
-        #t16.{core::Map::[]=}{Invariant}(#t17.{core::MapEntry::key}{core::String*}, #t17.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-      }
-    }
-    #t16.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t16;
+    final core::Map<core::String*, dynamic>* #t15 = <core::String*, dynamic>{};
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t15.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t15.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t15;
   core::List<core::List<core::int*>*>* list22 = block {
-    final core::List<core::List<core::int*>*>* #t18 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t16 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t18.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t18;
+      #t16.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t16;
   core::Set<core::List<core::int*>*>* set22 = block {
-    final core::Set<core::List<core::int*>*>* #t19 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t17 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t19.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t19.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t19;
+      #t17.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t17.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t17;
   core::Map<core::String*, core::List<core::int*>*>* map22 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t20 = <core::String*, core::List<core::int*>*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
-      core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::_literal1<core::int*>(42)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::List<core::int*>*>* #t21 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-        #t20.{core::Map::[]=}{Invariant}(#t21.{core::MapEntry::key}{core::String*}, #t21.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-      }
-    }
-    #t20.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t20;
+    final core::Map<core::String*, core::List<core::int*>*>* #t18 = <core::String*, core::List<core::int*>*>{};
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t18.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::_literal1<core::int*>(42)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t18.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t18;
   core::List<core::int*>* list30 = block {
-    final core::List<core::int*>* #t22 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t19 = core::_GrowableList::•<core::int*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t22.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
-  } =>#t22;
+        #t19.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
+  } =>#t19;
   core::Set<core::int*>* set30 = block {
-    final core::Set<core::int*>* #t23 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t20 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t23.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
-    #t23.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t23;
+        #t20.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
+    #t20.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t20;
   core::Map<core::String*, core::int*>* map30 = block {
-    final core::Map<core::String*, core::int*>* #t24 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t21 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::int*>* #t25 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-          #t24.{core::Map::[]=}{Invariant}(#t25.{core::MapEntry::key}{core::String*}, #t25.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-        }
-      }
-    #t24.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t24;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t21.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t21.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t21;
   core::List<dynamic>* list31 = block {
-    final core::List<dynamic>* #t26 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t22 = core::_GrowableList::•<dynamic>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t26.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
-  } =>#t26;
+        #t22.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
+  } =>#t22;
   core::Set<dynamic>* set31 = block {
-    final core::Set<dynamic>* #t27 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t23 = new col::_CompactLinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t27.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
-    #t27.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t27;
+        #t23.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
+    #t23.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t23;
   core::Map<core::String*, dynamic>* map31 = block {
-    final core::Map<core::String*, dynamic>* #t28 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t24 = <core::String*, dynamic>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, dynamic>>* :sync-for-iterator = <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, dynamic>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, dynamic>* #t29 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, dynamic>};
-          #t28.{core::Map::[]=}{Invariant}(#t29.{core::MapEntry::key}{core::String*}, #t29.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-        }
-      }
-    #t28.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t28;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t24.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t24.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t24;
   core::List<core::List<core::int*>*>* list33 = block {
-    final core::List<core::List<core::int*>*>* #t30 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t25 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t30.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t30;
+        #t25.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t25;
   core::Set<core::List<core::int*>*>* set33 = block {
-    final core::Set<core::List<core::int*>*>* #t31 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t26 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t31.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t31.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t31;
+        #t26.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t26.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t26;
   core::Map<core::String*, core::List<core::int*>*>* map33 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t32 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t27 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::_literal1<core::int*>(42)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::List<core::int*>*>* #t33 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-          #t32.{core::Map::[]=}{Invariant}(#t33.{core::MapEntry::key}{core::String*}, #t33.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-        }
-      }
-    #t32.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t32;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t27.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::_literal1<core::int*>(42)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t27.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t27;
   core::List<core::List<core::int*>*>* list40 = block {
-    final core::List<core::List<core::int*>*>* #t34 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t28 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t34.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t34;
+      #t28.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t28;
   core::Set<core::List<core::int*>*>* set40 = block {
-    final core::Set<core::List<core::int*>*>* #t35 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t29 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t35.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t35.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t35;
+      #t29.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t29.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t29;
   core::Map<core::String*, core::List<core::int*>*>* map40 = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:41:34: Error: Both Iterable and Map spread elements encountered in ambiguous literal.
   Map<String, List<int>> map40 = {if (oracle(\"foo\")) ...{\"bar\", []}, \"baz\": null};
                                  ^";
   core::List<core::List<core::int*>*>* list41 = block {
-    final core::List<core::List<core::int*>*>* #t36 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t30 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t36.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t37 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
-        #t37.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
-      } =>#t37){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t36;
+      #t30.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t31 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+        #t31.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
+      } =>#t31){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t30;
   core::Set<core::List<core::int*>*>* set41 = block {
-    final core::Set<core::List<core::int*>*>* #t38 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t32 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t38.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t39 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
-        #t39.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
-      } =>#t39){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t38.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t38;
+      #t32.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t33 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+        #t33.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
+      } =>#t33){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t32.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t32;
   core::List<core::List<core::int*>*>* list42 = block {
-    final core::List<core::List<core::int*>*>* #t40 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t34 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t40.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t40;
+        #t34.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t34;
   core::Set<core::List<core::int*>*>* set42 = block {
-    final core::Set<core::List<core::int*>*>* #t41 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t35 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t41.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t41.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t41;
+        #t35.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t35.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t35;
   core::Map<core::String*, core::List<core::int*>*>* map42 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t42 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t36 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::List<core::int*>*>* #t43 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-          #t42.{core::Map::[]=}{Invariant}(#t43.{core::MapEntry::key}{core::String*}, #t43.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-        }
-      }
-    #t42.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t42;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t36.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t36.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t36;
   core::List<core::int*>* list50 = block {
+    final core::List<core::int*>* #t37 = core::_GrowableList::•<core::int*>(0);
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t37.{core::List::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
+  } =>#t37;
+  core::Set<core::int*>* set50 = block {
+    final core::Set<core::int*>* #t38 = new col::_CompactLinkedHashSet::•<core::int*>();
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t38.{core::Set::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
+    #t38.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t38;
+  core::Map<core::String*, core::int*>* map50 = block {
+    final core::Map<core::String*, core::int*>* #t39 = <core::String*, core::int*>{};
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t39.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
+    #t39.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t39;
+  core::List<core::int*>* list51 = block {
+    final core::List<core::int*>* #t40 = core::_GrowableList::•<core::int*>(0);
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t40.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t41 = new col::_CompactLinkedHashSet::•<core::int*>();
+      } =>#t41){(core::Iterable<core::int*>*) →* void};
+  } =>#t40;
+  core::Set<core::int*>* set51 = block {
+    final core::Set<core::int*>* #t42 = new col::_CompactLinkedHashSet::•<core::int*>();
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t42.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t43 = new col::_CompactLinkedHashSet::•<core::int*>();
+      } =>#t43){(core::Iterable<core::int*>*) →* void};
+    #t42.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t42;
+  core::List<core::int*>* list52 = block {
     final core::List<core::int*>* #t44 = core::_GrowableList::•<core::int*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t44.{core::List::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t44.{core::List::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
   } =>#t44;
-  core::Set<core::int*>* set50 = block {
+  core::Set<core::int*>* set52 = block {
     final core::Set<core::int*>* #t45 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t45.{core::Set::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t45.{core::Set::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
     #t45.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
   } =>#t45;
-  core::Map<core::String*, core::int*>* map50 = block {
+  core::Map<core::String*, core::int*>* map52 = block {
     final core::Map<core::String*, core::int*>* #t46 = <core::String*, core::int*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
-      core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::int*>* #t47 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t46.{core::Map::[]=}{Invariant}(#t47.{core::MapEntry::key}{core::String*}, #t47.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-      }
-    }
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t46.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
     #t46.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
   } =>#t46;
-  core::List<core::int*>* list51 = block {
-    final core::List<core::int*>* #t48 = core::_GrowableList::•<core::int*>(0);
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t48.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t49 = new col::_CompactLinkedHashSet::•<core::int*>();
-      } =>#t49){(core::Iterable<core::int*>*) →* void};
-  } =>#t48;
-  core::Set<core::int*>* set51 = block {
-    final core::Set<core::int*>* #t50 = new col::_CompactLinkedHashSet::•<core::int*>();
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t50.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t51 = new col::_CompactLinkedHashSet::•<core::int*>();
-      } =>#t51){(core::Iterable<core::int*>*) →* void};
-    #t50.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t50;
-  core::List<core::int*>* list52 = block {
-    final core::List<core::int*>* #t52 = core::_GrowableList::•<core::int*>(0);
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t52.{core::List::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
-  } =>#t52;
-  core::Set<core::int*>* set52 = block {
-    final core::Set<core::int*>* #t53 = new col::_CompactLinkedHashSet::•<core::int*>();
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t53.{core::Set::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
-    #t53.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t53;
-  core::Map<core::String*, core::int*>* map52 = block {
-    final core::Map<core::String*, core::int*>* #t54 = <core::String*, core::int*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::int*>* #t55 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-          #t54.{core::Map::[]=}{Invariant}(#t55.{core::MapEntry::key}{core::String*}, #t55.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-        }
-      }
-    #t54.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t54;
   core::List<core::List<core::int*>*>* list60 = block {
-    final core::List<core::List<core::int*>*>* #t56 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t47 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t56.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t56;
+      #t47.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t47;
   core::Set<core::List<core::int*>*>* set60 = block {
-    final core::Set<core::List<core::int*>*>* #t57 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t48 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t57.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t57.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t57;
+      #t48.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t48.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t48;
   core::Map<core::String*, core::List<core::int*>*>* map60 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t58 = <core::String*, core::List<core::int*>*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
-      core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::List<core::int*>*>* #t59 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-        #t58.{core::Map::[]=}{Invariant}(#t59.{core::MapEntry::key}{core::String*}, #t59.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-      }
-    }
-    #t58.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t58;
+    final core::Map<core::String*, core::List<core::int*>*>* #t49 = <core::String*, core::List<core::int*>*>{};
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t49.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t49.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t49;
   core::List<core::List<core::int*>*>* list61 = block {
-    final core::List<core::List<core::int*>*>* #t60 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t50 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t60.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t60;
+        #t50.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t50;
   core::Set<core::List<core::int*>*>* set61 = block {
-    final core::Set<core::List<core::int*>*>* #t61 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t51 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t61.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t61.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t61;
+        #t51.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t51.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t51;
   core::Map<core::String*, core::List<core::int*>*>* map61 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t62 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t52 = <core::String*, core::List<core::int*>*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::List<core::int*>*>* #t63 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-          #t62.{core::Map::[]=}{Invariant}(#t63.{core::MapEntry::key}{core::String*}, #t63.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-        }
-      }
-    #t62.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t62;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t52.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t52.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t52;
   core::List<core::List<core::int*>*>* list70 = block {
-    final core::List<core::List<core::int*>*>* #t64 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t53 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t64.{core::List::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* void};
-  } =>#t64;
+      #t53.{core::List::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* void};
+  } =>#t53;
   core::Set<core::List<core::int*>*>* set70 = block {
-    final core::Set<core::List<core::int*>*>* #t65 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t54 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t65.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
-    #t65.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t65;
+      #t54.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
+    #t54.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t54;
   core::List<core::List<core::int*>*>* list71 = block {
-    final core::List<core::List<core::int*>*>* #t66 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t55 = core::_GrowableList::•<core::List<core::int*>*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t66.{core::List::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* void};
-  } =>#t66;
+        #t55.{core::List::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* void};
+  } =>#t55;
   core::Set<core::List<core::int*>*>* set71 = block {
-    final core::Set<core::List<core::int*>*>* #t67 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t56 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t67.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
-    #t67.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t67;
+        #t56.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
+    #t56.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t56;
   core::List<core::num*>* list80 = block {
-    final core::List<core::num*>* #t68 = core::_GrowableList::•<core::num*>(0);
+    final core::List<core::num*>* #t57 = core::_GrowableList::•<core::num*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t68.{core::List::add}{Invariant}(42){(core::num*) →* void};
+      #t57.{core::List::add}{Invariant}(42){(core::num*) →* void};
     else
-      #t68.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
-  } =>#t68;
+      #t57.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
+  } =>#t57;
   core::Set<core::num*>* set80 = block {
-    final core::Set<core::num*>* #t69 = new col::_CompactLinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t58 = new col::_CompactLinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t69.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
+      #t58.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
     else
-      #t69.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t69.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t69;
+      #t58.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t58.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t58;
   core::Map<core::String*, core::num*>* map80 = block {
-    final core::Map<core::String*, core::num*>* #t70 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t59 = <core::String*, core::num*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t70.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
+      #t59.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
     else
-      #t70.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t70.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t70;
+      #t59.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t59.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t59;
   core::List<core::num*>* list81 = block {
-    final core::List<core::num*>* #t71 = core::_GrowableList::•<core::num*>(0);
+    final core::List<core::num*>* #t60 = core::_GrowableList::•<core::num*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t71.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t60.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t71.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t71;
+      #t60.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t60;
   core::Set<core::num*>* set81 = block {
-    final core::Set<core::num*>* #t72 = new col::_CompactLinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t61 = new col::_CompactLinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t72.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t61.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t72.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-    #t72.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t72;
+      #t61.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+    #t61.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t61;
   core::Map<core::String*, core::num*>* map81 = block {
-    final core::Map<core::String*, core::num*>* #t73 = <core::String*, core::num*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
-      core::Iterator<core::MapEntry<core::String*, core::num*>>* :sync-for-iterator = mapToInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::num*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::num*>* #t74 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::num*>};
-        #t73.{core::Map::[]=}{Invariant}(#t74.{core::MapEntry::key}{core::String*}, #t74.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-      }
-    }
-    else {
-      core::Iterator<core::MapEntry<core::String*, core::num*>>* :sync-for-iterator = mapToDouble.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::num*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::num*>* #t75 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::num*>};
-        #t73.{core::Map::[]=}{Invariant}(#t75.{core::MapEntry::key}{core::String*}, #t75.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-      }
-    }
-    #t73.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t73;
+    final core::Map<core::String*, core::num*>* #t62 = <core::String*, core::num*>{};
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t62.{core::Map::addAll}{Invariant}(mapToInt){(core::Map<core::String*, core::num*>*) →* void};
+    else
+      #t62.{core::Map::addAll}{Invariant}(mapToDouble){(core::Map<core::String*, core::num*>*) →* void};
+    #t62.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t62;
   core::List<dynamic>* list82 = block {
-    final core::List<dynamic>* #t76 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t63 = core::_GrowableList::•<dynamic>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t76.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+      #t63.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
     else
-      #t76.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-  } =>#t76;
+      #t63.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+  } =>#t63;
   core::Set<dynamic>* set82 = block {
-    final core::Set<dynamic>* #t77 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t64 = new col::_CompactLinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t77.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+      #t64.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
     else
-      #t77.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t77.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t77;
+      #t64.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t64.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t64;
   core::Set<dynamic>* map82 = block {
-    final core::Set<dynamic>* #t78 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t65 = new col::_CompactLinkedHashSet::•<dynamic>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t78.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:73:38: Error: Unexpected type 'Map<String, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t65.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:73:38: Error: Unexpected type 'Map<String, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   var map82 = {if (oracle(\"foo\")) ...mapToInt else ...dynVar, null};
                                      ^"){(dynamic) →* core::bool*};
     else
-      #t78.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t78.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t78;
+      #t65.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t65.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t65;
   core::List<core::num*>* list83 = block {
-    final core::List<core::num*>* #t79 = core::_GrowableList::•<core::num*>(0);
+    final core::List<core::num*>* #t66 = core::_GrowableList::•<core::num*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t79.{core::List::add}{Invariant}(42){(core::num*) →* void};
+      #t66.{core::List::add}{Invariant}(42){(core::num*) →* void};
     else
-      #t79.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t79;
+      #t66.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t66;
   core::Set<core::num*>* set83 = block {
-    final core::Set<core::num*>* #t80 = new col::_CompactLinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t67 = new col::_CompactLinkedHashSet::•<core::num*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t80.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+      #t67.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
     else
-      #t80.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t80.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t80;
+      #t67.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t67.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t67;
   core::Map<core::String*, core::num*>* map83 = block {
-    final core::Map<core::String*, core::num*>* #t81 = <core::String*, core::num*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
-      core::Iterator<core::MapEntry<core::String*, core::num*>>* :sync-for-iterator = mapToInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::num*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::num*>* #t82 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::num*>};
-        #t81.{core::Map::[]=}{Invariant}(#t82.{core::MapEntry::key}{core::String*}, #t82.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-      }
-    }
+    final core::Map<core::String*, core::num*>* #t68 = <core::String*, core::num*>{};
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t68.{core::Map::addAll}{Invariant}(mapToInt){(core::Map<core::String*, core::num*>*) →* void};
     else
-      #t81.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t81.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t81;
+      #t68.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t68.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t68;
   core::List<core::int*>* list90 = block {
-    final core::List<core::int*>* #t83 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t69 = core::_GrowableList::•<core::int*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t83.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
-  } =>#t83;
+      #t69.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+  } =>#t69;
   core::Set<core::int*>* set90 = block {
-    final core::Set<core::int*>* #t84 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t70 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t84.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
-    #t84.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t84;
+      #t70.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+    #t70.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t70;
   core::Map<core::String*, core::int*>* map90 = block {
-    final core::Map<core::String*, core::int*>* #t85 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t71 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t85.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
-    #t85.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t85;
+      #t71.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+    #t71.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t71;
   core::List<core::int*>* list91 = block {
-    final core::List<core::int*>* #t86 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t72 = core::_GrowableList::•<core::int*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
       core::Iterator<dynamic>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*).{core::Iterable::iterator}{core::Iterator<dynamic>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final dynamic #t87 = :sync-for-iterator.{core::Iterator::current}{dynamic};
+        final dynamic #t73 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
-          final core::int* #t88 = #t87 as{TypeError} core::int*;
-          #t86.{core::List::add}{Invariant}(#t88){(core::int*) →* void};
+          final core::int* #t74 = #t73 as{TypeError} core::int*;
+          #t72.{core::List::add}{Invariant}(#t74){(core::int*) →* void};
         }
       }
     }
-  } =>#t86;
+  } =>#t72;
   core::Set<core::int*>* set91 = block {
-    final core::Set<core::int*>* #t89 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t75 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
       core::Iterator<dynamic>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*).{core::Iterable::iterator}{core::Iterator<dynamic>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final dynamic #t90 = :sync-for-iterator.{core::Iterator::current}{dynamic};
+        final dynamic #t76 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
-          final core::int* #t91 = #t90 as{TypeError} core::int*;
-          #t89.{core::Set::add}{Invariant}(#t91){(core::int*) →* core::bool*};
+          final core::int* #t77 = #t76 as{TypeError} core::int*;
+          #t75.{core::Set::add}{Invariant}(#t77){(core::int*) →* core::bool*};
         }
       }
     }
-    #t89.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t89;
+    #t75.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t75;
   core::Map<core::String*, core::int*>* map91 = block {
-    final core::Map<core::String*, core::int*>* #t92 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t78 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
       core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<dynamic, dynamic>* #t93 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
+        final core::MapEntry<dynamic, dynamic>* #t79 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
         {
-          final core::String* #t94 = #t93.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
-          final core::int* #t95 = #t93.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-          #t92.{core::Map::[]=}{Invariant}(#t94, #t95){(core::String*, core::int*) →* void};
+          final core::String* #t80 = #t79.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
+          final core::int* #t81 = #t79.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
+          #t78.{core::Map::[]=}{Invariant}(#t80, #t81){(core::String*, core::int*) →* void};
         }
       }
     }
-    #t92.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t92;
+    #t78.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t78;
   core::List<core::int*>* list100 = block {
-    final core::List<core::int*>* #t96 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t82 = core::_GrowableList::•<core::int*>(0);
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t96.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t96;
+      #t82.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t82;
   core::Set<core::int*>* set100 = block {
-    final core::Set<core::int*>* #t97 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t83 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t97.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t97;
+      #t83.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t83;
   core::Map<core::int*, core::int*>* map100 = block {
-    final core::Map<core::int*, core::int*>* #t98 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t84 = <core::int*, core::int*>{};
     if(dynVar as{TypeError,ForDynamic} core::bool*)
-      #t98.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
-  } =>#t98;
+      #t84.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
+  } =>#t84;
 }
 static method testIfElementErrors(core::Map<core::int*, core::int*>* map) → dynamic {
   block {
-    final core::List<core::int*>* #t99 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t85 = core::_GrowableList::•<core::int*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t99.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:89:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t85.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:89:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[if (oracle(\"foo\")) \"bar\"];
                            ^" in "bar" as{TypeError} core::int*){(core::int*) →* void};
-  } =>#t99;
+  } =>#t85;
   block {
-    final core::Set<core::int*>* #t100 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t86 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t100.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:90:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t86.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:90:28: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{if (oracle(\"foo\")) \"bar\", null};
                            ^" in "bar" as{TypeError} core::int*){(core::int*) →* core::bool*};
-    #t100.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t100;
+    #t86.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t86;
   block {
-    final core::Map<core::String*, core::int*>* #t101 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t87 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t101.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:91:43: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t87.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:91:43: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <String, int>{if (oracle(\"foo\")) \"bar\": \"bar\", \"baz\": null};
                                           ^" in "bar" as{TypeError} core::int*){(core::String*, core::int*) →* void};
-    #t101.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t101;
+    #t87.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t87;
   block {
-    final core::List<core::int*>* #t102 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t88 = core::_GrowableList::•<core::int*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t102.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:92:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t88.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:92:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[if (oracle(\"foo\")) ...[\"bar\"]];
                                ^" in "bar" as{TypeError} core::int*)){(core::Iterable<core::int*>*) →* void};
-  } =>#t102;
+  } =>#t88;
   block {
-    final core::Set<core::int*>* #t103 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t89 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t103.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:93:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t89.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:93:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{if (oracle(\"foo\")) ...[\"bar\"], null};
                                ^" in "bar" as{TypeError} core::int*)){(core::Iterable<core::int*>*) →* void};
-    #t103.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t103;
+    #t89.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t89;
   block {
-    final core::Map<core::String*, core::int*>* #t104 = <core::String*, core::int*>{};
-    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*) {
-      core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = <core::String*, core::int*>{"bar": invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:94:47: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
-  <String, int>{if (oracle(\"foo\")) ...{\"bar\": \"bar\"}, \"baz\": null};
-                                              ^" in "bar" as{TypeError} core::int*}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::int*>* #t105 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t104.{core::Map::[]=}{Invariant}(#t105.{core::MapEntry::key}{core::String*}, #t105.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-      }
-    }
-    #t104.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t104;
-  block {
-    final core::List<core::int*>* #t106 = core::_GrowableList::•<core::int*>(0);
+    final core::Map<core::String*, core::int*>* #t90 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t106.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:95:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t90.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:94:47: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+  <String, int>{if (oracle(\"foo\")) ...{\"bar\": \"bar\"}, \"baz\": null};
+                                              ^" in "bar" as{TypeError} core::int*}){(core::Map<core::String*, core::int*>*) →* void};
+    #t90.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t90;
+  block {
+    final core::List<core::int*>* #t91 = core::_GrowableList::•<core::int*>(0);
+    if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
+      #t91.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:95:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) ...map];
                               ^"){(core::int*) →* void};
-  } =>#t106;
+  } =>#t91;
   block {
-    final core::Set<core::int*>* #t107 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t92 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t107.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:96:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t92.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:96:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map, null};
                               ^"){(core::int*) →* core::bool*};
-    #t107.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t107;
+    #t92.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t92;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:97:39: Error: Unexpected type 'List<String>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) ...[\"bar\"], \"baz\": null};
@@ -1094,61 +1019,61 @@
   <String, int>{if (oracle(\"foo\")) ...[\"bar\"], \"baz\": null};
                                       ^": null};
   block {
-    final core::List<core::String*>* #t108 = core::_GrowableList::•<core::String*>(0);
+    final core::List<core::String*>* #t93 = core::_GrowableList::•<core::String*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t108.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t93.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>[if (oracle(\"foo\")) 42 else 3.14];
                               ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
     else
-      #t108.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t93.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:98:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>[if (oracle(\"foo\")) 42 else 3.14];
                                       ^" in 3.14 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t108;
+  } =>#t93;
   block {
-    final core::Set<core::String*>* #t109 = new col::_CompactLinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t94 = new col::_CompactLinkedHashSet::•<core::String*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t109.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t94.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:31: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>{if (oracle(\"foo\")) 42 else 3.14, null};
                               ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
     else
-      #t109.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t94.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:99:39: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>{if (oracle(\"foo\")) 42 else 3.14, null};
                                       ^" in 3.14 as{TypeError} core::String*){(core::String*) →* core::bool*};
-    #t109.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
-  } =>#t109;
+    #t94.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
+  } =>#t94;
   block {
-    final core::Map<core::String*, core::String*>* #t110 = <core::String*, core::String*>{};
+    final core::Map<core::String*, core::String*>* #t95 = <core::String*, core::String*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t110.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:46: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t95.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:46: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String, String>{if (oracle(\"foo\")) \"bar\": 42 else \"baz\": 3.14, \"baz\": null};
                                              ^" in 42 as{TypeError} core::String*){(core::String*, core::String*) →* void};
     else
-      #t110.{core::Map::[]=}{Invariant}("baz", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:61: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+      #t95.{core::Map::[]=}{Invariant}("baz", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:100:61: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String, String>{if (oracle(\"foo\")) \"bar\": 42 else \"baz\": 3.14, \"baz\": null};
                                                             ^" in 3.14 as{TypeError} core::String*){(core::String*, core::String*) →* void};
-    #t110.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
-  } =>#t110;
+    #t95.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
+  } =>#t95;
   block {
-    final core::List<core::int*>* #t111 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t96 = core::_GrowableList::•<core::int*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t111.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:101:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t96.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:101:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) ...map else 42];
                               ^"){(core::int*) →* void};
     else
-      #t111.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t111;
+      #t96.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t96;
   block {
-    final core::Set<core::int*>* #t112 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t97 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t112.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:102:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t97.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:102:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map else 42, null};
                               ^"){(core::int*) →* core::bool*};
     else
-      #t112.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t112.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t112;
+      #t97.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t97.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t97;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:103:39: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) ...[42] else \"bar\": 42, \"baz\": null};
@@ -1157,26 +1082,26 @@
   <String, int>{if (oracle(\"foo\")) ...[42] else \"bar\": 42, \"baz\": null};
                                       ^": null};
   block {
-    final core::List<core::int*>* #t113 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t98 = core::_GrowableList::•<core::int*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t113.{core::List::add}{Invariant}(42){(core::int*) →* void};
+      #t98.{core::List::add}{Invariant}(42){(core::int*) →* void};
     else
-      #t113.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:104:39: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t98.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:104:39: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[if (oracle(\"foo\")) 42 else ...map];
                                       ^"){(core::int*) →* void};
-  } =>#t113;
+  } =>#t98;
   block {
-    final core::Set<core::int*>* #t114 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t99 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t114.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:105:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t99.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:105:31: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{if (oracle(\"foo\")) ...map else 42, null};
                               ^"){(core::int*) →* core::bool*};
     else
-      #t114.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t114.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t114;
+      #t99.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t99.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t99;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:106:54: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{if (oracle(\"foo\")) \"bar\": 42 else ...[42], \"baz\": null};
@@ -1203,822 +1128,737 @@
   var map13 = {if (oracle(\"foo\")) \"bar\": 3.14 else 42};
                                                    ^": null};
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t115 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t100 = core::_GrowableList::•<core::int*>(0);
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:114:27: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   List<int> list20 = [if (42) 42];
                           ^" in 42 as{TypeError} core::bool*)
-      #t115.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t115;
+      #t100.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t100;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t116 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t101 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:115:25: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   Set<int> set20 = {if (42) 42};
                         ^" in 42 as{TypeError} core::bool*)
-      #t116.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t116;
+      #t101.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t101;
   core::Map<core::int*, core::int*>* map30 = block {
-    final core::Map<core::int*, core::int*>* #t117 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t102 = <core::int*, core::int*>{};
     if(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:116:30: Error: A value of type 'int' can't be assigned to a variable of type 'bool'.
   Map<int, int> map30 = {if (42) 42: 42};
                              ^" in 42 as{TypeError} core::bool*)
-      #t117.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
-  } =>#t117;
+      #t102.{core::Map::[]=}{Invariant}(42, 42){(core::int*, core::int*) →* void};
+  } =>#t102;
   core::List<core::String*>* list40 = block {
-    final core::List<core::String*>* #t118 = core::_GrowableList::•<core::String*>(0);
+    final core::List<core::String*>* #t103 = core::_GrowableList::•<core::String*>(0);
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t118.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:53: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t103.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:53: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   List<String> list40 = <String>[if (oracle(\"foo\")) true else 42];
                                                     ^" in true as{TypeError} core::String*){(core::String*) →* void};
     else
-      #t118.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:63: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t103.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:117:63: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   List<String> list40 = <String>[if (oracle(\"foo\")) true else 42];
                                                               ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t118;
+  } =>#t103;
   core::Set<core::String*>* set40 = block {
-    final core::Set<core::String*>* #t119 = new col::_CompactLinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t104 = new col::_CompactLinkedHashSet::•<core::String*>();
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t119.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:51: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t104.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:51: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Set<String> set40 = <String>{if (oracle(\"foo\")) true else 42};
                                                   ^" in true as{TypeError} core::String*){(core::String*) →* core::bool*};
     else
-      #t119.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:61: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t104.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:118:61: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Set<String> set40 = <String>{if (oracle(\"foo\")) true else 42};
                                                             ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
-  } =>#t119;
+  } =>#t104;
   core::Map<core::String*, core::int*>* map40 = block {
-    final core::Map<core::String*, core::int*>* #t120 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t105 = <core::String*, core::int*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:61: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t105.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:61: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Map<String, int> map40 = <String, int>{if (oracle(\"foo\")) true: 42 else 42: 42};
                                                             ^" in true as{TypeError} core::String*, 42){(core::String*, core::int*) →* void};
     else
-      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:75: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t105.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:119:75: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Map<String, int> map40 = <String, int>{if (oracle(\"foo\")) true: 42 else 42: 42};
                                                                           ^" in 42 as{TypeError} core::String*, 42){(core::String*, core::int*) →* void};
-  } =>#t120;
+  } =>#t105;
   core::Map<core::int*, core::String*>* map41 = block {
-    final core::Map<core::int*, core::String*>* #t121 = <core::int*, core::String*>{};
+    final core::Map<core::int*, core::String*>* #t106 = <core::int*, core::String*>{};
     if(self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*)
-      #t121.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:65: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
+      #t106.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:65: Error: A value of type 'bool' can't be assigned to a variable of type 'String'.
   Map<int, String> map41 = <int, String>{if (oracle(\"foo\")) 42: true else 42: 42};
                                                                 ^" in true as{TypeError} core::String*){(core::int*, core::String*) →* void};
     else
-      #t121.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:79: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+      #t106.{core::Map::[]=}{Invariant}(42, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:120:79: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   Map<int, String> map41 = <int, String>{if (oracle(\"foo\")) 42: true else 42: 42};
                                                                               ^" in 42 as{TypeError} core::String*){(core::int*, core::String*) →* void};
-  } =>#t121;
+  } =>#t106;
 }
 static method testForElement(dynamic dynVar, core::List<core::int*>* listInt, core::List<core::double*>* listDouble, core::int* index, core::Map<core::String*, core::int*>* mapStringInt, core::Map<core::String*, core::double*>* mapStringDouble) → dynamic {
   core::List<core::int*>* list10 = block {
-    final core::List<core::int*>* #t122 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t107 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t122.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t122;
+      #t107.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t107;
   core::Set<core::int*>* set10 = block {
-    final core::Set<core::int*>* #t123 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t108 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t123.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t123.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t123;
+      #t108.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t108.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t108;
   core::Map<core::String*, core::int*>* map10 = block {
-    final core::Map<core::String*, core::int*>* #t124 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t109 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t124.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t124.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t124;
+      #t109.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t109.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t109;
   core::List<dynamic>* list11 = block {
-    final core::List<dynamic>* #t125 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t110 = core::_GrowableList::•<dynamic>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t125.{core::List::add}{Invariant}(dynVar){(dynamic) →* void};
-  } =>#t125;
+      #t110.{core::List::add}{Invariant}(dynVar){(dynamic) →* void};
+  } =>#t110;
   core::Set<dynamic>* set11 = block {
-    final core::Set<dynamic>* #t126 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t111 = new col::_CompactLinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t126.{core::Set::add}{Invariant}(dynVar){(dynamic) →* core::bool*};
-    #t126.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t126;
+      #t111.{core::Set::add}{Invariant}(dynVar){(dynamic) →* core::bool*};
+    #t111.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t111;
   core::Map<core::String*, dynamic>* map11 = block {
-    final core::Map<core::String*, dynamic>* #t127 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t112 = <core::String*, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t127.{core::Map::[]=}{Invariant}("bar", dynVar){(core::String*, dynamic) →* void};
-    #t127.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t127;
+      #t112.{core::Map::[]=}{Invariant}("bar", dynVar){(core::String*, dynamic) →* void};
+    #t112.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t112;
   core::List<core::List<core::int*>*>* list12 = block {
-    final core::List<core::List<core::int*>*>* #t128 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t113 = core::_GrowableList::•<core::List<core::int*>*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t128.{core::List::add}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::List<core::int*>*) →* void};
-  } =>#t128;
+      #t113.{core::List::add}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::List<core::int*>*) →* void};
+  } =>#t113;
   core::Set<core::List<core::int*>*>* set12 = block {
-    final core::Set<core::List<core::int*>*>* #t129 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t114 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t129.{core::Set::add}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::List<core::int*>*) →* core::bool*};
-    #t129.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t129;
+      #t114.{core::Set::add}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::List<core::int*>*) →* core::bool*};
+    #t114.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t114;
   core::Map<core::String*, core::List<core::int*>*>* map12 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t130 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t115 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t130.{core::Map::[]=}{Invariant}("bar", core::_GrowableList::_literal1<core::int*>(42)){(core::String*, core::List<core::int*>*) →* void};
-    #t130.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t130;
+      #t115.{core::Map::[]=}{Invariant}("bar", core::_GrowableList::_literal1<core::int*>(42)){(core::String*, core::List<core::int*>*) →* void};
+    #t115.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t115;
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t131 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t116 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t131.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
-  } =>#t131;
+      #t116.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
+  } =>#t116;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t132 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t117 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t132.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
-    #t132.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t132;
+      #t117.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
+    #t117.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t117;
   core::Map<core::String*, core::int*>* map20 = block {
-    final core::Map<core::String*, core::int*>* #t133 = <core::String*, core::int*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
-      core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::int*>* #t134 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t133.{core::Map::[]=}{Invariant}(#t134.{core::MapEntry::key}{core::String*}, #t134.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-      }
-    }
-    #t133.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t133;
+    final core::Map<core::String*, core::int*>* #t118 = <core::String*, core::int*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t118.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t118.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t118;
   core::List<dynamic>* list21 = block {
-    final core::List<dynamic>* #t135 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t119 = core::_GrowableList::•<dynamic>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t135.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
-  } =>#t135;
+      #t119.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
+  } =>#t119;
   core::Set<dynamic>* set21 = block {
-    final core::Set<dynamic>* #t136 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t120 = new col::_CompactLinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t136.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
-    #t136.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t136;
+      #t120.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
+    #t120.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t120;
   core::Map<core::String*, dynamic>* map21 = block {
-    final core::Map<core::String*, dynamic>* #t137 = <core::String*, dynamic>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
-      core::Iterator<core::MapEntry<core::String*, dynamic>>* :sync-for-iterator = <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, dynamic>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, dynamic>* #t138 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, dynamic>};
-        #t137.{core::Map::[]=}{Invariant}(#t138.{core::MapEntry::key}{core::String*}, #t138.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-      }
-    }
-    #t137.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t137;
+    final core::Map<core::String*, dynamic>* #t121 = <core::String*, dynamic>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t121.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t121.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t121;
   core::List<core::List<core::int*>*>* list22 = block {
-    final core::List<core::List<core::int*>*>* #t139 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t122 = core::_GrowableList::•<core::List<core::int*>*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t139.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t139;
+      #t122.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t122;
   core::Set<core::List<core::int*>*>* set22 = block {
-    final core::Set<core::List<core::int*>*>* #t140 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t123 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t140.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t140.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t140;
+      #t123.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t123.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t123;
   core::Map<core::String*, core::List<core::int*>*>* map22 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t141 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
-      core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::_literal1<core::int*>(42)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::List<core::int*>*>* #t142 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-        #t141.{core::Map::[]=}{Invariant}(#t142.{core::MapEntry::key}{core::String*}, #t142.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-      }
-    }
-    #t141.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t141;
+    final core::Map<core::String*, core::List<core::int*>*>* #t124 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t124.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::_literal1<core::int*>(42)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t124.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t124;
   core::List<core::int*>* list30 = block {
-    final core::List<core::int*>* #t143 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t125 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t143.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
-  } =>#t143;
+        #t125.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
+  } =>#t125;
   core::Set<core::int*>* set30 = block {
-    final core::Set<core::int*>* #t144 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t126 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t144.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
-    #t144.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t144;
+        #t126.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::Iterable<core::int*>*) →* void};
+    #t126.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t126;
   core::Map<core::String*, core::int*>* map30 = block {
-    final core::Map<core::String*, core::int*>* #t145 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t127 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = <core::String*, core::int*>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::int*>* #t146 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-          #t145.{core::Map::[]=}{Invariant}(#t146.{core::MapEntry::key}{core::String*}, #t146.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-        }
-      }
-    #t145.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t145;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t127.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{"bar": 42}){(core::Map<core::String*, core::int*>*) →* void};
+    #t127.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t127;
   core::List<dynamic>* list31 = block {
-    final core::List<dynamic>* #t147 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t128 = core::_GrowableList::•<dynamic>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t147.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
-  } =>#t147;
+        #t128.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
+  } =>#t128;
   core::Set<dynamic>* set31 = block {
-    final core::Set<dynamic>* #t148 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t129 = new col::_CompactLinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t148.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
-    #t148.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t148;
+        #t129.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<dynamic>(dynVar)){(core::Iterable<dynamic>*) →* void};
+    #t129.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t129;
   core::Map<core::String*, dynamic>* map31 = block {
-    final core::Map<core::String*, dynamic>* #t149 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t130 = <core::String*, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, dynamic>>* :sync-for-iterator = <core::String*, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, dynamic>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, dynamic>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, dynamic>* #t150 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, dynamic>};
-          #t149.{core::Map::[]=}{Invariant}(#t150.{core::MapEntry::key}{core::String*}, #t150.{core::MapEntry::value}{dynamic}){(core::String*, dynamic) →* void};
-        }
-      }
-    #t149.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t149;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t130.{core::Map::addAll}{Invariant}(<core::String*, dynamic>{"bar": dynVar}){(core::Map<core::String*, dynamic>*) →* void};
+    #t130.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t130;
   core::List<core::List<core::int*>*>* list33 = block {
-    final core::List<core::List<core::int*>*>* #t151 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t131 = core::_GrowableList::•<core::List<core::int*>*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t151.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t151;
+        #t131.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t131;
   core::Set<core::List<core::int*>*>* set33 = block {
-    final core::Set<core::List<core::int*>*>* #t152 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t132 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t152.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t152.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t152;
+        #t132.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::_literal1<core::int*>(42))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t132.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t132;
   core::Map<core::String*, core::List<core::int*>*>* map33 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t153 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t133 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::_literal1<core::int*>(42)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::List<core::int*>*>* #t154 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-          #t153.{core::Map::[]=}{Invariant}(#t154.{core::MapEntry::key}{core::String*}, #t154.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-        }
-      }
-    #t153.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t153;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t133.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::_literal1<core::int*>(42)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t133.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t133;
   core::List<core::List<core::int*>*>* list40 = block {
-    final core::List<core::List<core::int*>*>* #t155 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t134 = core::_GrowableList::•<core::List<core::int*>*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t155.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t155;
+      #t134.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t134;
   core::Set<core::List<core::int*>*>* set40 = block {
-    final core::Set<core::List<core::int*>*>* #t156 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t135 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t156.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t156.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t156;
+      #t135.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t135.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t135;
   core::Map<core::String*, core::List<core::int*>*>* map40 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t157 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
-      core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::List<core::int*>*>* #t158 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-        #t157.{core::Map::[]=}{Invariant}(#t158.{core::MapEntry::key}{core::String*}, #t158.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-      }
-    }
-    #t157.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t157;
+    final core::Map<core::String*, core::List<core::int*>*>* #t136 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t136.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t136.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t136;
   core::List<core::List<core::int*>*>* list41 = block {
+    final core::List<core::List<core::int*>*>* #t137 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t137.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t138 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+        #t138.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
+      } =>#t138){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t137;
+  core::Set<core::List<core::int*>*>* set41 = block {
+    final core::Set<core::List<core::int*>*>* #t139 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t139.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int*>*>* #t140 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+        #t140.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
+      } =>#t140){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t139.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t139;
+  core::List<core::List<core::int*>*>* list42 = block {
+    final core::List<core::List<core::int*>*>* #t141 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t141.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t141;
+  core::Set<core::List<core::int*>*>* set42 = block {
+    final core::Set<core::List<core::int*>*>* #t142 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t142.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t142.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t142;
+  core::Map<core::String*, core::List<core::int*>*>* map42 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t143 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t143.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t143.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t143;
+  core::List<core::int*>* list50 = block {
+    final core::List<core::int*>* #t144 = core::_GrowableList::•<core::int*>(0);
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t144.{core::List::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
+  } =>#t144;
+  core::Set<core::int*>* set50 = block {
+    final core::Set<core::int*>* #t145 = new col::_CompactLinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t145.{core::Set::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
+    #t145.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t145;
+  core::Map<core::String*, core::int*>* map50 = block {
+    final core::Map<core::String*, core::int*>* #t146 = <core::String*, core::int*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t146.{core::Map::addAll}{Invariant}(<core::String*, core::int*>{}){(core::Map<core::String*, core::int*>*) →* void};
+    #t146.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t146;
+  core::List<core::int*>* list51 = block {
+    final core::List<core::int*>* #t147 = core::_GrowableList::•<core::int*>(0);
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t147.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t148 = new col::_CompactLinkedHashSet::•<core::int*>();
+      } =>#t148){(core::Iterable<core::int*>*) →* void};
+  } =>#t147;
+  core::Set<core::int*>* set51 = block {
+    final core::Set<core::int*>* #t149 = new col::_CompactLinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t149.{core::Set::addAll}{Invariant}( block {
+        final core::Set<core::int*>* #t150 = new col::_CompactLinkedHashSet::•<core::int*>();
+      } =>#t150){(core::Iterable<core::int*>*) →* void};
+    #t149.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t149;
+  core::List<core::int*>* list52 = block {
+    final core::List<core::int*>* #t151 = core::_GrowableList::•<core::int*>(0);
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t151.{core::List::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
+  } =>#t151;
+  core::Set<core::int*>* set52 = block {
+    final core::Set<core::int*>* #t152 = new col::_CompactLinkedHashSet::•<core::int*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t152.{core::Set::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
+    #t152.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t152;
+  core::List<core::List<core::int*>*>* list60 = block {
+    final core::List<core::List<core::int*>*>* #t153 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t153.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t153;
+  core::Set<core::List<core::int*>*>* set60 = block {
+    final core::Set<core::List<core::int*>*>* #t154 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t154.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t154.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t154;
+  core::Map<core::String*, core::List<core::int*>*>* map60 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t155 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t155.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t155.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t155;
+  core::List<core::List<core::int*>*>* list61 = block {
+    final core::List<core::List<core::int*>*>* #t156 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t156.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+  } =>#t156;
+  core::Set<core::List<core::int*>*>* set61 = block {
+    final core::Set<core::List<core::int*>*>* #t157 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t157.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
+    #t157.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t157;
+  core::Map<core::String*, core::List<core::int*>*>* map61 = block {
+    final core::Map<core::String*, core::List<core::int*>*>* #t158 = <core::String*, core::List<core::int*>*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t158.{core::Map::addAll}{Invariant}(<core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}){(core::Map<core::String*, core::List<core::int*>*>*) →* void};
+    #t158.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t158;
+  core::List<core::List<core::int*>*>* list70 = block {
     final core::List<core::List<core::int*>*>* #t159 = core::_GrowableList::•<core::List<core::int*>*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t159.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t160 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
-        #t160.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
-      } =>#t160){(core::Iterable<core::List<core::int*>*>*) →* void};
+      #t159.{core::List::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* void};
   } =>#t159;
-  core::Set<core::List<core::int*>*>* set41 = block {
-    final core::Set<core::List<core::int*>*>* #t161 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t161.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int*>*>* #t162 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
-        #t162.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
-      } =>#t162){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t161.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t161;
-  core::List<core::List<core::int*>*>* list42 = block {
-    final core::List<core::List<core::int*>*>* #t163 = core::_GrowableList::•<core::List<core::int*>*>(0);
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t163.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t163;
-  core::Set<core::List<core::int*>*>* set42 = block {
-    final core::Set<core::List<core::int*>*>* #t164 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t164.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t164.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t164;
-  core::Map<core::String*, core::List<core::int*>*>* map42 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t165 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::List<core::int*>*>* #t166 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-          #t165.{core::Map::[]=}{Invariant}(#t166.{core::MapEntry::key}{core::String*}, #t166.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-        }
-      }
-    #t165.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t165;
-  core::List<core::int*>* list50 = block {
-    final core::List<core::int*>* #t167 = core::_GrowableList::•<core::int*>(0);
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t167.{core::List::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
-  } =>#t167;
-  core::Set<core::int*>* set50 = block {
-    final core::Set<core::int*>* #t168 = new col::_CompactLinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t168.{core::Set::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
-    #t168.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t168;
-  core::Map<core::String*, core::int*>* map50 = block {
-    final core::Map<core::String*, core::int*>* #t169 = <core::String*, core::int*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
-      core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::int*>* #t170 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t169.{core::Map::[]=}{Invariant}(#t170.{core::MapEntry::key}{core::String*}, #t170.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-      }
-    }
-    #t169.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t169;
-  core::List<core::int*>* list51 = block {
-    final core::List<core::int*>* #t171 = core::_GrowableList::•<core::int*>(0);
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t171.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t172 = new col::_CompactLinkedHashSet::•<core::int*>();
-      } =>#t172){(core::Iterable<core::int*>*) →* void};
-  } =>#t171;
-  core::Set<core::int*>* set51 = block {
-    final core::Set<core::int*>* #t173 = new col::_CompactLinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t173.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::int*>* #t174 = new col::_CompactLinkedHashSet::•<core::int*>();
-      } =>#t174){(core::Iterable<core::int*>*) →* void};
-    #t173.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t173;
-  core::List<core::int*>* list52 = block {
-    final core::List<core::int*>* #t175 = core::_GrowableList::•<core::int*>(0);
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t175.{core::List::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
-  } =>#t175;
-  core::Set<core::int*>* set52 = block {
-    final core::Set<core::int*>* #t176 = new col::_CompactLinkedHashSet::•<core::int*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t176.{core::Set::addAll}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::Iterable<core::int*>*) →* void};
-    #t176.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t176;
-  core::List<core::List<core::int*>*>* list60 = block {
-    final core::List<core::List<core::int*>*>* #t177 = core::_GrowableList::•<core::List<core::int*>*>(0);
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t177.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t177;
-  core::Set<core::List<core::int*>*>* set60 = block {
-    final core::Set<core::List<core::int*>*>* #t178 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t178.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t178.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t178;
-  core::Map<core::String*, core::List<core::int*>*>* map60 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t179 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
-      core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::String*, core::List<core::int*>*>* #t180 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-        #t179.{core::Map::[]=}{Invariant}(#t180.{core::MapEntry::key}{core::String*}, #t180.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-      }
-    }
-    #t179.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t179;
-  core::List<core::List<core::int*>*>* list61 = block {
-    final core::List<core::List<core::int*>*>* #t181 = core::_GrowableList::•<core::List<core::int*>*>(0);
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t181.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-  } =>#t181;
-  core::Set<core::List<core::int*>*>* set61 = block {
-    final core::Set<core::List<core::int*>*>* #t182 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t182.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0))){(core::Iterable<core::List<core::int*>*>*) →* void};
-    #t182.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t182;
-  core::Map<core::String*, core::List<core::int*>*>* map61 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t183 = <core::String*, core::List<core::int*>*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"bar": core::_GrowableList::•<core::int*>(0)}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::List<core::int*>*>* #t184 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-          #t183.{core::Map::[]=}{Invariant}(#t184.{core::MapEntry::key}{core::String*}, #t184.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
-        }
-      }
-    #t183.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t183;
-  core::List<core::List<core::int*>*>* list70 = block {
-    final core::List<core::List<core::int*>*>* #t185 = core::_GrowableList::•<core::List<core::int*>*>(0);
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t185.{core::List::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* void};
-  } =>#t185;
   core::Set<core::List<core::int*>*>* set70 = block {
-    final core::Set<core::List<core::int*>*>* #t186 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t160 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t186.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
-    #t186.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t186;
+      #t160.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
+    #t160.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t160;
   core::Map<core::String*, core::List<core::int*>*>* map70 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t187 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t161 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t187.{core::Map::[]=}{Invariant}("bar", core::_GrowableList::•<core::int*>(0)){(core::String*, core::List<core::int*>*) →* void};
-    #t187.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t187;
+      #t161.{core::Map::[]=}{Invariant}("bar", core::_GrowableList::•<core::int*>(0)){(core::String*, core::List<core::int*>*) →* void};
+    #t161.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t161;
   core::List<core::List<core::int*>*>* list71 = block {
-    final core::List<core::List<core::int*>*>* #t188 = core::_GrowableList::•<core::List<core::int*>*>(0);
+    final core::List<core::List<core::int*>*>* #t162 = core::_GrowableList::•<core::List<core::int*>*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t188.{core::List::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* void};
-  } =>#t188;
+        #t162.{core::List::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* void};
+  } =>#t162;
   core::Set<core::List<core::int*>*>* set71 = block {
-    final core::Set<core::List<core::int*>*>* #t189 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
+    final core::Set<core::List<core::int*>*>* #t163 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t189.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
-    #t189.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
-  } =>#t189;
+        #t163.{core::Set::add}{Invariant}(core::_GrowableList::•<core::int*>(0)){(core::List<core::int*>*) →* core::bool*};
+    #t163.{core::Set::add}{Invariant}(null){(core::List<core::int*>*) →* core::bool*};
+  } =>#t163;
   core::Map<core::String*, core::List<core::int*>*>* map71 = block {
-    final core::Map<core::String*, core::List<core::int*>*>* #t190 = <core::String*, core::List<core::int*>*>{};
+    final core::Map<core::String*, core::List<core::int*>*>* #t164 = <core::String*, core::List<core::int*>*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t190.{core::Map::[]=}{Invariant}("bar", core::_GrowableList::•<core::int*>(0)){(core::String*, core::List<core::int*>*) →* void};
-    #t190.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
-  } =>#t190;
+        #t164.{core::Map::[]=}{Invariant}("bar", core::_GrowableList::•<core::int*>(0)){(core::String*, core::List<core::int*>*) →* void};
+    #t164.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::List<core::int*>*) →* void};
+  } =>#t164;
   core::List<core::num*>* list80 = block {
-    final core::List<core::num*>* #t191 = core::_GrowableList::•<core::num*>(0);
+    final core::List<core::num*>* #t165 = core::_GrowableList::•<core::num*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t191.{core::List::add}{Invariant}(42){(core::num*) →* void};
+        #t165.{core::List::add}{Invariant}(42){(core::num*) →* void};
       else
-        #t191.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
-  } =>#t191;
+        #t165.{core::List::add}{Invariant}(3.14){(core::num*) →* void};
+  } =>#t165;
   core::Set<core::num*>* set80 = block {
-    final core::Set<core::num*>* #t192 = new col::_CompactLinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t166 = new col::_CompactLinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t192.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
+        #t166.{core::Set::add}{Invariant}(42){(core::num*) →* core::bool*};
       else
-        #t192.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t192.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t192;
+        #t166.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t166.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t166;
   core::Map<core::String*, core::num*>* map80 = block {
-    final core::Map<core::String*, core::num*>* #t193 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t167 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t193.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
+        #t167.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::num*) →* void};
       else
-        #t193.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t193.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t193;
+        #t167.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t167.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t167;
   core::List<core::num*>* list81 = block {
-    final core::List<core::num*>* #t194 = core::_GrowableList::•<core::num*>(0);
+    final core::List<core::num*>* #t168 = core::_GrowableList::•<core::num*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t194.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t168.{core::List::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t194.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t194;
+        #t168.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t168;
   core::Set<core::num*>* set81 = block {
-    final core::Set<core::num*>* #t195 = new col::_CompactLinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t169 = new col::_CompactLinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t195.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t169.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t195.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-    #t195.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t195;
+        #t169.{core::Set::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+    #t169.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t169;
   core::Map<core::String*, core::num*>* map81 = block {
-    final core::Map<core::String*, core::num*>* #t196 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t170 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::num*>>* :sync-for-iterator = mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::num*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::num*>* #t197 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::num*>};
-          #t196.{core::Map::[]=}{Invariant}(#t197.{core::MapEntry::key}{core::String*}, #t197.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-        }
-      }
-      else {
-        core::Iterator<core::MapEntry<core::String*, core::num*>>* :sync-for-iterator = mapStringDouble.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::num*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::num*>* #t198 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::num*>};
-          #t196.{core::Map::[]=}{Invariant}(#t198.{core::MapEntry::key}{core::String*}, #t198.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-        }
-      }
-    #t196.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t196;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t170.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<core::String*, core::num*>*) →* void};
+      else
+        #t170.{core::Map::addAll}{Invariant}(mapStringDouble){(core::Map<core::String*, core::num*>*) →* void};
+    #t170.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t170;
   core::List<dynamic>* list82 = block {
-    final core::List<dynamic>* #t199 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t171 = core::_GrowableList::•<dynamic>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t199.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+        #t171.{core::List::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
       else
-        #t199.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-  } =>#t199;
+        #t171.{core::List::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+  } =>#t171;
   core::Set<dynamic>* set82 = block {
-    final core::Set<dynamic>* #t200 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t172 = new col::_CompactLinkedHashSet::•<dynamic>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t200.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
+        #t172.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<dynamic>*) →* void};
       else
-        #t200.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
-    #t200.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t200;
+        #t172.{core::Set::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*){(core::Iterable<dynamic>*) →* void};
+    #t172.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t172;
   core::Map<dynamic, dynamic>* map82 = block {
-    final core::Map<dynamic, dynamic>* #t201 = <dynamic, dynamic>{};
+    final core::Map<dynamic, dynamic>* #t173 = <dynamic, dynamic>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<dynamic, dynamic>>* :sync-for-iterator = mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<dynamic, dynamic>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<dynamic, dynamic>* #t202 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-          #t201.{core::Map::[]=}{Invariant}(#t202.{core::MapEntry::key}{dynamic}, #t202.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
-        }
-      }
-      else {
-        core::Iterator<core::MapEntry<dynamic, dynamic>>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<dynamic, dynamic>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<dynamic, dynamic>* #t203 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-          #t201.{core::Map::[]=}{Invariant}(#t203.{core::MapEntry::key}{dynamic}, #t203.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
-        }
-      }
-    #t201.{core::Map::[]=}{Invariant}("baz", null){(dynamic, dynamic) →* void};
-  } =>#t201;
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t173.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<dynamic, dynamic>*) →* void};
+      else
+        #t173.{core::Map::addAll}{Invariant}(dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*){(core::Map<dynamic, dynamic>*) →* void};
+    #t173.{core::Map::[]=}{Invariant}("baz", null){(dynamic, dynamic) →* void};
+  } =>#t173;
   core::List<core::num*>* list83 = block {
-    final core::List<core::num*>* #t204 = core::_GrowableList::•<core::num*>(0);
+    final core::List<core::num*>* #t174 = core::_GrowableList::•<core::num*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t204.{core::List::add}{Invariant}(42){(core::num*) →* void};
+        #t174.{core::List::add}{Invariant}(42){(core::num*) →* void};
       else
-        #t204.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
-  } =>#t204;
+        #t174.{core::List::addAll}{Invariant}(listDouble){(core::Iterable<core::num*>*) →* void};
+  } =>#t174;
   core::Set<core::num*>* set83 = block {
-    final core::Set<core::num*>* #t205 = new col::_CompactLinkedHashSet::•<core::num*>();
+    final core::Set<core::num*>* #t175 = new col::_CompactLinkedHashSet::•<core::num*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t205.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
+        #t175.{core::Set::addAll}{Invariant}(listInt){(core::Iterable<core::num*>*) →* void};
       else
-        #t205.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
-    #t205.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
-  } =>#t205;
+        #t175.{core::Set::add}{Invariant}(3.14){(core::num*) →* core::bool*};
+    #t175.{core::Set::add}{Invariant}(null){(core::num*) →* core::bool*};
+  } =>#t175;
   core::Map<core::String*, core::num*>* map83 = block {
-    final core::Map<core::String*, core::num*>* #t206 = <core::String*, core::num*>{};
+    final core::Map<core::String*, core::num*>* #t176 = <core::String*, core::num*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*) {
-        core::Iterator<core::MapEntry<core::String*, core::num*>>* :sync-for-iterator = mapStringInt.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::num*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::num*>>*};
-        for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-          final core::MapEntry<core::String*, core::num*>* #t207 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::num*>};
-          #t206.{core::Map::[]=}{Invariant}(#t207.{core::MapEntry::key}{core::String*}, #t207.{core::MapEntry::value}{core::num*}){(core::String*, core::num*) →* void};
-        }
-      }
+      if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
+        #t176.{core::Map::addAll}{Invariant}(mapStringInt){(core::Map<core::String*, core::num*>*) →* void};
       else
-        #t206.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
-    #t206.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
-  } =>#t206;
+        #t176.{core::Map::[]=}{Invariant}("bar", 3.14){(core::String*, core::num*) →* void};
+    #t176.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::num*) →* void};
+  } =>#t176;
   core::List<core::int*>* list90 = block {
-    final core::List<core::int*>* #t208 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t177 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t208.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
-  } =>#t208;
+      #t177.{core::List::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+  } =>#t177;
   core::Set<core::int*>* set90 = block {
-    final core::Set<core::int*>* #t209 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t178 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t209.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
-    #t209.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t209;
+      #t178.{core::Set::add}{Invariant}(dynVar as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+    #t178.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t178;
   core::Map<core::String*, core::int*>* map90 = block {
-    final core::Map<core::String*, core::int*>* #t210 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t179 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t210.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
-    #t210.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t210;
+      #t179.{core::Map::[]=}{Invariant}("bar", dynVar as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+    #t179.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t179;
   core::List<core::int*>* list91 = block {
-    final core::List<core::int*>* #t211 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t180 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
       core::Iterator<dynamic>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*).{core::Iterable::iterator}{core::Iterator<dynamic>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final dynamic #t212 = :sync-for-iterator.{core::Iterator::current}{dynamic};
+        final dynamic #t181 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
-          final core::int* #t213 = #t212 as{TypeError} core::int*;
-          #t211.{core::List::add}{Invariant}(#t213){(core::int*) →* void};
+          final core::int* #t182 = #t181 as{TypeError} core::int*;
+          #t180.{core::List::add}{Invariant}(#t182){(core::int*) →* void};
         }
       }
     }
-  } =>#t211;
+  } =>#t180;
   core::Set<core::int*>* set91 = block {
-    final core::Set<core::int*>* #t214 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t183 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
       core::Iterator<dynamic>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*).{core::Iterable::iterator}{core::Iterator<dynamic>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final dynamic #t215 = :sync-for-iterator.{core::Iterator::current}{dynamic};
+        final dynamic #t184 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
-          final core::int* #t216 = #t215 as{TypeError} core::int*;
-          #t214.{core::Set::add}{Invariant}(#t216){(core::int*) →* core::bool*};
+          final core::int* #t185 = #t184 as{TypeError} core::int*;
+          #t183.{core::Set::add}{Invariant}(#t185){(core::int*) →* core::bool*};
         }
       }
     }
-    #t214.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t214;
+    #t183.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t183;
   core::Map<core::String*, core::int*>* map91 = block {
-    final core::Map<core::String*, core::int*>* #t217 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t186 = <core::String*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
       core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::String*, core::int*>>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<dynamic, dynamic>* #t218 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
+        final core::MapEntry<dynamic, dynamic>* #t187 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
         {
-          final core::String* #t219 = #t218.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
-          final core::int* #t220 = #t218.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-          #t217.{core::Map::[]=}{Invariant}(#t219, #t220){(core::String*, core::int*) →* void};
+          final core::String* #t188 = #t187.{core::MapEntry::key}{dynamic} as{TypeError} core::String*;
+          final core::int* #t189 = #t187.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
+          #t186.{core::Map::[]=}{Invariant}(#t188, #t189){(core::String*, core::int*) →* void};
         }
       }
     }
-    #t217.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t217;
+    #t186.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t186;
   core::List<core::int*>* list100 = block {
-    final core::List<core::int*>* #t221 = core::_GrowableList::•<core::int*>(0);
-    for (final core::int* #t222 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t221.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t221;
+    final core::List<core::int*>* #t190 = core::_GrowableList::•<core::int*>(0);
+    for (final core::int* #t191 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t190.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t190;
   core::Set<core::int*>* set100 = block {
-    final core::Set<core::int*>* #t223 = new col::_CompactLinkedHashSet::•<core::int*>();
-    for (final core::int* #t224 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t223.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-  } =>#t223;
+    final core::Set<core::int*>* #t192 = new col::_CompactLinkedHashSet::•<core::int*>();
+    for (final core::int* #t193 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t192.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+  } =>#t192;
   core::Map<core::String*, core::int*>* map100 = block {
-    final core::Map<core::String*, core::int*>* #t225 = <core::String*, core::int*>{};
-    for (final core::int* #t226 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
-      #t225.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-  } =>#t225;
+    final core::Map<core::String*, core::int*>* #t194 = <core::String*, core::int*>{};
+    for (final core::int* #t195 = index = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; index = index.{core::num::+}(1){(core::num*) →* core::int*})
+      #t194.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+  } =>#t194;
   core::List<core::int*>* list110 = block {
-    final core::List<core::int*>* #t227 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t196 = core::_GrowableList::•<core::int*>(0);
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal3<core::int*>(1, 2, 3).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
-        #t227.{core::List::add}{Invariant}(i){(core::int*) →* void};
+        #t196.{core::List::add}{Invariant}(i){(core::int*) →* void};
       }
     }
-  } =>#t227;
+  } =>#t196;
   core::Set<core::int*>* set110 = block {
-    final core::Set<core::int*>* #t228 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t197 = new col::_CompactLinkedHashSet::•<core::int*>();
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal3<core::int*>(1, 2, 3).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
-        #t228.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+        #t197.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
       }
     }
-    #t228.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t228;
+    #t197.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t197;
   core::Map<core::String*, core::int*>* map110 = block {
-    final core::Map<core::String*, core::int*>* #t229 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t198 = <core::String*, core::int*>{};
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal3<core::int*>(1, 2, 3).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
-        #t229.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+        #t198.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
       }
     }
-    #t229.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t229;
+    #t198.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t198;
   core::List<core::int*>* list120 = block {
-    final core::List<core::int*>* #t230 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t199 = core::_GrowableList::•<core::int*>(0);
     {
       core::Iterator<dynamic>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*).{core::Iterable::iterator}{core::Iterator<dynamic>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic i = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t230.{core::List::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
+        #t199.{core::List::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* void};
       }
     }
-  } =>#t230;
+  } =>#t199;
   core::Set<core::int*>* set120 = block {
-    final core::Set<core::int*>* #t231 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t200 = new col::_CompactLinkedHashSet::•<core::int*>();
     {
       core::Iterator<dynamic>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*).{core::Iterable::iterator}{core::Iterator<dynamic>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic i = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t231.{core::Set::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
+        #t200.{core::Set::add}{Invariant}(i as{TypeError,ForDynamic} core::int*){(core::int*) →* core::bool*};
       }
     }
-    #t231.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t231;
+    #t200.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t200;
   core::Map<core::String*, core::int*>* map120 = block {
-    final core::Map<core::String*, core::int*>* #t232 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t201 = <core::String*, core::int*>{};
     {
       core::Iterator<dynamic>* :sync-for-iterator = (dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*).{core::Iterable::iterator}{core::Iterator<dynamic>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic i = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t232.{core::Map::[]=}{Invariant}("bar", i as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
+        #t201.{core::Map::[]=}{Invariant}("bar", i as{TypeError,ForDynamic} core::int*){(core::String*, core::int*) →* void};
       }
     }
-    #t232.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t232;
+    #t201.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t201;
   core::List<core::int*>* list130 = block {
-    final core::List<core::int*>* #t233 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t202 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t233.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t233;
+      #t202.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t202;
   core::Set<core::int*>* set130 = block {
-    final core::Set<core::int*>* #t234 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t203 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t234.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-  } =>#t234;
+      #t203.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+  } =>#t203;
   core::Map<core::int*, core::int*>* map130 = block {
-    final core::Map<core::int*, core::int*>* #t235 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t204 = <core::int*, core::int*>{};
     for (core::int* i = 1; i.{core::num::<}(2){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t235.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
-  } =>#t235;
+      #t204.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
+  } =>#t204;
 }
 static method testForElementErrors(core::Map<core::int*, core::int*>* map, core::List<core::int*>* list) → dynamic async /* futureValueType= dynamic */ {
   block {
-    final core::List<core::int*>* #t236 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t205 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t236.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:212:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t205.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:212:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) \"bar\"];
                                             ^" in "bar" as{TypeError} core::int*){(core::int*) →* void};
-  } =>#t236;
+  } =>#t205;
   block {
-    final core::Set<core::int*>* #t237 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t206 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t237.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:213:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t206.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:213:45: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\", null};
                                             ^" in "bar" as{TypeError} core::int*){(core::int*) →* core::bool*};
-    #t237.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t237;
+    #t206.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t206;
   block {
-    final core::Map<core::int*, core::int*>* #t238 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t207 = <core::int*, core::int*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t238.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:50: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t207.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:50: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                  ^" in "bar" as{TypeError} core::int*, invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                         ^" in "bar" as{TypeError} core::int*){(core::int*, core::int*) →* void};
-    #t238.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+    #t207.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:214:64: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) \"bar\": \"bar\", \"baz\": null};
                                                                ^" in "baz" as{TypeError} core::int*, null){(core::int*, core::int*) →* void};
-  } =>#t238;
+  } =>#t207;
   block {
-    final core::List<core::int*>* #t239 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t208 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t239.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:215:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t208.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:215:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) ...[\"bar\"]];
                                                 ^" in "bar" as{TypeError} core::int*)){(core::Iterable<core::int*>*) →* void};
-  } =>#t239;
+  } =>#t208;
   block {
-    final core::Set<core::int*>* #t240 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t209 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t240.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:216:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+      #t209.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:216:49: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) ...[\"bar\"], null};
                                                 ^" in "bar" as{TypeError} core::int*)){(core::Iterable<core::int*>*) →* void};
-    #t240.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t240;
+    #t209.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t209;
   block {
-    final core::Map<core::int*, core::int*>* #t241 = <core::int*, core::int*>{};
-    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*}) {
-      core::Iterator<core::MapEntry<core::int*, core::int*>>* :sync-for-iterator = <core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:54: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+    final core::Map<core::int*, core::int*>* #t210 = <core::int*, core::int*>{};
+    for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
+      #t210.{core::Map::addAll}{Invariant}(<core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:54: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
                                                      ^" in "bar" as{TypeError} core::int*: invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:61: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
-                                                            ^" in "bar" as{TypeError} core::int*}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int*, core::int*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::int*, core::int*>>*};
-      for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::MapEntry<core::int*, core::int*>* #t242 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int*, core::int*>};
-        #t241.{core::Map::[]=}{Invariant}(#t242.{core::MapEntry::key}{core::int*}, #t242.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
-      }
-    }
-    #t241.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:69: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
+                                                            ^" in "bar" as{TypeError} core::int*}){(core::Map<core::int*, core::int*>*) →* void};
+    #t210.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:217:69: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...{\"bar\": \"bar\"}, \"baz\": null};
                                                                     ^" in "baz" as{TypeError} core::int*, null){(core::int*, core::int*) →* void};
-  } =>#t241;
+  } =>#t210;
   block {
-    final core::List<core::int*>* #t243 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t211 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t243.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:218:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t211.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:218:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) ...map];
                                                ^"){(core::int*) →* void};
-  } =>#t243;
+  } =>#t211;
   block {
-    final core::Set<core::int*>* #t244 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t212 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t244.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:219:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+      #t212.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:219:48: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) ...map, null};
                                                ^"){(core::int*) →* core::bool*};
-    #t244.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t244;
+    #t212.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t212;
   <core::int*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:220:53: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...list, 42: null};
@@ -2027,66 +1867,66 @@
   <int, int>{for (int i = 0; oracle(\"foo\"); i++) ...list, 42: null};
                                                     ^": null};
   block {
-    final core::List<core::String*>* #t245 = core::_GrowableList::•<core::String*>(0);
+    final core::List<core::String*>* #t213 = core::_GrowableList::•<core::String*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t245.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t213.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14];
                                                              ^" in 42 as{TypeError} core::String*){(core::String*) →* void};
       else
-        #t245.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t213.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:221:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14];
                                                                      ^" in 3.14 as{TypeError} core::String*){(core::String*) →* void};
-  } =>#t245;
+  } =>#t213;
   block {
-    final core::Set<core::String*>* #t246 = new col::_CompactLinkedHashSet::•<core::String*>();
+    final core::Set<core::String*>* #t214 = new col::_CompactLinkedHashSet::•<core::String*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t246.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t214.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:62: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14, null};
                                                              ^" in 42 as{TypeError} core::String*){(core::String*) →* core::bool*};
       else
-        #t246.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t214.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:222:70: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else 3.14, null};
                                                                      ^" in 3.14 as{TypeError} core::String*){(core::String*) →* core::bool*};
-    #t246.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
-  } =>#t246;
+    #t214.{core::Set::add}{Invariant}(null){(core::String*) →* core::bool*};
+  } =>#t214;
   block {
-    final core::Map<core::String*, core::String*>* #t247 = <core::String*, core::String*>{};
+    final core::Map<core::String*, core::String*>* #t215 = <core::String*, core::String*>{};
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t247.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:77: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
+        #t215.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:77: Error: A value of type 'int' can't be assigned to a variable of type 'String'.
   <String, String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else \"bar\": 3.14, \"baz\": null};
                                                                             ^" in 42 as{TypeError} core::String*){(core::String*, core::String*) →* void};
       else
-        #t247.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:92: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
+        #t215.{core::Map::[]=}{Invariant}("bar", invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:223:92: Error: A value of type 'double' can't be assigned to a variable of type 'String'.
   <String, String>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else \"bar\": 3.14, \"baz\": null};
                                                                                            ^" in 3.14 as{TypeError} core::String*){(core::String*, core::String*) →* void};
-    #t247.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
-  } =>#t247;
+    #t215.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::String*) →* void};
+  } =>#t215;
   block {
-    final core::List<core::int*>* #t248 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t216 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t248.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:224:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t216.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:224:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...map else 42];
                                                              ^"){(core::int*) →* void};
       else
-        #t248.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t248;
+        #t216.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t216;
   block {
-    final core::Set<core::int*>* #t249 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t217 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t249.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:225:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t217.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:225:62: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...map else 42, null};
                                                              ^"){(core::int*) →* core::bool*};
       else
-        #t249.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t249.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t249;
+        #t217.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t217.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t217;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:226:70: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...list else \"bar\": 42, \"baz\": null};
@@ -2095,28 +1935,28 @@
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) ...list else \"bar\": 42, \"baz\": null};
                                                                      ^": null};
   block {
-    final core::List<core::int*>* #t250 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t218 = core::_GrowableList::•<core::int*>(0);
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t250.{core::List::add}{Invariant}(42){(core::int*) →* void};
+        #t218.{core::List::add}{Invariant}(42){(core::int*) →* void};
       else
-        #t250.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:227:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t218.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:227:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>[for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else ...map];
                                                                      ^"){(core::int*) →* void};
-  } =>#t250;
+  } =>#t218;
   block {
-    final core::Set<core::int*>* #t251 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t219 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (core::int* i = 0; self::oracle<core::String*>("foo") as{TypeError,ForDynamic} core::bool*; i = i.{core::num::+}(1){(core::num*) →* core::int*})
       if(self::oracle<dynamic>() as{TypeError,ForDynamic} core::bool*)
-        #t251.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+        #t219.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
       else
-        #t251.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:228:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
+        #t219.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:228:70: Error: Unexpected type 'Map<int, int>' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
   <int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) 42 else ...map, null};
                                                                      ^"){(core::int*) →* core::bool*};
-    #t251.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t251;
+    #t219.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t219;
   <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:229:85: Error: Unexpected type 'List<int>' of a map spread entry.  Expected 'dynamic' or a Map.
  - 'List' is from 'dart:core'.
   <String, int>{for (int i = 0; oracle(\"foo\"); i++) if (oracle()) \"bar\": 42 else ...list, \"baz\": null};
@@ -2126,54 +1966,54 @@
                                                                                     ^": null};
   final core::int* i = 0;
   block {
-    final core::List<core::int*>* #t252 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t220 = core::_GrowableList::•<core::int*>(0);
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal1<core::int*>(1).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::int* #t253 = :sync-for-iterator.{core::Iterator::current}{core::int*};
+        final core::int* #t221 = :sync-for-iterator.{core::Iterator::current}{core::int*};
         {
           invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:232:14: Error: Can't assign to the final variable 'i'.
   <int>[for (i in <int>[1]) i];
              ^";
-          #t252.{core::List::add}{Invariant}(i){(core::int*) →* void};
+          #t220.{core::List::add}{Invariant}(i){(core::int*) →* void};
         }
       }
     }
-  } =>#t252;
+  } =>#t220;
   block {
-    final core::Set<core::int*>* #t254 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t222 = new col::_CompactLinkedHashSet::•<core::int*>();
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal1<core::int*>(1).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::int* #t255 = :sync-for-iterator.{core::Iterator::current}{core::int*};
+        final core::int* #t223 = :sync-for-iterator.{core::Iterator::current}{core::int*};
         {
           invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:233:14: Error: Can't assign to the final variable 'i'.
   <int>{for (i in <int>[1]) i, null};
              ^";
-          #t254.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+          #t222.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
         }
       }
     }
-    #t254.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t254;
+    #t222.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t222;
   block {
-    final core::Map<core::String*, core::int*>* #t256 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t224 = <core::String*, core::int*>{};
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal1<core::int*>(1).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
-        final core::int* #t257 = :sync-for-iterator.{core::Iterator::current}{core::int*};
+        final core::int* #t225 = :sync-for-iterator.{core::Iterator::current}{core::int*};
         {
           invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:234:21: Error: Can't assign to the final variable 'i'.
 \t<String, int>{for (i in <int>[1]) \"bar\": i, \"baz\": null};
 \t                   ^";
-          #t256.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+          #t224.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
         }
       }
     }
-    #t256.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t256;
+    #t224.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t224;
   core::List<dynamic>* list10 = block {
-    final core::List<dynamic>* #t258 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t226 = core::_GrowableList::•<dynamic>(0);
     {
       core::Iterator<Never>* :sync-for-iterator = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:236:31: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
@@ -2181,12 +2021,12 @@
                               ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*.{core::Iterable::iterator}{core::Iterator<Never>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic i = :sync-for-iterator.{core::Iterator::current}{Never};
-        #t258.{core::List::add}{Invariant}(i){(dynamic) →* void};
+        #t226.{core::List::add}{Invariant}(i){(dynamic) →* void};
       }
     }
-  } =>#t258;
+  } =>#t226;
   core::Set<dynamic>* set10 = block {
-    final core::Set<dynamic>* #t259 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t227 = new col::_CompactLinkedHashSet::•<dynamic>();
     {
       core::Iterator<Never>* :sync-for-iterator = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:237:30: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
@@ -2194,13 +2034,13 @@
                              ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*.{core::Iterable::iterator}{core::Iterator<Never>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic i = :sync-for-iterator.{core::Iterator::current}{Never};
-        #t259.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
+        #t227.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
       }
     }
-    #t259.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t259;
+    #t227.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t227;
   core::Map<core::String*, dynamic>* map10 = block {
-    final core::Map<core::String*, dynamic>* #t260 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t228 = <core::String*, dynamic>{};
     {
       core::Iterator<Never>* :sync-for-iterator = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:238:30: Error: The type 'String' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Iterable' is from 'dart:core'.
@@ -2208,13 +2048,13 @@
                              ^" in "not iterable" as{TypeError} core::Iterable<dynamic>*.{core::Iterable::iterator}{core::Iterator<Never>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic i = :sync-for-iterator.{core::Iterator::current}{Never};
-        #t260.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
+        #t228.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
       }
     }
-    #t260.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t260;
+    #t228.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t228;
   core::List<core::int*>* list20 = block {
-    final core::List<core::int*>* #t261 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t229 = core::_GrowableList::•<core::int*>(0);
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal2<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:239:32: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list20 = [for (int i in [\"not\", \"int\"]) i];
@@ -2223,12 +2063,12 @@
                                       ^" in "int" as{TypeError} core::int*).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
-        #t261.{core::List::add}{Invariant}(i){(core::int*) →* void};
+        #t229.{core::List::add}{Invariant}(i){(core::int*) →* void};
       }
     }
-  } =>#t261;
+  } =>#t229;
   core::Set<core::int*>* set20 = block {
-    final core::Set<core::int*>* #t262 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t230 = new col::_CompactLinkedHashSet::•<core::int*>();
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal2<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:240:31: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set20 = {for (int i in [\"not\", \"int\"]) i, null};
@@ -2237,13 +2077,13 @@
                                      ^" in "int" as{TypeError} core::int*).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
-        #t262.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+        #t230.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
       }
     }
-    #t262.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t262;
+    #t230.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t230;
   core::Map<core::String*, core::int*>* map20 = block {
-    final core::Map<core::String*, core::int*>* #t263 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t231 = <core::String*, core::int*>{};
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal2<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:241:31: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map20 = {for (int i in [\"not\", \"int\"]) \"bar\": i, \"baz\": null};
@@ -2252,13 +2092,13 @@
                                      ^" in "int" as{TypeError} core::int*).{core::Iterable::iterator}{core::Iterator<core::int*>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
-        #t263.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+        #t231.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
       }
     }
-    #t263.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t263;
+    #t231.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t231;
   core::List<dynamic>* list30 = block {
-    final core::List<dynamic>* #t264 = core::_GrowableList::•<dynamic>(0);
+    final core::List<dynamic>* #t232 = core::_GrowableList::•<dynamic>(0);
     {
       Never :stream = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:242:37: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
@@ -2266,17 +2106,17 @@
                                     ^" in "not stream" as{TypeError} asy::Stream<dynamic>*;
       asy::_StreamIterator<dynamic>* :for-iterator = new asy::_StreamIterator::•<dynamic>(:stream);
       try
-        while (let dynamic #t265 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
+        while (let dynamic #t233 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
           dynamic i = :for-iterator.{asy::_StreamIterator::current}{dynamic};
-          #t264.{core::List::add}{Invariant}(i){(dynamic) →* void};
+          #t232.{core::List::add}{Invariant}(i){(dynamic) →* void};
         }
       finally
         if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null))
           await :for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>};
     }
-  } =>#t264;
+  } =>#t232;
   core::Set<dynamic>* set30 = block {
-    final core::Set<dynamic>* #t266 = new col::_CompactLinkedHashSet::•<dynamic>();
+    final core::Set<dynamic>* #t234 = new col::_CompactLinkedHashSet::•<dynamic>();
     {
       Never :stream = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:243:36: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
@@ -2284,18 +2124,18 @@
                                    ^" in "not stream" as{TypeError} asy::Stream<dynamic>*;
       asy::_StreamIterator<dynamic>* :for-iterator = new asy::_StreamIterator::•<dynamic>(:stream);
       try
-        while (let dynamic #t267 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
+        while (let dynamic #t235 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
           dynamic i = :for-iterator.{asy::_StreamIterator::current}{dynamic};
-          #t266.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
+          #t234.{core::Set::add}{Invariant}(i){(dynamic) →* core::bool*};
         }
       finally
         if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null))
           await :for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>};
     }
-    #t266.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
-  } =>#t266;
+    #t234.{core::Set::add}{Invariant}(null){(dynamic) →* core::bool*};
+  } =>#t234;
   core::Map<core::String*, dynamic>* map30 = block {
-    final core::Map<core::String*, dynamic>* #t268 = <core::String*, dynamic>{};
+    final core::Map<core::String*, dynamic>* #t236 = <core::String*, dynamic>{};
     {
       Never :stream = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:244:36: Error: The type 'String' used in the 'for' loop must implement 'Stream<dynamic>'.
  - 'Stream' is from 'dart:async'.
@@ -2303,18 +2143,18 @@
                                    ^" in "not stream" as{TypeError} asy::Stream<dynamic>*;
       asy::_StreamIterator<dynamic>* :for-iterator = new asy::_StreamIterator::•<dynamic>(:stream);
       try
-        while (let dynamic #t269 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
+        while (let dynamic #t237 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
           dynamic i = :for-iterator.{asy::_StreamIterator::current}{dynamic};
-          #t268.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
+          #t236.{core::Map::[]=}{Invariant}("bar", i){(core::String*, dynamic) →* void};
         }
       finally
         if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<dynamic>?} == null))
           await :for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>};
     }
-    #t268.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
-  } =>#t268;
+    #t236.{core::Map::[]=}{Invariant}("baz", null){(core::String*, dynamic) →* void};
+  } =>#t236;
   core::List<core::int*>* list40 = block {
-    final core::List<core::int*>* #t270 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t238 = core::_GrowableList::•<core::int*>(0);
     {
       asy::Stream<core::int*> :stream = asy::Stream::fromIterable<core::int*>(core::_GrowableList::_literal2<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:245:58: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var list40 = [await for (int i in Stream.fromIterable([\"not\", \"int\"])) i];
@@ -2323,17 +2163,17 @@
                                                                 ^" in "int" as{TypeError} core::int*));
       asy::_StreamIterator<core::int*>* :for-iterator = new asy::_StreamIterator::•<core::int*>(:stream);
       try
-        while (let dynamic #t271 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
+        while (let dynamic #t239 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
           core::int* i = :for-iterator.{asy::_StreamIterator::current}{core::int*};
-          #t270.{core::List::add}{Invariant}(i){(core::int*) →* void};
+          #t238.{core::List::add}{Invariant}(i){(core::int*) →* void};
         }
       finally
         if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::int*>?} == null))
           await :for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>};
     }
-  } =>#t270;
+  } =>#t238;
   core::Set<core::int*>* set40 = block {
-    final core::Set<core::int*>* #t272 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t240 = new col::_CompactLinkedHashSet::•<core::int*>();
     {
       asy::Stream<core::int*> :stream = asy::Stream::fromIterable<core::int*>(core::_GrowableList::_literal2<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:246:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var set40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) i, null};
@@ -2342,18 +2182,18 @@
                                                                ^" in "int" as{TypeError} core::int*));
       asy::_StreamIterator<core::int*>* :for-iterator = new asy::_StreamIterator::•<core::int*>(:stream);
       try
-        while (let dynamic #t273 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
+        while (let dynamic #t241 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
           core::int* i = :for-iterator.{asy::_StreamIterator::current}{core::int*};
-          #t272.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+          #t240.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
         }
       finally
         if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::int*>?} == null))
           await :for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>};
     }
-    #t272.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t272;
+    #t240.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t240;
   core::Map<core::String*, core::int*>* map40 = block {
-    final core::Map<core::String*, core::int*>* #t274 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t242 = <core::String*, core::int*>{};
     {
       asy::Stream<core::int*> :stream = asy::Stream::fromIterable<core::int*>(core::_GrowableList::_literal2<core::int*>(invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:247:57: Error: A value of type 'String' can't be assigned to a variable of type 'int'.
   var map40 = {await for (int i in Stream.fromIterable([\"not\", \"int\"])) \"bar\": i, \"baz\": null};
@@ -2362,90 +2202,90 @@
                                                                ^" in "int" as{TypeError} core::int*));
       asy::_StreamIterator<core::int*>* :for-iterator = new asy::_StreamIterator::•<core::int*>(:stream);
       try
-        while (let dynamic #t275 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
+        while (let dynamic #t243 = asy::_asyncStarMoveNextHelper(:stream) in await :for-iterator.{asy::_StreamIterator::moveNext}(){() → asy::Future<core::bool>}) {
           core::int* i = :for-iterator.{asy::_StreamIterator::current}{core::int*};
-          #t274.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+          #t242.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
         }
       finally
         if(!(:for-iterator.{asy::_StreamIterator::_subscription}{asy::StreamSubscription<core::int*>?} == null))
           await :for-iterator.{asy::_StreamIterator::cancel}(){() → asy::Future<dynamic>};
     }
-    #t274.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t274;
+    #t242.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t242;
   core::List<core::int*>* list50 = block {
-    final core::List<core::int*>* #t276 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t244 = core::_GrowableList::•<core::int*>(0);
     for (; ; )
-      #t276.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t276;
+      #t244.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t244;
   core::Set<core::int*>* set50 = block {
-    final core::Set<core::int*>* #t277 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t245 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (; ; )
-      #t277.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t277.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t277;
+      #t245.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t245.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t245;
   core::Map<core::String*, core::int*>* map50 = block {
-    final core::Map<core::String*, core::int*>* #t278 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t246 = <core::String*, core::int*>{};
     for (; ; )
-      #t278.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t278.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t278;
+      #t246.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t246.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t246;
   core::List<core::int*>* list60 = block {
-    final core::List<core::int*>* #t279 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t247 = core::_GrowableList::•<core::int*>(0);
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:251:24: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var list60 = [for (; \"not bool\";) 42];
                        ^" in "not bool" as{TypeError} core::bool*; )
-      #t279.{core::List::add}{Invariant}(42){(core::int*) →* void};
-  } =>#t279;
+      #t247.{core::List::add}{Invariant}(42){(core::int*) →* void};
+  } =>#t247;
   core::Set<core::int*>* set60 = block {
-    final core::Set<core::int*>* #t280 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t248 = new col::_CompactLinkedHashSet::•<core::int*>();
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:252:23: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var set60 = {for (; \"not bool\";) 42, null};
                       ^" in "not bool" as{TypeError} core::bool*; )
-      #t280.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
-    #t280.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
-  } =>#t280;
+      #t248.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
+    #t248.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+  } =>#t248;
   core::Map<core::String*, core::int*>* map60 = block {
-    final core::Map<core::String*, core::int*>* #t281 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t249 = <core::String*, core::int*>{};
     for (; invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference.dart:253:23: Error: A value of type 'String' can't be assigned to a variable of type 'bool'.
   var map60 = {for (; \"not bool\";) \"bar\": 42, \"baz\": null};
                       ^" in "not bool" as{TypeError} core::bool*; )
-      #t281.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
-    #t281.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
-  } =>#t281;
+      #t249.{core::Map::[]=}{Invariant}("bar", 42){(core::String*, core::int*) →* void};
+    #t249.{core::Map::[]=}{Invariant}("baz", null){(core::String*, core::int*) →* void};
+  } =>#t249;
 }
 static method testForElementErrorsNotAsync(asy::Stream<core::int*>* stream) → dynamic {
   block {
-    final core::List<core::int*>* #t282 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t250 = core::_GrowableList::•<core::int*>(0);
     await for (core::int* i in stream)
-      #t282.{core::List::add}{Invariant}(i){(core::int*) →* void};
-  } =>#t282;
+      #t250.{core::List::add}{Invariant}(i){(core::int*) →* void};
+  } =>#t250;
   block {
-    final core::Set<core::int*>* #t283 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t251 = new col::_CompactLinkedHashSet::•<core::int*>();
     await for (core::int* i in stream)
-      #t283.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
-  } =>#t283;
+      #t251.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
+  } =>#t251;
   block {
-    final core::Map<core::String*, core::int*>* #t284 = <core::String*, core::int*>{};
+    final core::Map<core::String*, core::int*>* #t252 = <core::String*, core::int*>{};
     await for (core::int* i in stream)
-      #t284.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
-  } =>#t284;
+      #t252.{core::Map::[]=}{Invariant}("bar", i){(core::String*, core::int*) →* void};
+  } =>#t252;
 }
 static method testPromotion(self::A* a) → dynamic {
   core::List<core::int*>* list10 = block {
-    final core::List<core::int*>* #t285 = core::_GrowableList::•<core::int*>(0);
+    final core::List<core::int*>* #t253 = core::_GrowableList::•<core::int*>(0);
     if(a is self::B*)
-      #t285.{core::List::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* void};
-  } =>#t285;
+      #t253.{core::List::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* void};
+  } =>#t253;
   core::Set<core::int*>* set10 = block {
-    final core::Set<core::int*>* #t286 = new col::_CompactLinkedHashSet::•<core::int*>();
+    final core::Set<core::int*>* #t254 = new col::_CompactLinkedHashSet::•<core::int*>();
     if(a is self::B*)
-      #t286.{core::Set::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* core::bool*};
-  } =>#t286;
+      #t254.{core::Set::add}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}){(core::int*) →* core::bool*};
+  } =>#t254;
   core::Map<core::int*, core::int*>* map10 = block {
-    final core::Map<core::int*, core::int*>* #t287 = <core::int*, core::int*>{};
+    final core::Map<core::int*, core::int*>* #t255 = <core::int*, core::int*>{};
     if(a is self::B*)
-      #t287.{core::Map::[]=}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}, a{self::B*}.{self::B::foo}{core::int*}){(core::int*, core::int*) →* void};
-  } =>#t287;
+      #t255.{core::Map::[]=}{Invariant}(a{self::B*}.{self::B::foo}{core::int*}, a{self::B*}.{self::B::foo}{core::int*}){(core::int*, core::int*) →* void};
+  } =>#t255;
 }
 static method main() → dynamic {}
 
diff --git a/pkg/front_end/testcases/general/control_flow_collection_inference2.dart.weak.expect b/pkg/front_end/testcases/general/control_flow_collection_inference2.dart.weak.expect
index 8e550b8..8fb5c78 100644
--- a/pkg/front_end/testcases/general/control_flow_collection_inference2.dart.weak.expect
+++ b/pkg/front_end/testcases/general/control_flow_collection_inference2.dart.weak.expect
@@ -506,501 +506,486 @@
   core::Map<core::String, core::int?> map20 = block {
     final core::Map<core::String, core::int?> #t12 = <core::String, core::int?>{};
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      for (final has-declared-initializer core::MapEntry<core::String, core::int?> #t13 in <core::String, core::int>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, core::int?>>})
-        #t12.{core::Map::[]=}{Invariant}(#t13.{core::MapEntry::key}{core::String}, #t13.{core::MapEntry::value}{core::int?}){(core::String, core::int?) → void};
+      #t12.{core::Map::addAll}{Invariant}(<core::String, core::int>{"bar": 42}){(core::Map<core::String, core::int?>) → void};
     #t12.{core::Map::[]=}{Invariant}("baz", null){(core::String, core::int?) → void};
   } =>#t12;
   core::List<dynamic> list21 = block {
-    final core::List<dynamic> #t14 = <dynamic>[];
+    final core::List<dynamic> #t13 = <dynamic>[];
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      #t14.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>) → void};
-  } =>#t14;
+      #t13.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>) → void};
+  } =>#t13;
   core::Set<dynamic> set21 = block {
-    final core::Set<dynamic> #t15 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic> #t14 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      #t15.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>) → void};
-    #t15.{core::Set::add}{Invariant}(null){(dynamic) → core::bool};
-  } =>#t15;
+      #t14.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>) → void};
+    #t14.{core::Set::add}{Invariant}(null){(dynamic) → core::bool};
+  } =>#t14;
   core::Map<core::String, dynamic> map21 = block {
-    final core::Map<core::String, dynamic> #t16 = <core::String, dynamic>{};
+    final core::Map<core::String, dynamic> #t15 = <core::String, dynamic>{};
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      for (final has-declared-initializer core::MapEntry<core::String, dynamic> #t17 in <core::String, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, dynamic>>})
-        #t16.{core::Map::[]=}{Invariant}(#t17.{core::MapEntry::key}{core::String}, #t17.{core::MapEntry::value}{dynamic}){(core::String, dynamic) → void};
-    #t16.{core::Map::[]=}{Invariant}("baz", null){(core::String, dynamic) → void};
-  } =>#t16;
+      #t15.{core::Map::addAll}{Invariant}(<core::String, dynamic>{"bar": dynVar}){(core::Map<core::String, dynamic>) → void};
+    #t15.{core::Map::[]=}{Invariant}("baz", null){(core::String, dynamic) → void};
+  } =>#t15;
   core::List<core::List<core::int>> list22 = block {
-    final core::List<core::List<core::int>> #t18 = <core::List<core::int>>[];
+    final core::List<core::List<core::int>> #t16 = <core::List<core::int>>[];
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      #t18.{core::List::addAll}{Invariant}(<core::List<core::int>>[<core::int>[42]]){(core::Iterable<core::List<core::int>>) → void};
-  } =>#t18;
+      #t16.{core::List::addAll}{Invariant}(<core::List<core::int>>[<core::int>[42]]){(core::Iterable<core::List<core::int>>) → void};
+  } =>#t16;
   core::Set<core::List<core::int>?> set22 = block {
-    final core::Set<core::List<core::int>?> #t19 = col::LinkedHashSet::•<core::List<core::int>?>();
+    final core::Set<core::List<core::int>?> #t17 = col::LinkedHashSet::•<core::List<core::int>?>();
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      #t19.{core::Set::addAll}{Invariant}(<core::List<core::int>>[<core::int>[42]]){(core::Iterable<core::List<core::int>?>) → void};
-    #t19.{core::Set::add}{Invariant}(null){(core::List<core::int>?) → core::bool};
-  } =>#t19;
+      #t17.{core::Set::addAll}{Invariant}(<core::List<core::int>>[<core::int>[42]]){(core::Iterable<core::List<core::int>?>) → void};
+    #t17.{core::Set::add}{Invariant}(null){(core::List<core::int>?) → core::bool};
+  } =>#t17;
   core::Map<core::String, core::List<core::int>?> map22 = block {
-    final core::Map<core::String, core::List<core::int>?> #t20 = <core::String, core::List<core::int>?>{};
+    final core::Map<core::String, core::List<core::int>?> #t18 = <core::String, core::List<core::int>?>{};
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      for (final has-declared-initializer core::MapEntry<core::String, core::List<core::int>?> #t21 in <core::String, core::List<core::int>>{"bar": <core::int>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, core::List<core::int>?>>})
-        #t20.{core::Map::[]=}{Invariant}(#t21.{core::MapEntry::key}{core::String}, #t21.{core::MapEntry::value}{core::List<core::int>?}){(core::String, core::List<core::int>?) → void};
-    #t20.{core::Map::[]=}{Invariant}("baz", null){(core::String, core::List<core::int>?) → void};
-  } =>#t20;
+      #t18.{core::Map::addAll}{Invariant}(<core::String, core::List<core::int>>{"bar": <core::int>[42]}){(core::Map<core::String, core::List<core::int>?>) → void};
+    #t18.{core::Map::[]=}{Invariant}("baz", null){(core::String, core::List<core::int>?) → void};
+  } =>#t18;
   core::List<core::int> list30 = block {
-    final core::List<core::int> #t22 = <core::int>[];
+    final core::List<core::int> #t19 = <core::int>[];
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        #t22.{core::List::addAll}{Invariant}(<core::int>[42]){(core::Iterable<core::int>) → void};
-  } =>#t22;
+        #t19.{core::List::addAll}{Invariant}(<core::int>[42]){(core::Iterable<core::int>) → void};
+  } =>#t19;
   core::Set<core::int?> set30 = block {
-    final core::Set<core::int?> #t23 = col::LinkedHashSet::•<core::int?>();
+    final core::Set<core::int?> #t20 = col::LinkedHashSet::•<core::int?>();
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        #t23.{core::Set::addAll}{Invariant}(<core::int>[42]){(core::Iterable<core::int?>) → void};
-    #t23.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
-  } =>#t23;
+        #t20.{core::Set::addAll}{Invariant}(<core::int>[42]){(core::Iterable<core::int?>) → void};
+    #t20.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
+  } =>#t20;
   core::Map<core::String, core::int?> map30 = block {
-    final core::Map<core::String, core::int?> #t24 = <core::String, core::int?>{};
+    final core::Map<core::String, core::int?> #t21 = <core::String, core::int?>{};
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        for (final has-declared-initializer core::MapEntry<core::String, core::int?> #t25 in <core::String, core::int>{"bar": 42}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, core::int?>>})
-          #t24.{core::Map::[]=}{Invariant}(#t25.{core::MapEntry::key}{core::String}, #t25.{core::MapEntry::value}{core::int?}){(core::String, core::int?) → void};
-    #t24.{core::Map::[]=}{Invariant}("baz", null){(core::String, core::int?) → void};
-  } =>#t24;
+        #t21.{core::Map::addAll}{Invariant}(<core::String, core::int>{"bar": 42}){(core::Map<core::String, core::int?>) → void};
+    #t21.{core::Map::[]=}{Invariant}("baz", null){(core::String, core::int?) → void};
+  } =>#t21;
   core::List<dynamic> list31 = block {
-    final core::List<dynamic> #t26 = <dynamic>[];
+    final core::List<dynamic> #t22 = <dynamic>[];
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        #t26.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>) → void};
-  } =>#t26;
+        #t22.{core::List::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>) → void};
+  } =>#t22;
   core::Set<dynamic> set31 = block {
-    final core::Set<dynamic> #t27 = col::LinkedHashSet::•<dynamic>();
+    final core::Set<dynamic> #t23 = col::LinkedHashSet::•<dynamic>();
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        #t27.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>) → void};
-    #t27.{core::Set::add}{Invariant}(null){(dynamic) → core::bool};
-  } =>#t27;
+        #t23.{core::Set::addAll}{Invariant}(<dynamic>[dynVar]){(core::Iterable<dynamic>) → void};
+    #t23.{core::Set::add}{Invariant}(null){(dynamic) → core::bool};
+  } =>#t23;
   core::Map<core::String, dynamic> map31 = block {
-    final core::Map<core::String, dynamic> #t28 = <core::String, dynamic>{};
+    final core::Map<core::String, dynamic> #t24 = <core::String, dynamic>{};
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        for (final has-declared-initializer core::MapEntry<core::String, dynamic> #t29 in <core::String, dynamic>{"bar": dynVar}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, dynamic>>})
-          #t28.{core::Map::[]=}{Invariant}(#t29.{core::MapEntry::key}{core::String}, #t29.{core::MapEntry::value}{dynamic}){(core::String, dynamic) → void};
-    #t28.{core::Map::[]=}{Invariant}("baz", null){(core::String, dynamic) → void};
-  } =>#t28;
+        #t24.{core::Map::addAll}{Invariant}(<core::String, dynamic>{"bar": dynVar}){(core::Map<core::String, dynamic>) → void};
+    #t24.{core::Map::[]=}{Invariant}("baz", null){(core::String, dynamic) → void};
+  } =>#t24;
   core::List<core::List<core::int>> list33 = block {
-    final core::List<core::List<core::int>> #t30 = <core::List<core::int>>[];
+    final core::List<core::List<core::int>> #t25 = <core::List<core::int>>[];
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        #t30.{core::List::addAll}{Invariant}(<core::List<core::int>>[<core::int>[42]]){(core::Iterable<core::List<core::int>>) → void};
-  } =>#t30;
+        #t25.{core::List::addAll}{Invariant}(<core::List<core::int>>[<core::int>[42]]){(core::Iterable<core::List<core::int>>) → void};
+  } =>#t25;
   core::Set<core::List<core::int>?> set33 = block {
-    final core::Set<core::List<core::int>?> #t31 = col::LinkedHashSet::•<core::List<core::int>?>();
+    final core::Set<core::List<core::int>?> #t26 = col::LinkedHashSet::•<core::List<core::int>?>();
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        #t31.{core::Set::addAll}{Invariant}(<core::List<core::int>>[<core::int>[42]]){(core::Iterable<core::List<core::int>?>) → void};
-    #t31.{core::Set::add}{Invariant}(null){(core::List<core::int>?) → core::bool};
-  } =>#t31;
+        #t26.{core::Set::addAll}{Invariant}(<core::List<core::int>>[<core::int>[42]]){(core::Iterable<core::List<core::int>?>) → void};
+    #t26.{core::Set::add}{Invariant}(null){(core::List<core::int>?) → core::bool};
+  } =>#t26;
   core::Map<core::String, core::List<core::int>?> map33 = block {
-    final core::Map<core::String, core::List<core::int>?> #t32 = <core::String, core::List<core::int>?>{};
+    final core::Map<core::String, core::List<core::int>?> #t27 = <core::String, core::List<core::int>?>{};
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
       if(self::oracle<dynamic>() as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-        for (final has-declared-initializer core::MapEntry<core::String, core::List<core::int>?> #t33 in <core::String, core::List<core::int>>{"bar": <core::int>[42]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, core::List<core::int>?>>})
-          #t32.{core::Map::[]=}{Invariant}(#t33.{core::MapEntry::key}{core::String}, #t33.{core::MapEntry::value}{core::List<core::int>?}){(core::String, core::List<core::int>?) → void};
-    #t32.{core::Map::[]=}{Invariant}("baz", null){(core::String, core::List<core::int>?) → void};
-  } =>#t32;
+        #t27.{core::Map::addAll}{Invariant}(<core::String, core::List<core::int>>{"bar": <core::int>[42]}){(core::Map<core::String, core::List<core::int>?>) → void};
+    #t27.{core::Map::[]=}{Invariant}("baz", null){(core::String, core::List<core::int>?) → void};
+  } =>#t27;
   core::List<core::List<core::int>> list40 = block {
-    final core::List<core::List<core::int>> #t34 = <core::List<core::int>>[];
+    final core::List<core::List<core::int>> #t28 = <core::List<core::int>>[];
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      #t34.{core::List::addAll}{Invariant}(<core::List<core::int>>[<core::int>[]]){(core::Iterable<core::List<core::int>>) → void};
-  } =>#t34;
+      #t28.{core::List::addAll}{Invariant}(<core::List<core::int>>[<core::int>[]]){(core::Iterable<core::List<core::int>>) → void};
+  } =>#t28;
   core::Set<core::List<core::int>?> set40 = block {
-    final core::Set<core::List<core::int>?> #t35 = col::LinkedHashSet::•<core::List<core::int>?>();
+    final core::Set<core::List<core::int>?> #t29 = col::LinkedHashSet::•<core::List<core::int>?>();
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      #t35.{core::Set::addAll}{Invariant}(<core::List<core::int>?>[<core::int>[]]){(core::Iterable<core::List<core::int>?>) → void};
-    #t35.{core::Set::add}{Invariant}(null){(core::List<core::int>?) → core::bool};
-  } =>#t35;
+      #t29.{core::Set::addAll}{Invariant}(<core::List<core::int>?>[<core::int>[]]){(core::Iterable<core::List<core::int>?>) → void};
+    #t29.{core::Set::add}{Invariant}(null){(core::List<core::int>?) → core::bool};
+  } =>#t29;
   core::Map<core::String, core::List<core::int>?> map40 = invalid-expression "pkg/front_end/testcases/general/control_flow_collection_inference2.dart:39:35: Error: Both Iterable and Map spread elements encountered in ambiguous literal.
   Map<String, List<int>?> map40 = {if (oracle(\"foo\")) ...{\"bar\", []}, \"baz\": null};
                                   ^";
   core::List<core::List<core::int>> list41 = block {
-    final core::List<core::List<core::int>> #t36 = <core::List<core::int>>[];
+    final core::List<core::List<core::int>> #t30 = <core::List<core::int>>[];
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      #t36.{core::List::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int>> #t37 = col::LinkedHashSet::•<core::List<core::int>>();
-        #t37.{core::Set::add}{Invariant}(<core::int>[]){(core::List<core::int>) → core::bool};
-      } =>#t37){(core::Iterable<core::List<core::int>>) → void};
-  } =>#t36;
+      #t30.{core::List::addAll}{Invariant}( block {
+        final core::Set<core::List<core::int>> #t31 = col::LinkedHashSet::•<core::List<core::int>>();
+        #t31.{core::Set::add}{Invariant}(<core::int>[]){(core::List<core::int>) → core::bool};
+      } =>#t31){(core::Iterable<core::List<core::int>>) → void};
+  } =>#t30;
   core::Set<core::List<core::int>?> set41 = block {
-    final core::Set<core::List<core::int>?> #t38 = col::LinkedHashSet::•<core::List<core::int>?>();
+    final core::Set<core::List<core::int>?> #t32 = col::LinkedHashSet::•<core::List<core::int>?>();
     if(self::oracle<core::String>("foo") as{TypeError,ForDynamic,ForNonNullableByDefault} core::bool)
-      #t38.{core::Set::addAll}{Invariant}( block {
-        final core::Set<core::List<core::int>?> #t39 = col::LinkedHashSet::•<core::List<core::int>?>