[cfe] Verify that only new method invocation nodes are generated when supported

Closes https://github.com/dart-lang/sdk/issues/46339

Change-Id: I404a8afd141f615cfcb6050f280a1410adaac0ab
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/204580
Commit-Queue: Johnni Winther <johnniwinther@google.com>
Reviewed-by: Jens Johansen <jensj@google.com>

pkg/compiler/lib/src/kernel/transformations/list_factory_specializer.dart

@@ -6,6 +6,7 @@ import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 import 'package:kernel/clone.dart' show CloneVisitorNotMembers;
 import 'package:kernel/core_types.dart' show CoreTypes;
+import 'package:kernel/type_algebra.dart';
 import 'factory_specializer.dart';
 
 /// Replaces invocation of List factory constructors.
@@ -41,16 +42,16 @@ class ListFactorySpecializer extends BaseSpecializer {
     });
   }
 
-  Member _intPlus;
-  Member get intPlus =>
+  Procedure _intPlus;
+  Procedure get intPlus =>
       _intPlus ??= hierarchy.getInterfaceMember(_intClass, Name('+'));
 
-  Member _intLess;
-  Member get intLess =>
+  Procedure _intLess;
+  Procedure get intLess =>
       _intLess ??= hierarchy.getInterfaceMember(_intClass, Name('<'));
 
-  Member _jsArrayIndexSet;
-  Member get jsArrayIndexSet => _jsArrayIndexSet ??=
+  Procedure _jsArrayIndexSet;
+  Procedure get jsArrayIndexSet => _jsArrayIndexSet ??=
       hierarchy.getInterfaceMember(_jsArrayClass, Name('[]='));
 
   /// Replace calls to `List.generate(length, (i) => e)` with an expansion
@@ -131,20 +132,30 @@ class ListFactorySpecializer extends BaseSpecializer {
       // initializers: _i = 0
       [indexVariable],
       // condition: _i < _length
-      MethodInvocation(
+      InstanceInvocation(
+        InstanceAccessKind.Instance,
         VariableGet(indexVariable)..fileOffset = node.fileOffset,
         Name('<'),
         Arguments([getLength()]),
-      )..interfaceTarget = intLess,
+        interfaceTarget: intLess,
+        functionType: intLess.getterType,
+      ),
       // updates: _i++
       [
         VariableSet(
           indexVariable,
-          MethodInvocation(
-            VariableGet(indexVariable)..fileOffset = node.fileOffset,
-            Name('+'),
-            Arguments([IntLiteral(1)]),
-          )..interfaceTarget = intPlus,
+          InstanceInvocation(
+              InstanceAccessKind.Instance,
+              VariableGet(indexVariable)..fileOffset = node.fileOffset,
+              Name('+'),
+              Arguments([IntLiteral(1)]),
+              interfaceTarget: intPlus,
+              functionType: FunctionType(
+                  [intType],
+                  intType,
+                  contextMember.isNonNullableByDefault
+                      ? Nullability.nonNullable
+                      : Nullability.legacy)),
         )..fileOffset = node.fileOffset,
       ],
       // body, e.g. _list[_i] = expression;
@@ -315,15 +326,18 @@ class ListGenerateLoopBodyInliner extends CloneVisitorNotMembers {
     final value = expression == null ? NullLiteral() : clone(expression);
     // TODO(sra): Indicate that this indexed setter is safe.
     return ExpressionStatement(
-      MethodInvocation(
-        VariableGet(listVariable)..fileOffset = constructorFileOffset,
-        Name('[]='),
-        Arguments([
-          VariableGet(argument)..fileOffset = node.fileOffset,
-          value,
-        ]),
-      )
-        ..interfaceTarget = listFactorySpecializer.jsArrayIndexSet
+      InstanceInvocation(
+          InstanceAccessKind.Instance,
+          VariableGet(listVariable)..fileOffset = constructorFileOffset,
+          Name('[]='),
+          Arguments([
+            VariableGet(argument)..fileOffset = node.fileOffset,
+            value,
+          ]),
+          interfaceTarget: listFactorySpecializer.jsArrayIndexSet,
+          functionType: Substitution.fromInterfaceType(listVariable.type)
+              .substituteType(
+                  listFactorySpecializer.jsArrayIndexSet.getterType))
         ..isInvariant = true
         ..isBoundsSafe = true
         ..fileOffset = constructorFileOffset,

pkg/compiler/test/kernel/data/list_generate_1.dart.expect

@@ -5,23 +5,23 @@ import "dart:_interceptors" as _in;
 
 static field core::List<core::int*>* list1 = block {
   final _in::JSArray<core::int*> _list = _in::JSArray::allocateGrowable<core::int*>(10);
-  for (core::int i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+  for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int) →* core::int}) {
     core::int* i = i;
-    _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i);
+    _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i){(core::int, core::int*) → void};
   }
 } =>_list;
 static field core::List<core::int*>* list2 = block {
   final _in::JSArray<core::int*> _list = _in::JSArray::allocateGrowable<core::int*>(10);
-  for (core::int i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+  for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int) →* core::int}) {
     core::int* i = i;
-    _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i);
+    _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i){(core::int, core::int*) → void};
   }
 } =>_list;
 static field core::List<core::int*>* list3 = block {
   final _in::JSArray<core::int*> _list = _in::JSArray::allocateFixed<core::int*>(10);
-  for (core::int i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+  for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int) →* core::int}) {
     core::int* i = i;
-    _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i);
+    _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i){(core::int, core::int*) → void};
   }
 } =>_list;
 static field core::List<core::int*>* list4 = core::List::generate<core::int*>(10, (core::int* i) → core::int* => i, growable: self::someGrowable);

pkg/compiler/test/kernel/data/list_generate_2.dart.expect

@@ -6,16 +6,16 @@ import "dart:_interceptors" as _in;
 static method main() → void {
   core::print( block {
     final _in::JSArray<core::List<core::int*>*> _list = _in::JSArray::allocateGrowable<core::List<core::int*>*>(10);
-    for (core::int i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+    for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int) →* core::int}) {
       core::int* i = i;
       _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, block {
         final core::int _length = i;
         final _in::JSArray<core::int*> _list = _in::JSArray::allocateGrowable<core::int*>(_length);
-        for (core::int i = 0; i.{core::num::<}(_length); i = i.{core::num::+}(1)) {
+        for (core::int i = 0; i.{core::num::<}(_length){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int) →* core::int}) {
           core::int* i = i;
-          _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i.{core::num::+}(1){(core::num*) →* core::int*});
+          _list.{_in::JSArray::[]=}(i, i.{core::num::+}(1){(core::num*) →* core::int*}){(core::int, core::int*) → void};
         }
-      } =>_list);
+      } =>_list){(core::int, core::List<core::int*>*) → void};
     }
   } =>_list);
 }

pkg/compiler/test/kernel/data/list_generate_3.dart.expect

@@ -5,28 +5,28 @@ import "dart:_interceptors" as _in;
 
 static field core::List<core::int*>* list1 = block {
   final _in::JSArray<core::int*> _list = _in::JSArray::allocateGrowable<core::int*>(10);
-  for (core::int i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+  for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int) →* core::int}) {
     core::int* i = i;
     {
-      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i);
+      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i){(core::int, core::int*) → void};
     }
   }
 } =>_list;
 static field core::List<core::int*>* list2 = block {
   final _in::JSArray<core::int*> _list = _in::JSArray::allocateGrowable<core::int*>(10);
-  for (core::int i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+  for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int) →* core::int}) {
     core::int* i = i;
     {
-      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i);
+      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i){(core::int, core::int*) → void};
     }
   }
 } =>_list;
 static field core::List<core::int*>* list3 = block {
   final _in::JSArray<core::int*> _list = _in::JSArray::allocateFixed<core::int*>(10);
-  for (core::int i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+  for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int) →* core::int}) {
     core::int* i = i;
     {
-      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i);
+      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i){(core::int, core::int*) → void};
     }
   }
 } =>_list;

pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart

@@ -1370,9 +1370,11 @@ class InferenceVisitor
   }
 
   void visitShadowInvalidInitializer(ShadowInvalidInitializer node) {
-    inferrer.inferExpression(
+    ExpressionInferenceResult initializerResult = inferrer.inferExpression(
         node.variable.initializer, const UnknownType(), !inferrer.isTopLevel,
         isVoidAllowed: false);
+    node.variable.initializer = initializerResult.expression
+      ..parent = node.variable;
   }
 
   void visitShadowInvalidFieldInitializer(ShadowInvalidFieldInitializer node) {

pkg/front_end/lib/src/fasta/kernel/kernel_target.dart

@@ -1229,7 +1229,9 @@ class KernelTarget extends TargetImplementation {
     if (loader.target.context.options
         .isExperimentEnabledGlobally(ExperimentalFlag.valueClass)) {
       valueClass.transformComponent(
-          component, loader.coreTypes, loader.hierarchy, environment);
+          component, loader.coreTypes, loader.hierarchy, environment,
+          useNewMethodInvocationEncoding:
+              backendTarget.supportsNewMethodInvocationEncoding);
       ticker.logMs("Lowered value classes");
     }
 
@@ -1301,7 +1303,7 @@ class KernelTarget extends TargetImplementation {
 
   void verify() {
     // TODO(ahe): How to handle errors.
-    verifyComponent(component,
+    verifyComponent(component, context.options.target,
         skipPlatform: context.options.skipPlatformVerification);
     ClassHierarchy hierarchy =
         new ClassHierarchy(component, new CoreTypes(component),

pkg/front_end/lib/src/fasta/kernel/verifier.dart

@@ -9,6 +9,7 @@ library fasta.verifier;
 import 'package:_fe_analyzer_shared/src/messages/severity.dart' show Severity;
 
 import 'package:kernel/ast.dart';
+import 'package:kernel/target/targets.dart';
 
 import 'package:kernel/transformations/flags.dart' show TransformerFlag;
 
@@ -34,22 +35,24 @@ import 'redirecting_factory_body.dart'
         getRedirectingFactoryBody,
         isRedirectingFactory;
 
-List<LocatedMessage> verifyComponent(Component component,
+List<LocatedMessage> verifyComponent(Component component, Target target,
     {bool isOutline, bool afterConst, bool skipPlatform: false}) {
   FastaVerifyingVisitor verifier =
-      new FastaVerifyingVisitor(isOutline, afterConst, skipPlatform);
+      new FastaVerifyingVisitor(target, isOutline, afterConst, skipPlatform);
   component.accept(verifier);
   return verifier.errors;
 }
 
 class FastaVerifyingVisitor extends VerifyingVisitor {
+  final Target target;
   final List<LocatedMessage> errors = <LocatedMessage>[];
 
   Uri fileUri;
   final List<TreeNode> treeNodeStack = <TreeNode>[];
   final bool skipPlatform;
 
-  FastaVerifyingVisitor(bool isOutline, bool afterConst, this.skipPlatform)
+  FastaVerifyingVisitor(
+      this.target, bool isOutline, bool afterConst, this.skipPlatform)
       : super(isOutline: isOutline, afterConst: afterConst);
 
   /// Invoked by all visit methods if the visited node is a [TreeNode].
@@ -425,6 +428,39 @@ class FastaVerifyingVisitor extends VerifyingVisitor {
     exitTreeNode(node);
   }
 
+  @override
+  void visitMethodInvocation(MethodInvocation node) {
+    if (target.supportsNewMethodInvocationEncoding) {
+      problem(
+          node,
+          "New method invocation encoding is supported, "
+          "but found a MethodInvocation.");
+    }
+    super.visitMethodInvocation(node);
+  }
+
+  @override
+  void visitPropertyGet(PropertyGet node) {
+    if (target.supportsNewMethodInvocationEncoding) {
+      problem(
+          node,
+          "New method invocation encoding is supported, "
+          "but found a PropertyGet.");
+    }
+    super.visitPropertyGet(node);
+  }
+
+  @override
+  void visitPropertySet(PropertySet node) {
+    if (target.supportsNewMethodInvocationEncoding) {
+      problem(
+          node,
+          "New method invocation encoding is supported, "
+          "but found a PropertySet.");
+    }
+    super.visitPropertySet(node);
+  }
+
   @override
   void defaultTreeNode(TreeNode node) {
     enterTreeNode(node);

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart

@@ -737,12 +737,19 @@ class TypeInferrerImpl implements TypeInferrer {
               <Expression>[new NullLiteral()..fileOffset = fileOffset]))
         ..fileOffset = fileOffset;
     }
-    PropertyGet tearOff =
-        new PropertyGet(new VariableGet(t), callName, callMember)
-          ..fileOffset = fileOffset;
+    Expression tearOff;
     DartType tearoffType =
         getGetterTypeForMemberTarget(callMember, expressionType)
             .withDeclaredNullability(expressionType.nullability);
+    if (useNewMethodInvocationEncoding) {
+      tearOff = new InstanceTearOff(
+          InstanceAccessKind.Instance, new VariableGet(t), callName,
+          interfaceTarget: callMember, resultType: tearoffType)
+        ..fileOffset = fileOffset;
+    } else {
+      tearOff = new PropertyGet(new VariableGet(t), callName, callMember)
+        ..fileOffset = fileOffset;
+    }
     ConditionalExpression conditional = new ConditionalExpression(nullCheck,
         new NullLiteral()..fileOffset = fileOffset, tearOff, tearoffType);
     return new TypedTearoff(
@@ -3543,24 +3550,38 @@ class TypeInferrerImpl implements TypeInferrer {
               ..fileOffset = nullAwareAction.fileOffset);
       } else if (nullAwareAction is InstanceInvocation &&
           nullAwareAction.receiver == originalPropertyGet) {
+        // TODO(johnniwinther): Remove this when [MethodInvocation] is no longer
+        // used and [originalPropertyGet] can be an [InstanceGet].
+        InstanceGet instanceGet = originalPropertyGet;
         invocationResult = new ExpressionInferenceResult(
             invocationResult.inferredType,
-            new MethodInvocation(originalReceiver, originalName,
-                nullAwareAction.arguments, originalTarget)
+            new InstanceGetterInvocation(instanceGet.kind, originalReceiver,
+                originalName, nullAwareAction.arguments,
+                interfaceTarget: originalTarget,
+                functionType: nullAwareAction.functionType)
               ..fileOffset = nullAwareAction.fileOffset);
       } else if (nullAwareAction is DynamicInvocation &&
           nullAwareAction.receiver == originalPropertyGet) {
+        // TODO(johnniwinther): Remove this when [MethodInvocation] is no longer
+        // used and [originalPropertyGet] can be an [InstanceGet].
+        InstanceGet instanceGet = originalPropertyGet;
         invocationResult = new ExpressionInferenceResult(
             invocationResult.inferredType,
-            new MethodInvocation(originalReceiver, originalName,
-                nullAwareAction.arguments, originalTarget)
+            new InstanceGetterInvocation(instanceGet.kind, originalReceiver,
+                originalName, nullAwareAction.arguments,
+                interfaceTarget: originalTarget, functionType: null)
               ..fileOffset = nullAwareAction.fileOffset);
       } else if (nullAwareAction is FunctionInvocation &&
           nullAwareAction.receiver == originalPropertyGet) {
+        // TODO(johnniwinther): Remove this when [MethodInvocation] is no longer
+        // used and [originalPropertyGet] can be an [InstanceGet].
+        InstanceGet instanceGet = originalPropertyGet;
         invocationResult = new ExpressionInferenceResult(
             invocationResult.inferredType,
-            new MethodInvocation(originalReceiver, originalName,
-                nullAwareAction.arguments, originalTarget)
+            new InstanceGetterInvocation(instanceGet.kind, originalReceiver,
+                originalName, nullAwareAction.arguments,
+                interfaceTarget: originalTarget,
+                functionType: nullAwareAction.functionType)
               ..fileOffset = nullAwareAction.fileOffset);
       }
     }

pkg/front_end/lib/src/kernel_generator_impl.dart

@@ -104,7 +104,8 @@ Future<CompilerResult> generateKernelInternal(
     List<int> summary = null;
     if (buildSummary) {
       if (options.verify) {
-        for (LocatedMessage error in verifyComponent(summaryComponent)) {
+        for (LocatedMessage error
+            in verifyComponent(summaryComponent, options.target)) {
           options.report(error, Severity.error);
         }
       }

pkg/front_end/test/fasta/testing/suite.dart

@@ -1979,7 +1979,8 @@ class Verify extends Step<ComponentResult, ComponentResult, FastaContext> {
     return await CompilerContext.runWithOptions(options,
         (compilerContext) async {
       compilerContext.uriToSource.addAll(component.uriToSource);
-      List<LocatedMessage> verificationErrors = verifyComponent(component,
+      List<LocatedMessage> verificationErrors = verifyComponent(
+          component, options.target,
           isOutline: !fullCompile, skipPlatform: true);
       assert(verificationErrors.isEmpty || messages.isNotEmpty);
       if (messages.isEmpty) {

pkg/front_end/test/issue_34856_test.dart

@@ -97,7 +97,7 @@ Future<void> test() async {
   List<Object> errors = await CompilerContext.runWithOptions(
       new ProcessedOptions(options: options, inputs: inputs),
       (_) => new Future<List<Object>>.value(
-          verifyComponent(component, skipPlatform: true)));
+          verifyComponent(component, options.target, skipPlatform: true)));
 
   serializeComponent(component);
 

pkg/front_end/testcases/dart2js/list_generate.dart.strong.transformed.expect

@@ -6,9 +6,9 @@ import "dart:core" as core;
 static method main() → dynamic {
   block {
     final _in::JSArray<core::int> _list = _in::JSArray::allocateGrowable<core::int>(10);
-    for (core::int* i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+    for (core::int* i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int*) → core::int*}) {
       core::int i = i;
-      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i.{core::num::*}(2){(core::num) → core::int});
+      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i.{core::num::*}(2){(core::num) → core::int}){(core::int, core::int) → void};
     }
   } =>_list;
 }

pkg/front_end/testcases/dart2js/list_generate.dart.weak.transformed.expect

@@ -6,9 +6,9 @@ import "dart:core" as core;
 static method main() → dynamic {
   block {
     final _in::JSArray<core::int> _list = _in::JSArray::allocateGrowable<core::int>(10);
-    for (core::int* i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+    for (core::int* i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int*) → core::int*}) {
       core::int i = i;
-      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i.{core::num::*}(2){(core::num) → core::int});
+      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, i.{core::num::*}(2){(core::num) → core::int}){(core::int, core::int) → void};
     }
   } =>_list;
 }

pkg/front_end/testcases/dart2js/list_generate_local_function_invocation.dart.strong.transformed.expect

@@ -8,9 +8,9 @@ static method main() → dynamic {
     return i.{core::num::*}(2){(core::num) → core::int};
   block {
     final _in::JSArray<core::int> _list = _in::JSArray::allocateGrowable<core::int>(10);
-    for (core::int* i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+    for (core::int* i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int*) → core::int*}) {
       core::int i = i;
-      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, localFunction(i){(core::int) → core::int});
+      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, localFunction(i){(core::int) → core::int}){(core::int, core::int) → void};
     }
   } =>_list;
 }

pkg/front_end/testcases/dart2js/list_generate_local_function_invocation.dart.weak.transformed.expect

@@ -8,9 +8,9 @@ static method main() → dynamic {
     return i.{core::num::*}(2){(core::num) → core::int};
   block {
     final _in::JSArray<core::int> _list = _in::JSArray::allocateGrowable<core::int>(10);
-    for (core::int* i = 0; i.{core::num::<}(10); i = i.{core::num::+}(1)) {
+    for (core::int* i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::int*) → core::int*}) {
       core::int i = i;
-      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, localFunction(i){(core::int) → core::int});
+      _list.{_in::JSArray::[]=}{Invariant,BoundsSafe}(i, localFunction(i){(core::int) → core::int}){(core::int, core::int) → void};
     }
   } =>_list;
 }

pkg/front_end/testcases/expression/set_literal.expression.yaml.expect

@@ -3,5 +3,5 @@ Errors: {
 method /* from org-dartlang-debug:synthetic_debug_expression */ debugExpr() → dynamic
   return block {
     final dart.core::Set<dart.core::String*>* #t1 = new dart.collection::_CompactLinkedHashSet::•<dart.core::String*>();
-    #t1.{dart.core::Set::add}("a"){(dart.core::String*) →* dart.core::bool*};
+    #t1.{dart.core::Set::add}{Invariant}("a"){(dart.core::String*) →* dart.core::bool*};
   } =>#t1;

pkg/front_end/testcases/general/bug32426.dart.weak.expect

@@ -36,7 +36,7 @@ class C extends core::Object implements self::I {
 }
 static method main() → dynamic {
   self::I* i = new self::C::•();
-  ([core::int*]) →* void f = (let final self::I* #t1 = i in #t1 == null ?{() →* void} null : #t1.{self::I::call}) as{TypeError} ([core::int*]) →* void;
+  ([core::int*]) →* void f = (let final self::I* #t1 = i in #t1 == null ?{() →* void} null : #t1.{self::I::call}{() →* void}) as{TypeError} ([core::int*]) →* void;
 }
 
 constants  {

pkg/front_end/testcases/general/bug32426.dart.weak.transformed.expect

@@ -36,7 +36,7 @@ class C extends core::Object implements self::I {
 }
 static method main() → dynamic {
   self::I* i = new self::C::•();
-  ([core::int*]) →* void f = (let final self::I* #t1 = i in #t1 == null ?{() →* void} null : #t1.{self::I::call}) as{TypeError} ([core::int*]) →* void;
+  ([core::int*]) →* void f = (let final self::I* #t1 = i in #t1 == null ?{() →* void} null : #t1.{self::I::call}{() →* void}) as{TypeError} ([core::int*]) →* void;
 }
 
 constants  {

pkg/front_end/testcases/general/bug32629.dart.weak.expect

@@ -32,6 +32,6 @@ static method foo<S extends core::Object* = dynamic>((self::foo::S*, dynamic)
 static method test() → void {
   self::foo<core::String*>(let final Never* #t1 = invalid-expression "pkg/front_end/testcases/general/bug32629.dart:16:19: Error: The argument type 'dynamic Function(dynamic, dynamic)' can't be assigned to the parameter type 'String Function(String, dynamic)'.
   foo<String>(new A());
-                  ^" in (let final self::A* #t2 = new self::A::•() in #t2 == null ?{(dynamic, dynamic) →* dynamic} null : #t2.{self::A::call}) as{TypeError} (core::String*, dynamic) →* core::String*);
+                  ^" in (let final self::A* #t2 = new self::A::•() in #t2 == null ?{(dynamic, dynamic) →* dynamic} null : #t2.{self::A::call}{(dynamic, dynamic) →* dynamic}) as{TypeError} (core::String*, dynamic) →* core::String*);
 }
 static method main() → dynamic {}

pkg/front_end/testcases/general/bug32629.dart.weak.transformed.expect

@@ -32,6 +32,6 @@ static method foo<S extends core::Object* = dynamic>((self::foo::S*, dynamic)
 static method test() → void {
   self::foo<core::String*>(let final Never* #t1 = invalid-expression "pkg/front_end/testcases/general/bug32629.dart:16:19: Error: The argument type 'dynamic Function(dynamic, dynamic)' can't be assigned to the parameter type 'String Function(String, dynamic)'.
   foo<String>(new A());
-                  ^" in (let final self::A* #t2 = new self::A::•() in #t2 == null ?{(dynamic, dynamic) →* dynamic} null : #t2.{self::A::call}) as{TypeError} (core::String*, dynamic) →* core::String*);
+                  ^" in (let final self::A* #t2 = new self::A::•() in #t2 == null ?{(dynamic, dynamic) →* dynamic} null : #t2.{self::A::call}{(dynamic, dynamic) →* dynamic}) as{TypeError} (core::String*, dynamic) →* core::String*);
 }
 static method main() → dynamic {}

pkg/front_end/testcases/general/bug33298.dart.weak.expect

@@ -63,14 +63,14 @@ class C extends core::Object {
 static method test() → dynamic {
   self::A* a = new self::A::•();
   core::List<core::String*>* list1 = <core::String*>["a", "b", "c"].{core::Iterable::map}<core::String*>(a.{self::A::call}{(core::String*) →* core::String*}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
-  core::List<core::String*>* list2 = <core::String*>["a", "b", "c"].{core::Iterable::map}<core::String*>(let final self::A* #t1 = a in #t1 == null ?{(core::String*) →* core::String*} null : #t1.{self::A::call}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
+  core::List<core::String*>* list2 = <core::String*>["a", "b", "c"].{core::Iterable::map}<core::String*>(let final self::A* #t1 = a in #t1 == null ?{(core::String*) →* core::String*} null : #t1.{self::A::call}{(core::String*) →* core::String*}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
   self::B<core::String*>* b = new self::B::•<core::String*>();
   core::List<core::String*>* list3 = <core::String*>["a", "b", "c"].{core::Iterable::map}<core::String*>(b.{self::B::call}{(core::String*) →* core::String*}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
-  core::List<core::String*>* list4 = <core::String*>["a", "b", "c"].{core::Iterable::map}<core::String*>(let final self::B<core::String*>* #t2 = b in #t2 == null ?{(core::String*) →* core::String*} null : #t2.{self::B::call}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
+  core::List<core::String*>* list4 = <core::String*>["a", "b", "c"].{core::Iterable::map}<core::String*>(let final self::B<core::String*>* #t2 = b in #t2 == null ?{(core::String*) →* core::String*} null : #t2.{self::B::call}{(core::String*) →* core::String*}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
   self::C* c = new self::C::•();
   core::List<core::String*>* list5 = <core::String*>["a", "b", "c"].{core::Iterable::map}<core::String*>(c.{self::C::call}{<T extends core::Object* = dynamic>(T*) →* T*}<core::String*>){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
   core::List<core::String*>* list6 = <core::String*>["a", "b", "c"].{core::Iterable::map}<dynamic>(let final Never* #t3 = invalid-expression "pkg/front_end/testcases/general/bug33298.dart:28:44: Error: The argument type 'T Function<T>(T)' can't be assigned to the parameter type 'dynamic Function(String)'.
   List<String> list6 = ['a', 'b', 'c'].map(c).toList();
-                                           ^" in (let final self::C* #t4 = c in #t4 == null ?{<T extends core::Object* = dynamic>(T*) →* T*} null : #t4.{self::C::call}) as{TypeError} (core::String*) →* dynamic){((core::String*) →* dynamic) →* core::Iterable<dynamic>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<dynamic>*} as{TypeError} core::List<core::String*>*;
+                                           ^" in (let final self::C* #t4 = c in #t4 == null ?{<T extends core::Object* = dynamic>(T*) →* T*} null : #t4.{self::C::call}{<T extends core::Object* = dynamic>(T*) →* T*}) as{TypeError} (core::String*) →* dynamic){((core::String*) →* dynamic) →* core::Iterable<dynamic>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<dynamic>*} as{TypeError} core::List<core::String*>*;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/general/bug33298.dart.weak.transformed.expect

@@ -63,14 +63,14 @@ class C extends core::Object {
 static method test() → dynamic {
   self::A* a = new self::A::•();
   core::List<core::String*>* list1 = core::_GrowableList::_literal3<core::String*>("a", "b", "c").{core::Iterable::map}<core::String*>(a.{self::A::call}{(core::String*) →* core::String*}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
-  core::List<core::String*>* list2 = core::_GrowableList::_literal3<core::String*>("a", "b", "c").{core::Iterable::map}<core::String*>(let final self::A* #t1 = a in #t1 == null ?{(core::String*) →* core::String*} null : #t1.{self::A::call}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
+  core::List<core::String*>* list2 = core::_GrowableList::_literal3<core::String*>("a", "b", "c").{core::Iterable::map}<core::String*>(let final self::A* #t1 = a in #t1 == null ?{(core::String*) →* core::String*} null : #t1.{self::A::call}{(core::String*) →* core::String*}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
   self::B<core::String*>* b = new self::B::•<core::String*>();
   core::List<core::String*>* list3 = core::_GrowableList::_literal3<core::String*>("a", "b", "c").{core::Iterable::map}<core::String*>(b.{self::B::call}{(core::String*) →* core::String*}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
-  core::List<core::String*>* list4 = core::_GrowableList::_literal3<core::String*>("a", "b", "c").{core::Iterable::map}<core::String*>(let final self::B<core::String*>* #t2 = b in #t2 == null ?{(core::String*) →* core::String*} null : #t2.{self::B::call}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
+  core::List<core::String*>* list4 = core::_GrowableList::_literal3<core::String*>("a", "b", "c").{core::Iterable::map}<core::String*>(let final self::B<core::String*>* #t2 = b in #t2 == null ?{(core::String*) →* core::String*} null : #t2.{self::B::call}{(core::String*) →* core::String*}){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
   self::C* c = new self::C::•();
   core::List<core::String*>* list5 = core::_GrowableList::_literal3<core::String*>("a", "b", "c").{core::Iterable::map}<core::String*>(c.{self::C::call}{<T extends core::Object* = dynamic>(T*) →* T*}<core::String*>){((core::String*) →* core::String*) →* core::Iterable<core::String*>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
   core::List<core::String*>* list6 = core::_GrowableList::_literal3<core::String*>("a", "b", "c").{core::Iterable::map}<dynamic>(let final Never* #t3 = invalid-expression "pkg/front_end/testcases/general/bug33298.dart:28:44: Error: The argument type 'T Function<T>(T)' can't be assigned to the parameter type 'dynamic Function(String)'.
   List<String> list6 = ['a', 'b', 'c'].map(c).toList();
-                                           ^" in (let final self::C* #t4 = c in #t4 == null ?{<T extends core::Object* = dynamic>(T*) →* T*} null : #t4.{self::C::call}) as{TypeError} (core::String*) →* dynamic){((core::String*) →* dynamic) →* core::Iterable<dynamic>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<dynamic>*} as{TypeError} core::List<core::String*>*;
+                                           ^" in (let final self::C* #t4 = c in #t4 == null ?{<T extends core::Object* = dynamic>(T*) →* T*} null : #t4.{self::C::call}{<T extends core::Object* = dynamic>(T*) →* T*}) as{TypeError} (core::String*) →* dynamic){((core::String*) →* dynamic) →* core::Iterable<dynamic>*}.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<dynamic>*} as{TypeError} core::List<core::String*>*;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/general/constants/const_collections.dart.weak.expect

@@ -402,7 +402,7 @@ static const field core::List<core::String*>* foo = #C8;
 static const field core::List<core::String*>* bar = #C10;
 static field core::List<core::String*>* barAsVar = block {
   final core::List<core::String*>* #t1 = core::List::of<core::String*>(#C8);
-  #t1.{core::List::add}("!"){(core::String*) →* void};
+  #t1.{core::List::add}{Invariant}("!"){(core::String*) →* void};
 } =>#t1;
 static const field core::List<core::String*>* barWithNullSpread = invalid-expression "Null value during constant evaluation.";
 static const field core::List<core::String*>* barWithIntSpread = invalid-expression "pkg/front_end/testcases/general/constants/const_collections.dart:23:51: Error: Unexpected type 'int' of a spread.  Expected 'dynamic' or an Iterable.
@@ -476,7 +476,7 @@ static method main() → dynamic {
   core::print(#C22);
   core::print( block {
     final core::Set<core::String*>* #t2 = col::LinkedHashSet::•<core::String*>();
-    #t2.{core::Set::add}("hello"){(core::String*) →* core::bool*};
+    #t2.{core::Set::add}{Invariant}("hello"){(core::String*) →* core::bool*};
   } =>#t2);
   core::print(#C26);
 }

pkg/front_end/testcases/general/constants/const_collections.dart.weak.transformed.expect

@@ -402,7 +402,7 @@ static const field core::List<core::String*>* foo = #C8;
 static const field core::List<core::String*>* bar = #C10;
 static field core::List<core::String*>* barAsVar = block {
   final core::List<core::String*>* #t1 = core::List::of<core::String*>(#C8);
-  #t1.{core::List::add}("!"){(core::String*) →* void};
+  #t1.{core::List::add}{Invariant}("!"){(core::String*) →* void};
 } =>#t1;
 static const field core::List<core::String*>* barWithNullSpread = invalid-expression "Null value during constant evaluation.";
 static const field core::List<core::String*>* barWithIntSpread = invalid-expression "pkg/front_end/testcases/general/constants/const_collections.dart:23:51: Error: Unexpected type 'int' of a spread.  Expected 'dynamic' or an Iterable.
@@ -476,7 +476,7 @@ static method main() → dynamic {
   core::print(#C22);
   core::print( block {
     final core::Set<core::String*>* #t2 = new col::_CompactLinkedHashSet::•<core::String*>();
-    #t2.{core::Set::add}("hello"){(core::String*) →* core::bool*};
+    #t2.{core::Set::add}{Invariant}("hello"){(core::String*) →* core::bool*};
   } =>#t2);
   core::print(#C26);
 }

pkg/front_end/testcases/general/control_flow_collection.dart.weak.expect

@@ -7,61 +7,61 @@ static method main() → dynamic {
   final core::List<core::int*>* aList = block {
     final core::List<core::int*>* #t1 = <core::int*>[1];
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t1.{core::List::add}(2){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(2){(core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t1.{core::List::add}(3){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(3){(core::int*) →* void};
     else
-      #t1.{core::List::add}(1.{core::int::unary-}(){() →* core::int*}){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(1.{core::int::unary-}(){() →* core::int*}){(core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t1.{core::List::add}(4){(core::int*) →* void};
+        #t1.{core::List::add}{Invariant}(4){(core::int*) →* void};
     for (core::int* i in <core::int*>[5, 6, 7])
-      #t1.{core::List::add}(i){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(i){(core::int*) →* void};
     for (core::int* i in <core::int*>[8, 9, 10])
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t1.{core::List::add}(i){(core::int*) →* void};
+        #t1.{core::List::add}{Invariant}(i){(core::int*) →* void};
     for (core::int* i = 11; i.{core::num::<=}(14){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t1.{core::List::add}(i){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(i){(core::int*) →* void};
   } =>#t1;
   final core::Set<core::int*>* aSet = block {
     final core::Set<core::int*>* #t2 = col::LinkedHashSet::•<core::int*>();
-    #t2.{core::Set::add}(1){(core::int*) →* core::bool*};
+    #t2.{core::Set::add}{Invariant}(1){(core::int*) →* core::bool*};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t2.{core::Set::add}(2){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(2){(core::int*) →* core::bool*};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t2.{core::Set::add}(3){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(3){(core::int*) →* core::bool*};
     else
-      #t2.{core::Set::add}(1.{core::int::unary-}(){() →* core::int*}){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(1.{core::int::unary-}(){() →* core::int*}){(core::int*) →* core::bool*};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t2.{core::Set::add}(4){(core::int*) →* core::bool*};
+        #t2.{core::Set::add}{Invariant}(4){(core::int*) →* core::bool*};
     for (core::int* i in <core::int*>[5, 6, 7])
-      #t2.{core::Set::add}(i){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
     for (core::int* i in <core::int*>[8, 9, 10])
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t2.{core::Set::add}(i){(core::int*) →* core::bool*};
+        #t2.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
     for (core::int* i = 11; i.{core::num::<=}(14){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t2.{core::Set::add}(i){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
   } =>#t2;
   final core::Map<core::int*, core::int*>* aMap = block {
     final core::Map<core::int*, core::int*>* #t3 = <core::int*, core::int*>{};
-    #t3.{core::Map::[]=}(1, 1){(core::int*, core::int*) →* void};
+    #t3.{core::Map::[]=}{Invariant}(1, 1){(core::int*, core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t3.{core::Map::[]=}(2, 2){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(2, 2){(core::int*, core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t3.{core::Map::[]=}(3, 3){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(3, 3){(core::int*, core::int*) →* void};
     else
-      #t3.{core::Map::[]=}(1.{core::int::unary-}(){() →* core::int*}, 1.{core::int::unary-}(){() →* core::int*}){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(1.{core::int::unary-}(){() →* core::int*}, 1.{core::int::unary-}(){() →* core::int*}){(core::int*, core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t3.{core::Map::[]=}(4, 4){(core::int*, core::int*) →* void};
+        #t3.{core::Map::[]=}{Invariant}(4, 4){(core::int*, core::int*) →* void};
     for (core::int* i in <core::int*>[5, 6, 7])
-      #t3.{core::Map::[]=}(i, i){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
     for (core::int* i in <core::int*>[8, 9, 10])
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t3.{core::Map::[]=}(i, i){(core::int*, core::int*) →* void};
+        #t3.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
     for (core::int* i = 11; i.{core::num::<=}(14){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t3.{core::Map::[]=}(i, i){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
   } =>#t3;
   core::print(aList);
   core::print(aSet);

pkg/front_end/testcases/general/control_flow_collection.dart.weak.transformed.expect

@@ -7,19 +7,19 @@ static method main() → dynamic {
   final core::List<core::int*>* aList = block {
     final core::List<core::int*>* #t1 = core::_GrowableList::_literal1<core::int*>(1);
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t1.{core::List::add}(2){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(2){(core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t1.{core::List::add}(3){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(3){(core::int*) →* void};
     else
-      #t1.{core::List::add}(1.{core::int::unary-}(){() →* core::int*}){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(1.{core::int::unary-}(){() →* core::int*}){(core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t1.{core::List::add}(4){(core::int*) →* void};
+        #t1.{core::List::add}{Invariant}(4){(core::int*) →* void};
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal3<core::int*>(5, 6, 7).{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*};
-        #t1.{core::List::add}(i){(core::int*) →* void};
+        #t1.{core::List::add}{Invariant}(i){(core::int*) →* void};
       }
     }
     {
@@ -27,29 +27,29 @@ static method main() → dynamic {
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
         if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-          #t1.{core::List::add}(i){(core::int*) →* void};
+          #t1.{core::List::add}{Invariant}(i){(core::int*) →* void};
       }
     }
     for (core::int* i = 11; i.{core::num::<=}(14){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t1.{core::List::add}(i){(core::int*) →* void};
+      #t1.{core::List::add}{Invariant}(i){(core::int*) →* void};
   } =>#t1;
   final core::Set<core::int*>* aSet = block {
     final core::Set<core::int*>* #t2 = new col::_CompactLinkedHashSet::•<core::int*>();
-    #t2.{core::Set::add}(1){(core::int*) →* core::bool*};
+    #t2.{core::Set::add}{Invariant}(1){(core::int*) →* core::bool*};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t2.{core::Set::add}(2){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(2){(core::int*) →* core::bool*};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t2.{core::Set::add}(3){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(3){(core::int*) →* core::bool*};
     else
-      #t2.{core::Set::add}(1.{core::int::unary-}(){() →* core::int*}){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(1.{core::int::unary-}(){() →* core::int*}){(core::int*) →* core::bool*};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t2.{core::Set::add}(4){(core::int*) →* core::bool*};
+        #t2.{core::Set::add}{Invariant}(4){(core::int*) →* core::bool*};
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal3<core::int*>(5, 6, 7).{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*};
-        #t2.{core::Set::add}(i){(core::int*) →* core::bool*};
+        #t2.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
       }
     }
     {
@@ -57,29 +57,29 @@ static method main() → dynamic {
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
         if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-          #t2.{core::Set::add}(i){(core::int*) →* core::bool*};
+          #t2.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
       }
     }
     for (core::int* i = 11; i.{core::num::<=}(14){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t2.{core::Set::add}(i){(core::int*) →* core::bool*};
+      #t2.{core::Set::add}{Invariant}(i){(core::int*) →* core::bool*};
   } =>#t2;
   final core::Map<core::int*, core::int*>* aMap = block {
     final core::Map<core::int*, core::int*>* #t3 = <core::int*, core::int*>{};
-    #t3.{core::Map::[]=}(1, 1){(core::int*, core::int*) →* void};
+    #t3.{core::Map::[]=}{Invariant}(1, 1){(core::int*, core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t3.{core::Map::[]=}(2, 2){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(2, 2){(core::int*, core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-      #t3.{core::Map::[]=}(3, 3){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(3, 3){(core::int*, core::int*) →* void};
     else
-      #t3.{core::Map::[]=}(1.{core::int::unary-}(){() →* core::int*}, 1.{core::int::unary-}(){() →* core::int*}){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(1.{core::int::unary-}(){() →* core::int*}, 1.{core::int::unary-}(){() →* core::int*}){(core::int*, core::int*) →* void};
     if(self::oracle() as{TypeError,ForDynamic} core::bool*)
       if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-        #t3.{core::Map::[]=}(4, 4){(core::int*, core::int*) →* void};
+        #t3.{core::Map::[]=}{Invariant}(4, 4){(core::int*, core::int*) →* void};
     {
       core::Iterator<core::int*>* :sync-for-iterator = core::_GrowableList::_literal3<core::int*>(5, 6, 7).{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*};
-        #t3.{core::Map::[]=}(i, i){(core::int*, core::int*) →* void};
+        #t3.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
       }
     }
     {
@@ -87,11 +87,11 @@ static method main() → dynamic {
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int* i = :sync-for-iterator.{core::Iterator::current}{core::int*};
         if(self::oracle() as{TypeError,ForDynamic} core::bool*)
-          #t3.{core::Map::[]=}(i, i){(core::int*, core::int*) →* void};
+          #t3.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
       }
     }
     for (core::int* i = 11; i.{core::num::<=}(14){(core::num*) →* core::bool*}; i = i.{core::num::+}(1){(core::num*) →* core::int*})
-      #t3.{core::Map::[]=}(i, i){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(i, i){(core::int*, core::int*) →* void};
   } =>#t3;
   core::print(aList);
   core::print(aSet);

pkg/front_end/testcases/general/if_null_in_set_literal.dart.weak.expect

@@ -8,6 +8,6 @@ static method main() → dynamic {
   core::Object* b;
   return block {
     final core::Set<core::Object*>* #t1 = col::LinkedHashSet::•<core::Object*>();
-    #t1.{core::Set::add}(let final core::Object* #t2 = a in #t2 == null ?{core::Object*} b : #t2){(core::Object*) →* core::bool*};
+    #t1.{core::Set::add}{Invariant}(let final core::Object* #t2 = a in #t2 == null ?{core::Object*} b : #t2){(core::Object*) →* core::bool*};
   } =>#t1;
 }

pkg/front_end/testcases/general/if_null_in_set_literal.dart.weak.transformed.expect

@@ -8,6 +8,6 @@ static method main() → dynamic {
   core::Object* b;
   return block {
     final core::Set<core::Object*>* #t1 = new col::_CompactLinkedHashSet::•<core::Object*>();
-    #t1.{core::Set::add}(let final core::Object* #t2 = a in #t2 == null ?{core::Object*} b : #t2){(core::Object*) →* core::bool*};
+    #t1.{core::Set::add}{Invariant}(let final core::Object* #t2 = a in #t2 == null ?{core::Object*} b : #t2){(core::Object*) →* core::bool*};
   } =>#t1;
 }

pkg/front_end/testcases/general/issue37027.dart.weak.expect

@@ -10,7 +10,7 @@ class C extends core::Object {
       final core::Set<core::int> #t1 = col::LinkedHashSet::•<core::int>();
       for (core::int e in ell)
         if(e.{core::int::isOdd}{core::bool})
-          #t1.{core::Set::add}(2.{core::num::*}(e){(core::num) → core::int}){(core::int) → core::bool};
+          #t1.{core::Set::add}{Invariant}(2.{core::num::*}(e){(core::num) → core::int}){(core::int) → core::bool};
     } =>#t1, super core::Object::•()
     ;
 }

pkg/front_end/testcases/general/issue37027.dart.weak.transformed.expect

@@ -13,7 +13,7 @@ class C extends core::Object {
         for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
           core::int e = :sync-for-iterator.{core::Iterator::current}{core::int};
           if(e.{core::int::isOdd}{core::bool})
-            #t1.{core::Set::add}(2.{core::num::*}(e){(core::num) → core::int}){(core::int) → core::bool};
+            #t1.{core::Set::add}{Invariant}(2.{core::num::*}(e){(core::num) → core::int}){(core::int) → core::bool};
         }
       }
     } =>#t1, super core::Object::•()

pkg/front_end/testcases/general/null_aware_spread.dart.weak.expect

@@ -8,26 +8,26 @@ static method nullAwareListSpread(core::List<core::String*>* list) → dynamic {
     final core::List<core::String*>* #t1 = <core::String*>["foo"];
     final core::Iterable<core::String*>* #t2 = list;
     if(!(#t2 == null))
-      #t1.{core::List::addAll}(#t2){(core::Iterable<core::String*>*) →* void};
+      #t1.{core::List::addAll}{Invariant}(#t2){(core::Iterable<core::String*>*) →* void};
   } =>#t1;
 }
 static method nullAwareSetSpread(core::Set<core::String*>* set) → dynamic {
   set = block {
     final core::Set<core::String*>* #t3 = col::LinkedHashSet::•<core::String*>();
-    #t3.{core::Set::add}("foo"){(core::String*) →* core::bool*};
+    #t3.{core::Set::add}{Invariant}("foo"){(core::String*) →* core::bool*};
     final core::Iterable<core::String*>* #t4 = set;
     if(!(#t4 == null))
-      #t3.{core::Set::addAll}(#t4){(core::Iterable<core::String*>*) →* void};
+      #t3.{core::Set::addAll}{Invariant}(#t4){(core::Iterable<core::String*>*) →* void};
   } =>#t3;
 }
 static method nullAwareMapSpread(core::Map<core::int*, core::String*>* map) → dynamic {
   map = block {
     final core::Map<core::int*, core::String*>* #t5 = <core::int*, core::String*>{};
-    #t5.{core::Map::[]=}(0, "foo"){(core::int*, core::String*) →* void};
+    #t5.{core::Map::[]=}{Invariant}(0, "foo"){(core::int*, core::String*) →* void};
     final core::Map<core::int*, core::String*>* #t6 = map;
     if(!(#t6 == null))
       for (final core::MapEntry<core::int*, core::String*>* #t7 in #t6.{core::Map::entries}{core::Iterable<core::MapEntry<core::int*, core::String*>>})
-        #t5.{core::Map::[]=}(#t7.{core::MapEntry::key}{core::int*}, #t7.{core::MapEntry::value}{core::String*}){(core::int*, core::String*) →* void};
+        #t5.{core::Map::[]=}{Invariant}(#t7.{core::MapEntry::key}{core::int*}, #t7.{core::MapEntry::value}{core::String*}){(core::int*, core::String*) →* void};
   } =>#t5;
 }
 static method main() → dynamic {

pkg/front_end/testcases/general/null_aware_spread.dart.weak.transformed.expect

@@ -8,28 +8,28 @@ static method nullAwareListSpread(core::List<core::String*>* list) → dynamic {
     final core::List<core::String*>* #t1 = core::_GrowableList::_literal1<core::String*>("foo");
     final core::Iterable<core::String*>* #t2 = list;
     if(!(#t2 == null))
-      #t1.{core::List::addAll}(#t2){(core::Iterable<core::String*>*) →* void};
+      #t1.{core::List::addAll}{Invariant}(#t2){(core::Iterable<core::String*>*) →* void};
   } =>#t1;
 }
 static method nullAwareSetSpread(core::Set<core::String*>* set) → dynamic {
   set = block {
     final core::Set<core::String*>* #t3 = new col::_CompactLinkedHashSet::•<core::String*>();
-    #t3.{core::Set::add}("foo"){(core::String*) →* core::bool*};
+    #t3.{core::Set::add}{Invariant}("foo"){(core::String*) →* core::bool*};
     final core::Iterable<core::String*>* #t4 = set;
     if(!(#t4 == null))
-      #t3.{core::Set::addAll}(#t4){(core::Iterable<core::String*>*) →* void};
+      #t3.{core::Set::addAll}{Invariant}(#t4){(core::Iterable<core::String*>*) →* void};
   } =>#t3;
 }
 static method nullAwareMapSpread(core::Map<core::int*, core::String*>* map) → dynamic {
   map = block {
     final core::Map<core::int*, core::String*>* #t5 = <core::int*, core::String*>{};
-    #t5.{core::Map::[]=}(0, "foo"){(core::int*, core::String*) →* void};
+    #t5.{core::Map::[]=}{Invariant}(0, "foo"){(core::int*, core::String*) →* void};
     final core::Map<core::int*, core::String*>* #t6 = map;
     if(!(#t6 == null)) {
       core::Iterator<core::MapEntry<core::int*, core::String*>>* :sync-for-iterator = #t6.{core::Map::entries}{core::Iterable<core::MapEntry<core::int*, core::String*>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<core::int*, core::String*>>*};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<core::int*, core::String*>* #t7 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int*, core::String*>};
-        #t5.{core::Map::[]=}(#t7.{core::MapEntry::key}{core::int*}, #t7.{core::MapEntry::value}{core::String*}){(core::int*, core::String*) →* void};
+        #t5.{core::Map::[]=}{Invariant}(#t7.{core::MapEntry::key}{core::int*}, #t7.{core::MapEntry::value}{core::String*}){(core::int*, core::String*) →* void};
       }
     }
   } =>#t5;

pkg/front_end/testcases/general/spread_collection.dart.weak.expect

@@ -14,28 +14,28 @@ import "dart:collection" as col;
 static method main() → dynamic {
   final core::List<core::int*>* aList = block {
     final core::List<core::int*>* #t1 = <core::int*>[1];
-    #t1.{core::List::addAll}(<core::int*>[2]){(core::Iterable<core::int*>*) →* void};
+    #t1.{core::List::addAll}{Invariant}(<core::int*>[2]){(core::Iterable<core::int*>*) →* void};
     final core::Iterable<core::int*>* #t2 = <core::int*>[3];
     if(!(#t2 == null))
-      #t1.{core::List::addAll}(#t2){(core::Iterable<core::int*>*) →* void};
+      #t1.{core::List::addAll}{Invariant}(#t2){(core::Iterable<core::int*>*) →* void};
   } =>#t1;
   final core::Map<core::int*, core::int*>* aMap = block {
     final core::Map<core::int*, core::int*>* #t3 = <core::int*, core::int*>{};
-    #t3.{core::Map::[]=}(1, 1){(core::int*, core::int*) →* void};
+    #t3.{core::Map::[]=}{Invariant}(1, 1){(core::int*, core::int*) →* void};
     for (final core::MapEntry<core::int*, core::int*>* #t4 in <core::int*, core::int*>{2: 2}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int*, core::int*>>})
-      #t3.{core::Map::[]=}(#t4.{core::MapEntry::key}{core::int*}, #t4.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
+      #t3.{core::Map::[]=}{Invariant}(#t4.{core::MapEntry::key}{core::int*}, #t4.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
     final core::Map<core::int*, core::int*>* #t5 = <core::int*, core::int*>{3: 3};
     if(!(#t5 == null))
       for (final core::MapEntry<core::int*, core::int*>* #t6 in #t5.{core::Map::entries}{core::Iterable<core::MapEntry<core::int*, core::int*>>})
-        #t3.{core::Map::[]=}(#t6.{core::MapEntry::key}{core::int*}, #t6.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
+        #t3.{core::Map::[]=}{Invariant}(#t6.{core::MapEntry::key}{core::int*}, #t6.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
   } =>#t3;
   final core::Set<core::int*>* aSet = block {
     final core::Set<core::int*>* #t7 = col::LinkedHashSet::•<core::int*>();
-    #t7.{core::Set::add}(1){(core::int*) →* core::bool*};
-    #t7.{core::Set::addAll}(<core::int*>[2]){(core::Iterable<core::int*>*) →* void};
+    #t7.{core::Set::add}{Invariant}(1){(core::int*) →* core::bool*};
+    #t7.{core::Set::addAll}{Invariant}(<core::int*>[2]){(core::Iterable<core::int*>*) →* void};
     final core::Iterable<core::int*>* #t8 = <core::int*>[3];
     if(!(#t8 == null))
-      #t7.{core::Set::addAll}(#t8){(core::Iterable<core::int*>*) →* void};
+      #t7.{core::Set::addAll}{Invariant}(#t8){(core::Iterable<core::int*>*) →* void};
   } =>#t7;
   final Never* aSetOrMap = invalid-expression "pkg/front_end/testcases/general/spread_collection.dart:21:21: Error: Not enough type information to disambiguate between literal set and literal map.
 Try providing type arguments for the literal explicitly to disambiguate it.

pkg/front_end/testcases/general/spread_collection.dart.weak.transformed.expect

@@ -14,19 +14,19 @@ import "dart:collection" as col;
 static method main() → dynamic {
   final core::List<core::int*>* aList = block {
     final core::List<core::int*>* #t1 = core::_GrowableList::_literal1<core::int*>(1);
-    #t1.{core::List::addAll}(core::_GrowableList::_literal1<core::int*>(2)){(core::Iterable<core::int*>*) →* void};
+    #t1.{core::List::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(2)){(core::Iterable<core::int*>*) →* void};
     final core::Iterable<core::int*>* #t2 = core::_GrowableList::_literal1<core::int*>(3);
     if(!(#t2 == null))
-      #t1.{core::List::addAll}(#t2){(core::Iterable<core::int*>*) →* void};
+      #t1.{core::List::addAll}{Invariant}(#t2){(core::Iterable<core::int*>*) →* void};
   } =>#t1;
   final core::Map<core::int*, core::int*>* aMap = block {
     final core::Map<core::int*, core::int*>* #t3 = <core::int*, core::int*>{};
-    #t3.{core::Map::[]=}(1, 1){(core::int*, core::int*) →* void};
+    #t3.{core::Map::[]=}{Invariant}(1, 1){(core::int*, core::int*) →* void};
     {
       core::Iterator<core::MapEntry<core::int*, core::int*>>* :sync-for-iterator = <core::int*, core::int*>{2: 2}.{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*>* #t4 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int*, core::int*>};
-        #t3.{core::Map::[]=}(#t4.{core::MapEntry::key}{core::int*}, #t4.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
+        #t3.{core::Map::[]=}{Invariant}(#t4.{core::MapEntry::key}{core::int*}, #t4.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
       }
     }
     final core::Map<core::int*, core::int*>* #t5 = <core::int*, core::int*>{3: 3};
@@ -34,17 +34,17 @@ static method main() → dynamic {
       core::Iterator<core::MapEntry<core::int*, core::int*>>* :sync-for-iterator = #t5.{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*>* #t6 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int*, core::int*>};
-        #t3.{core::Map::[]=}(#t6.{core::MapEntry::key}{core::int*}, #t6.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
+        #t3.{core::Map::[]=}{Invariant}(#t6.{core::MapEntry::key}{core::int*}, #t6.{core::MapEntry::value}{core::int*}){(core::int*, core::int*) →* void};
       }
     }
   } =>#t3;
   final core::Set<core::int*>* aSet = block {
     final core::Set<core::int*>* #t7 = new col::_CompactLinkedHashSet::•<core::int*>();
-    #t7.{core::Set::add}(1){(core::int*) →* core::bool*};
-    #t7.{core::Set::addAll}(core::_GrowableList::_literal1<core::int*>(2)){(core::Iterable<core::int*>*) →* void};
+    #t7.{core::Set::add}{Invariant}(1){(core::int*) →* core::bool*};
+    #t7.{core::Set::addAll}{Invariant}(core::_GrowableList::_literal1<core::int*>(2)){(core::Iterable<core::int*>*) →* void};
     final core::Iterable<core::int*>* #t8 = core::_GrowableList::_literal1<core::int*>(3);
     if(!(#t8 == null))
-      #t7.{core::Set::addAll}(#t8){(core::Iterable<core::int*>*) →* void};
+      #t7.{core::Set::addAll}{Invariant}(#t8){(core::Iterable<core::int*>*) →* void};
   } =>#t7;
   final Never* aSetOrMap = invalid-expression "pkg/front_end/testcases/general/spread_collection.dart:21:21: Error: Not enough type information to disambiguate between literal set and literal map.
 Try providing type arguments for the literal explicitly to disambiguate it.

pkg/front_end/testcases/general/spread_collection_inference.dart.weak.expect

@@ -114,50 +114,50 @@ static method foo(dynamic dynVar) → dynamic {
   core::Map<dynamic, dynamic>* map10 = block {
     final core::Map<dynamic, dynamic>* #t3 = <dynamic, dynamic>{};
     for (final core::MapEntry<dynamic, dynamic>* #t4 in <dynamic, dynamic>{}.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-      #t3.{core::Map::[]=}(#t4.{core::MapEntry::key}{dynamic}, #t4.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
+      #t3.{core::Map::[]=}{Invariant}(#t4.{core::MapEntry::key}{dynamic}, #t4.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
   } =>#t3;
   core::Map<dynamic, dynamic>* map10ambiguous = block {
     final core::Map<dynamic, dynamic>* #t5 = <dynamic, dynamic>{};
     for (final core::MapEntry<dynamic, dynamic>* #t6 in <dynamic, dynamic>{}.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-      #t5.{core::Map::[]=}(#t6.{core::MapEntry::key}{dynamic}, #t6.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
+      #t5.{core::Map::[]=}{Invariant}(#t6.{core::MapEntry::key}{dynamic}, #t6.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
   } =>#t5;
   core::List<core::int*>* lhs20 = block {
     final core::List<core::int*>* #t7 = core::List::of<core::int*>(spread);
   } =>#t7;
   core::Set<core::int*>* set20 = block {
     final core::Set<core::int*>* #t8 = col::LinkedHashSet::of<core::int*>(spread);
-    #t8.{core::Set::add}(42){(core::int*) →* core::bool*};
+    #t8.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
   } =>#t8;
   core::Set<core::int*>* set20ambiguous = block {
     final core::Set<core::int*>* #t9 = col::LinkedHashSet::•<core::int*>();
     for (final dynamic #t10 in spread) {
       final core::int* #t11 = #t10 as{TypeError} core::int*;
-      #t9.{core::Set::add}(#t11){(core::int*) →* core::bool*};
+      #t9.{core::Set::add}{Invariant}(#t11){(core::int*) →* core::bool*};
     }
   } =>#t9;
   core::Map<core::String*, core::int*>* map20 = block {
     final core::Map<core::String*, core::int*>* #t12 = <core::String*, core::int*>{};
     for (final core::MapEntry<core::String*, core::int*>* #t13 in mapSpread.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-      #t12.{core::Map::[]=}(#t13.{core::MapEntry::key}{core::String*}, #t13.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t12.{core::Map::[]=}("baz", 42){(core::String*, core::int*) →* void};
+      #t12.{core::Map::[]=}{Invariant}(#t13.{core::MapEntry::key}{core::String*}, #t13.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+    #t12.{core::Map::[]=}{Invariant}("baz", 42){(core::String*, core::int*) →* void};
   } =>#t12;
   core::Map<core::String*, core::int*>* map20ambiguous = block {
     final core::Map<core::String*, core::int*>* #t14 = <core::String*, core::int*>{};
     for (final core::MapEntry<core::String*, core::int*>* #t15 in mapSpread.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-      #t14.{core::Map::[]=}(#t15.{core::MapEntry::key}{core::String*}, #t15.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+      #t14.{core::Map::[]=}{Invariant}(#t15.{core::MapEntry::key}{core::String*}, #t15.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
   } =>#t14;
   core::List<dynamic>* lhs21 = block {
     final core::List<dynamic>* #t16 = core::List::of<dynamic>((spread as dynamic) as{TypeError,ForDynamic} core::Iterable<dynamic>*);
   } =>#t16;
   core::Set<dynamic>* set21 = block {
     final core::Set<dynamic>* #t17 = col::LinkedHashSet::of<dynamic>((spread as dynamic) as{TypeError,ForDynamic} core::Iterable<dynamic>*);
-    #t17.{core::Set::add}(42){(dynamic) →* core::bool*};
+    #t17.{core::Set::add}{Invariant}(42){(dynamic) →* core::bool*};
   } =>#t17;
   core::Map<dynamic, dynamic>* map21 = block {
     final core::Map<dynamic, dynamic>* #t18 = <dynamic, dynamic>{};
     for (final core::MapEntry<dynamic, dynamic>* #t19 in ((mapSpread as dynamic) as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-      #t18.{core::Map::[]=}(#t19.{core::MapEntry::key}{dynamic}, #t19.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
-    #t18.{core::Map::[]=}("baz", 42){(dynamic, dynamic) →* void};
+      #t18.{core::Map::[]=}{Invariant}(#t19.{core::MapEntry::key}{dynamic}, #t19.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
+    #t18.{core::Map::[]=}{Invariant}("baz", 42){(dynamic, dynamic) →* void};
   } =>#t18;
   dynamic map21ambiguous = invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:64:28: Error: Not enough type information to disambiguate between literal set and literal map.
 Try providing type arguments for the literal explicitly to disambiguate it.
@@ -168,38 +168,38 @@ Try providing type arguments for the literal explicitly to disambiguate it.
   } =>#t20;
   core::Set<core::int*>* set22 = block {
     final core::Set<core::int*>* #t21 = col::LinkedHashSet::of<core::int*>(<core::int*>[]);
-    #t21.{core::Set::add}(42){(core::int*) →* core::bool*};
+    #t21.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
   } =>#t21;
   core::Set<core::int*>* set22ambiguous = block {
     final core::Set<core::int*>* #t22 = col::LinkedHashSet::•<core::int*>();
     for (final dynamic #t23 in <core::int*>[]) {
       final core::int* #t24 = #t23 as{TypeError} core::int*;
-      #t22.{core::Set::add}(#t24){(core::int*) →* core::bool*};
+      #t22.{core::Set::add}{Invariant}(#t24){(core::int*) →* core::bool*};
     }
   } =>#t22;
   core::Map<core::String*, core::int*>* map22 = block {
     final core::Map<core::String*, core::int*>* #t25 = <core::String*, core::int*>{};
     for (final core::MapEntry<core::String*, core::int*>* #t26 in <core::String*, core::int*>{}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-      #t25.{core::Map::[]=}(#t26.{core::MapEntry::key}{core::String*}, #t26.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+      #t25.{core::Map::[]=}{Invariant}(#t26.{core::MapEntry::key}{core::String*}, #t26.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
   } =>#t25;
   core::List<core::List<core::int*>*>* lhs23 = block {
     final core::List<core::List<core::int*>*>* #t27 = core::List::of<core::List<core::int*>*>(<core::List<core::int*>*>[<core::int*>[]]);
   } =>#t27;
   core::Set<core::List<core::int*>*>* set23 = block {
     final core::Set<core::List<core::int*>*>* #t28 = col::LinkedHashSet::of<core::List<core::int*>*>(<core::List<core::int*>*>[<core::int*>[]]);
-    #t28.{core::Set::add}(<core::int*>[42]){(core::List<core::int*>*) →* core::bool*};
+    #t28.{core::Set::add}{Invariant}(<core::int*>[42]){(core::List<core::int*>*) →* core::bool*};
   } =>#t28;
   core::Set<core::List<core::int*>*>* set23ambiguous = block {
     final core::Set<core::List<core::int*>*>* #t29 = col::LinkedHashSet::•<core::List<core::int*>*>();
     for (final dynamic #t30 in <core::List<core::int*>*>[<core::int*>[]]) {
       final core::List<core::int*>* #t31 = #t30 as{TypeError} core::List<core::int*>*;
-      #t29.{core::Set::add}(#t31){(core::List<core::int*>*) →* core::bool*};
+      #t29.{core::Set::add}{Invariant}(#t31){(core::List<core::int*>*) →* core::bool*};
     }
   } =>#t29;
   core::Map<core::String*, core::List<core::int*>*>* map23 = block {
     final core::Map<core::String*, core::List<core::int*>*>* #t32 = <core::String*, core::List<core::int*>*>{};
     for (final core::MapEntry<core::String*, core::List<core::int*>*>* #t33 in <core::String*, core::List<core::int*>*>{"baz": <core::int*>[]}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::List<core::int*>*>>})
-      #t32.{core::Map::[]=}(#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}(#t33.{core::MapEntry::key}{core::String*}, #t33.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
   } =>#t32;
   dynamic map24ambiguous = invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:96:28: Error: Both Iterable and Map spread elements encountered in ambiguous literal.
   dynamic map24ambiguous = {...spread, ...mapSpread};
@@ -215,7 +215,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
   int set30 = /*@ typeArgs=int* */ {...spread, 42};
                                    ^" in ( block {
     final core::Set<core::int*>* #t37 = col::LinkedHashSet::of<core::int*>(spread);
-    #t37.{core::Set::add}(42){(core::int*) →* core::bool*};
+    #t37.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
   } =>#t37) as{TypeError} core::int*;
   core::int* set30ambiguous = let final Never* #t38 = invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:103:7: Error: A value of type 'Set<int>' can't be assigned to a variable of type 'int'.
  - 'Set' is from 'dart:core'.
@@ -224,7 +224,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
     final core::Set<core::int*>* #t39 = col::LinkedHashSet::•<core::int*>();
     for (final dynamic #t40 in spread) {
       final core::int* #t41 = #t40 as{TypeError} core::int*;
-      #t39.{core::Set::add}(#t41){(core::int*) →* core::bool*};
+      #t39.{core::Set::add}{Invariant}(#t41){(core::int*) →* core::bool*};
     }
   } =>#t39) as{TypeError} core::int*;
   core::int* map30 = let final Never* #t42 = invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:106:7: Error: A value of type 'Map<String, int>' can't be assigned to a variable of type 'int'.
@@ -233,8 +233,8 @@ Try providing type arguments for the literal explicitly to disambiguate it.
       ^" in ( block {
     final core::Map<core::String*, core::int*>* #t43 = <core::String*, core::int*>{};
     for (final core::MapEntry<core::String*, core::int*>* #t44 in mapSpread.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-      #t43.{core::Map::[]=}(#t44.{core::MapEntry::key}{core::String*}, #t44.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
-    #t43.{core::Map::[]=}("baz", 42){(core::String*, core::int*) →* void};
+      #t43.{core::Map::[]=}{Invariant}(#t44.{core::MapEntry::key}{core::String*}, #t44.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+    #t43.{core::Map::[]=}{Invariant}("baz", 42){(core::String*, core::int*) →* void};
   } =>#t43) as{TypeError} core::int*;
   core::int* map30ambiguous = let final Never* #t45 = invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:109:7: Error: A value of type 'Map<String, int>' can't be assigned to a variable of type 'int'.
  - 'Map' is from 'dart:core'.
@@ -242,14 +242,14 @@ Try providing type arguments for the literal explicitly to disambiguate it.
       ^" in ( block {
     final core::Map<core::String*, core::int*>* #t46 = <core::String*, core::int*>{};
     for (final core::MapEntry<core::String*, core::int*>* #t47 in mapSpread.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-      #t46.{core::Map::[]=}(#t47.{core::MapEntry::key}{core::String*}, #t47.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+      #t46.{core::Map::[]=}{Invariant}(#t47.{core::MapEntry::key}{core::String*}, #t47.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
   } =>#t46) as{TypeError} core::int*;
   core::List<dynamic>* lhs40 = <dynamic>[invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:111:38: Error: Unexpected type 'int' of a spread.  Expected 'dynamic' or an Iterable.
   List<dynamic> lhs40 = <dynamic>[...notSpreadInt];
                                      ^"];
   core::Set<dynamic>* set40 = block {
     final core::Set<dynamic>* #t48 = col::LinkedHashSet::•<dynamic>();
-    #t48.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:113:37: Error: Unexpected type 'int' of a spread.  Expected 'dynamic' or an Iterable.
+    #t48.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:113:37: Error: Unexpected type 'int' of a spread.  Expected 'dynamic' or an Iterable.
   Set<dynamic> set40 = <dynamic>{...notSpreadInt};
                                     ^"){(dynamic) →* core::bool*};
   } =>#t48;
@@ -261,7 +261,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
                                      ^"];
   core::Set<dynamic>* set50 = block {
     final core::Set<dynamic>* #t49 = col::LinkedHashSet::•<dynamic>();
-    #t49.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:119:37: Error: Unexpected type 'int Function()' of a spread.  Expected 'dynamic' or an Iterable.
+    #t49.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:119:37: Error: Unexpected type 'int Function()' of a spread.  Expected 'dynamic' or an Iterable.
   Set<dynamic> set50 = <dynamic>{...notSpreadFunction};
                                     ^"){(dynamic) →* core::bool*};
   } =>#t49;
@@ -273,7 +273,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
                                    ^"];
   core::Set<core::String*>* set60 = block {
     final core::Set<core::String*>* #t50 = col::LinkedHashSet::•<core::String*>();
-    #t50.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:125:35: Error: Can't assign spread elements of type 'int' to collection elements of type 'String'.
+    #t50.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:125:35: Error: Can't assign spread elements of type 'int' to collection elements of type 'String'.
   Set<String> set60 = <String>{...spread};
                                   ^"){(core::String*) →* core::bool*};
   } =>#t50;
@@ -288,18 +288,18 @@ Try providing type arguments for the literal explicitly to disambiguate it.
                              ^"];
   core::Set<core::int*>* set70 = block {
     final core::Set<core::int*>* #t51 = col::LinkedHashSet::•<core::int*>();
-    #t51.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:133:29: Error: Can't spread a value with static type 'Null'.
+    #t51.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:133:29: Error: Can't spread a value with static type 'Null'.
   Set<int> set70 = <int>{...null};
                             ^"){(core::int*) →* core::bool*};
   } =>#t51;
   core::Set<dynamic>* set71ambiguous = block {
     final core::Set<dynamic>* #t52 = col::LinkedHashSet::•<dynamic>();
-    #t52.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:137:8: Error: Can't spread a value with static type 'Null'.
+    #t52.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:137:8: Error: Can't spread a value with static type 'Null'.
     ...null,
        ^"){(dynamic) →* core::bool*};
     for (final dynamic #t53 in <dynamic>[]) {
       final dynamic #t54 = #t53 as{TypeError} dynamic;
-      #t52.{core::Set::add}(#t54){(dynamic) →* core::bool*};
+      #t52.{core::Set::add}{Invariant}(#t54){(dynamic) →* core::bool*};
     }
   } =>#t52;
   core::Map<core::String*, core::int*>* map70 = <core::String*, core::int*>{invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:142:45: Error: Can't spread a value with static type 'Null'.
@@ -309,13 +309,13 @@ Try providing type arguments for the literal explicitly to disambiguate it.
     final core::List<core::int*>* #t55 = <core::int*>[];
     final core::Iterable<core::int*>* #t56 = null;
     if(!(#t56 == null))
-      #t55.{core::List::addAll}(#t56){(core::Iterable<core::int*>*) →* void};
+      #t55.{core::List::addAll}{Invariant}(#t56){(core::Iterable<core::int*>*) →* void};
   } =>#t55;
   core::Set<core::int*>* set80 = block {
     final core::Set<core::int*>* #t57 = col::LinkedHashSet::•<core::int*>();
     final core::Iterable<core::int*>* #t58 = null;
     if(!(#t58 == null))
-      #t57.{core::Set::addAll}(#t58){(core::Iterable<core::int*>*) →* void};
+      #t57.{core::Set::addAll}{Invariant}(#t58){(core::Iterable<core::int*>*) →* void};
   } =>#t57;
   core::Set<dynamic>* set81ambiguous = block {
     final core::Set<dynamic>* #t59 = col::LinkedHashSet::•<dynamic>();
@@ -323,11 +323,11 @@ Try providing type arguments for the literal explicitly to disambiguate it.
     if(!(#t60 == null))
       for (final dynamic #t61 in #t60) {
         final dynamic #t62 = #t61 as{TypeError} dynamic;
-        #t59.{core::Set::add}(#t62){(dynamic) →* core::bool*};
+        #t59.{core::Set::add}{Invariant}(#t62){(dynamic) →* core::bool*};
       }
     for (final dynamic #t63 in <dynamic>[]) {
       final dynamic #t64 = #t63 as{TypeError} dynamic;
-      #t59.{core::Set::add}(#t64){(dynamic) →* core::bool*};
+      #t59.{core::Set::add}{Invariant}(#t64){(dynamic) →* core::bool*};
     }
   } =>#t59;
   core::Map<core::String*, core::int*>* map80 = block {
@@ -335,18 +335,18 @@ Try providing type arguments for the literal explicitly to disambiguate it.
     final core::Map<core::String*, core::int*>* #t66 = null;
     if(!(#t66 == null))
       for (final core::MapEntry<core::String*, core::int*>* #t67 in #t66.{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-        #t65.{core::Map::[]=}(#t67.{core::MapEntry::key}{core::String*}, #t67.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+        #t65.{core::Map::[]=}{Invariant}(#t67.{core::MapEntry::key}{core::String*}, #t67.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
   } =>#t65;
   core::Map<core::String*, core::int*>* map90 = block {
     final core::Map<core::String*, core::int*>* #t68 = <core::String*, core::int*>{};
     for (final core::MapEntry<core::String*, core::int*>* #t69 in self::bar<core::String*, core::int*>().{core::Map::entries}{core::Iterable<core::MapEntry<core::String*, core::int*>>})
-      #t68.{core::Map::[]=}(#t69.{core::MapEntry::key}{core::String*}, #t69.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+      #t68.{core::Map::[]=}{Invariant}(#t69.{core::MapEntry::key}{core::String*}, #t69.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
   } =>#t68;
   core::List<core::int*>* list100 = block {
     final core::List<core::int*>* #t70 = <core::int*>[];
     for (final dynamic #t71 in listNum) {
       final core::int* #t72 = #t71 as{TypeError} core::int*;
-      #t70.{core::List::add}(#t72){(core::int*) →* void};
+      #t70.{core::List::add}{Invariant}(#t72){(core::int*) →* void};
     }
   } =>#t70;
   core::Map<core::num*, core::int*>* map100 = block {
@@ -354,14 +354,14 @@ Try providing type arguments for the literal explicitly to disambiguate it.
     for (final core::MapEntry<dynamic, dynamic>* #t74 in mapIntNum.{core::Map::entries}{core::Iterable<core::MapEntry<core::num*, core::int*>>}) {
       final core::num* #t75 = #t74.{core::MapEntry::key}{dynamic} as{TypeError} core::num*;
       final core::int* #t76 = #t74.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-      #t73.{core::Map::[]=}(#t75, #t76){(core::num*, core::int*) →* void};
+      #t73.{core::Map::[]=}{Invariant}(#t75, #t76){(core::num*, core::int*) →* void};
     }
   } =>#t73;
   core::List<core::int*>* list110 = block {
     final core::List<core::int*>* #t77 = <core::int*>[];
     for (final dynamic #t78 in dynVar as{TypeError,ForDynamic} core::Iterable<dynamic>*) {
       final core::int* #t79 = #t78 as{TypeError} core::int*;
-      #t77.{core::List::add}(#t79){(core::int*) →* void};
+      #t77.{core::List::add}{Invariant}(#t79){(core::int*) →* void};
     }
   } =>#t77;
   core::Map<core::num*, core::int*>* map110 = block {
@@ -369,7 +369,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
     for (final core::MapEntry<dynamic, dynamic>* #t81 in (dynVar as{TypeError,ForDynamic} core::Map<dynamic, dynamic>*).{core::Map::entries}{core::Iterable<core::MapEntry<core::num*, core::int*>>}) {
       final core::num* #t82 = #t81.{core::MapEntry::key}{dynamic} as{TypeError} core::num*;
       final core::int* #t83 = #t81.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-      #t80.{core::Map::[]=}(#t82, #t83){(core::num*, core::int*) →* void};
+      #t80.{core::Map::[]=}{Invariant}(#t82, #t83){(core::num*, core::int*) →* void};
     }
   } =>#t80;
 }

pkg/front_end/testcases/general/spread_collection_inference.dart.weak.transformed.expect

@@ -117,7 +117,7 @@ static method foo(dynamic dynVar) → dynamic {
       core::Iterator<core::MapEntry<dynamic, dynamic>>* :sync-for-iterator = <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>* #t4 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-        #t3.{core::Map::[]=}(#t4.{core::MapEntry::key}{dynamic}, #t4.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
+        #t3.{core::Map::[]=}{Invariant}(#t4.{core::MapEntry::key}{dynamic}, #t4.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
       }
     }
   } =>#t3;
@@ -127,7 +127,7 @@ static method foo(dynamic dynVar) → dynamic {
       core::Iterator<core::MapEntry<dynamic, dynamic>>* :sync-for-iterator = <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>* #t6 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-        #t5.{core::Map::[]=}(#t6.{core::MapEntry::key}{dynamic}, #t6.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
+        #t5.{core::Map::[]=}{Invariant}(#t6.{core::MapEntry::key}{dynamic}, #t6.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
       }
     }
   } =>#t5;
@@ -136,7 +136,7 @@ static method foo(dynamic dynVar) → dynamic {
   } =>#t7;
   core::Set<core::int*>* set20 = block {
     final core::Set<core::int*>* #t8 = col::LinkedHashSet::of<core::int*>(spread);
-    #t8.{core::Set::add}(42){(core::int*) →* core::bool*};
+    #t8.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
   } =>#t8;
   core::Set<core::int*>* set20ambiguous = block {
     final core::Set<core::int*>* #t9 = new col::_CompactLinkedHashSet::•<core::int*>();
@@ -146,7 +146,7 @@ static method foo(dynamic dynVar) → dynamic {
         final dynamic #t10 = :sync-for-iterator.{core::Iterator::current}{core::int*};
         {
           final core::int* #t11 = #t10 as{TypeError} core::int*;
-          #t9.{core::Set::add}(#t11){(core::int*) →* core::bool*};
+          #t9.{core::Set::add}{Invariant}(#t11){(core::int*) →* core::bool*};
         }
       }
     }
@@ -157,10 +157,10 @@ static method foo(dynamic dynVar) → dynamic {
       core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = mapSpread.{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::[]=}(#t13.{core::MapEntry::key}{core::String*}, #t13.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+        #t12.{core::Map::[]=}{Invariant}(#t13.{core::MapEntry::key}{core::String*}, #t13.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
       }
     }
-    #t12.{core::Map::[]=}("baz", 42){(core::String*, core::int*) →* void};
+    #t12.{core::Map::[]=}{Invariant}("baz", 42){(core::String*, core::int*) →* void};
   } =>#t12;
   core::Map<core::String*, core::int*>* map20ambiguous = block {
     final core::Map<core::String*, core::int*>* #t14 = <core::String*, core::int*>{};
@@ -168,7 +168,7 @@ static method foo(dynamic dynVar) → dynamic {
       core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = mapSpread.{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*>* #t15 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t14.{core::Map::[]=}(#t15.{core::MapEntry::key}{core::String*}, #t15.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+        #t14.{core::Map::[]=}{Invariant}(#t15.{core::MapEntry::key}{core::String*}, #t15.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
       }
     }
   } =>#t14;
@@ -177,7 +177,7 @@ static method foo(dynamic dynVar) → dynamic {
   } =>#t16;
   core::Set<dynamic>* set21 = block {
     final core::Set<dynamic>* #t17 = col::LinkedHashSet::of<dynamic>((spread as dynamic) as{TypeError,ForDynamic} core::Iterable<dynamic>*);
-    #t17.{core::Set::add}(42){(dynamic) →* core::bool*};
+    #t17.{core::Set::add}{Invariant}(42){(dynamic) →* core::bool*};
   } =>#t17;
   core::Map<dynamic, dynamic>* map21 = block {
     final core::Map<dynamic, dynamic>* #t18 = <dynamic, dynamic>{};
@@ -185,10 +185,10 @@ static method foo(dynamic dynVar) → dynamic {
       core::Iterator<core::MapEntry<dynamic, dynamic>>* :sync-for-iterator = ((mapSpread as dynamic) 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>* #t19 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-        #t18.{core::Map::[]=}(#t19.{core::MapEntry::key}{dynamic}, #t19.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
+        #t18.{core::Map::[]=}{Invariant}(#t19.{core::MapEntry::key}{dynamic}, #t19.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) →* void};
       }
     }
-    #t18.{core::Map::[]=}("baz", 42){(dynamic, dynamic) →* void};
+    #t18.{core::Map::[]=}{Invariant}("baz", 42){(dynamic, dynamic) →* void};
   } =>#t18;
   dynamic map21ambiguous = invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:64:28: Error: Not enough type information to disambiguate between literal set and literal map.
 Try providing type arguments for the literal explicitly to disambiguate it.
@@ -199,7 +199,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
   } =>#t20;
   core::Set<core::int*>* set22 = block {
     final core::Set<core::int*>* #t21 = col::LinkedHashSet::of<core::int*>(core::_GrowableList::•<core::int*>(0));
-    #t21.{core::Set::add}(42){(core::int*) →* core::bool*};
+    #t21.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
   } =>#t21;
   core::Set<core::int*>* set22ambiguous = block {
     final core::Set<core::int*>* #t22 = new col::_CompactLinkedHashSet::•<core::int*>();
@@ -209,7 +209,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         final dynamic #t23 = :sync-for-iterator.{core::Iterator::current}{core::int*};
         {
           final core::int* #t24 = #t23 as{TypeError} core::int*;
-          #t22.{core::Set::add}(#t24){(core::int*) →* core::bool*};
+          #t22.{core::Set::add}{Invariant}(#t24){(core::int*) →* core::bool*};
         }
       }
     }
@@ -220,7 +220,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
       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*>* #t26 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t25.{core::Map::[]=}(#t26.{core::MapEntry::key}{core::String*}, #t26.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+        #t25.{core::Map::[]=}{Invariant}(#t26.{core::MapEntry::key}{core::String*}, #t26.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
       }
     }
   } =>#t25;
@@ -229,7 +229,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
   } =>#t27;
   core::Set<core::List<core::int*>*>* set23 = block {
     final core::Set<core::List<core::int*>*>* #t28 = col::LinkedHashSet::of<core::List<core::int*>*>(core::_GrowableList::_literal1<core::List<core::int*>*>(core::_GrowableList::•<core::int*>(0)));
-    #t28.{core::Set::add}(core::_GrowableList::_literal1<core::int*>(42)){(core::List<core::int*>*) →* core::bool*};
+    #t28.{core::Set::add}{Invariant}(core::_GrowableList::_literal1<core::int*>(42)){(core::List<core::int*>*) →* core::bool*};
   } =>#t28;
   core::Set<core::List<core::int*>*>* set23ambiguous = block {
     final core::Set<core::List<core::int*>*>* #t29 = new col::_CompactLinkedHashSet::•<core::List<core::int*>*>();
@@ -239,7 +239,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         final dynamic #t30 = :sync-for-iterator.{core::Iterator::current}{core::List<core::int*>*};
         {
           final core::List<core::int*>* #t31 = #t30 as{TypeError} core::List<core::int*>*;
-          #t29.{core::Set::add}(#t31){(core::List<core::int*>*) →* core::bool*};
+          #t29.{core::Set::add}{Invariant}(#t31){(core::List<core::int*>*) →* core::bool*};
         }
       }
     }
@@ -250,7 +250,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
       core::Iterator<core::MapEntry<core::String*, core::List<core::int*>*>>* :sync-for-iterator = <core::String*, core::List<core::int*>*>{"baz": 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*>*>* #t33 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::List<core::int*>*>};
-        #t32.{core::Map::[]=}(#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}(#t33.{core::MapEntry::key}{core::String*}, #t33.{core::MapEntry::value}{core::List<core::int*>*}){(core::String*, core::List<core::int*>*) →* void};
       }
     }
   } =>#t32;
@@ -268,7 +268,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
   int set30 = /*@ typeArgs=int* */ {...spread, 42};
                                    ^" in ( block {
     final core::Set<core::int*>* #t37 = col::LinkedHashSet::of<core::int*>(spread);
-    #t37.{core::Set::add}(42){(core::int*) →* core::bool*};
+    #t37.{core::Set::add}{Invariant}(42){(core::int*) →* core::bool*};
   } =>#t37) as{TypeError} core::int*;
   core::int* set30ambiguous = let final Never* #t38 = invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:103:7: Error: A value of type 'Set<int>' can't be assigned to a variable of type 'int'.
  - 'Set' is from 'dart:core'.
@@ -281,7 +281,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         final dynamic #t40 = :sync-for-iterator.{core::Iterator::current}{core::int*};
         {
           final core::int* #t41 = #t40 as{TypeError} core::int*;
-          #t39.{core::Set::add}(#t41){(core::int*) →* core::bool*};
+          #t39.{core::Set::add}{Invariant}(#t41){(core::int*) →* core::bool*};
         }
       }
     }
@@ -295,10 +295,10 @@ Try providing type arguments for the literal explicitly to disambiguate it.
       core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = mapSpread.{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*>* #t44 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t43.{core::Map::[]=}(#t44.{core::MapEntry::key}{core::String*}, #t44.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+        #t43.{core::Map::[]=}{Invariant}(#t44.{core::MapEntry::key}{core::String*}, #t44.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
       }
     }
-    #t43.{core::Map::[]=}("baz", 42){(core::String*, core::int*) →* void};
+    #t43.{core::Map::[]=}{Invariant}("baz", 42){(core::String*, core::int*) →* void};
   } =>#t43) as{TypeError} core::int*;
   core::int* map30ambiguous = let final Never* #t45 = invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:109:7: Error: A value of type 'Map<String, int>' can't be assigned to a variable of type 'int'.
  - 'Map' is from 'dart:core'.
@@ -309,7 +309,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
       core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = mapSpread.{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::[]=}(#t47.{core::MapEntry::key}{core::String*}, #t47.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+        #t46.{core::Map::[]=}{Invariant}(#t47.{core::MapEntry::key}{core::String*}, #t47.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
       }
     }
   } =>#t46) as{TypeError} core::int*;
@@ -318,7 +318,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
                                      ^");
   core::Set<dynamic>* set40 = block {
     final core::Set<dynamic>* #t48 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t48.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:113:37: Error: Unexpected type 'int' of a spread.  Expected 'dynamic' or an Iterable.
+    #t48.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:113:37: Error: Unexpected type 'int' of a spread.  Expected 'dynamic' or an Iterable.
   Set<dynamic> set40 = <dynamic>{...notSpreadInt};
                                     ^"){(dynamic) →* core::bool*};
   } =>#t48;
@@ -330,7 +330,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
                                      ^");
   core::Set<dynamic>* set50 = block {
     final core::Set<dynamic>* #t49 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t49.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:119:37: Error: Unexpected type 'int Function()' of a spread.  Expected 'dynamic' or an Iterable.
+    #t49.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:119:37: Error: Unexpected type 'int Function()' of a spread.  Expected 'dynamic' or an Iterable.
   Set<dynamic> set50 = <dynamic>{...notSpreadFunction};
                                     ^"){(dynamic) →* core::bool*};
   } =>#t49;
@@ -342,7 +342,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
                                    ^");
   core::Set<core::String*>* set60 = block {
     final core::Set<core::String*>* #t50 = new col::_CompactLinkedHashSet::•<core::String*>();
-    #t50.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:125:35: Error: Can't assign spread elements of type 'int' to collection elements of type 'String'.
+    #t50.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:125:35: Error: Can't assign spread elements of type 'int' to collection elements of type 'String'.
   Set<String> set60 = <String>{...spread};
                                   ^"){(core::String*) →* core::bool*};
   } =>#t50;
@@ -357,13 +357,13 @@ Try providing type arguments for the literal explicitly to disambiguate it.
                              ^");
   core::Set<core::int*>* set70 = block {
     final core::Set<core::int*>* #t51 = new col::_CompactLinkedHashSet::•<core::int*>();
-    #t51.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:133:29: Error: Can't spread a value with static type 'Null'.
+    #t51.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:133:29: Error: Can't spread a value with static type 'Null'.
   Set<int> set70 = <int>{...null};
                             ^"){(core::int*) →* core::bool*};
   } =>#t51;
   core::Set<dynamic>* set71ambiguous = block {
     final core::Set<dynamic>* #t52 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t52.{core::Set::add}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:137:8: Error: Can't spread a value with static type 'Null'.
+    #t52.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/general/spread_collection_inference.dart:137:8: Error: Can't spread a value with static type 'Null'.
     ...null,
        ^"){(dynamic) →* core::bool*};
     {
@@ -372,7 +372,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         final dynamic #t53 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final dynamic #t54 = #t53 as{TypeError} dynamic;
-          #t52.{core::Set::add}(#t54){(dynamic) →* core::bool*};
+          #t52.{core::Set::add}{Invariant}(#t54){(dynamic) →* core::bool*};
         }
       }
     }
@@ -384,13 +384,13 @@ Try providing type arguments for the literal explicitly to disambiguate it.
     final core::List<core::int*>* #t55 = core::_GrowableList::•<core::int*>(0);
     final core::Iterable<core::int*>* #t56 = null;
     if(!(#t56 == null))
-      #t55.{core::List::addAll}(#t56){(core::Iterable<core::int*>*) →* void};
+      #t55.{core::List::addAll}{Invariant}(#t56){(core::Iterable<core::int*>*) →* void};
   } =>#t55;
   core::Set<core::int*>* set80 = block {
     final core::Set<core::int*>* #t57 = new col::_CompactLinkedHashSet::•<core::int*>();
     final core::Iterable<core::int*>* #t58 = null;
     if(!(#t58 == null))
-      #t57.{core::Set::addAll}(#t58){(core::Iterable<core::int*>*) →* void};
+      #t57.{core::Set::addAll}{Invariant}(#t58){(core::Iterable<core::int*>*) →* void};
   } =>#t57;
   core::Set<dynamic>* set81ambiguous = block {
     final core::Set<dynamic>* #t59 = new col::_CompactLinkedHashSet::•<dynamic>();
@@ -401,7 +401,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         final dynamic #t61 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final dynamic #t62 = #t61 as{TypeError} dynamic;
-          #t59.{core::Set::add}(#t62){(dynamic) →* core::bool*};
+          #t59.{core::Set::add}{Invariant}(#t62){(dynamic) →* core::bool*};
         }
       }
     }
@@ -411,7 +411,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         final dynamic #t63 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final dynamic #t64 = #t63 as{TypeError} dynamic;
-          #t59.{core::Set::add}(#t64){(dynamic) →* core::bool*};
+          #t59.{core::Set::add}{Invariant}(#t64){(dynamic) →* core::bool*};
         }
       }
     }
@@ -423,7 +423,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
       core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = #t66.{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*>* #t67 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t65.{core::Map::[]=}(#t67.{core::MapEntry::key}{core::String*}, #t67.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+        #t65.{core::Map::[]=}{Invariant}(#t67.{core::MapEntry::key}{core::String*}, #t67.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
       }
     }
   } =>#t65;
@@ -433,7 +433,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
       core::Iterator<core::MapEntry<core::String*, core::int*>>* :sync-for-iterator = self::bar<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*>* #t69 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String*, core::int*>};
-        #t68.{core::Map::[]=}(#t69.{core::MapEntry::key}{core::String*}, #t69.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
+        #t68.{core::Map::[]=}{Invariant}(#t69.{core::MapEntry::key}{core::String*}, #t69.{core::MapEntry::value}{core::int*}){(core::String*, core::int*) →* void};
       }
     }
   } =>#t68;
@@ -445,7 +445,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         final dynamic #t71 = :sync-for-iterator.{core::Iterator::current}{core::num*};
         {
           final core::int* #t72 = #t71 as{TypeError} core::int*;
-          #t70.{core::List::add}(#t72){(core::int*) →* void};
+          #t70.{core::List::add}{Invariant}(#t72){(core::int*) →* void};
         }
       }
     }
@@ -459,7 +459,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         {
           final core::num* #t75 = #t74.{core::MapEntry::key}{dynamic} as{TypeError} core::num*;
           final core::int* #t76 = #t74.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-          #t73.{core::Map::[]=}(#t75, #t76){(core::num*, core::int*) →* void};
+          #t73.{core::Map::[]=}{Invariant}(#t75, #t76){(core::num*, core::int*) →* void};
         }
       }
     }
@@ -472,7 +472,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         final dynamic #t78 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int* #t79 = #t78 as{TypeError} core::int*;
-          #t77.{core::List::add}(#t79){(core::int*) →* void};
+          #t77.{core::List::add}{Invariant}(#t79){(core::int*) →* void};
         }
       }
     }
@@ -486,7 +486,7 @@ Try providing type arguments for the literal explicitly to disambiguate it.
         {
           final core::num* #t82 = #t81.{core::MapEntry::key}{dynamic} as{TypeError} core::num*;
           final core::int* #t83 = #t81.{core::MapEntry::value}{dynamic} as{TypeError} core::int*;
-          #t80.{core::Map::[]=}(#t82, #t83){(core::num*, core::int*) →* void};
+          #t80.{core::Map::[]=}{Invariant}(#t82, #t83){(core::num*, core::int*) →* void};
         }
       }
     }

pkg/front_end/testcases/generic_metadata/inferred_generic_types_in_arguments_and_bounds.dart.strong.expect

@@ -15,7 +15,7 @@ static method test() → dynamic {
   core::List<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> y = <<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>>[#C1];
   core::Set<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> z = block {
     final core::Set<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> #t1 = col::LinkedHashSet::•<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>>();
-    #t1.{core::Set::add}(y.{core::Iterable::first}{<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>}){(<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>) → core::bool};
+    #t1.{core::Set::add}{Invariant}(y.{core::Iterable::first}{<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>}){(<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>) → core::bool};
   } =>#t1;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/generic_metadata/inferred_generic_types_in_arguments_and_bounds.dart.strong.transformed.expect

@@ -15,7 +15,7 @@ static method test() → dynamic {
   core::List<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> y = core::_GrowableList::_literal1<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>>(#C1);
   core::Set<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> z = block {
     final core::Set<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> #t1 = new col::_CompactLinkedHashSet::•<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>>();
-    #t1.{core::Set::add}(y.{core::Iterable::first}{<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>}){(<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>) → core::bool};
+    #t1.{core::Set::add}{Invariant}(y.{core::Iterable::first}{<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>}){(<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>) → core::bool};
   } =>#t1;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/generic_metadata/inferred_generic_types_in_arguments_and_bounds.dart.weak.expect

@@ -15,7 +15,7 @@ static method test() → dynamic {
   core::List<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> y = <<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>>[#C1];
   core::Set<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> z = block {
     final core::Set<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> #t1 = col::LinkedHashSet::•<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>>();
-    #t1.{core::Set::add}(y.{core::Iterable::first}{<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>}){(<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>) → core::bool};
+    #t1.{core::Set::add}{Invariant}(y.{core::Iterable::first}{<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>}){(<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>) → core::bool};
   } =>#t1;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/generic_metadata/inferred_generic_types_in_arguments_and_bounds.dart.weak.transformed.expect

@@ -15,7 +15,7 @@ static method test() → dynamic {
   core::List<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> y = core::_GrowableList::_literal1<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>>(#C1);
   core::Set<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> z = block {
     final core::Set<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>> #t1 = new col::_CompactLinkedHashSet::•<<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>>();
-    #t1.{core::Set::add}(y.{core::Iterable::first}{<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>}){(<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>) → core::bool};
+    #t1.{core::Set::add}{Invariant}(y.{core::Iterable::first}{<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>}){(<Y extends core::Object? = dynamic>(Y%) → self::A<Y%>) → core::bool};
   } =>#t1;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/implicit_getter_calls/getter_call.dart.weak.expect

@@ -135,21 +135,21 @@ static method main() → dynamic {
 }
 static method callField(self::Class* c) → dynamic {
   self::expect(0, c.{self::Class::field1a}());
-  self::expect(0, c.{self::Class::field1b}());
-  self::expect(42.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t1 = c in let final core::int* #t2 = self::read(42) in #t1.{self::Class::field2}(#t2));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t3 = c in let final core::int* #t4 = self::read(12) in let final core::int* #t5 = self::read(23) in #t3.{self::Class::field3}(#t4, #t5));
-  self::expect(12, let final self::Class* #t6 = c in let final core::int* #t7 = self::read(12) in #t6.{self::Class::field4}(#t7));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t8 = c in let final core::int* #t9 = self::read(12) in let final core::int* #t10 = self::read(23) in #t8.{self::Class::field4}(#t9, #t10));
-  self::expect(0, c.{self::Class::field5}());
-  self::expect(12, let final self::Class* #t11 = c in let final core::int* #t12 = self::read(12) in #t11.{self::Class::field5}(#t12));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t13 = c in let final core::int* #t14 = self::read(12) in let final core::int* #t15 = self::read(23) in #t13.{self::Class::field5}(#t14, #t15));
-  self::expect(12, let final self::Class* #t16 = c in let final core::int* #t17 = self::read(12) in #t16.{self::Class::field6}(#t17));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t18 = c in let final core::int* #t19 = self::read(12) in let final core::int* #t20 = self::read(23) in #t18.{self::Class::field6}(#t19, b: #t20));
-  self::expect(0, c.{self::Class::field7}());
-  self::expect(12, let final self::Class* #t21 = c in let final core::int* #t22 = self::read(12) in #t21.{self::Class::field7}(a: #t22));
-  self::expect(23.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t23 = c in let final core::int* #t24 = self::read(23) in #t23.{self::Class::field7}(b: #t24));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t25 = c in let final core::int* #t26 = self::read(12) in let final core::int* #t27 = self::read(23) in #t25.{self::Class::field7}(a: #t26, b: #t27));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t28 = c in let final core::int* #t29 = self::read(23) in let final core::int* #t30 = self::read(12) in #t28.{self::Class::field7}(b: #t29, a: #t30));
+  self::expect(0, c.{self::Class::field1b}(){() →* core::int*});
+  self::expect(42.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t1 = c in let final core::int* #t2 = self::read(42) in #t1.{self::Class::field2}(#t2){(core::int*) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t3 = c in let final core::int* #t4 = self::read(12) in let final core::int* #t5 = self::read(23) in #t3.{self::Class::field3}(#t4, #t5){(core::int*, core::int*) →* core::int*});
+  self::expect(12, let final self::Class* #t6 = c in let final core::int* #t7 = self::read(12) in #t6.{self::Class::field4}(#t7){(core::int*, [core::int*]) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t8 = c in let final core::int* #t9 = self::read(12) in let final core::int* #t10 = self::read(23) in #t8.{self::Class::field4}(#t9, #t10){(core::int*, [core::int*]) →* core::int*});
+  self::expect(0, c.{self::Class::field5}(){([core::int*, core::int*]) →* core::int*});
+  self::expect(12, let final self::Class* #t11 = c in let final core::int* #t12 = self::read(12) in #t11.{self::Class::field5}(#t12){([core::int*, core::int*]) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t13 = c in let final core::int* #t14 = self::read(12) in let final core::int* #t15 = self::read(23) in #t13.{self::Class::field5}(#t14, #t15){([core::int*, core::int*]) →* core::int*});
+  self::expect(12, let final self::Class* #t16 = c in let final core::int* #t17 = self::read(12) in #t16.{self::Class::field6}(#t17){(core::int*, {b: core::int*}) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t18 = c in let final core::int* #t19 = self::read(12) in let final core::int* #t20 = self::read(23) in #t18.{self::Class::field6}(#t19, b: #t20){(core::int*, {b: core::int*}) →* core::int*});
+  self::expect(0, c.{self::Class::field7}(){({a: core::int*, b: core::int*}) →* core::int*});
+  self::expect(12, let final self::Class* #t21 = c in let final core::int* #t22 = self::read(12) in #t21.{self::Class::field7}(a: #t22){({a: core::int*, b: core::int*}) →* core::int*});
+  self::expect(23.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t23 = c in let final core::int* #t24 = self::read(23) in #t23.{self::Class::field7}(b: #t24){({a: core::int*, b: core::int*}) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t25 = c in let final core::int* #t26 = self::read(12) in let final core::int* #t27 = self::read(23) in #t25.{self::Class::field7}(a: #t26, b: #t27){({a: core::int*, b: core::int*}) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t28 = c in let final core::int* #t29 = self::read(23) in let final core::int* #t30 = self::read(12) in #t28.{self::Class::field7}(b: #t29, a: #t30){({a: core::int*, b: core::int*}) →* core::int*});
 }
 static method callGetter(self::Class* c) → dynamic {
   self::expect(0, c.{self::Class::getter1a}());

pkg/front_end/testcases/implicit_getter_calls/getter_call.dart.weak.transformed.expect

@@ -135,21 +135,21 @@ static method main() → dynamic {
 }
 static method callField(self::Class* c) → dynamic {
   self::expect(0, c.{self::Class::field1a}());
-  self::expect(0, c.{self::Class::field1b}());
-  self::expect(42.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t1 = c in let final core::int* #t2 = self::read(42) in #t1.{self::Class::field2}(#t2));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t3 = c in let final core::int* #t4 = self::read(12) in let final core::int* #t5 = self::read(23) in #t3.{self::Class::field3}(#t4, #t5));
-  self::expect(12, let final self::Class* #t6 = c in let final core::int* #t7 = self::read(12) in #t6.{self::Class::field4}(#t7));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t8 = c in let final core::int* #t9 = self::read(12) in let final core::int* #t10 = self::read(23) in #t8.{self::Class::field4}(#t9, #t10));
-  self::expect(0, c.{self::Class::field5}());
-  self::expect(12, let final self::Class* #t11 = c in let final core::int* #t12 = self::read(12) in #t11.{self::Class::field5}(#t12));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t13 = c in let final core::int* #t14 = self::read(12) in let final core::int* #t15 = self::read(23) in #t13.{self::Class::field5}(#t14, #t15));
-  self::expect(12, let final self::Class* #t16 = c in let final core::int* #t17 = self::read(12) in #t16.{self::Class::field6}(#t17));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t18 = c in let final core::int* #t19 = self::read(12) in let final core::int* #t20 = self::read(23) in #t18.{self::Class::field6}(#t19, b: #t20));
-  self::expect(0, c.{self::Class::field7}());
-  self::expect(12, let final self::Class* #t21 = c in let final core::int* #t22 = self::read(12) in #t21.{self::Class::field7}(a: #t22));
-  self::expect(23.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t23 = c in let final core::int* #t24 = self::read(23) in #t23.{self::Class::field7}(b: #t24));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t25 = c in let final core::int* #t26 = self::read(12) in let final core::int* #t27 = self::read(23) in #t25.{self::Class::field7}(a: #t26, b: #t27));
-  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t28 = c in let final core::int* #t29 = self::read(23) in let final core::int* #t30 = self::read(12) in #t28.{self::Class::field7}(b: #t29, a: #t30));
+  self::expect(0, c.{self::Class::field1b}(){() →* core::int*});
+  self::expect(42.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t1 = c in let final core::int* #t2 = self::read(42) in #t1.{self::Class::field2}(#t2){(core::int*) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t3 = c in let final core::int* #t4 = self::read(12) in let final core::int* #t5 = self::read(23) in #t3.{self::Class::field3}(#t4, #t5){(core::int*, core::int*) →* core::int*});
+  self::expect(12, let final self::Class* #t6 = c in let final core::int* #t7 = self::read(12) in #t6.{self::Class::field4}(#t7){(core::int*, [core::int*]) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t8 = c in let final core::int* #t9 = self::read(12) in let final core::int* #t10 = self::read(23) in #t8.{self::Class::field4}(#t9, #t10){(core::int*, [core::int*]) →* core::int*});
+  self::expect(0, c.{self::Class::field5}(){([core::int*, core::int*]) →* core::int*});
+  self::expect(12, let final self::Class* #t11 = c in let final core::int* #t12 = self::read(12) in #t11.{self::Class::field5}(#t12){([core::int*, core::int*]) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t13 = c in let final core::int* #t14 = self::read(12) in let final core::int* #t15 = self::read(23) in #t13.{self::Class::field5}(#t14, #t15){([core::int*, core::int*]) →* core::int*});
+  self::expect(12, let final self::Class* #t16 = c in let final core::int* #t17 = self::read(12) in #t16.{self::Class::field6}(#t17){(core::int*, {b: core::int*}) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t18 = c in let final core::int* #t19 = self::read(12) in let final core::int* #t20 = self::read(23) in #t18.{self::Class::field6}(#t19, b: #t20){(core::int*, {b: core::int*}) →* core::int*});
+  self::expect(0, c.{self::Class::field7}(){({a: core::int*, b: core::int*}) →* core::int*});
+  self::expect(12, let final self::Class* #t21 = c in let final core::int* #t22 = self::read(12) in #t21.{self::Class::field7}(a: #t22){({a: core::int*, b: core::int*}) →* core::int*});
+  self::expect(23.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t23 = c in let final core::int* #t24 = self::read(23) in #t23.{self::Class::field7}(b: #t24){({a: core::int*, b: core::int*}) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t25 = c in let final core::int* #t26 = self::read(12) in let final core::int* #t27 = self::read(23) in #t25.{self::Class::field7}(a: #t26, b: #t27){({a: core::int*, b: core::int*}) →* core::int*});
+  self::expect(11.{core::int::unary-}(){() →* core::int*}, let final self::Class* #t28 = c in let final core::int* #t29 = self::read(23) in let final core::int* #t30 = self::read(12) in #t28.{self::Class::field7}(b: #t29, a: #t30){({a: core::int*, b: core::int*}) →* core::int*});
 }
 static method callGetter(self::Class* c) → dynamic {
   self::expect(0, c.{self::Class::getter1a}());

pkg/front_end/testcases/implicit_getter_calls/this_field_call.dart.weak.expect

@@ -8,7 +8,7 @@ class A<T extends core::Object* = dynamic> extends core::Object {
     : self::A::f = f, super core::Object::•()
     ;
   method foo(generic-covariant-impl self::A::T* x) → dynamic
-    return let final self::A::T* #t1 = x in this.{self::A::f}(#t1);
+    return let final self::A::T* #t1 = x in this.{self::A::f}(#t1){(self::A::T*) →* void};
   abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
   abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
   abstract member-signature method _simpleInstanceOf(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOf

pkg/front_end/testcases/implicit_getter_calls/this_field_call.dart.weak.transformed.expect

@@ -8,7 +8,7 @@ class A<T extends core::Object* = dynamic> extends core::Object {
     : self::A::f = f, super core::Object::•()
     ;
   method foo(generic-covariant-impl self::A::T* x) → dynamic
-    return let final self::A::T* #t1 = x in this.{self::A::f}(#t1);
+    return let final self::A::T* #t1 = x in this.{self::A::f}(#t1){(self::A::T*) →* void};
   abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
   abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf
   abstract member-signature method _simpleInstanceOf(dynamic type) → core::bool*; -> core::Object::_simpleInstanceOf

pkg/front_end/testcases/late_lowering/later.dart.strong.expect

@@ -127,7 +127,7 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
   block {
     final core::List<core::int> #t7 = <core::int>[];
     for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t7.{core::List::add}(i){(core::int) → void};
+      #t7.{core::List::add}{Invariant}(i){(core::int) → void};
   } =>#t7;
 }
 static method hest() → dynamic async {

pkg/front_end/testcases/late_lowering/later.dart.strong.transformed.expect

@@ -133,7 +133,7 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
   block {
     final core::List<core::int> #t7 = core::_GrowableList::•<core::int>(0);
     for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t7.{core::List::add}(i){(core::int) → void};
+      #t7.{core::List::add}{Invariant}(i){(core::int) → void};
   } =>#t7;
 }
 static method hest() → dynamic /* originally async */ {

pkg/front_end/testcases/late_lowering/later.dart.weak.expect

@@ -147,7 +147,7 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
   block {
     final core::List<core::int> #t7 = <core::int>[];
     for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t7.{core::List::add}(i){(core::int) → void};
+      #t7.{core::List::add}{Invariant}(i){(core::int) → void};
   } =>#t7;
 }
 static method hest() → dynamic async {

pkg/front_end/testcases/late_lowering/later.dart.weak.transformed.expect

@@ -153,7 +153,7 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
   block {
     final core::List<core::int> #t7 = core::_GrowableList::•<core::int>(0);
     for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t7.{core::List::add}(i){(core::int) → void};
+      #t7.{core::List::add}{Invariant}(i){(core::int) → void};
   } =>#t7;
 }
 static method hest() → dynamic /* originally async */ {

pkg/front_end/testcases/nnbd/assignability.dart.strong.expect

@@ -1014,10 +1014,10 @@ static method ok<XnonNull extends core::Object, YnonNull extends self::ok::XnonN
   core::Function functionVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} core::Function;
   functionVar = functionArg;
   functionVar = toVoidArg;
-  functionVar = let final self::Tearoffable #t1 = tearoffableArg in #t1 == null ?{() → void} null : #t1.{self::Tearoffable::call};
+  functionVar = let final self::Tearoffable #t1 = tearoffableArg in #t1 == null ?{() → void} null : #t1.{self::Tearoffable::call}{() → void};
   () → void toVoidVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} () → void;
   toVoidVar = toVoidArg;
-  toVoidVar = let final self::Tearoffable #t2 = tearoffableArg in #t2 == null ?{() → void} null : #t2.{self::Tearoffable::call};
+  toVoidVar = let final self::Tearoffable #t2 = tearoffableArg in #t2 == null ?{() → void} null : #t2.{self::Tearoffable::call}{() → void};
   self::Tearoffable tearoffableVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} self::Tearoffable;
   tearoffableVar = tearoffableArg;
   self::ok::XnonNull xNonNullVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} self::ok::XnonNull;

pkg/front_end/testcases/nnbd/assignability.dart.strong.transformed.expect

@@ -1014,10 +1014,10 @@ static method ok<XnonNull extends core::Object, YnonNull extends self::ok::XnonN
   core::Function functionVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} core::Function;
   functionVar = functionArg;
   functionVar = toVoidArg;
-  functionVar = let final self::Tearoffable #t2 = tearoffableArg in #t2 == null ?{() → void} null : #t2.{self::Tearoffable::call};
+  functionVar = let final self::Tearoffable #t2 = tearoffableArg in #t2 == null ?{() → void} null : #t2.{self::Tearoffable::call}{() → void};
   () → void toVoidVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} () → void;
   toVoidVar = toVoidArg;
-  toVoidVar = let final self::Tearoffable #t3 = tearoffableArg in #t3 == null ?{() → void} null : #t3.{self::Tearoffable::call};
+  toVoidVar = let final self::Tearoffable #t3 = tearoffableArg in #t3 == null ?{() → void} null : #t3.{self::Tearoffable::call}{() → void};
   self::Tearoffable tearoffableVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} self::Tearoffable;
   tearoffableVar = tearoffableArg;
   self::ok::XnonNull xNonNullVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} self::ok::XnonNull;

pkg/front_end/testcases/nnbd/assignability.dart.weak.expect

@@ -1014,10 +1014,10 @@ static method ok<XnonNull extends core::Object, YnonNull extends self::ok::XnonN
   core::Function functionVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} core::Function;
   functionVar = functionArg;
   functionVar = toVoidArg;
-  functionVar = let final self::Tearoffable #t1 = tearoffableArg in #t1 == null ?{() → void} null : #t1.{self::Tearoffable::call};
+  functionVar = let final self::Tearoffable #t1 = tearoffableArg in #t1 == null ?{() → void} null : #t1.{self::Tearoffable::call}{() → void};
   () → void toVoidVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} () → void;
   toVoidVar = toVoidArg;
-  toVoidVar = let final self::Tearoffable #t2 = tearoffableArg in #t2 == null ?{() → void} null : #t2.{self::Tearoffable::call};
+  toVoidVar = let final self::Tearoffable #t2 = tearoffableArg in #t2 == null ?{() → void} null : #t2.{self::Tearoffable::call}{() → void};
   self::Tearoffable tearoffableVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} self::Tearoffable;
   tearoffableVar = tearoffableArg;
   self::ok::XnonNull xNonNullVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} self::ok::XnonNull;

pkg/front_end/testcases/nnbd/assignability.dart.weak.transformed.expect

@@ -1014,10 +1014,10 @@ static method ok<XnonNull extends core::Object, YnonNull extends self::ok::XnonN
   core::Function functionVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} core::Function;
   functionVar = functionArg;
   functionVar = toVoidArg;
-  functionVar = let final self::Tearoffable #t1 = tearoffableArg in #t1 == null ?{() → void} null : #t1.{self::Tearoffable::call};
+  functionVar = let final self::Tearoffable #t1 = tearoffableArg in #t1 == null ?{() → void} null : #t1.{self::Tearoffable::call}{() → void};
   () → void toVoidVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} () → void;
   toVoidVar = toVoidArg;
-  toVoidVar = let final self::Tearoffable #t2 = tearoffableArg in #t2 == null ?{() → void} null : #t2.{self::Tearoffable::call};
+  toVoidVar = let final self::Tearoffable #t2 = tearoffableArg in #t2 == null ?{() → void} null : #t2.{self::Tearoffable::call}{() → void};
   self::Tearoffable tearoffableVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} self::Tearoffable;
   tearoffableVar = tearoffableArg;
   self::ok::XnonNull xNonNullVar = dynamicArg as{TypeError,ForDynamic,ForNonNullableByDefault} self::ok::XnonNull;

pkg/front_end/testcases/nnbd/assignability_error_messages.dart.strong.expect

@@ -333,7 +333,7 @@ Try changing the type of the variable.
 static method baz(self::C c) → void {
   self::bazContext(let final Never #t14 = invalid-expression "pkg/front_end/testcases/nnbd/assignability_error_messages.dart:62:14: Error: The argument type 'num? Function()' can't be assigned to the parameter type 'num Function()' because 'num?' is nullable and 'num' isn't.
   bazContext(c);
-             ^" in (let final self::C #t15 = c in #t15 == null ?{() → core::num?} null : #t15.{self::C::call}) as{TypeError,ForNonNullableByDefault} () → core::num);
+             ^" in (let final self::C #t15 = c in #t15 == null ?{() → core::num?} null : #t15.{self::C::call}{() → core::num?}) as{TypeError,ForNonNullableByDefault} () → core::num);
 }
 static method boz(Null x) → self::A {
   self::fooContext(let final Never #t16 = invalid-expression "pkg/front_end/testcases/nnbd/assignability_error_messages.dart:66:14: Error: The argument type 'Null' can't be assigned to the parameter type 'A' because 'A' is not nullable.

pkg/front_end/testcases/nnbd/assignability_error_messages.dart.strong.transformed.expect

@@ -375,7 +375,7 @@ Try changing the type of the variable.
 static method baz(self::C c) → void {
   self::bazContext(let final Never #t20 = invalid-expression "pkg/front_end/testcases/nnbd/assignability_error_messages.dart:62:14: Error: The argument type 'num? Function()' can't be assigned to the parameter type 'num Function()' because 'num?' is nullable and 'num' isn't.
   bazContext(c);
-             ^" in (let final self::C #t21 = c in #t21 == null ?{() → core::num?} null : #t21.{self::C::call}) as{TypeError,ForNonNullableByDefault} () → core::num);
+             ^" in (let final self::C #t21 = c in #t21 == null ?{() → core::num?} null : #t21.{self::C::call}{() → core::num?}) as{TypeError,ForNonNullableByDefault} () → core::num);
 }
 static method boz(Null x) → self::A {
   self::fooContext(let final Never #t22 = invalid-expression "pkg/front_end/testcases/nnbd/assignability_error_messages.dart:66:14: Error: The argument type 'Null' can't be assigned to the parameter type 'A' because 'A' is not nullable.

pkg/front_end/testcases/nnbd/assignability_error_messages.dart.weak.expect

@@ -333,7 +333,7 @@ Try changing the type of the variable.
 static method baz(self::C c) → void {
   self::bazContext(let final Never #t14 = invalid-expression "pkg/front_end/testcases/nnbd/assignability_error_messages.dart:62:14: Error: The argument type 'num? Function()' can't be assigned to the parameter type 'num Function()' because 'num?' is nullable and 'num' isn't.
   bazContext(c);
-             ^" in (let final self::C #t15 = c in #t15 == null ?{() → core::num?} null : #t15.{self::C::call}) as{TypeError,ForNonNullableByDefault} () → core::num);
+             ^" in (let final self::C #t15 = c in #t15 == null ?{() → core::num?} null : #t15.{self::C::call}{() → core::num?}) as{TypeError,ForNonNullableByDefault} () → core::num);
 }
 static method boz(Null x) → self::A {
   self::fooContext(let final Never #t16 = invalid-expression "pkg/front_end/testcases/nnbd/assignability_error_messages.dart:66:14: Error: The argument type 'Null' can't be assigned to the parameter type 'A' because 'A' is not nullable.

pkg/front_end/testcases/nnbd/assignability_error_messages.dart.weak.transformed.expect

@@ -375,7 +375,7 @@ Try changing the type of the variable.
 static method baz(self::C c) → void {
   self::bazContext(let final Never #t14 = invalid-expression "pkg/front_end/testcases/nnbd/assignability_error_messages.dart:62:14: Error: The argument type 'num? Function()' can't be assigned to the parameter type 'num Function()' because 'num?' is nullable and 'num' isn't.
   bazContext(c);
-             ^" in let final self::C #t15 = c in #t15 == null ?{() → core::num?} null : #t15.{self::C::call});
+             ^" in let final self::C #t15 = c in #t15 == null ?{() → core::num?} null : #t15.{self::C::call}{() → core::num?});
 }
 static method boz(Null x) → self::A {
   self::fooContext(let final Never #t16 = invalid-expression "pkg/front_end/testcases/nnbd/assignability_error_messages.dart:66:14: Error: The argument type 'Null' can't be assigned to the parameter type 'A' because 'A' is not nullable.

pkg/front_end/testcases/nnbd/forin.dart.strong.expect

@@ -63,7 +63,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
  - 'Iterable' is from 'dart:core'.
   [for (int x in i2) x];
                  ^" in i2 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic>)
-      #t2.{core::List::add}(x){(core::int) → void};
+      #t2.{core::List::add}{Invariant}(x){(core::int) → void};
   } =>#t2;
   for (core::int x in let final Never #t4 = invalid-expression "pkg/front_end/testcases/nnbd/forin.dart:12:17: Error: The type 'List<int>?' used in the 'for' loop must implement 'Iterable<dynamic>' because 'List<int>?' is nullable and 'Iterable<dynamic>' isn't.
  - 'List' is from 'dart:core'.
@@ -78,7 +78,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
  - 'Iterable' is from 'dart:core'.
   [for (int x in l2) x];
                  ^" in l2 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic>)
-      #t5.{core::List::add}(x){(core::int) → void};
+      #t5.{core::List::add}{Invariant}(x){(core::int) → void};
   } =>#t5;
   for (final dynamic #t7 in let final Never #t8 = invalid-expression "pkg/front_end/testcases/nnbd/forin.dart:15:17: Error: The type 'Object' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Object' is from 'dart:core'.
@@ -96,7 +96,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
   [for (int x in o1) x];
                  ^" in o1 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic>) {
       core::int x = #t10 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-      #t9.{core::List::add}(x){(core::int) → void};
+      #t9.{core::List::add}{Invariant}(x){(core::int) → void};
     }
   } =>#t9;
   for (final dynamic #t12 in let final Never #t13 = invalid-expression "pkg/front_end/testcases/nnbd/forin.dart:18:17: Error: The type 'Object?' used in the 'for' loop must implement 'Iterable<dynamic>'.
@@ -115,7 +115,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
   [for (int x in o2) x];
                  ^" in o2 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic>) {
       core::int x = #t15 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-      #t14.{core::List::add}(x){(core::int) → void};
+      #t14.{core::List::add}{Invariant}(x){(core::int) → void};
     }
   } =>#t14;
 }
@@ -125,14 +125,14 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
   block {
     final core::List<core::int> #t17 = <core::int>[];
     for (core::int x in i1)
-      #t17.{core::List::add}(x){(core::int) → void};
+      #t17.{core::List::add}{Invariant}(x){(core::int) → void};
   } =>#t17;
   for (core::int x in l1)
     x;
   block {
     final core::List<core::int> #t18 = <core::int>[];
     for (core::int x in l1)
-      #t18.{core::List::add}(x){(core::int) → void};
+      #t18.{core::List::add}{Invariant}(x){(core::int) → void};
   } =>#t18;
   for (final dynamic #t19 in d as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
     core::int x = #t19 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
@@ -142,7 +142,7 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
     final core::List<core::int> #t20 = <core::int>[];
     for (final dynamic #t21 in d as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
       core::int x = #t21 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-      #t20.{core::List::add}(x){(core::int) → void};
+      #t20.{core::List::add}{Invariant}(x){(core::int) → void};
     }
   } =>#t20;
 }

pkg/front_end/testcases/nnbd/forin.dart.strong.transformed.expect

@@ -71,7 +71,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
                  ^" in let core::Iterable<core::int>? #t5 = i2 in #t5 == null ?{core::Iterable<dynamic>} #t5 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic> : #t5{core::Iterable<dynamic>}).{core::Iterable::iterator}{core::Iterator<dynamic>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int x = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t3.{core::List::add}(x){(core::int) → void};
+        #t3.{core::List::add}{Invariant}(x){(core::int) → void};
       }
     }
   } =>#t3;
@@ -96,7 +96,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
                  ^" in let core::List<core::int>? #t10 = l2 in #t10 == null ?{core::Iterable<dynamic>} #t10 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic> : #t10{core::Iterable<dynamic>}).{core::Iterable::iterator}{core::Iterator<dynamic>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int x = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t8.{core::List::add}(x){(core::int) → void};
+        #t8.{core::List::add}{Invariant}(x){(core::int) → void};
       }
     }
   } =>#t8;
@@ -126,7 +126,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
         final dynamic #t15 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           core::int x = #t15 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-          #t13.{core::List::add}(x){(core::int) → void};
+          #t13.{core::List::add}{Invariant}(x){(core::int) → void};
         }
       }
     }
@@ -157,7 +157,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
         final dynamic #t20 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           core::int x = #t20 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-          #t18.{core::List::add}(x){(core::int) → void};
+          #t18.{core::List::add}{Invariant}(x){(core::int) → void};
         }
       }
     }
@@ -177,7 +177,7 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
       core::Iterator<core::int> :sync-for-iterator = i1.{core::Iterable::iterator}{core::Iterator<core::int>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int x = :sync-for-iterator.{core::Iterator::current}{core::int};
-        #t21.{core::List::add}(x){(core::int) → void};
+        #t21.{core::List::add}{Invariant}(x){(core::int) → void};
       }
     }
   } =>#t21;
@@ -194,7 +194,7 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
       core::Iterator<core::int> :sync-for-iterator = l1.{core::Iterable::iterator}{core::Iterator<core::int>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int x = :sync-for-iterator.{core::Iterator::current}{core::int};
-        #t22.{core::List::add}(x){(core::int) → void};
+        #t22.{core::List::add}{Invariant}(x){(core::int) → void};
       }
     }
   } =>#t22;
@@ -216,7 +216,7 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
         final dynamic #t25 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           core::int x = #t25 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-          #t24.{core::List::add}(x){(core::int) → void};
+          #t24.{core::List::add}{Invariant}(x){(core::int) → void};
         }
       }
     }

pkg/front_end/testcases/nnbd/forin.dart.weak.expect

@@ -63,7 +63,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
  - 'Iterable' is from 'dart:core'.
   [for (int x in i2) x];
                  ^" in i2 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic>)
-      #t2.{core::List::add}(x){(core::int) → void};
+      #t2.{core::List::add}{Invariant}(x){(core::int) → void};
   } =>#t2;
   for (core::int x in let final Never #t4 = invalid-expression "pkg/front_end/testcases/nnbd/forin.dart:12:17: Error: The type 'List<int>?' used in the 'for' loop must implement 'Iterable<dynamic>' because 'List<int>?' is nullable and 'Iterable<dynamic>' isn't.
  - 'List' is from 'dart:core'.
@@ -78,7 +78,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
  - 'Iterable' is from 'dart:core'.
   [for (int x in l2) x];
                  ^" in l2 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic>)
-      #t5.{core::List::add}(x){(core::int) → void};
+      #t5.{core::List::add}{Invariant}(x){(core::int) → void};
   } =>#t5;
   for (final dynamic #t7 in let final Never #t8 = invalid-expression "pkg/front_end/testcases/nnbd/forin.dart:15:17: Error: The type 'Object' used in the 'for' loop must implement 'Iterable<dynamic>'.
  - 'Object' is from 'dart:core'.
@@ -96,7 +96,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
   [for (int x in o1) x];
                  ^" in o1 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic>) {
       core::int x = #t10 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-      #t9.{core::List::add}(x){(core::int) → void};
+      #t9.{core::List::add}{Invariant}(x){(core::int) → void};
     }
   } =>#t9;
   for (final dynamic #t12 in let final Never #t13 = invalid-expression "pkg/front_end/testcases/nnbd/forin.dart:18:17: Error: The type 'Object?' used in the 'for' loop must implement 'Iterable<dynamic>'.
@@ -115,7 +115,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
   [for (int x in o2) x];
                  ^" in o2 as{TypeError,ForNonNullableByDefault} core::Iterable<dynamic>) {
       core::int x = #t15 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-      #t14.{core::List::add}(x){(core::int) → void};
+      #t14.{core::List::add}{Invariant}(x){(core::int) → void};
     }
   } =>#t14;
 }
@@ -125,14 +125,14 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
   block {
     final core::List<core::int> #t17 = <core::int>[];
     for (core::int x in i1)
-      #t17.{core::List::add}(x){(core::int) → void};
+      #t17.{core::List::add}{Invariant}(x){(core::int) → void};
   } =>#t17;
   for (core::int x in l1)
     x;
   block {
     final core::List<core::int> #t18 = <core::int>[];
     for (core::int x in l1)
-      #t18.{core::List::add}(x){(core::int) → void};
+      #t18.{core::List::add}{Invariant}(x){(core::int) → void};
   } =>#t18;
   for (final dynamic #t19 in d as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
     core::int x = #t19 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
@@ -142,7 +142,7 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
     final core::List<core::int> #t20 = <core::int>[];
     for (final dynamic #t21 in d as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>) {
       core::int x = #t21 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-      #t20.{core::List::add}(x){(core::int) → void};
+      #t20.{core::List::add}{Invariant}(x){(core::int) → void};
     }
   } =>#t20;
 }

pkg/front_end/testcases/nnbd/forin.dart.weak.transformed.expect

@@ -71,7 +71,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
                  ^" in i2).{core::Iterable::iterator}{core::Iterator<dynamic>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int x = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t2.{core::List::add}(x){(core::int) → void};
+        #t2.{core::List::add}{Invariant}(x){(core::int) → void};
       }
     }
   } =>#t2;
@@ -96,7 +96,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
                  ^" in l2).{core::Iterable::iterator}{core::Iterator<dynamic>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int x = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t5.{core::List::add}(x){(core::int) → void};
+        #t5.{core::List::add}{Invariant}(x){(core::int) → void};
       }
     }
   } =>#t5;
@@ -126,7 +126,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
         final dynamic #t11 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           core::int x = #t11 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-          #t9.{core::List::add}(x){(core::int) → void};
+          #t9.{core::List::add}{Invariant}(x){(core::int) → void};
         }
       }
     }
@@ -157,7 +157,7 @@ static method error(core::Iterable<core::int>? i2, core::List<core::int>? l2, co
         final dynamic #t16 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           core::int x = #t16 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-          #t14.{core::List::add}(x){(core::int) → void};
+          #t14.{core::List::add}{Invariant}(x){(core::int) → void};
         }
       }
     }
@@ -177,7 +177,7 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
       core::Iterator<core::int> :sync-for-iterator = i1.{core::Iterable::iterator}{core::Iterator<core::int>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int x = :sync-for-iterator.{core::Iterator::current}{core::int};
-        #t17.{core::List::add}(x){(core::int) → void};
+        #t17.{core::List::add}{Invariant}(x){(core::int) → void};
       }
     }
   } =>#t17;
@@ -194,7 +194,7 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
       core::Iterator<core::int> :sync-for-iterator = l1.{core::Iterable::iterator}{core::Iterator<core::int>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         core::int x = :sync-for-iterator.{core::Iterator::current}{core::int};
-        #t18.{core::List::add}(x){(core::int) → void};
+        #t18.{core::List::add}{Invariant}(x){(core::int) → void};
       }
     }
   } =>#t18;
@@ -216,7 +216,7 @@ static method ok(core::Iterable<core::int> i1, core::List<core::int> l1, dynamic
         final dynamic #t21 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           core::int x = #t21 as{TypeError,ForDynamic,ForNonNullableByDefault} core::int;
-          #t20.{core::List::add}(x){(core::int) → void};
+          #t20.{core::List::add}{Invariant}(x){(core::int) → void};
         }
       }
     }

pkg/front_end/testcases/nnbd/issue42758.dart.strong.expect

@@ -86,7 +86,7 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t2 = <Never>[];
     final core::Iterable<Never>? #t3 = n1;
     if(!(#t3 == null))
-      #t2.{core::List::addAll}(#t3{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t2.{core::List::addAll}{Invariant}(#t3{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t2;
   core::List<dynamic> l3 = <dynamic>[invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:8:16: Error: Can't spread a value with static type 'Never?'.
   var l3 = [...n2];
@@ -95,7 +95,7 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t4 = <Never>[];
     final core::Iterable<Never>? #t5 = n2;
     if(!(#t5 == null))
-      #t4.{core::List::addAll}(#t5{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t4.{core::List::addAll}{Invariant}(#t5{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t4;
   core::List<dynamic> l5 = <dynamic>[invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:10:16: Error: Can't spread a value with static type 'Null'.
   var l5 = [...n3];
@@ -104,60 +104,60 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t6 = <Never>[];
     final core::Iterable<Never>? #t7 = n3;
     if(!(#t7 == null))
-      #t6.{core::List::addAll}(#t7{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t6.{core::List::addAll}{Invariant}(#t7{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t6;
   core::Set<Never> s1 = block {
     final core::Set<Never> #t8 = col::LinkedHashSet::of<Never>(n1);
-    #t8.{core::Set::add}(n1){(Never) → core::bool};
+    #t8.{core::Set::add}{Invariant}(n1){(Never) → core::bool};
   } =>#t8;
   core::Set<Never> s2 = block {
     final core::Set<Never> #t9 = col::LinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t10 = n1;
     if(!(#t10 == null))
-      #t9.{core::Set::addAll}(#t10{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t9.{core::Set::add}(n1){(Never) → core::bool};
+      #t9.{core::Set::addAll}{Invariant}(#t10{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t9.{core::Set::add}{Invariant}(n1){(Never) → core::bool};
   } =>#t9;
   core::Set<dynamic> s3 = block {
     final core::Set<dynamic> #t11 = col::LinkedHashSet::•<dynamic>();
-    #t11.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:14:16: Error: Can't spread a value with static type 'Never?'.
+    #t11.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:14:16: Error: Can't spread a value with static type 'Never?'.
   var s3 = {...n2, n1};
                ^"){(dynamic) → core::bool};
-    #t11.{core::Set::add}(n1){(dynamic) → core::bool};
+    #t11.{core::Set::add}{Invariant}(n1){(dynamic) → core::bool};
   } =>#t11;
   core::Set<Never> s4 = block {
     final core::Set<Never> #t12 = col::LinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t13 = n2;
     if(!(#t13 == null))
-      #t12.{core::Set::addAll}(#t13{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t12.{core::Set::add}(n1){(Never) → core::bool};
+      #t12.{core::Set::addAll}{Invariant}(#t13{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t12.{core::Set::add}{Invariant}(n1){(Never) → core::bool};
   } =>#t12;
   core::Set<dynamic> s5 = block {
     final core::Set<dynamic> #t14 = col::LinkedHashSet::•<dynamic>();
-    #t14.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:16:16: Error: Can't spread a value with static type 'Null'.
+    #t14.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:16:16: Error: Can't spread a value with static type 'Null'.
   var s5 = {...n3, n1};
                ^"){(dynamic) → core::bool};
-    #t14.{core::Set::add}(n1){(dynamic) → core::bool};
+    #t14.{core::Set::add}{Invariant}(n1){(dynamic) → core::bool};
   } =>#t14;
   core::Set<Never> s6 = block {
     final core::Set<Never> #t15 = col::LinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t16 = n3;
     if(!(#t16 == null))
-      #t15.{core::Set::addAll}(#t16{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t15.{core::Set::add}(n1){(Never) → core::bool};
+      #t15.{core::Set::addAll}{Invariant}(#t16{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t15.{core::Set::add}{Invariant}(n1){(Never) → core::bool};
   } =>#t15;
   core::Map<Never, Never> m1 = block {
     final core::Map<Never, Never> #t17 = <Never, Never>{};
     for (final core::MapEntry<Never, Never> #t18 in n1.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>})
-      #t17.{core::Map::[]=}(#t18.{core::MapEntry::key}{Never}, #t18.{core::MapEntry::value}{Never}){(Never, Never) → void};
-    #t17.{core::Map::[]=}(n1, n1){(Never, Never) → void};
+      #t17.{core::Map::[]=}{Invariant}(#t18.{core::MapEntry::key}{Never}, #t18.{core::MapEntry::value}{Never}){(Never, Never) → void};
+    #t17.{core::Map::[]=}{Invariant}(n1, n1){(Never, Never) → void};
   } =>#t17;
   core::Map<Never, Never> m2 = block {
     final core::Map<Never, Never> #t19 = <Never, Never>{};
     final core::Map<Never, Never>? #t20 = n1;
     if(!(#t20 == null))
       for (final core::MapEntry<Never, Never> #t21 in #t20{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>})
-        #t19.{core::Map::[]=}(#t21.{core::MapEntry::key}{Never}, #t21.{core::MapEntry::value}{Never}){(Never, Never) → void};
-    #t19.{core::Map::[]=}(n1, n1){(Never, Never) → void};
+        #t19.{core::Map::[]=}{Invariant}(#t21.{core::MapEntry::key}{Never}, #t21.{core::MapEntry::value}{Never}){(Never, Never) → void};
+    #t19.{core::Map::[]=}{Invariant}(n1, n1){(Never, Never) → void};
   } =>#t19;
   core::Map<dynamic, dynamic> m3 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:20:16: Error: Can't spread a value with static type 'Never?'.
   var m3 = {...n2, n1: n1};
@@ -167,8 +167,8 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::Map<Never, Never>? #t23 = n2;
     if(!(#t23 == null))
       for (final core::MapEntry<Never, Never> #t24 in #t23{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>})
-        #t22.{core::Map::[]=}(#t24.{core::MapEntry::key}{Never}, #t24.{core::MapEntry::value}{Never}){(Never, Never) → void};
-    #t22.{core::Map::[]=}(n1, n1){(Never, Never) → void};
+        #t22.{core::Map::[]=}{Invariant}(#t24.{core::MapEntry::key}{Never}, #t24.{core::MapEntry::value}{Never}){(Never, Never) → void};
+    #t22.{core::Map::[]=}{Invariant}(n1, n1){(Never, Never) → void};
   } =>#t22;
   core::Map<dynamic, dynamic> m5 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:22:16: Error: Can't spread a value with static type 'Null'.
   var m5 = {...n3, n1: n1};
@@ -178,8 +178,8 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::Map<Never, Never>? #t26 = n3;
     if(!(#t26 == null))
       for (final core::MapEntry<Never, Never> #t27 in #t26{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>})
-        #t25.{core::Map::[]=}(#t27.{core::MapEntry::key}{Never}, #t27.{core::MapEntry::value}{Never}){(Never, Never) → void};
-    #t25.{core::Map::[]=}(n1, n1){(Never, Never) → void};
+        #t25.{core::Map::[]=}{Invariant}(#t27.{core::MapEntry::key}{Never}, #t27.{core::MapEntry::value}{Never}){(Never, Never) → void};
+    #t25.{core::Map::[]=}{Invariant}(n1, n1){(Never, Never) → void};
   } =>#t25;
 }
 static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::test2::N1 n1, self::test2::N2% n2, self::test2::N3% n3) → dynamic {
@@ -190,7 +190,7 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t29 = <Never>[];
     final core::Iterable<Never>? #t30 = n1;
     if(!(#t30 == null))
-      #t29.{core::List::addAll}(#t30{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t29.{core::List::addAll}{Invariant}(#t30{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t29;
   core::List<dynamic> l3 = <dynamic>[invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:30:16: Error: Can't spread a value with static type 'N2'.
   var l3 = [...n2];
@@ -199,7 +199,7 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t31 = <Never>[];
     final core::Iterable<Never>? #t32 = n2;
     if(!(#t32 == null))
-      #t31.{core::List::addAll}(#t32{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t31.{core::List::addAll}{Invariant}(#t32{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t31;
   core::List<dynamic> l5 = <dynamic>[invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:32:16: Error: Can't spread a value with static type 'N3'.
   var l5 = [...n3];
@@ -208,60 +208,60 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t33 = <Never>[];
     final core::Iterable<Never>? #t34 = n3;
     if(!(#t34 == null))
-      #t33.{core::List::addAll}(#t34{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t33.{core::List::addAll}{Invariant}(#t34{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t33;
   core::Set<self::test2::N1> s1 = block {
     final core::Set<self::test2::N1> #t35 = col::LinkedHashSet::of<self::test2::N1>(n1);
-    #t35.{core::Set::add}(n1){(self::test2::N1) → core::bool};
+    #t35.{core::Set::add}{Invariant}(n1){(self::test2::N1) → core::bool};
   } =>#t35;
   core::Set<self::test2::N1> s2 = block {
     final core::Set<self::test2::N1> #t36 = col::LinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t37 = n1;
     if(!(#t37 == null))
-      #t36.{core::Set::addAll}(#t37{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t36.{core::Set::add}(n1){(self::test2::N1) → core::bool};
+      #t36.{core::Set::addAll}{Invariant}(#t37{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t36.{core::Set::add}{Invariant}(n1){(self::test2::N1) → core::bool};
   } =>#t36;
   core::Set<dynamic> s3 = block {
     final core::Set<dynamic> #t38 = col::LinkedHashSet::•<dynamic>();
-    #t38.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:36:16: Error: Can't spread a value with static type 'N2'.
+    #t38.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:36:16: Error: Can't spread a value with static type 'N2'.
   var s3 = {...n2, n1};
                ^"){(dynamic) → core::bool};
-    #t38.{core::Set::add}(n1){(dynamic) → core::bool};
+    #t38.{core::Set::add}{Invariant}(n1){(dynamic) → core::bool};
   } =>#t38;
   core::Set<self::test2::N1> s4 = block {
     final core::Set<self::test2::N1> #t39 = col::LinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t40 = n2;
     if(!(#t40 == null))
-      #t39.{core::Set::addAll}(#t40{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t39.{core::Set::add}(n1){(self::test2::N1) → core::bool};
+      #t39.{core::Set::addAll}{Invariant}(#t40{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t39.{core::Set::add}{Invariant}(n1){(self::test2::N1) → core::bool};
   } =>#t39;
   core::Set<dynamic> s5 = block {
     final core::Set<dynamic> #t41 = col::LinkedHashSet::•<dynamic>();
-    #t41.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:38:16: Error: Can't spread a value with static type 'N3'.
+    #t41.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:38:16: Error: Can't spread a value with static type 'N3'.
   var s5 = {...n3, n1};
                ^"){(dynamic) → core::bool};
-    #t41.{core::Set::add}(n1){(dynamic) → core::bool};
+    #t41.{core::Set::add}{Invariant}(n1){(dynamic) → core::bool};
   } =>#t41;
   core::Set<self::test2::N1> s6 = block {
     final core::Set<self::test2::N1> #t42 = col::LinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t43 = n3;
     if(!(#t43 == null))
-      #t42.{core::Set::addAll}(#t43{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t42.{core::Set::add}(n1){(self::test2::N1) → core::bool};
+      #t42.{core::Set::addAll}{Invariant}(#t43{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t42.{core::Set::add}{Invariant}(n1){(self::test2::N1) → core::bool};
   } =>#t42;
   core::Map<self::test2::N1, self::test2::N1> m1 = block {
     final core::Map<self::test2::N1, self::test2::N1> #t44 = <self::test2::N1, self::test2::N1>{};
     for (final core::MapEntry<self::test2::N1, self::test2::N1> #t45 in n1.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>})
-      #t44.{core::Map::[]=}(#t45.{core::MapEntry::key}{self::test2::N1}, #t45.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
-    #t44.{core::Map::[]=}(n1, n1){(self::test2::N1, self::test2::N1) → void};
+      #t44.{core::Map::[]=}{Invariant}(#t45.{core::MapEntry::key}{self::test2::N1}, #t45.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+    #t44.{core::Map::[]=}{Invariant}(n1, n1){(self::test2::N1, self::test2::N1) → void};
   } =>#t44;
   core::Map<self::test2::N1, self::test2::N1> m2 = block {
     final core::Map<self::test2::N1, self::test2::N1> #t46 = <self::test2::N1, self::test2::N1>{};
     final core::Map<self::test2::N1, self::test2::N1>? #t47 = n1;
     if(!(#t47 == null))
       for (final core::MapEntry<self::test2::N1, self::test2::N1> #t48 in #t47{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>})
-        #t46.{core::Map::[]=}(#t48.{core::MapEntry::key}{self::test2::N1}, #t48.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
-    #t46.{core::Map::[]=}(n1, n1){(self::test2::N1, self::test2::N1) → void};
+        #t46.{core::Map::[]=}{Invariant}(#t48.{core::MapEntry::key}{self::test2::N1}, #t48.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+    #t46.{core::Map::[]=}{Invariant}(n1, n1){(self::test2::N1, self::test2::N1) → void};
   } =>#t46;
   core::Map<dynamic, dynamic> m3 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:42:16: Error: Can't spread a value with static type 'N2'.
   var m3 = {...n2, n1: n1};
@@ -271,8 +271,8 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::Map<self::test2::N1, self::test2::N1>? #t50 = n2;
     if(!(#t50 == null))
       for (final core::MapEntry<self::test2::N1, self::test2::N1> #t51 in #t50{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>})
-        #t49.{core::Map::[]=}(#t51.{core::MapEntry::key}{self::test2::N1}, #t51.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
-    #t49.{core::Map::[]=}(n1, n1){(self::test2::N1, self::test2::N1) → void};
+        #t49.{core::Map::[]=}{Invariant}(#t51.{core::MapEntry::key}{self::test2::N1}, #t51.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+    #t49.{core::Map::[]=}{Invariant}(n1, n1){(self::test2::N1, self::test2::N1) → void};
   } =>#t49;
   core::Map<dynamic, dynamic> m5 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:44:16: Error: Can't spread a value with static type 'N3'.
   var m5 = {...n3, n1: n1};
@@ -282,8 +282,8 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::Map<self::test2::N1, self::test2::N1>? #t53 = n3;
     if(!(#t53 == null))
       for (final core::MapEntry<self::test2::N1, self::test2::N1> #t54 in #t53{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>})
-        #t52.{core::Map::[]=}(#t54.{core::MapEntry::key}{self::test2::N1}, #t54.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
-    #t52.{core::Map::[]=}(n1, n1){(self::test2::N1, self::test2::N1) → void};
+        #t52.{core::Map::[]=}{Invariant}(#t54.{core::MapEntry::key}{self::test2::N1}, #t54.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+    #t52.{core::Map::[]=}{Invariant}(n1, n1){(self::test2::N1, self::test2::N1) → void};
   } =>#t52;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/nnbd/issue42758.dart.strong.transformed.expect

@@ -86,7 +86,7 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t2 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t3 = n1;
     if(!(#t3 == null))
-      #t2.{core::List::addAll}(#t3{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t2.{core::List::addAll}{Invariant}(#t3{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t2;
   core::List<dynamic> l3 = core::_GrowableList::_literal1<dynamic>(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:8:16: Error: Can't spread a value with static type 'Never?'.
   var l3 = [...n2];
@@ -95,7 +95,7 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t4 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t5 = n2;
     if(!(#t5 == null))
-      #t4.{core::List::addAll}(#t5{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t4.{core::List::addAll}{Invariant}(#t5{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t4;
   core::List<dynamic> l5 = core::_GrowableList::_literal1<dynamic>(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:10:16: Error: Can't spread a value with static type 'Null'.
   var l5 = [...n3];
@@ -104,46 +104,46 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t6 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t7 = n3;
     if(!(#t7 == null))
-      #t6.{core::List::addAll}(#t7{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t6.{core::List::addAll}{Invariant}(#t7{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t6;
   core::Set<Never> s1 = block {
     final core::Set<Never> #t8 = col::LinkedHashSet::of<Never>(n1);
-    #t8.{core::Set::add}(n1){(Never) → core::bool};
+    #t8.{core::Set::add}{Invariant}(n1){(Never) → core::bool};
   } =>#t8;
   core::Set<Never> s2 = block {
     final core::Set<Never> #t9 = new col::_CompactLinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t10 = n1;
     if(!(#t10 == null))
-      #t9.{core::Set::addAll}(#t10{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t9.{core::Set::add}(n1){(Never) → core::bool};
+      #t9.{core::Set::addAll}{Invariant}(#t10{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t9.{core::Set::add}{Invariant}(n1){(Never) → core::bool};
   } =>#t9;
   core::Set<dynamic> s3 = block {
     final core::Set<dynamic> #t11 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t11.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:14:16: Error: Can't spread a value with static type 'Never?'.
+    #t11.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:14:16: Error: Can't spread a value with static type 'Never?'.
   var s3 = {...n2, n1};
                ^"){(dynamic) → core::bool};
-    #t11.{core::Set::add}(n1){(dynamic) → core::bool};
+    #t11.{core::Set::add}{Invariant}(n1){(dynamic) → core::bool};
   } =>#t11;
   core::Set<Never> s4 = block {
     final core::Set<Never> #t12 = new col::_CompactLinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t13 = n2;
     if(!(#t13 == null))
-      #t12.{core::Set::addAll}(#t13{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t12.{core::Set::add}(n1){(Never) → core::bool};
+      #t12.{core::Set::addAll}{Invariant}(#t13{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t12.{core::Set::add}{Invariant}(n1){(Never) → core::bool};
   } =>#t12;
   core::Set<dynamic> s5 = block {
     final core::Set<dynamic> #t14 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t14.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:16:16: Error: Can't spread a value with static type 'Null'.
+    #t14.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:16:16: Error: Can't spread a value with static type 'Null'.
   var s5 = {...n3, n1};
                ^"){(dynamic) → core::bool};
-    #t14.{core::Set::add}(n1){(dynamic) → core::bool};
+    #t14.{core::Set::add}{Invariant}(n1){(dynamic) → core::bool};
   } =>#t14;
   core::Set<Never> s6 = block {
     final core::Set<Never> #t15 = new col::_CompactLinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t16 = n3;
     if(!(#t16 == null))
-      #t15.{core::Set::addAll}(#t16{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t15.{core::Set::add}(n1){(Never) → core::bool};
+      #t15.{core::Set::addAll}{Invariant}(#t16{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t15.{core::Set::add}{Invariant}(n1){(Never) → core::bool};
   } =>#t15;
   core::Map<Never, Never> m1 = block {
     final core::Map<Never, Never> #t17 = <Never, Never>{};
@@ -151,10 +151,10 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
       core::Iterator<core::MapEntry<Never, Never>> :sync-for-iterator = n1.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<Never, Never>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<Never, Never> #t18 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<Never, Never>};
-        #t17.{core::Map::[]=}(#t18.{core::MapEntry::key}{Never}, #t18.{core::MapEntry::value}{Never}){(Never, Never) → void};
+        #t17.{core::Map::[]=}{Invariant}(#t18.{core::MapEntry::key}{Never}, #t18.{core::MapEntry::value}{Never}){(Never, Never) → void};
       }
     }
-    #t17.{core::Map::[]=}(n1, n1){(Never, Never) → void};
+    #t17.{core::Map::[]=}{Invariant}(n1, n1){(Never, Never) → void};
   } =>#t17;
   core::Map<Never, Never> m2 = block {
     final core::Map<Never, Never> #t19 = <Never, Never>{};
@@ -163,10 +163,10 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
       core::Iterator<core::MapEntry<Never, Never>> :sync-for-iterator = #t20{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<Never, Never>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<Never, Never> #t21 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<Never, Never>};
-        #t19.{core::Map::[]=}(#t21.{core::MapEntry::key}{Never}, #t21.{core::MapEntry::value}{Never}){(Never, Never) → void};
+        #t19.{core::Map::[]=}{Invariant}(#t21.{core::MapEntry::key}{Never}, #t21.{core::MapEntry::value}{Never}){(Never, Never) → void};
       }
     }
-    #t19.{core::Map::[]=}(n1, n1){(Never, Never) → void};
+    #t19.{core::Map::[]=}{Invariant}(n1, n1){(Never, Never) → void};
   } =>#t19;
   core::Map<dynamic, dynamic> m3 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:20:16: Error: Can't spread a value with static type 'Never?'.
   var m3 = {...n2, n1: n1};
@@ -178,10 +178,10 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
       core::Iterator<core::MapEntry<Never, Never>> :sync-for-iterator = #t23{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<Never, Never>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<Never, Never> #t24 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<Never, Never>};
-        #t22.{core::Map::[]=}(#t24.{core::MapEntry::key}{Never}, #t24.{core::MapEntry::value}{Never}){(Never, Never) → void};
+        #t22.{core::Map::[]=}{Invariant}(#t24.{core::MapEntry::key}{Never}, #t24.{core::MapEntry::value}{Never}){(Never, Never) → void};
       }
     }
-    #t22.{core::Map::[]=}(n1, n1){(Never, Never) → void};
+    #t22.{core::Map::[]=}{Invariant}(n1, n1){(Never, Never) → void};
   } =>#t22;
   core::Map<dynamic, dynamic> m5 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:22:16: Error: Can't spread a value with static type 'Null'.
   var m5 = {...n3, n1: n1};
@@ -193,10 +193,10 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
       core::Iterator<core::MapEntry<Never, Never>> :sync-for-iterator = #t26{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<Never, Never>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<Never, Never> #t27 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<Never, Never>};
-        #t25.{core::Map::[]=}(#t27.{core::MapEntry::key}{Never}, #t27.{core::MapEntry::value}{Never}){(Never, Never) → void};
+        #t25.{core::Map::[]=}{Invariant}(#t27.{core::MapEntry::key}{Never}, #t27.{core::MapEntry::value}{Never}){(Never, Never) → void};
       }
     }
-    #t25.{core::Map::[]=}(n1, n1){(Never, Never) → void};
+    #t25.{core::Map::[]=}{Invariant}(n1, n1){(Never, Never) → void};
   } =>#t25;
 }
 static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::test2::N1 n1, self::test2::N2% n2, self::test2::N3% n3) → dynamic {
@@ -207,7 +207,7 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t29 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t30 = n1;
     if(!(#t30 == null))
-      #t29.{core::List::addAll}(#t30{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t29.{core::List::addAll}{Invariant}(#t30{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t29;
   core::List<dynamic> l3 = core::_GrowableList::_literal1<dynamic>(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:30:16: Error: Can't spread a value with static type 'N2'.
   var l3 = [...n2];
@@ -216,7 +216,7 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t31 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t32 = n2;
     if(!(#t32 == null))
-      #t31.{core::List::addAll}(#t32{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t31.{core::List::addAll}{Invariant}(#t32{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t31;
   core::List<dynamic> l5 = core::_GrowableList::_literal1<dynamic>(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:32:16: Error: Can't spread a value with static type 'N3'.
   var l5 = [...n3];
@@ -225,46 +225,46 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t33 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t34 = n3;
     if(!(#t34 == null))
-      #t33.{core::List::addAll}(#t34{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t33.{core::List::addAll}{Invariant}(#t34{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t33;
   core::Set<self::test2::N1> s1 = block {
     final core::Set<self::test2::N1> #t35 = col::LinkedHashSet::of<self::test2::N1>(n1);
-    #t35.{core::Set::add}(n1){(self::test2::N1) → core::bool};
+    #t35.{core::Set::add}{Invariant}(n1){(self::test2::N1) → core::bool};
   } =>#t35;
   core::Set<self::test2::N1> s2 = block {
     final core::Set<self::test2::N1> #t36 = new col::_CompactLinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t37 = n1;
     if(!(#t37 == null))
-      #t36.{core::Set::addAll}(#t37{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t36.{core::Set::add}(n1){(self::test2::N1) → core::bool};
+      #t36.{core::Set::addAll}{Invariant}(#t37{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t36.{core::Set::add}{Invariant}(n1){(self::test2::N1) → core::bool};
   } =>#t36;
   core::Set<dynamic> s3 = block {
     final core::Set<dynamic> #t38 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t38.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:36:16: Error: Can't spread a value with static type 'N2'.
+    #t38.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:36:16: Error: Can't spread a value with static type 'N2'.
   var s3 = {...n2, n1};
                ^"){(dynamic) → core::bool};
-    #t38.{core::Set::add}(n1){(dynamic) → core::bool};
+    #t38.{core::Set::add}{Invariant}(n1){(dynamic) → core::bool};
   } =>#t38;
   core::Set<self::test2::N1> s4 = block {
     final core::Set<self::test2::N1> #t39 = new col::_CompactLinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t40 = n2;
     if(!(#t40 == null))
-      #t39.{core::Set::addAll}(#t40{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t39.{core::Set::add}(n1){(self::test2::N1) → core::bool};
+      #t39.{core::Set::addAll}{Invariant}(#t40{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t39.{core::Set::add}{Invariant}(n1){(self::test2::N1) → core::bool};
   } =>#t39;
   core::Set<dynamic> s5 = block {
     final core::Set<dynamic> #t41 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t41.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:38:16: Error: Can't spread a value with static type 'N3'.
+    #t41.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:38:16: Error: Can't spread a value with static type 'N3'.
   var s5 = {...n3, n1};
                ^"){(dynamic) → core::bool};
-    #t41.{core::Set::add}(n1){(dynamic) → core::bool};
+    #t41.{core::Set::add}{Invariant}(n1){(dynamic) → core::bool};
   } =>#t41;
   core::Set<self::test2::N1> s6 = block {
     final core::Set<self::test2::N1> #t42 = new col::_CompactLinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t43 = n3;
     if(!(#t43 == null))
-      #t42.{core::Set::addAll}(#t43{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t42.{core::Set::add}(n1){(self::test2::N1) → core::bool};
+      #t42.{core::Set::addAll}{Invariant}(#t43{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t42.{core::Set::add}{Invariant}(n1){(self::test2::N1) → core::bool};
   } =>#t42;
   core::Map<self::test2::N1, self::test2::N1> m1 = block {
     final core::Map<self::test2::N1, self::test2::N1> #t44 = <self::test2::N1, self::test2::N1>{};
@@ -272,10 +272,10 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
       core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>> :sync-for-iterator = n1.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<self::test2::N1, self::test2::N1> #t45 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<self::test2::N1, self::test2::N1>};
-        #t44.{core::Map::[]=}(#t45.{core::MapEntry::key}{self::test2::N1}, #t45.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+        #t44.{core::Map::[]=}{Invariant}(#t45.{core::MapEntry::key}{self::test2::N1}, #t45.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
       }
     }
-    #t44.{core::Map::[]=}(n1, n1){(self::test2::N1, self::test2::N1) → void};
+    #t44.{core::Map::[]=}{Invariant}(n1, n1){(self::test2::N1, self::test2::N1) → void};
   } =>#t44;
   core::Map<self::test2::N1, self::test2::N1> m2 = block {
     final core::Map<self::test2::N1, self::test2::N1> #t46 = <self::test2::N1, self::test2::N1>{};
@@ -284,10 +284,10 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
       core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>> :sync-for-iterator = #t47{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<self::test2::N1, self::test2::N1> #t48 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<self::test2::N1, self::test2::N1>};
-        #t46.{core::Map::[]=}(#t48.{core::MapEntry::key}{self::test2::N1}, #t48.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+        #t46.{core::Map::[]=}{Invariant}(#t48.{core::MapEntry::key}{self::test2::N1}, #t48.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
       }
     }
-    #t46.{core::Map::[]=}(n1, n1){(self::test2::N1, self::test2::N1) → void};
+    #t46.{core::Map::[]=}{Invariant}(n1, n1){(self::test2::N1, self::test2::N1) → void};
   } =>#t46;
   core::Map<dynamic, dynamic> m3 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:42:16: Error: Can't spread a value with static type 'N2'.
   var m3 = {...n2, n1: n1};
@@ -299,10 +299,10 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
       core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>> :sync-for-iterator = #t50{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<self::test2::N1, self::test2::N1> #t51 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<self::test2::N1, self::test2::N1>};
-        #t49.{core::Map::[]=}(#t51.{core::MapEntry::key}{self::test2::N1}, #t51.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+        #t49.{core::Map::[]=}{Invariant}(#t51.{core::MapEntry::key}{self::test2::N1}, #t51.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
       }
     }
-    #t49.{core::Map::[]=}(n1, n1){(self::test2::N1, self::test2::N1) → void};
+    #t49.{core::Map::[]=}{Invariant}(n1, n1){(self::test2::N1, self::test2::N1) → void};
   } =>#t49;
   core::Map<dynamic, dynamic> m5 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:44:16: Error: Can't spread a value with static type 'N3'.
   var m5 = {...n3, n1: n1};
@@ -314,10 +314,10 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
       core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>> :sync-for-iterator = #t53{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<self::test2::N1, self::test2::N1> #t54 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<self::test2::N1, self::test2::N1>};
-        #t52.{core::Map::[]=}(#t54.{core::MapEntry::key}{self::test2::N1}, #t54.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+        #t52.{core::Map::[]=}{Invariant}(#t54.{core::MapEntry::key}{self::test2::N1}, #t54.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
       }
     }
-    #t52.{core::Map::[]=}(n1, n1){(self::test2::N1, self::test2::N1) → void};
+    #t52.{core::Map::[]=}{Invariant}(n1, n1){(self::test2::N1, self::test2::N1) → void};
   } =>#t52;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/nnbd/issue42758.dart.weak.expect

@@ -87,7 +87,7 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t3 = <Never>[];
     final core::Iterable<Never>? #t4 = let final Never #t5 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t4 == null))
-      #t3.{core::List::addAll}(#t4{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t3.{core::List::addAll}{Invariant}(#t4{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t3;
   core::List<dynamic> l3 = <dynamic>[invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:8:16: Error: Can't spread a value with static type 'Never?'.
   var l3 = [...n2];
@@ -96,7 +96,7 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t6 = <Never>[];
     final core::Iterable<Never>? #t7 = n2;
     if(!(#t7 == null))
-      #t6.{core::List::addAll}(#t7{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t6.{core::List::addAll}{Invariant}(#t7{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t6;
   core::List<dynamic> l5 = <dynamic>[invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:10:16: Error: Can't spread a value with static type 'Null'.
   var l5 = [...n3];
@@ -105,60 +105,60 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t8 = <Never>[];
     final core::Iterable<Never>? #t9 = n3;
     if(!(#t9 == null))
-      #t8.{core::List::addAll}(#t9{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t8.{core::List::addAll}{Invariant}(#t9{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t8;
   core::Set<Never> s1 = block {
     final core::Set<Never> #t10 = col::LinkedHashSet::of<Never>(let final Never #t11 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."));
-    #t10.{core::Set::add}(let final Never #t12 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
+    #t10.{core::Set::add}{Invariant}(let final Never #t12 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
   } =>#t10;
   core::Set<Never> s2 = block {
     final core::Set<Never> #t13 = col::LinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t14 = let final Never #t15 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t14 == null))
-      #t13.{core::Set::addAll}(#t14{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t13.{core::Set::add}(let final Never #t16 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
+      #t13.{core::Set::addAll}{Invariant}(#t14{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t13.{core::Set::add}{Invariant}(let final Never #t16 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
   } =>#t13;
   core::Set<dynamic> s3 = block {
     final core::Set<dynamic> #t17 = col::LinkedHashSet::•<dynamic>();
-    #t17.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:14:16: Error: Can't spread a value with static type 'Never?'.
+    #t17.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:14:16: Error: Can't spread a value with static type 'Never?'.
   var s3 = {...n2, n1};
                ^"){(dynamic) → core::bool};
-    #t17.{core::Set::add}(let final Never #t18 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
+    #t17.{core::Set::add}{Invariant}(let final Never #t18 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
   } =>#t17;
   core::Set<Never> s4 = block {
     final core::Set<Never> #t19 = col::LinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t20 = n2;
     if(!(#t20 == null))
-      #t19.{core::Set::addAll}(#t20{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t19.{core::Set::add}(let final Never #t21 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
+      #t19.{core::Set::addAll}{Invariant}(#t20{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t19.{core::Set::add}{Invariant}(let final Never #t21 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
   } =>#t19;
   core::Set<dynamic> s5 = block {
     final core::Set<dynamic> #t22 = col::LinkedHashSet::•<dynamic>();
-    #t22.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:16:16: Error: Can't spread a value with static type 'Null'.
+    #t22.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:16:16: Error: Can't spread a value with static type 'Null'.
   var s5 = {...n3, n1};
                ^"){(dynamic) → core::bool};
-    #t22.{core::Set::add}(let final Never #t23 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
+    #t22.{core::Set::add}{Invariant}(let final Never #t23 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
   } =>#t22;
   core::Set<Never> s6 = block {
     final core::Set<Never> #t24 = col::LinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t25 = n3;
     if(!(#t25 == null))
-      #t24.{core::Set::addAll}(#t25{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t24.{core::Set::add}(let final Never #t26 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
+      #t24.{core::Set::addAll}{Invariant}(#t25{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t24.{core::Set::add}{Invariant}(let final Never #t26 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
   } =>#t24;
   core::Map<Never, Never> m1 = block {
     final core::Map<Never, Never> #t27 = <Never, Never>{};
     for (final core::MapEntry<Never, Never> #t28 in (let final Never #t29 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")).{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>})
-      #t27.{core::Map::[]=}(#t28.{core::MapEntry::key}{Never}, #t28.{core::MapEntry::value}{Never}){(Never, Never) → void};
-    #t27.{core::Map::[]=}(let final Never #t30 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t31 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
+      #t27.{core::Map::[]=}{Invariant}(#t28.{core::MapEntry::key}{Never}, #t28.{core::MapEntry::value}{Never}){(Never, Never) → void};
+    #t27.{core::Map::[]=}{Invariant}(let final Never #t30 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t31 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
   } =>#t27;
   core::Map<Never, Never> m2 = block {
     final core::Map<Never, Never> #t32 = <Never, Never>{};
     final core::Map<Never, Never>? #t33 = let final Never #t34 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t33 == null))
       for (final core::MapEntry<Never, Never> #t35 in #t33{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>})
-        #t32.{core::Map::[]=}(#t35.{core::MapEntry::key}{Never}, #t35.{core::MapEntry::value}{Never}){(Never, Never) → void};
-    #t32.{core::Map::[]=}(let final Never #t36 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t37 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
+        #t32.{core::Map::[]=}{Invariant}(#t35.{core::MapEntry::key}{Never}, #t35.{core::MapEntry::value}{Never}){(Never, Never) → void};
+    #t32.{core::Map::[]=}{Invariant}(let final Never #t36 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t37 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
   } =>#t32;
   core::Map<dynamic, dynamic> m3 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:20:16: Error: Can't spread a value with static type 'Never?'.
   var m3 = {...n2, n1: n1};
@@ -168,8 +168,8 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::Map<Never, Never>? #t41 = n2;
     if(!(#t41 == null))
       for (final core::MapEntry<Never, Never> #t42 in #t41{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>})
-        #t40.{core::Map::[]=}(#t42.{core::MapEntry::key}{Never}, #t42.{core::MapEntry::value}{Never}){(Never, Never) → void};
-    #t40.{core::Map::[]=}(let final Never #t43 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t44 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
+        #t40.{core::Map::[]=}{Invariant}(#t42.{core::MapEntry::key}{Never}, #t42.{core::MapEntry::value}{Never}){(Never, Never) → void};
+    #t40.{core::Map::[]=}{Invariant}(let final Never #t43 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t44 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
   } =>#t40;
   core::Map<dynamic, dynamic> m5 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:22:16: Error: Can't spread a value with static type 'Null'.
   var m5 = {...n3, n1: n1};
@@ -179,8 +179,8 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::Map<Never, Never>? #t48 = n3;
     if(!(#t48 == null))
       for (final core::MapEntry<Never, Never> #t49 in #t48{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>})
-        #t47.{core::Map::[]=}(#t49.{core::MapEntry::key}{Never}, #t49.{core::MapEntry::value}{Never}){(Never, Never) → void};
-    #t47.{core::Map::[]=}(let final Never #t50 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t51 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
+        #t47.{core::Map::[]=}{Invariant}(#t49.{core::MapEntry::key}{Never}, #t49.{core::MapEntry::value}{Never}){(Never, Never) → void};
+    #t47.{core::Map::[]=}{Invariant}(let final Never #t50 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t51 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
   } =>#t47;
 }
 static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::test2::N1 n1, self::test2::N2% n2, self::test2::N3% n3) → dynamic {
@@ -191,7 +191,7 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t54 = <Never>[];
     final core::Iterable<Never>? #t55 = let final self::test2::N1 #t56 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t55 == null))
-      #t54.{core::List::addAll}(#t55{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t54.{core::List::addAll}{Invariant}(#t55{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t54;
   core::List<dynamic> l3 = <dynamic>[invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:30:16: Error: Can't spread a value with static type 'N2'.
   var l3 = [...n2];
@@ -200,7 +200,7 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t57 = <Never>[];
     final core::Iterable<Never>? #t58 = n2;
     if(!(#t58 == null))
-      #t57.{core::List::addAll}(#t58{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t57.{core::List::addAll}{Invariant}(#t58{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t57;
   core::List<dynamic> l5 = <dynamic>[invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:32:16: Error: Can't spread a value with static type 'N3'.
   var l5 = [...n3];
@@ -209,60 +209,60 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t59 = <Never>[];
     final core::Iterable<Never>? #t60 = n3;
     if(!(#t60 == null))
-      #t59.{core::List::addAll}(#t60{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t59.{core::List::addAll}{Invariant}(#t60{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t59;
   core::Set<self::test2::N1> s1 = block {
     final core::Set<self::test2::N1> #t61 = col::LinkedHashSet::of<self::test2::N1>(let final self::test2::N1 #t62 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."));
-    #t61.{core::Set::add}(let final self::test2::N1 #t63 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
+    #t61.{core::Set::add}{Invariant}(let final self::test2::N1 #t63 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
   } =>#t61;
   core::Set<self::test2::N1> s2 = block {
     final core::Set<self::test2::N1> #t64 = col::LinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t65 = let final self::test2::N1 #t66 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t65 == null))
-      #t64.{core::Set::addAll}(#t65{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t64.{core::Set::add}(let final self::test2::N1 #t67 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
+      #t64.{core::Set::addAll}{Invariant}(#t65{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t64.{core::Set::add}{Invariant}(let final self::test2::N1 #t67 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
   } =>#t64;
   core::Set<dynamic> s3 = block {
     final core::Set<dynamic> #t68 = col::LinkedHashSet::•<dynamic>();
-    #t68.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:36:16: Error: Can't spread a value with static type 'N2'.
+    #t68.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:36:16: Error: Can't spread a value with static type 'N2'.
   var s3 = {...n2, n1};
                ^"){(dynamic) → core::bool};
-    #t68.{core::Set::add}(let final self::test2::N1 #t69 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
+    #t68.{core::Set::add}{Invariant}(let final self::test2::N1 #t69 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
   } =>#t68;
   core::Set<self::test2::N1> s4 = block {
     final core::Set<self::test2::N1> #t70 = col::LinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t71 = n2;
     if(!(#t71 == null))
-      #t70.{core::Set::addAll}(#t71{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t70.{core::Set::add}(let final self::test2::N1 #t72 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
+      #t70.{core::Set::addAll}{Invariant}(#t71{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t70.{core::Set::add}{Invariant}(let final self::test2::N1 #t72 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
   } =>#t70;
   core::Set<dynamic> s5 = block {
     final core::Set<dynamic> #t73 = col::LinkedHashSet::•<dynamic>();
-    #t73.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:38:16: Error: Can't spread a value with static type 'N3'.
+    #t73.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:38:16: Error: Can't spread a value with static type 'N3'.
   var s5 = {...n3, n1};
                ^"){(dynamic) → core::bool};
-    #t73.{core::Set::add}(let final self::test2::N1 #t74 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
+    #t73.{core::Set::add}{Invariant}(let final self::test2::N1 #t74 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
   } =>#t73;
   core::Set<self::test2::N1> s6 = block {
     final core::Set<self::test2::N1> #t75 = col::LinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t76 = n3;
     if(!(#t76 == null))
-      #t75.{core::Set::addAll}(#t76{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t75.{core::Set::add}(let final self::test2::N1 #t77 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
+      #t75.{core::Set::addAll}{Invariant}(#t76{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t75.{core::Set::add}{Invariant}(let final self::test2::N1 #t77 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
   } =>#t75;
   core::Map<self::test2::N1, self::test2::N1> m1 = block {
     final core::Map<self::test2::N1, self::test2::N1> #t78 = <self::test2::N1, self::test2::N1>{};
     for (final core::MapEntry<self::test2::N1, self::test2::N1> #t79 in (let final self::test2::N1 #t80 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")).{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>})
-      #t78.{core::Map::[]=}(#t79.{core::MapEntry::key}{self::test2::N1}, #t79.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
-    #t78.{core::Map::[]=}(let final self::test2::N1 #t81 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t82 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
+      #t78.{core::Map::[]=}{Invariant}(#t79.{core::MapEntry::key}{self::test2::N1}, #t79.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+    #t78.{core::Map::[]=}{Invariant}(let final self::test2::N1 #t81 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t82 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
   } =>#t78;
   core::Map<self::test2::N1, self::test2::N1> m2 = block {
     final core::Map<self::test2::N1, self::test2::N1> #t83 = <self::test2::N1, self::test2::N1>{};
     final core::Map<self::test2::N1, self::test2::N1>? #t84 = let final self::test2::N1 #t85 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t84 == null))
       for (final core::MapEntry<self::test2::N1, self::test2::N1> #t86 in #t84{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>})
-        #t83.{core::Map::[]=}(#t86.{core::MapEntry::key}{self::test2::N1}, #t86.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
-    #t83.{core::Map::[]=}(let final self::test2::N1 #t87 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t88 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
+        #t83.{core::Map::[]=}{Invariant}(#t86.{core::MapEntry::key}{self::test2::N1}, #t86.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+    #t83.{core::Map::[]=}{Invariant}(let final self::test2::N1 #t87 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t88 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
   } =>#t83;
   core::Map<dynamic, dynamic> m3 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:42:16: Error: Can't spread a value with static type 'N2'.
   var m3 = {...n2, n1: n1};
@@ -272,8 +272,8 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::Map<self::test2::N1, self::test2::N1>? #t92 = n2;
     if(!(#t92 == null))
       for (final core::MapEntry<self::test2::N1, self::test2::N1> #t93 in #t92{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>})
-        #t91.{core::Map::[]=}(#t93.{core::MapEntry::key}{self::test2::N1}, #t93.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
-    #t91.{core::Map::[]=}(let final self::test2::N1 #t94 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t95 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
+        #t91.{core::Map::[]=}{Invariant}(#t93.{core::MapEntry::key}{self::test2::N1}, #t93.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+    #t91.{core::Map::[]=}{Invariant}(let final self::test2::N1 #t94 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t95 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
   } =>#t91;
   core::Map<dynamic, dynamic> m5 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:44:16: Error: Can't spread a value with static type 'N3'.
   var m5 = {...n3, n1: n1};
@@ -283,8 +283,8 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::Map<self::test2::N1, self::test2::N1>? #t99 = n3;
     if(!(#t99 == null))
       for (final core::MapEntry<self::test2::N1, self::test2::N1> #t100 in #t99{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>})
-        #t98.{core::Map::[]=}(#t100.{core::MapEntry::key}{self::test2::N1}, #t100.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
-    #t98.{core::Map::[]=}(let final self::test2::N1 #t101 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t102 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
+        #t98.{core::Map::[]=}{Invariant}(#t100.{core::MapEntry::key}{self::test2::N1}, #t100.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+    #t98.{core::Map::[]=}{Invariant}(let final self::test2::N1 #t101 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t102 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
   } =>#t98;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/nnbd/issue42758.dart.weak.transformed.expect

@@ -87,7 +87,7 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t3 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t4 = let final Never #t5 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t4 == null))
-      #t3.{core::List::addAll}(#t4{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t3.{core::List::addAll}{Invariant}(#t4{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t3;
   core::List<dynamic> l3 = core::_GrowableList::_literal1<dynamic>(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:8:16: Error: Can't spread a value with static type 'Never?'.
   var l3 = [...n2];
@@ -96,7 +96,7 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t6 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t7 = n2;
     if(!(#t7 == null))
-      #t6.{core::List::addAll}(#t7{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t6.{core::List::addAll}{Invariant}(#t7{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t6;
   core::List<dynamic> l5 = core::_GrowableList::_literal1<dynamic>(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:10:16: Error: Can't spread a value with static type 'Null'.
   var l5 = [...n3];
@@ -105,46 +105,46 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
     final core::List<Never> #t8 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t9 = n3;
     if(!(#t9 == null))
-      #t8.{core::List::addAll}(#t9{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t8.{core::List::addAll}{Invariant}(#t9{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t8;
   core::Set<Never> s1 = block {
     final core::Set<Never> #t10 = col::LinkedHashSet::of<Never>(let final Never #t11 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."));
-    #t10.{core::Set::add}(let final Never #t12 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
+    #t10.{core::Set::add}{Invariant}(let final Never #t12 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
   } =>#t10;
   core::Set<Never> s2 = block {
     final core::Set<Never> #t13 = new col::_CompactLinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t14 = let final Never #t15 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t14 == null))
-      #t13.{core::Set::addAll}(#t14{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t13.{core::Set::add}(let final Never #t16 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
+      #t13.{core::Set::addAll}{Invariant}(#t14{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t13.{core::Set::add}{Invariant}(let final Never #t16 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
   } =>#t13;
   core::Set<dynamic> s3 = block {
     final core::Set<dynamic> #t17 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t17.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:14:16: Error: Can't spread a value with static type 'Never?'.
+    #t17.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:14:16: Error: Can't spread a value with static type 'Never?'.
   var s3 = {...n2, n1};
                ^"){(dynamic) → core::bool};
-    #t17.{core::Set::add}(let final Never #t18 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
+    #t17.{core::Set::add}{Invariant}(let final Never #t18 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
   } =>#t17;
   core::Set<Never> s4 = block {
     final core::Set<Never> #t19 = new col::_CompactLinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t20 = n2;
     if(!(#t20 == null))
-      #t19.{core::Set::addAll}(#t20{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t19.{core::Set::add}(let final Never #t21 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
+      #t19.{core::Set::addAll}{Invariant}(#t20{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t19.{core::Set::add}{Invariant}(let final Never #t21 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
   } =>#t19;
   core::Set<dynamic> s5 = block {
     final core::Set<dynamic> #t22 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t22.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:16:16: Error: Can't spread a value with static type 'Null'.
+    #t22.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:16:16: Error: Can't spread a value with static type 'Null'.
   var s5 = {...n3, n1};
                ^"){(dynamic) → core::bool};
-    #t22.{core::Set::add}(let final Never #t23 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
+    #t22.{core::Set::add}{Invariant}(let final Never #t23 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
   } =>#t22;
   core::Set<Never> s6 = block {
     final core::Set<Never> #t24 = new col::_CompactLinkedHashSet::•<Never>();
     final core::Iterable<Never>? #t25 = n3;
     if(!(#t25 == null))
-      #t24.{core::Set::addAll}(#t25{core::Iterable<Never>}){(core::Iterable<Never>) → void};
-    #t24.{core::Set::add}(let final Never #t26 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
+      #t24.{core::Set::addAll}{Invariant}(#t25{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+    #t24.{core::Set::add}{Invariant}(let final Never #t26 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never) → core::bool};
   } =>#t24;
   core::Map<Never, Never> m1 = block {
     final core::Map<Never, Never> #t27 = <Never, Never>{};
@@ -152,10 +152,10 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
       core::Iterator<core::MapEntry<Never, Never>> :sync-for-iterator = (let final Never #t28 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")).{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<Never, Never>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<Never, Never> #t29 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<Never, Never>};
-        #t27.{core::Map::[]=}(#t29.{core::MapEntry::key}{Never}, #t29.{core::MapEntry::value}{Never}){(Never, Never) → void};
+        #t27.{core::Map::[]=}{Invariant}(#t29.{core::MapEntry::key}{Never}, #t29.{core::MapEntry::value}{Never}){(Never, Never) → void};
       }
     }
-    #t27.{core::Map::[]=}(let final Never #t30 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t31 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
+    #t27.{core::Map::[]=}{Invariant}(let final Never #t30 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t31 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
   } =>#t27;
   core::Map<Never, Never> m2 = block {
     final core::Map<Never, Never> #t32 = <Never, Never>{};
@@ -164,10 +164,10 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
       core::Iterator<core::MapEntry<Never, Never>> :sync-for-iterator = #t33{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<Never, Never>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<Never, Never> #t35 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<Never, Never>};
-        #t32.{core::Map::[]=}(#t35.{core::MapEntry::key}{Never}, #t35.{core::MapEntry::value}{Never}){(Never, Never) → void};
+        #t32.{core::Map::[]=}{Invariant}(#t35.{core::MapEntry::key}{Never}, #t35.{core::MapEntry::value}{Never}){(Never, Never) → void};
       }
     }
-    #t32.{core::Map::[]=}(let final Never #t36 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t37 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
+    #t32.{core::Map::[]=}{Invariant}(let final Never #t36 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t37 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
   } =>#t32;
   core::Map<dynamic, dynamic> m3 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:20:16: Error: Can't spread a value with static type 'Never?'.
   var m3 = {...n2, n1: n1};
@@ -179,10 +179,10 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
       core::Iterator<core::MapEntry<Never, Never>> :sync-for-iterator = #t41{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<Never, Never>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<Never, Never> #t42 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<Never, Never>};
-        #t40.{core::Map::[]=}(#t42.{core::MapEntry::key}{Never}, #t42.{core::MapEntry::value}{Never}){(Never, Never) → void};
+        #t40.{core::Map::[]=}{Invariant}(#t42.{core::MapEntry::key}{Never}, #t42.{core::MapEntry::value}{Never}){(Never, Never) → void};
       }
     }
-    #t40.{core::Map::[]=}(let final Never #t43 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t44 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
+    #t40.{core::Map::[]=}{Invariant}(let final Never #t43 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t44 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
   } =>#t40;
   core::Map<dynamic, dynamic> m5 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:22:16: Error: Can't spread a value with static type 'Null'.
   var m5 = {...n3, n1: n1};
@@ -194,10 +194,10 @@ static method test1(Never n1, Never? n2, Null n3) → dynamic {
       core::Iterator<core::MapEntry<Never, Never>> :sync-for-iterator = #t48{core::Map<Never, Never>}.{core::Map::entries}{core::Iterable<core::MapEntry<Never, Never>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<Never, Never>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<Never, Never> #t49 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<Never, Never>};
-        #t47.{core::Map::[]=}(#t49.{core::MapEntry::key}{Never}, #t49.{core::MapEntry::value}{Never}){(Never, Never) → void};
+        #t47.{core::Map::[]=}{Invariant}(#t49.{core::MapEntry::key}{Never}, #t49.{core::MapEntry::value}{Never}){(Never, Never) → void};
       }
     }
-    #t47.{core::Map::[]=}(let final Never #t50 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t51 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
+    #t47.{core::Map::[]=}{Invariant}(let final Never #t50 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final Never #t51 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(Never, Never) → void};
   } =>#t47;
 }
 static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::test2::N1 n1, self::test2::N2% n2, self::test2::N3% n3) → dynamic {
@@ -208,7 +208,7 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t54 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t55 = let final self::test2::N1 #t56 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t55 == null))
-      #t54.{core::List::addAll}(#t55{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t54.{core::List::addAll}{Invariant}(#t55{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t54;
   core::List<dynamic> l3 = core::_GrowableList::_literal1<dynamic>(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:30:16: Error: Can't spread a value with static type 'N2'.
   var l3 = [...n2];
@@ -217,7 +217,7 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t57 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t58 = n2;
     if(!(#t58 == null))
-      #t57.{core::List::addAll}(#t58{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t57.{core::List::addAll}{Invariant}(#t58{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t57;
   core::List<dynamic> l5 = core::_GrowableList::_literal1<dynamic>(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:32:16: Error: Can't spread a value with static type 'N3'.
   var l5 = [...n3];
@@ -226,46 +226,46 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
     final core::List<Never> #t59 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t60 = n3;
     if(!(#t60 == null))
-      #t59.{core::List::addAll}(#t60{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t59.{core::List::addAll}{Invariant}(#t60{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t59;
   core::Set<self::test2::N1> s1 = block {
     final core::Set<self::test2::N1> #t61 = col::LinkedHashSet::of<self::test2::N1>(let final self::test2::N1 #t62 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."));
-    #t61.{core::Set::add}(let final self::test2::N1 #t63 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
+    #t61.{core::Set::add}{Invariant}(let final self::test2::N1 #t63 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
   } =>#t61;
   core::Set<self::test2::N1> s2 = block {
     final core::Set<self::test2::N1> #t64 = new col::_CompactLinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t65 = let final self::test2::N1 #t66 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.");
     if(!(#t65 == null))
-      #t64.{core::Set::addAll}(#t65{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t64.{core::Set::add}(let final self::test2::N1 #t67 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
+      #t64.{core::Set::addAll}{Invariant}(#t65{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t64.{core::Set::add}{Invariant}(let final self::test2::N1 #t67 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
   } =>#t64;
   core::Set<dynamic> s3 = block {
     final core::Set<dynamic> #t68 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t68.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:36:16: Error: Can't spread a value with static type 'N2'.
+    #t68.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:36:16: Error: Can't spread a value with static type 'N2'.
   var s3 = {...n2, n1};
                ^"){(dynamic) → core::bool};
-    #t68.{core::Set::add}(let final self::test2::N1 #t69 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
+    #t68.{core::Set::add}{Invariant}(let final self::test2::N1 #t69 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
   } =>#t68;
   core::Set<self::test2::N1> s4 = block {
     final core::Set<self::test2::N1> #t70 = new col::_CompactLinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t71 = n2;
     if(!(#t71 == null))
-      #t70.{core::Set::addAll}(#t71{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t70.{core::Set::add}(let final self::test2::N1 #t72 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
+      #t70.{core::Set::addAll}{Invariant}(#t71{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t70.{core::Set::add}{Invariant}(let final self::test2::N1 #t72 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
   } =>#t70;
   core::Set<dynamic> s5 = block {
     final core::Set<dynamic> #t73 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t73.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:38:16: Error: Can't spread a value with static type 'N3'.
+    #t73.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:38:16: Error: Can't spread a value with static type 'N3'.
   var s5 = {...n3, n1};
                ^"){(dynamic) → core::bool};
-    #t73.{core::Set::add}(let final self::test2::N1 #t74 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
+    #t73.{core::Set::add}{Invariant}(let final self::test2::N1 #t74 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(dynamic) → core::bool};
   } =>#t73;
   core::Set<self::test2::N1> s6 = block {
     final core::Set<self::test2::N1> #t75 = new col::_CompactLinkedHashSet::•<self::test2::N1>();
     final core::Iterable<self::test2::N1>? #t76 = n3;
     if(!(#t76 == null))
-      #t75.{core::Set::addAll}(#t76{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
-    #t75.{core::Set::add}(let final self::test2::N1 #t77 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
+      #t75.{core::Set::addAll}{Invariant}(#t76{core::Iterable<self::test2::N1>}){(core::Iterable<self::test2::N1>) → void};
+    #t75.{core::Set::add}{Invariant}(let final self::test2::N1 #t77 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1) → core::bool};
   } =>#t75;
   core::Map<self::test2::N1, self::test2::N1> m1 = block {
     final core::Map<self::test2::N1, self::test2::N1> #t78 = <self::test2::N1, self::test2::N1>{};
@@ -273,10 +273,10 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
       core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>> :sync-for-iterator = (let final self::test2::N1 #t79 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")).{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<self::test2::N1, self::test2::N1> #t80 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<self::test2::N1, self::test2::N1>};
-        #t78.{core::Map::[]=}(#t80.{core::MapEntry::key}{self::test2::N1}, #t80.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+        #t78.{core::Map::[]=}{Invariant}(#t80.{core::MapEntry::key}{self::test2::N1}, #t80.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
       }
     }
-    #t78.{core::Map::[]=}(let final self::test2::N1 #t81 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t82 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
+    #t78.{core::Map::[]=}{Invariant}(let final self::test2::N1 #t81 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t82 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
   } =>#t78;
   core::Map<self::test2::N1, self::test2::N1> m2 = block {
     final core::Map<self::test2::N1, self::test2::N1> #t83 = <self::test2::N1, self::test2::N1>{};
@@ -285,10 +285,10 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
       core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>> :sync-for-iterator = #t84{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<self::test2::N1, self::test2::N1> #t86 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<self::test2::N1, self::test2::N1>};
-        #t83.{core::Map::[]=}(#t86.{core::MapEntry::key}{self::test2::N1}, #t86.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+        #t83.{core::Map::[]=}{Invariant}(#t86.{core::MapEntry::key}{self::test2::N1}, #t86.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
       }
     }
-    #t83.{core::Map::[]=}(let final self::test2::N1 #t87 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t88 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
+    #t83.{core::Map::[]=}{Invariant}(let final self::test2::N1 #t87 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t88 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
   } =>#t83;
   core::Map<dynamic, dynamic> m3 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:42:16: Error: Can't spread a value with static type 'N2'.
   var m3 = {...n2, n1: n1};
@@ -300,10 +300,10 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
       core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>> :sync-for-iterator = #t92{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<self::test2::N1, self::test2::N1> #t93 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<self::test2::N1, self::test2::N1>};
-        #t91.{core::Map::[]=}(#t93.{core::MapEntry::key}{self::test2::N1}, #t93.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+        #t91.{core::Map::[]=}{Invariant}(#t93.{core::MapEntry::key}{self::test2::N1}, #t93.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
       }
     }
-    #t91.{core::Map::[]=}(let final self::test2::N1 #t94 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t95 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
+    #t91.{core::Map::[]=}{Invariant}(let final self::test2::N1 #t94 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t95 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
   } =>#t91;
   core::Map<dynamic, dynamic> m5 = <dynamic, dynamic>{invalid-expression "pkg/front_end/testcases/nnbd/issue42758.dart:44:16: Error: Can't spread a value with static type 'N3'.
   var m5 = {...n3, n1: n1};
@@ -315,10 +315,10 @@ static method test2<N1 extends Never, N2 extends Never?, N3 extends Null>(self::
       core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>> :sync-for-iterator = #t99{core::Map<self::test2::N1, self::test2::N1>}.{core::Map::entries}{core::Iterable<core::MapEntry<self::test2::N1, self::test2::N1>>}.{core::Iterable::iterator}{core::Iterator<core::MapEntry<self::test2::N1, self::test2::N1>>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         final core::MapEntry<self::test2::N1, self::test2::N1> #t100 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<self::test2::N1, self::test2::N1>};
-        #t98.{core::Map::[]=}(#t100.{core::MapEntry::key}{self::test2::N1}, #t100.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
+        #t98.{core::Map::[]=}{Invariant}(#t100.{core::MapEntry::key}{self::test2::N1}, #t100.{core::MapEntry::value}{self::test2::N1}){(self::test2::N1, self::test2::N1) → void};
       }
     }
-    #t98.{core::Map::[]=}(let final self::test2::N1 #t101 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t102 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
+    #t98.{core::Map::[]=}{Invariant}(let final self::test2::N1 #t101 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`."), let final self::test2::N1 #t102 = n1 in throw new _in::ReachabilityError::•("`null` encountered as the result from expression with type `Never`.")){(self::test2::N1, self::test2::N1) → void};
   } =>#t98;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/nnbd/issue43256.dart.strong.expect

@@ -58,85 +58,85 @@ static field dynamic dynamicList = <core::int>[1, 2, 3];
 static field core::Map<dynamic, dynamic> map1 = block {
   final core::Map<dynamic, dynamic> #t1 = <dynamic, dynamic>{};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t1.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:16:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t1.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:16:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableMap, // error
                 ^", null){(dynamic, dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
     for (final core::MapEntry<dynamic, dynamic> #t2 in (self::dynamicMap as{TypeError,ForDynamic,ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-      #t1.{core::Map::[]=}(#t2.{core::MapEntry::key}{dynamic}, #t2.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+      #t1.{core::Map::[]=}{Invariant}(#t2.{core::MapEntry::key}{dynamic}, #t2.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
     for (final core::MapEntry<dynamic, dynamic> #t3 in self::nullableMap!.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-      #t1.{core::Map::[]=}(#t3.{core::MapEntry::key}{dynamic}, #t3.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+      #t1.{core::Map::[]=}{Invariant}(#t3.{core::MapEntry::key}{dynamic}, #t3.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
 } =>#t1;
 static field core::Set<dynamic> set1 = block {
   final core::Set<dynamic> #t4 = col::LinkedHashSet::•<dynamic>();
-  #t4.{core::Set::add}(0){(dynamic) → core::bool};
+  #t4.{core::Set::add}{Invariant}(0){(dynamic) → core::bool};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:23:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t4.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:23:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableList, // error
                 ^"){(dynamic) → core::bool};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::addAll}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
+    #t4.{core::Set::addAll}{Invariant}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::addAll}(self::nullableList!){(core::Iterable<dynamic>) → void};
+    #t4.{core::Set::addAll}{Invariant}(self::nullableList!){(core::Iterable<dynamic>) → void};
 } =>#t4;
 static field core::List<dynamic> list1 = block {
   final core::List<dynamic> #t5 = <dynamic>[];
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:29:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t5.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:29:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableList, // error
                 ^"){(dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::addAll}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
+    #t5.{core::List::addAll}{Invariant}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::addAll}(self::nullableList!){(core::Iterable<dynamic>) → void};
+    #t5.{core::List::addAll}{Invariant}(self::nullableList!){(core::Iterable<dynamic>) → void};
 } =>#t5;
 static method testMap<X extends dynamic, Y extends core::Map<core::int, core::String>?, Z extends core::Map<core::int, core::String>>(self::testMap::X% x, self::testMap::Y% y, self::testMap::Z z) → dynamic {
   core::Map<dynamic, dynamic> map2 = block {
     final core::Map<dynamic, dynamic> #t6 = <dynamic, dynamic>{};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t6.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:37:19: Error: Unexpected type 'X' of a map spread entry.  Expected 'dynamic' or a Map.
+      #t6.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:37:19: Error: Unexpected type 'X' of a map spread entry.  Expected 'dynamic' or a Map.
     if (i > 0) ...x, // error
                   ^", null){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t6.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:38:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t6.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:38:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^", null){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
       for (final core::MapEntry<dynamic, dynamic> #t7 in z.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-        #t6.{core::Map::[]=}(#t7.{core::MapEntry::key}{dynamic}, #t7.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+        #t6.{core::Map::[]=}{Invariant}(#t7.{core::MapEntry::key}{dynamic}, #t7.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
       for (final core::MapEntry<dynamic, dynamic> #t8 in y!.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-        #t6.{core::Map::[]=}(#t8.{core::MapEntry::key}{dynamic}, #t8.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+        #t6.{core::Map::[]=}{Invariant}(#t8.{core::MapEntry::key}{dynamic}, #t8.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
   } =>#t6;
 }
 static method testIterables<X extends dynamic, Y extends core::List<core::int>?, Z extends core::List<core::int>>(self::testIterables::X% x, self::testIterables::Y% y, self::testIterables::Z z) → dynamic {
   core::Set<dynamic> set2 = block {
     final core::Set<dynamic> #t9 = col::LinkedHashSet::•<dynamic>();
-    #t9.{core::Set::add}(0){(dynamic) → core::bool};
+    #t9.{core::Set::add}{Invariant}(0){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:48:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
+      #t9.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:48:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
     if (i > 0) ...x, // error
                   ^"){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:49:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t9.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:49:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^"){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::addAll}(z){(core::Iterable<dynamic>) → void};
+      #t9.{core::Set::addAll}{Invariant}(z){(core::Iterable<dynamic>) → void};
   } =>#t9;
   core::List<dynamic> list2 = block {
     final core::List<dynamic> #t10 = <dynamic>[];
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:53:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
+      #t10.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:53:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
     if (i > 0) ...x, // error
                   ^"){(dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:54:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t10.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:54:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^"){(dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::addAll}(z){(core::Iterable<dynamic>) → void};
+      #t10.{core::List::addAll}{Invariant}(z){(core::Iterable<dynamic>) → void};
   } =>#t10;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/nnbd/issue43256.dart.strong.transformed.expect

@@ -58,70 +58,70 @@ static field dynamic dynamicList = core::_GrowableList::_literal3<core::int>(1,
 static field core::Map<dynamic, dynamic> map1 = block {
   final core::Map<dynamic, dynamic> #t1 = <dynamic, dynamic>{};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t1.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:16:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t1.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:16:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableMap, // error
                 ^", null){(dynamic, dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool}) {
     core::Iterator<core::MapEntry<dynamic, dynamic>> :sync-for-iterator = (self::dynamicMap as{TypeError,ForDynamic,ForNonNullableByDefault} 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> #t2 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-      #t1.{core::Map::[]=}(#t2.{core::MapEntry::key}{dynamic}, #t2.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+      #t1.{core::Map::[]=}{Invariant}(#t2.{core::MapEntry::key}{dynamic}, #t2.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
     }
   }
   if(self::i.{core::num::>}(0){(core::num) → core::bool}) {
     core::Iterator<core::MapEntry<dynamic, dynamic>> :sync-for-iterator = self::nullableMap!.{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> #t3 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-      #t1.{core::Map::[]=}(#t3.{core::MapEntry::key}{dynamic}, #t3.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+      #t1.{core::Map::[]=}{Invariant}(#t3.{core::MapEntry::key}{dynamic}, #t3.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
     }
   }
 } =>#t1;
 static field core::Set<dynamic> set1 = block {
   final core::Set<dynamic> #t4 = new col::_CompactLinkedHashSet::•<dynamic>();
-  #t4.{core::Set::add}(0){(dynamic) → core::bool};
+  #t4.{core::Set::add}{Invariant}(0){(dynamic) → core::bool};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:23:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t4.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:23:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableList, // error
                 ^"){(dynamic) → core::bool};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::addAll}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
+    #t4.{core::Set::addAll}{Invariant}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::addAll}(self::nullableList!){(core::Iterable<dynamic>) → void};
+    #t4.{core::Set::addAll}{Invariant}(self::nullableList!){(core::Iterable<dynamic>) → void};
 } =>#t4;
 static field core::List<dynamic> list1 = block {
   final core::List<dynamic> #t5 = core::_GrowableList::•<dynamic>(0);
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:29:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t5.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:29:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableList, // error
                 ^"){(dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::addAll}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
+    #t5.{core::List::addAll}{Invariant}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::addAll}(self::nullableList!){(core::Iterable<dynamic>) → void};
+    #t5.{core::List::addAll}{Invariant}(self::nullableList!){(core::Iterable<dynamic>) → void};
 } =>#t5;
 static method testMap<X extends dynamic, Y extends core::Map<core::int, core::String>?, Z extends core::Map<core::int, core::String>>(self::testMap::X% x, self::testMap::Y% y, self::testMap::Z z) → dynamic {
   core::Map<dynamic, dynamic> map2 = block {
     final core::Map<dynamic, dynamic> #t6 = <dynamic, dynamic>{};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t6.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:37:19: Error: Unexpected type 'X' of a map spread entry.  Expected 'dynamic' or a Map.
+      #t6.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:37:19: Error: Unexpected type 'X' of a map spread entry.  Expected 'dynamic' or a Map.
     if (i > 0) ...x, // error
                   ^", null){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t6.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:38:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t6.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:38:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^", null){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool}) {
       core::Iterator<core::MapEntry<dynamic, dynamic>> :sync-for-iterator = z.{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> #t7 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-        #t6.{core::Map::[]=}(#t7.{core::MapEntry::key}{dynamic}, #t7.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+        #t6.{core::Map::[]=}{Invariant}(#t7.{core::MapEntry::key}{dynamic}, #t7.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
       }
     }
     if(self::i.{core::num::>}(0){(core::num) → core::bool}) {
       core::Iterator<core::MapEntry<dynamic, dynamic>> :sync-for-iterator = y!.{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> #t8 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-        #t6.{core::Map::[]=}(#t8.{core::MapEntry::key}{dynamic}, #t8.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+        #t6.{core::Map::[]=}{Invariant}(#t8.{core::MapEntry::key}{dynamic}, #t8.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
       }
     }
   } =>#t6;
@@ -129,30 +129,30 @@ static method testMap<X extends dynamic, Y extends core::Map<core::int, core::St
 static method testIterables<X extends dynamic, Y extends core::List<core::int>?, Z extends core::List<core::int>>(self::testIterables::X% x, self::testIterables::Y% y, self::testIterables::Z z) → dynamic {
   core::Set<dynamic> set2 = block {
     final core::Set<dynamic> #t9 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t9.{core::Set::add}(0){(dynamic) → core::bool};
+    #t9.{core::Set::add}{Invariant}(0){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:48:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
+      #t9.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:48:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
     if (i > 0) ...x, // error
                   ^"){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:49:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t9.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:49:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^"){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::addAll}(z){(core::Iterable<dynamic>) → void};
+      #t9.{core::Set::addAll}{Invariant}(z){(core::Iterable<dynamic>) → void};
   } =>#t9;
   core::List<dynamic> list2 = block {
     final core::List<dynamic> #t10 = core::_GrowableList::•<dynamic>(0);
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:53:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
+      #t10.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:53:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
     if (i > 0) ...x, // error
                   ^"){(dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:54:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t10.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:54:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^"){(dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::addAll}(z){(core::Iterable<dynamic>) → void};
+      #t10.{core::List::addAll}{Invariant}(z){(core::Iterable<dynamic>) → void};
   } =>#t10;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/nnbd/issue43256.dart.weak.expect

@@ -58,85 +58,85 @@ static field dynamic dynamicList = <core::int>[1, 2, 3];
 static field core::Map<dynamic, dynamic> map1 = block {
   final core::Map<dynamic, dynamic> #t1 = <dynamic, dynamic>{};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t1.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:16:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t1.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:16:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableMap, // error
                 ^", null){(dynamic, dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
     for (final core::MapEntry<dynamic, dynamic> #t2 in (self::dynamicMap as{TypeError,ForDynamic,ForNonNullableByDefault} core::Map<dynamic, dynamic>).{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-      #t1.{core::Map::[]=}(#t2.{core::MapEntry::key}{dynamic}, #t2.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+      #t1.{core::Map::[]=}{Invariant}(#t2.{core::MapEntry::key}{dynamic}, #t2.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
     for (final core::MapEntry<dynamic, dynamic> #t3 in self::nullableMap!.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-      #t1.{core::Map::[]=}(#t3.{core::MapEntry::key}{dynamic}, #t3.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+      #t1.{core::Map::[]=}{Invariant}(#t3.{core::MapEntry::key}{dynamic}, #t3.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
 } =>#t1;
 static field core::Set<dynamic> set1 = block {
   final core::Set<dynamic> #t4 = col::LinkedHashSet::•<dynamic>();
-  #t4.{core::Set::add}(0){(dynamic) → core::bool};
+  #t4.{core::Set::add}{Invariant}(0){(dynamic) → core::bool};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:23:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t4.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:23:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableList, // error
                 ^"){(dynamic) → core::bool};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::addAll}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
+    #t4.{core::Set::addAll}{Invariant}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::addAll}(self::nullableList!){(core::Iterable<dynamic>) → void};
+    #t4.{core::Set::addAll}{Invariant}(self::nullableList!){(core::Iterable<dynamic>) → void};
 } =>#t4;
 static field core::List<dynamic> list1 = block {
   final core::List<dynamic> #t5 = <dynamic>[];
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:29:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t5.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:29:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableList, // error
                 ^"){(dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::addAll}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
+    #t5.{core::List::addAll}{Invariant}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::addAll}(self::nullableList!){(core::Iterable<dynamic>) → void};
+    #t5.{core::List::addAll}{Invariant}(self::nullableList!){(core::Iterable<dynamic>) → void};
 } =>#t5;
 static method testMap<X extends dynamic, Y extends core::Map<core::int, core::String>?, Z extends core::Map<core::int, core::String>>(self::testMap::X% x, self::testMap::Y% y, self::testMap::Z z) → dynamic {
   core::Map<dynamic, dynamic> map2 = block {
     final core::Map<dynamic, dynamic> #t6 = <dynamic, dynamic>{};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t6.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:37:19: Error: Unexpected type 'X' of a map spread entry.  Expected 'dynamic' or a Map.
+      #t6.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:37:19: Error: Unexpected type 'X' of a map spread entry.  Expected 'dynamic' or a Map.
     if (i > 0) ...x, // error
                   ^", null){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t6.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:38:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t6.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:38:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^", null){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
       for (final core::MapEntry<dynamic, dynamic> #t7 in z.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-        #t6.{core::Map::[]=}(#t7.{core::MapEntry::key}{dynamic}, #t7.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+        #t6.{core::Map::[]=}{Invariant}(#t7.{core::MapEntry::key}{dynamic}, #t7.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
       for (final core::MapEntry<dynamic, dynamic> #t8 in y!.{core::Map::entries}{core::Iterable<core::MapEntry<dynamic, dynamic>>})
-        #t6.{core::Map::[]=}(#t8.{core::MapEntry::key}{dynamic}, #t8.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+        #t6.{core::Map::[]=}{Invariant}(#t8.{core::MapEntry::key}{dynamic}, #t8.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
   } =>#t6;
 }
 static method testIterables<X extends dynamic, Y extends core::List<core::int>?, Z extends core::List<core::int>>(self::testIterables::X% x, self::testIterables::Y% y, self::testIterables::Z z) → dynamic {
   core::Set<dynamic> set2 = block {
     final core::Set<dynamic> #t9 = col::LinkedHashSet::•<dynamic>();
-    #t9.{core::Set::add}(0){(dynamic) → core::bool};
+    #t9.{core::Set::add}{Invariant}(0){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:48:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
+      #t9.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:48:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
     if (i > 0) ...x, // error
                   ^"){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:49:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t9.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:49:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^"){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::addAll}(z){(core::Iterable<dynamic>) → void};
+      #t9.{core::Set::addAll}{Invariant}(z){(core::Iterable<dynamic>) → void};
   } =>#t9;
   core::List<dynamic> list2 = block {
     final core::List<dynamic> #t10 = <dynamic>[];
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:53:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
+      #t10.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:53:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
     if (i > 0) ...x, // error
                   ^"){(dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:54:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t10.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:54:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^"){(dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::addAll}(z){(core::Iterable<dynamic>) → void};
+      #t10.{core::List::addAll}{Invariant}(z){(core::Iterable<dynamic>) → void};
   } =>#t10;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/nnbd/issue43256.dart.weak.transformed.expect

@@ -58,70 +58,70 @@ static field dynamic dynamicList = core::_GrowableList::_literal3<core::int>(1,
 static field core::Map<dynamic, dynamic> map1 = block {
   final core::Map<dynamic, dynamic> #t1 = <dynamic, dynamic>{};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t1.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:16:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t1.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:16:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableMap, // error
                 ^", null){(dynamic, dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool}) {
     core::Iterator<core::MapEntry<dynamic, dynamic>> :sync-for-iterator = (self::dynamicMap as{TypeError,ForDynamic,ForNonNullableByDefault} 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> #t2 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-      #t1.{core::Map::[]=}(#t2.{core::MapEntry::key}{dynamic}, #t2.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+      #t1.{core::Map::[]=}{Invariant}(#t2.{core::MapEntry::key}{dynamic}, #t2.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
     }
   }
   if(self::i.{core::num::>}(0){(core::num) → core::bool}) {
     core::Iterator<core::MapEntry<dynamic, dynamic>> :sync-for-iterator = self::nullableMap!.{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> #t3 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-      #t1.{core::Map::[]=}(#t3.{core::MapEntry::key}{dynamic}, #t3.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+      #t1.{core::Map::[]=}{Invariant}(#t3.{core::MapEntry::key}{dynamic}, #t3.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
     }
   }
 } =>#t1;
 static field core::Set<dynamic> set1 = block {
   final core::Set<dynamic> #t4 = new col::_CompactLinkedHashSet::•<dynamic>();
-  #t4.{core::Set::add}(0){(dynamic) → core::bool};
+  #t4.{core::Set::add}{Invariant}(0){(dynamic) → core::bool};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:23:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t4.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:23:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableList, // error
                 ^"){(dynamic) → core::bool};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::addAll}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
+    #t4.{core::Set::addAll}{Invariant}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t4.{core::Set::addAll}(self::nullableList!){(core::Iterable<dynamic>) → void};
+    #t4.{core::Set::addAll}{Invariant}(self::nullableList!){(core::Iterable<dynamic>) → void};
 } =>#t4;
 static field core::List<dynamic> list1 = block {
   final core::List<dynamic> #t5 = core::_GrowableList::•<dynamic>(0);
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:29:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+    #t5.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:29:17: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
   if (i > 0) ...nullableList, // error
                 ^"){(dynamic) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::addAll}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
+    #t5.{core::List::addAll}{Invariant}(self::dynamicList as{TypeError,ForDynamic,ForNonNullableByDefault} core::Iterable<dynamic>){(core::Iterable<dynamic>) → void};
   if(self::i.{core::num::>}(0){(core::num) → core::bool})
-    #t5.{core::List::addAll}(self::nullableList!){(core::Iterable<dynamic>) → void};
+    #t5.{core::List::addAll}{Invariant}(self::nullableList!){(core::Iterable<dynamic>) → void};
 } =>#t5;
 static method testMap<X extends dynamic, Y extends core::Map<core::int, core::String>?, Z extends core::Map<core::int, core::String>>(self::testMap::X% x, self::testMap::Y% y, self::testMap::Z z) → dynamic {
   core::Map<dynamic, dynamic> map2 = block {
     final core::Map<dynamic, dynamic> #t6 = <dynamic, dynamic>{};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t6.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:37:19: Error: Unexpected type 'X' of a map spread entry.  Expected 'dynamic' or a Map.
+      #t6.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:37:19: Error: Unexpected type 'X' of a map spread entry.  Expected 'dynamic' or a Map.
     if (i > 0) ...x, // error
                   ^", null){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t6.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:38:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t6.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:38:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^", null){(dynamic, dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool}) {
       core::Iterator<core::MapEntry<dynamic, dynamic>> :sync-for-iterator = z.{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> #t7 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-        #t6.{core::Map::[]=}(#t7.{core::MapEntry::key}{dynamic}, #t7.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+        #t6.{core::Map::[]=}{Invariant}(#t7.{core::MapEntry::key}{dynamic}, #t7.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
       }
     }
     if(self::i.{core::num::>}(0){(core::num) → core::bool}) {
       core::Iterator<core::MapEntry<dynamic, dynamic>> :sync-for-iterator = y!.{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> #t8 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<dynamic, dynamic>};
-        #t6.{core::Map::[]=}(#t8.{core::MapEntry::key}{dynamic}, #t8.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
+        #t6.{core::Map::[]=}{Invariant}(#t8.{core::MapEntry::key}{dynamic}, #t8.{core::MapEntry::value}{dynamic}){(dynamic, dynamic) → void};
       }
     }
   } =>#t6;
@@ -129,30 +129,30 @@ static method testMap<X extends dynamic, Y extends core::Map<core::int, core::St
 static method testIterables<X extends dynamic, Y extends core::List<core::int>?, Z extends core::List<core::int>>(self::testIterables::X% x, self::testIterables::Y% y, self::testIterables::Z z) → dynamic {
   core::Set<dynamic> set2 = block {
     final core::Set<dynamic> #t9 = new col::_CompactLinkedHashSet::•<dynamic>();
-    #t9.{core::Set::add}(0){(dynamic) → core::bool};
+    #t9.{core::Set::add}{Invariant}(0){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:48:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
+      #t9.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:48:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
     if (i > 0) ...x, // error
                   ^"){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:49:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t9.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:49:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^"){(dynamic) → core::bool};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t9.{core::Set::addAll}(z){(core::Iterable<dynamic>) → void};
+      #t9.{core::Set::addAll}{Invariant}(z){(core::Iterable<dynamic>) → void};
   } =>#t9;
   core::List<dynamic> list2 = block {
     final core::List<dynamic> #t10 = core::_GrowableList::•<dynamic>(0);
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:53:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
+      #t10.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:53:19: Error: Unexpected type 'X' of a spread.  Expected 'dynamic' or an Iterable.
     if (i > 0) ...x, // error
                   ^"){(dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:54:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t10.{core::List::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43256.dart:54:19: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     if (i > 0) ...y, // error
                   ^"){(dynamic) → void};
     if(self::i.{core::num::>}(0){(core::num) → core::bool})
-      #t10.{core::List::addAll}(z){(core::Iterable<dynamic>) → void};
+      #t10.{core::List::addAll}{Invariant}(z){(core::Iterable<dynamic>) → void};
   } =>#t10;
 }
 static method main() → dynamic {}

pkg/front_end/testcases/nnbd/issue43455.dart.strong.expect

@@ -10,23 +10,23 @@ class C<X extends core::Object?, Y extends core::Object> extends core::Object {
   method test(generic-covariant-impl self::C::X% x, generic-covariant-impl self::C::Y? y) → dynamic {
     core::Set<core::Object?> v = block {
       final core::Set<core::Object?> #t1 = col::LinkedHashSet::•<core::Object?>();
-      #t1.{core::Set::add}(x){(core::Object?) → core::bool};
-      #t1.{core::Set::add}(42){(core::Object?) → core::bool};
+      #t1.{core::Set::add}{Invariant}(x){(core::Object?) → core::bool};
+      #t1.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
     } =>#t1;
     core::Set<core::Object?> w = block {
       final core::Set<core::Object?> #t2 = col::LinkedHashSet::•<core::Object?>();
-      #t2.{core::Set::add}(42){(core::Object?) → core::bool};
-      #t2.{core::Set::add}(x){(core::Object?) → core::bool};
+      #t2.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+      #t2.{core::Set::add}{Invariant}(x){(core::Object?) → core::bool};
     } =>#t2;
     core::Set<core::Object?> p = block {
       final core::Set<core::Object?> #t3 = col::LinkedHashSet::•<core::Object?>();
-      #t3.{core::Set::add}(y){(core::Object?) → core::bool};
-      #t3.{core::Set::add}(42){(core::Object?) → core::bool};
+      #t3.{core::Set::add}{Invariant}(y){(core::Object?) → core::bool};
+      #t3.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
     } =>#t3;
     core::Set<core::Object?> q = block {
       final core::Set<core::Object?> #t4 = col::LinkedHashSet::•<core::Object?>();
-      #t4.{core::Set::add}(42){(core::Object?) → core::bool};
-      #t4.{core::Set::add}(y){(core::Object?) → core::bool};
+      #t4.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+      #t4.{core::Set::add}{Invariant}(y){(core::Object?) → core::bool};
     } =>#t4;
     self::assertRightSubtype(v);
     self::assertLeftSubtype<core::Set<core::Object?>>(v);
@@ -39,13 +39,13 @@ class C<X extends core::Object?, Y extends core::Object> extends core::Object {
     if(x is{ForNonNullableByDefault} core::Object?) {
       core::Set<core::Object?> v = block {
         final core::Set<core::Object?> #t5 = col::LinkedHashSet::•<core::Object?>();
-        #t5.{core::Set::add}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
-        #t5.{core::Set::add}(42){(core::Object?) → core::bool};
+        #t5.{core::Set::add}{Invariant}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
+        #t5.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
       } =>#t5;
       core::Set<core::Object?> w = block {
         final core::Set<core::Object?> #t6 = col::LinkedHashSet::•<core::Object?>();
-        #t6.{core::Set::add}(42){(core::Object?) → core::bool};
-        #t6.{core::Set::add}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
+        #t6.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+        #t6.{core::Set::add}{Invariant}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
       } =>#t6;
       self::assertRightSubtype(v);
       self::assertLeftSubtype<core::Set<core::Object?>>(v);

pkg/front_end/testcases/nnbd/issue43455.dart.strong.transformed.expect

@@ -10,23 +10,23 @@ class C<X extends core::Object?, Y extends core::Object> extends core::Object {
   method test(generic-covariant-impl self::C::X% x, generic-covariant-impl self::C::Y? y) → dynamic {
     core::Set<core::Object?> v = block {
       final core::Set<core::Object?> #t1 = new col::_CompactLinkedHashSet::•<core::Object?>();
-      #t1.{core::Set::add}(x){(core::Object?) → core::bool};
-      #t1.{core::Set::add}(42){(core::Object?) → core::bool};
+      #t1.{core::Set::add}{Invariant}(x){(core::Object?) → core::bool};
+      #t1.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
     } =>#t1;
     core::Set<core::Object?> w = block {
       final core::Set<core::Object?> #t2 = new col::_CompactLinkedHashSet::•<core::Object?>();
-      #t2.{core::Set::add}(42){(core::Object?) → core::bool};
-      #t2.{core::Set::add}(x){(core::Object?) → core::bool};
+      #t2.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+      #t2.{core::Set::add}{Invariant}(x){(core::Object?) → core::bool};
     } =>#t2;
     core::Set<core::Object?> p = block {
       final core::Set<core::Object?> #t3 = new col::_CompactLinkedHashSet::•<core::Object?>();
-      #t3.{core::Set::add}(y){(core::Object?) → core::bool};
-      #t3.{core::Set::add}(42){(core::Object?) → core::bool};
+      #t3.{core::Set::add}{Invariant}(y){(core::Object?) → core::bool};
+      #t3.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
     } =>#t3;
     core::Set<core::Object?> q = block {
       final core::Set<core::Object?> #t4 = new col::_CompactLinkedHashSet::•<core::Object?>();
-      #t4.{core::Set::add}(42){(core::Object?) → core::bool};
-      #t4.{core::Set::add}(y){(core::Object?) → core::bool};
+      #t4.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+      #t4.{core::Set::add}{Invariant}(y){(core::Object?) → core::bool};
     } =>#t4;
     self::assertRightSubtype(v);
     self::assertLeftSubtype<core::Set<core::Object?>>(v);
@@ -39,13 +39,13 @@ class C<X extends core::Object?, Y extends core::Object> extends core::Object {
     if(x is{ForNonNullableByDefault} core::Object?) {
       core::Set<core::Object?> v = block {
         final core::Set<core::Object?> #t5 = new col::_CompactLinkedHashSet::•<core::Object?>();
-        #t5.{core::Set::add}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
-        #t5.{core::Set::add}(42){(core::Object?) → core::bool};
+        #t5.{core::Set::add}{Invariant}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
+        #t5.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
       } =>#t5;
       core::Set<core::Object?> w = block {
         final core::Set<core::Object?> #t6 = new col::_CompactLinkedHashSet::•<core::Object?>();
-        #t6.{core::Set::add}(42){(core::Object?) → core::bool};
-        #t6.{core::Set::add}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
+        #t6.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+        #t6.{core::Set::add}{Invariant}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
       } =>#t6;
       self::assertRightSubtype(v);
       self::assertLeftSubtype<core::Set<core::Object?>>(v);

pkg/front_end/testcases/nnbd/issue43455.dart.weak.expect

@@ -10,23 +10,23 @@ class C<X extends core::Object?, Y extends core::Object> extends core::Object {
   method test(generic-covariant-impl self::C::X% x, generic-covariant-impl self::C::Y? y) → dynamic {
     core::Set<core::Object?> v = block {
       final core::Set<core::Object?> #t1 = col::LinkedHashSet::•<core::Object?>();
-      #t1.{core::Set::add}(x){(core::Object?) → core::bool};
-      #t1.{core::Set::add}(42){(core::Object?) → core::bool};
+      #t1.{core::Set::add}{Invariant}(x){(core::Object?) → core::bool};
+      #t1.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
     } =>#t1;
     core::Set<core::Object?> w = block {
       final core::Set<core::Object?> #t2 = col::LinkedHashSet::•<core::Object?>();
-      #t2.{core::Set::add}(42){(core::Object?) → core::bool};
-      #t2.{core::Set::add}(x){(core::Object?) → core::bool};
+      #t2.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+      #t2.{core::Set::add}{Invariant}(x){(core::Object?) → core::bool};
     } =>#t2;
     core::Set<core::Object?> p = block {
       final core::Set<core::Object?> #t3 = col::LinkedHashSet::•<core::Object?>();
-      #t3.{core::Set::add}(y){(core::Object?) → core::bool};
-      #t3.{core::Set::add}(42){(core::Object?) → core::bool};
+      #t3.{core::Set::add}{Invariant}(y){(core::Object?) → core::bool};
+      #t3.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
     } =>#t3;
     core::Set<core::Object?> q = block {
       final core::Set<core::Object?> #t4 = col::LinkedHashSet::•<core::Object?>();
-      #t4.{core::Set::add}(42){(core::Object?) → core::bool};
-      #t4.{core::Set::add}(y){(core::Object?) → core::bool};
+      #t4.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+      #t4.{core::Set::add}{Invariant}(y){(core::Object?) → core::bool};
     } =>#t4;
     self::assertRightSubtype(v);
     self::assertLeftSubtype<core::Set<core::Object?>>(v);
@@ -39,13 +39,13 @@ class C<X extends core::Object?, Y extends core::Object> extends core::Object {
     if(x is{ForNonNullableByDefault} core::Object?) {
       core::Set<core::Object?> v = block {
         final core::Set<core::Object?> #t5 = col::LinkedHashSet::•<core::Object?>();
-        #t5.{core::Set::add}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
-        #t5.{core::Set::add}(42){(core::Object?) → core::bool};
+        #t5.{core::Set::add}{Invariant}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
+        #t5.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
       } =>#t5;
       core::Set<core::Object?> w = block {
         final core::Set<core::Object?> #t6 = col::LinkedHashSet::•<core::Object?>();
-        #t6.{core::Set::add}(42){(core::Object?) → core::bool};
-        #t6.{core::Set::add}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
+        #t6.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+        #t6.{core::Set::add}{Invariant}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
       } =>#t6;
       self::assertRightSubtype(v);
       self::assertLeftSubtype<core::Set<core::Object?>>(v);

pkg/front_end/testcases/nnbd/issue43455.dart.weak.transformed.expect

@@ -10,23 +10,23 @@ class C<X extends core::Object?, Y extends core::Object> extends core::Object {
   method test(generic-covariant-impl self::C::X% x, generic-covariant-impl self::C::Y? y) → dynamic {
     core::Set<core::Object?> v = block {
       final core::Set<core::Object?> #t1 = new col::_CompactLinkedHashSet::•<core::Object?>();
-      #t1.{core::Set::add}(x){(core::Object?) → core::bool};
-      #t1.{core::Set::add}(42){(core::Object?) → core::bool};
+      #t1.{core::Set::add}{Invariant}(x){(core::Object?) → core::bool};
+      #t1.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
     } =>#t1;
     core::Set<core::Object?> w = block {
       final core::Set<core::Object?> #t2 = new col::_CompactLinkedHashSet::•<core::Object?>();
-      #t2.{core::Set::add}(42){(core::Object?) → core::bool};
-      #t2.{core::Set::add}(x){(core::Object?) → core::bool};
+      #t2.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+      #t2.{core::Set::add}{Invariant}(x){(core::Object?) → core::bool};
     } =>#t2;
     core::Set<core::Object?> p = block {
       final core::Set<core::Object?> #t3 = new col::_CompactLinkedHashSet::•<core::Object?>();
-      #t3.{core::Set::add}(y){(core::Object?) → core::bool};
-      #t3.{core::Set::add}(42){(core::Object?) → core::bool};
+      #t3.{core::Set::add}{Invariant}(y){(core::Object?) → core::bool};
+      #t3.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
     } =>#t3;
     core::Set<core::Object?> q = block {
       final core::Set<core::Object?> #t4 = new col::_CompactLinkedHashSet::•<core::Object?>();
-      #t4.{core::Set::add}(42){(core::Object?) → core::bool};
-      #t4.{core::Set::add}(y){(core::Object?) → core::bool};
+      #t4.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+      #t4.{core::Set::add}{Invariant}(y){(core::Object?) → core::bool};
     } =>#t4;
     self::assertRightSubtype(v);
     self::assertLeftSubtype<core::Set<core::Object?>>(v);
@@ -39,13 +39,13 @@ class C<X extends core::Object?, Y extends core::Object> extends core::Object {
     if(x is{ForNonNullableByDefault} core::Object?) {
       core::Set<core::Object?> v = block {
         final core::Set<core::Object?> #t5 = new col::_CompactLinkedHashSet::•<core::Object?>();
-        #t5.{core::Set::add}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
-        #t5.{core::Set::add}(42){(core::Object?) → core::bool};
+        #t5.{core::Set::add}{Invariant}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
+        #t5.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
       } =>#t5;
       core::Set<core::Object?> w = block {
         final core::Set<core::Object?> #t6 = new col::_CompactLinkedHashSet::•<core::Object?>();
-        #t6.{core::Set::add}(42){(core::Object?) → core::bool};
-        #t6.{core::Set::add}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
+        #t6.{core::Set::add}{Invariant}(42){(core::Object?) → core::bool};
+        #t6.{core::Set::add}{Invariant}(x{self::C::X% & core::Object? /* '%' & '?' = '%' */}){(core::Object?) → core::bool};
       } =>#t6;
       self::assertRightSubtype(v);
       self::assertLeftSubtype<core::Set<core::Object?>>(v);

pkg/front_end/testcases/nnbd/issue43495.dart.strong.expect

@@ -175,7 +175,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {...a}, // Error.
         ^") {
       final core::int #t3 = #t2 as{TypeError,ForNonNullableByDefault} core::int;
-      #t1.{core::Set::add}(#t3){(core::int) → core::bool};
+      #t1.{core::Set::add}{Invariant}(#t3){(core::int) → core::bool};
     }
   } =>#t1, block {
     final core::Set<core::int> #t4 = col::LinkedHashSet::•<core::int>();
@@ -183,7 +183,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {...b}, // Error.
         ^") {
       final core::int #t6 = #t5 as{TypeError,ForNonNullableByDefault} core::int;
-      #t4.{core::Set::add}(#t6){(core::int) → core::bool};
+      #t4.{core::Set::add}{Invariant}(#t6){(core::int) → core::bool};
     }
   } =>#t4, block {
     final core::Set<core::int> #t7 = col::LinkedHashSet::•<core::int>();
@@ -191,7 +191,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {...c}, // Error.
         ^") {
       final core::int #t9 = #t8 as{TypeError,ForNonNullableByDefault} core::int;
-      #t7.{core::Set::add}(#t9){(core::int) → core::bool};
+      #t7.{core::Set::add}{Invariant}(#t9){(core::int) → core::bool};
     }
   } =>#t7, <core::int, core::int>{invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:11:9: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {...d}, // Error.
@@ -200,7 +200,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     <int, int>{...a}, // Error.
                   ^": null}, block {
     final core::Set<core::int> #t10 = col::LinkedHashSet::•<core::int>();
-    #t10.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:13:14: Error: Unexpected type 'Map<int, int>?' of a spread.  Expected 'dynamic' or an Iterable.
+    #t10.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:13:14: Error: Unexpected type 'Map<int, int>?' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
     <int>{...d}, // Error.
              ^"){(core::int) → core::bool};
@@ -211,7 +211,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {if (condition) ...a}, // Error.
                        ^") {
         final core::int #t13 = #t12 as{TypeError,ForNonNullableByDefault} core::int;
-        #t11.{core::Set::add}(#t13){(core::int) → core::bool};
+        #t11.{core::Set::add}{Invariant}(#t13){(core::int) → core::bool};
       }
   } =>#t11, block {
     final core::Set<core::int> #t14 = col::LinkedHashSet::•<core::int>();
@@ -220,7 +220,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {if (condition) ...b}, // Error.
                        ^") {
         final core::int #t16 = #t15 as{TypeError,ForNonNullableByDefault} core::int;
-        #t14.{core::Set::add}(#t16){(core::int) → core::bool};
+        #t14.{core::Set::add}{Invariant}(#t16){(core::int) → core::bool};
       }
   } =>#t14, block {
     final core::Set<core::int> #t17 = col::LinkedHashSet::•<core::int>();
@@ -229,12 +229,12 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {if (condition) ...c}, // Error.
                        ^") {
         final core::int #t19 = #t18 as{TypeError,ForNonNullableByDefault} core::int;
-        #t17.{core::Set::add}(#t19){(core::int) → core::bool};
+        #t17.{core::Set::add}{Invariant}(#t19){(core::int) → core::bool};
       }
   } =>#t17, block {
     final core::Map<core::int, core::int> #t20 = <core::int, core::int>{};
     if(condition)
-      #t20.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:17:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t20.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:17:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {if (condition) ...d}, // Error.
                        ^", null){(core::int, core::int) → void};
   } =>#t20, block {
@@ -244,7 +244,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (dynamic e in iterable) ...a}, // Error.
                                     ^") {
         final core::int #t23 = #t22 as{TypeError,ForNonNullableByDefault} core::int;
-        #t21.{core::Set::add}(#t23){(core::int) → core::bool};
+        #t21.{core::Set::add}{Invariant}(#t23){(core::int) → core::bool};
       }
   } =>#t21, block {
     final core::Set<core::int> #t24 = col::LinkedHashSet::•<core::int>();
@@ -253,7 +253,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (dynamic e in iterable) ...b}, // Error.
                                     ^") {
         final core::int #t26 = #t25 as{TypeError,ForNonNullableByDefault} core::int;
-        #t24.{core::Set::add}(#t26){(core::int) → core::bool};
+        #t24.{core::Set::add}{Invariant}(#t26){(core::int) → core::bool};
       }
   } =>#t24, block {
     final core::Set<core::int> #t27 = col::LinkedHashSet::•<core::int>();
@@ -262,12 +262,12 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (dynamic e in iterable) ...c}, // Error.
                                     ^") {
         final core::int #t29 = #t28 as{TypeError,ForNonNullableByDefault} core::int;
-        #t27.{core::Set::add}(#t29){(core::int) → core::bool};
+        #t27.{core::Set::add}{Invariant}(#t29){(core::int) → core::bool};
       }
   } =>#t27, block {
     final core::Map<core::int, core::int> #t30 = <core::int, core::int>{};
     for (dynamic e in iterable)
-      #t30.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:21:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t30.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:21:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (dynamic e in iterable) ...d}, // Error.
                                     ^", null){(core::int, core::int) → void};
   } =>#t30, block {
@@ -277,7 +277,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (int i = 0; i < 42; ++i) ...a}, // Error.
                                      ^") {
         final core::int #t33 = #t32 as{TypeError,ForNonNullableByDefault} core::int;
-        #t31.{core::Set::add}(#t33){(core::int) → core::bool};
+        #t31.{core::Set::add}{Invariant}(#t33){(core::int) → core::bool};
       }
   } =>#t31, block {
     final core::Set<core::int> #t34 = col::LinkedHashSet::•<core::int>();
@@ -286,7 +286,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (int i = 0; i < 42; ++i) ...b}, // Error.
                                      ^") {
         final core::int #t36 = #t35 as{TypeError,ForNonNullableByDefault} core::int;
-        #t34.{core::Set::add}(#t36){(core::int) → core::bool};
+        #t34.{core::Set::add}{Invariant}(#t36){(core::int) → core::bool};
       }
   } =>#t34, block {
     final core::Set<core::int> #t37 = col::LinkedHashSet::•<core::int>();
@@ -295,12 +295,12 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (int i = 0; i < 42; ++i) ...c}, // Error.
                                      ^") {
         final core::int #t39 = #t38 as{TypeError,ForNonNullableByDefault} core::int;
-        #t37.{core::Set::add}(#t39){(core::int) → core::bool};
+        #t37.{core::Set::add}{Invariant}(#t39){(core::int) → core::bool};
       }
   } =>#t37, block {
     final core::Map<core::int, core::int> #t40 = <core::int, core::int>{};
     for (core::int i = 0; i.{core::num::<}(42){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t40.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:25:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t40.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:25:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (int i = 0; i < 42; ++i) ...d}, // Error.
                                      ^", null){(core::int, core::int) → void};
   } =>#t40, block {
@@ -309,7 +309,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     if(!(#t42 == null))
       for (final dynamic #t43 in #t42{core::Iterable<dynamic>}) {
         final core::int #t44 = #t43 as{TypeError,ForNonNullableByDefault} core::int;
-        #t41.{core::Set::add}(#t44){(core::int) → core::bool};
+        #t41.{core::Set::add}{Invariant}(#t44){(core::int) → core::bool};
       }
   } =>#t41, block {
     final core::Set<core::int> #t45 = col::LinkedHashSet::•<core::int>();
@@ -317,7 +317,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     if(!(#t46 == null))
       for (final dynamic #t47 in #t46{core::Iterable<dynamic>}) {
         final core::int #t48 = #t47 as{TypeError,ForNonNullableByDefault} core::int;
-        #t45.{core::Set::add}(#t48){(core::int) → core::bool};
+        #t45.{core::Set::add}{Invariant}(#t48){(core::int) → core::bool};
       }
   } =>#t45, block {
     final core::Set<core::int> #t49 = col::LinkedHashSet::•<core::int>();
@@ -325,14 +325,14 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     if(!(#t50 == null))
       for (final dynamic #t51 in #t50{core::Iterable<dynamic>}) {
         final core::int #t52 = #t51 as{TypeError,ForNonNullableByDefault} core::int;
-        #t49.{core::Set::add}(#t52){(core::int) → core::bool};
+        #t49.{core::Set::add}{Invariant}(#t52){(core::int) → core::bool};
       }
   } =>#t49, block {
     final core::Map<core::int, core::int> #t53 = <core::int, core::int>{};
     final core::Map<core::int, core::int>? #t54 = d;
     if(!(#t54 == null))
       for (final core::MapEntry<core::int, core::int> #t55 in #t54{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t53.{core::Map::[]=}(#t55.{core::MapEntry::key}{core::int}, #t55.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t53.{core::Map::[]=}{Invariant}(#t55.{core::MapEntry::key}{core::int}, #t55.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
   } =>#t53, block {
     final core::Set<core::int> #t56 = col::LinkedHashSet::•<core::int>();
     if(condition) {
@@ -340,7 +340,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t57 == null))
         for (final dynamic #t58 in #t57{core::Iterable<dynamic>}) {
           final core::int #t59 = #t58 as{TypeError,ForNonNullableByDefault} core::int;
-          #t56.{core::Set::add}(#t59){(core::int) → core::bool};
+          #t56.{core::Set::add}{Invariant}(#t59){(core::int) → core::bool};
         }
     }
   } =>#t56, block {
@@ -350,7 +350,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t61 == null))
         for (final dynamic #t62 in #t61{core::Iterable<dynamic>}) {
           final core::int #t63 = #t62 as{TypeError,ForNonNullableByDefault} core::int;
-          #t60.{core::Set::add}(#t63){(core::int) → core::bool};
+          #t60.{core::Set::add}{Invariant}(#t63){(core::int) → core::bool};
         }
     }
   } =>#t60, block {
@@ -360,7 +360,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t65 == null))
         for (final dynamic #t66 in #t65{core::Iterable<dynamic>}) {
           final core::int #t67 = #t66 as{TypeError,ForNonNullableByDefault} core::int;
-          #t64.{core::Set::add}(#t67){(core::int) → core::bool};
+          #t64.{core::Set::add}{Invariant}(#t67){(core::int) → core::bool};
         }
     }
   } =>#t64, block {
@@ -369,7 +369,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       final core::Map<core::int, core::int>? #t69 = d;
       if(!(#t69 == null))
         for (final core::MapEntry<core::int, core::int> #t70 in #t69{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t68.{core::Map::[]=}(#t70.{core::MapEntry::key}{core::int}, #t70.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t68.{core::Map::[]=}{Invariant}(#t70.{core::MapEntry::key}{core::int}, #t70.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t68, block {
     final core::Set<core::int> #t71 = col::LinkedHashSet::•<core::int>();
@@ -378,7 +378,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t72 == null))
         for (final dynamic #t73 in #t72{core::Iterable<dynamic>}) {
           final core::int #t74 = #t73 as{TypeError,ForNonNullableByDefault} core::int;
-          #t71.{core::Set::add}(#t74){(core::int) → core::bool};
+          #t71.{core::Set::add}{Invariant}(#t74){(core::int) → core::bool};
         }
     }
   } =>#t71, block {
@@ -388,7 +388,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t76 == null))
         for (final dynamic #t77 in #t76{core::Iterable<dynamic>}) {
           final core::int #t78 = #t77 as{TypeError,ForNonNullableByDefault} core::int;
-          #t75.{core::Set::add}(#t78){(core::int) → core::bool};
+          #t75.{core::Set::add}{Invariant}(#t78){(core::int) → core::bool};
         }
     }
   } =>#t75, block {
@@ -398,7 +398,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t80 == null))
         for (final dynamic #t81 in #t80{core::Iterable<dynamic>}) {
           final core::int #t82 = #t81 as{TypeError,ForNonNullableByDefault} core::int;
-          #t79.{core::Set::add}(#t82){(core::int) → core::bool};
+          #t79.{core::Set::add}{Invariant}(#t82){(core::int) → core::bool};
         }
     }
   } =>#t79, block {
@@ -407,7 +407,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       final core::Map<core::int, core::int>? #t84 = d;
       if(!(#t84 == null))
         for (final core::MapEntry<core::int, core::int> #t85 in #t84{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t83.{core::Map::[]=}(#t85.{core::MapEntry::key}{core::int}, #t85.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t83.{core::Map::[]=}{Invariant}(#t85.{core::MapEntry::key}{core::int}, #t85.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t83, block {
     final core::Set<core::int> #t86 = col::LinkedHashSet::•<core::int>();
@@ -416,7 +416,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t87 == null))
         for (final dynamic #t88 in #t87{core::Iterable<dynamic>}) {
           final core::int #t89 = #t88 as{TypeError,ForNonNullableByDefault} core::int;
-          #t86.{core::Set::add}(#t89){(core::int) → core::bool};
+          #t86.{core::Set::add}{Invariant}(#t89){(core::int) → core::bool};
         }
     }
   } =>#t86, block {
@@ -426,7 +426,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t91 == null))
         for (final dynamic #t92 in #t91{core::Iterable<dynamic>}) {
           final core::int #t93 = #t92 as{TypeError,ForNonNullableByDefault} core::int;
-          #t90.{core::Set::add}(#t93){(core::int) → core::bool};
+          #t90.{core::Set::add}{Invariant}(#t93){(core::int) → core::bool};
         }
     }
   } =>#t90, block {
@@ -436,7 +436,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t95 == null))
         for (final dynamic #t96 in #t95{core::Iterable<dynamic>}) {
           final core::int #t97 = #t96 as{TypeError,ForNonNullableByDefault} core::int;
-          #t94.{core::Set::add}(#t97){(core::int) → core::bool};
+          #t94.{core::Set::add}{Invariant}(#t97){(core::int) → core::bool};
         }
     }
   } =>#t94, block {
@@ -445,7 +445,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       final core::Map<core::int, core::int>? #t99 = d;
       if(!(#t99 == null))
         for (final core::MapEntry<core::int, core::int> #t100 in #t99{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t98.{core::Map::[]=}(#t100.{core::MapEntry::key}{core::int}, #t100.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t98.{core::Map::[]=}{Invariant}(#t100.{core::MapEntry::key}{core::int}, #t100.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t98];
 }
@@ -456,7 +456,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {...x}, // Error.
         ^") {
       final core::int #t103 = #t102 as{TypeError,ForNonNullableByDefault} core::int;
-      #t101.{core::Set::add}(#t103){(core::int) → core::bool};
+      #t101.{core::Set::add}{Invariant}(#t103){(core::int) → core::bool};
     }
   } =>#t101, block {
     final core::Set<core::int> #t104 = col::LinkedHashSet::•<core::int>();
@@ -464,7 +464,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {...y}, // Error.
         ^") {
       final core::int #t106 = #t105 as{TypeError,ForNonNullableByDefault} core::int;
-      #t104.{core::Set::add}(#t106){(core::int) → core::bool};
+      #t104.{core::Set::add}{Invariant}(#t106){(core::int) → core::bool};
     }
   } =>#t104, block {
     final core::Set<core::int> #t107 = col::LinkedHashSet::•<core::int>();
@@ -472,7 +472,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {...z}, // Error.
         ^") {
       final core::int #t109 = #t108 as{TypeError,ForNonNullableByDefault} core::int;
-      #t107.{core::Set::add}(#t109){(core::int) → core::bool};
+      #t107.{core::Set::add}{Invariant}(#t109){(core::int) → core::bool};
     }
   } =>#t107, <core::int, core::int>{invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:53:9: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {...w}, // Error.
@@ -480,7 +480,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     <int, int>{...x}, // Error.
                   ^": null}, block {
     final core::Set<core::int> #t110 = col::LinkedHashSet::•<core::int>();
-    #t110.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:55:14: Error: Unexpected type 'W' of a spread.  Expected 'dynamic' or an Iterable.
+    #t110.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:55:14: Error: Unexpected type 'W' of a spread.  Expected 'dynamic' or an Iterable.
     <int>{...w}, // Error.
              ^"){(core::int) → core::bool};
   } =>#t110, block {
@@ -490,7 +490,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {if (condition) ...x}, // Error.
                        ^") {
         final core::int #t113 = #t112 as{TypeError,ForNonNullableByDefault} core::int;
-        #t111.{core::Set::add}(#t113){(core::int) → core::bool};
+        #t111.{core::Set::add}{Invariant}(#t113){(core::int) → core::bool};
       }
   } =>#t111, block {
     final core::Set<core::int> #t114 = col::LinkedHashSet::•<core::int>();
@@ -499,7 +499,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {if (condition) ...y}, // Error.
                        ^") {
         final core::int #t116 = #t115 as{TypeError,ForNonNullableByDefault} core::int;
-        #t114.{core::Set::add}(#t116){(core::int) → core::bool};
+        #t114.{core::Set::add}{Invariant}(#t116){(core::int) → core::bool};
       }
   } =>#t114, block {
     final core::Set<core::int> #t117 = col::LinkedHashSet::•<core::int>();
@@ -508,12 +508,12 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {if (condition) ...z}, // Error.
                        ^") {
         final core::int #t119 = #t118 as{TypeError,ForNonNullableByDefault} core::int;
-        #t117.{core::Set::add}(#t119){(core::int) → core::bool};
+        #t117.{core::Set::add}{Invariant}(#t119){(core::int) → core::bool};
       }
   } =>#t117, block {
     final core::Map<core::int, core::int> #t120 = <core::int, core::int>{};
     if(condition)
-      #t120.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:59:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:59:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {if (condition) ...w}, // Error.
                        ^", null){(core::int, core::int) → void};
   } =>#t120, block {
@@ -523,7 +523,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (dynamic e in iterable) ...x}, // Error.
                                     ^") {
         final core::int #t123 = #t122 as{TypeError,ForNonNullableByDefault} core::int;
-        #t121.{core::Set::add}(#t123){(core::int) → core::bool};
+        #t121.{core::Set::add}{Invariant}(#t123){(core::int) → core::bool};
       }
   } =>#t121, block {
     final core::Set<core::int> #t124 = col::LinkedHashSet::•<core::int>();
@@ -532,7 +532,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (dynamic e in iterable) ...y}, // Error.
                                     ^") {
         final core::int #t126 = #t125 as{TypeError,ForNonNullableByDefault} core::int;
-        #t124.{core::Set::add}(#t126){(core::int) → core::bool};
+        #t124.{core::Set::add}{Invariant}(#t126){(core::int) → core::bool};
       }
   } =>#t124, block {
     final core::Set<core::int> #t127 = col::LinkedHashSet::•<core::int>();
@@ -541,12 +541,12 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (dynamic e in iterable) ...z}, // Error.
                                     ^") {
         final core::int #t129 = #t128 as{TypeError,ForNonNullableByDefault} core::int;
-        #t127.{core::Set::add}(#t129){(core::int) → core::bool};
+        #t127.{core::Set::add}{Invariant}(#t129){(core::int) → core::bool};
       }
   } =>#t127, block {
     final core::Map<core::int, core::int> #t130 = <core::int, core::int>{};
     for (dynamic e in iterable)
-      #t130.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:63:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t130.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:63:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (dynamic e in iterable) ...w}, // Error.
                                     ^", null){(core::int, core::int) → void};
   } =>#t130, block {
@@ -556,7 +556,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (int i = 0; i < 42; ++i) ...x}, // Error.
                                      ^") {
         final core::int #t133 = #t132 as{TypeError,ForNonNullableByDefault} core::int;
-        #t131.{core::Set::add}(#t133){(core::int) → core::bool};
+        #t131.{core::Set::add}{Invariant}(#t133){(core::int) → core::bool};
       }
   } =>#t131, block {
     final core::Set<core::int> #t134 = col::LinkedHashSet::•<core::int>();
@@ -565,7 +565,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (int i = 0; i < 42; ++i) ...y}, // Error.
                                      ^") {
         final core::int #t136 = #t135 as{TypeError,ForNonNullableByDefault} core::int;
-        #t134.{core::Set::add}(#t136){(core::int) → core::bool};
+        #t134.{core::Set::add}{Invariant}(#t136){(core::int) → core::bool};
       }
   } =>#t134, block {
     final core::Set<core::int> #t137 = col::LinkedHashSet::•<core::int>();
@@ -574,12 +574,12 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (int i = 0; i < 42; ++i) ...z}, // Error.
                                      ^") {
         final core::int #t139 = #t138 as{TypeError,ForNonNullableByDefault} core::int;
-        #t137.{core::Set::add}(#t139){(core::int) → core::bool};
+        #t137.{core::Set::add}{Invariant}(#t139){(core::int) → core::bool};
       }
   } =>#t137, block {
     final core::Map<core::int, core::int> #t140 = <core::int, core::int>{};
     for (core::int i = 0; i.{core::num::<}(42){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t140.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:67:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t140.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:67:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (int i = 0; i < 42; ++i) ...w}, // Error.
                                      ^", null){(core::int, core::int) → void};
   } =>#t140, block {
@@ -588,7 +588,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     if(!(#t142 == null))
       for (final dynamic #t143 in #t142{core::Iterable<dynamic>}) {
         final core::int #t144 = #t143 as{TypeError,ForNonNullableByDefault} core::int;
-        #t141.{core::Set::add}(#t144){(core::int) → core::bool};
+        #t141.{core::Set::add}{Invariant}(#t144){(core::int) → core::bool};
       }
   } =>#t141, block {
     final core::Set<core::int> #t145 = col::LinkedHashSet::•<core::int>();
@@ -596,7 +596,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     if(!(#t146 == null))
       for (final dynamic #t147 in #t146{core::Iterable<dynamic>}) {
         final core::int #t148 = #t147 as{TypeError,ForNonNullableByDefault} core::int;
-        #t145.{core::Set::add}(#t148){(core::int) → core::bool};
+        #t145.{core::Set::add}{Invariant}(#t148){(core::int) → core::bool};
       }
   } =>#t145, block {
     final core::Set<core::int> #t149 = col::LinkedHashSet::•<core::int>();
@@ -604,14 +604,14 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     if(!(#t150 == null))
       for (final dynamic #t151 in #t150{core::Iterable<dynamic>}) {
         final core::int #t152 = #t151 as{TypeError,ForNonNullableByDefault} core::int;
-        #t149.{core::Set::add}(#t152){(core::int) → core::bool};
+        #t149.{core::Set::add}{Invariant}(#t152){(core::int) → core::bool};
       }
   } =>#t149, block {
     final core::Map<core::int, core::int> #t153 = <core::int, core::int>{};
     final core::Map<core::int, core::int>? #t154 = w;
     if(!(#t154 == null))
       for (final core::MapEntry<core::int, core::int> #t155 in #t154{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t153.{core::Map::[]=}(#t155.{core::MapEntry::key}{core::int}, #t155.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t153.{core::Map::[]=}{Invariant}(#t155.{core::MapEntry::key}{core::int}, #t155.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
   } =>#t153, block {
     final core::Set<core::int> #t156 = col::LinkedHashSet::•<core::int>();
     if(condition) {
@@ -619,7 +619,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t157 == null))
         for (final dynamic #t158 in #t157{core::Iterable<dynamic>}) {
           final core::int #t159 = #t158 as{TypeError,ForNonNullableByDefault} core::int;
-          #t156.{core::Set::add}(#t159){(core::int) → core::bool};
+          #t156.{core::Set::add}{Invariant}(#t159){(core::int) → core::bool};
         }
     }
   } =>#t156, block {
@@ -629,7 +629,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t161 == null))
         for (final dynamic #t162 in #t161{core::Iterable<dynamic>}) {
           final core::int #t163 = #t162 as{TypeError,ForNonNullableByDefault} core::int;
-          #t160.{core::Set::add}(#t163){(core::int) → core::bool};
+          #t160.{core::Set::add}{Invariant}(#t163){(core::int) → core::bool};
         }
     }
   } =>#t160, block {
@@ -639,7 +639,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t165 == null))
         for (final dynamic #t166 in #t165{core::Iterable<dynamic>}) {
           final core::int #t167 = #t166 as{TypeError,ForNonNullableByDefault} core::int;
-          #t164.{core::Set::add}(#t167){(core::int) → core::bool};
+          #t164.{core::Set::add}{Invariant}(#t167){(core::int) → core::bool};
         }
     }
   } =>#t164, block {
@@ -648,7 +648,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       final core::Map<core::int, core::int>? #t169 = w;
       if(!(#t169 == null))
         for (final core::MapEntry<core::int, core::int> #t170 in #t169{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t168.{core::Map::[]=}(#t170.{core::MapEntry::key}{core::int}, #t170.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t168.{core::Map::[]=}{Invariant}(#t170.{core::MapEntry::key}{core::int}, #t170.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t168, block {
     final core::Set<core::int> #t171 = col::LinkedHashSet::•<core::int>();
@@ -657,7 +657,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t172 == null))
         for (final dynamic #t173 in #t172{core::Iterable<dynamic>}) {
           final core::int #t174 = #t173 as{TypeError,ForNonNullableByDefault} core::int;
-          #t171.{core::Set::add}(#t174){(core::int) → core::bool};
+          #t171.{core::Set::add}{Invariant}(#t174){(core::int) → core::bool};
         }
     }
   } =>#t171, block {
@@ -667,7 +667,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t176 == null))
         for (final dynamic #t177 in #t176{core::Iterable<dynamic>}) {
           final core::int #t178 = #t177 as{TypeError,ForNonNullableByDefault} core::int;
-          #t175.{core::Set::add}(#t178){(core::int) → core::bool};
+          #t175.{core::Set::add}{Invariant}(#t178){(core::int) → core::bool};
         }
     }
   } =>#t175, block {
@@ -677,7 +677,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t180 == null))
         for (final dynamic #t181 in #t180{core::Iterable<dynamic>}) {
           final core::int #t182 = #t181 as{TypeError,ForNonNullableByDefault} core::int;
-          #t179.{core::Set::add}(#t182){(core::int) → core::bool};
+          #t179.{core::Set::add}{Invariant}(#t182){(core::int) → core::bool};
         }
     }
   } =>#t179, block {
@@ -686,7 +686,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       final core::Map<core::int, core::int>? #t184 = w;
       if(!(#t184 == null))
         for (final core::MapEntry<core::int, core::int> #t185 in #t184{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t183.{core::Map::[]=}(#t185.{core::MapEntry::key}{core::int}, #t185.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t183.{core::Map::[]=}{Invariant}(#t185.{core::MapEntry::key}{core::int}, #t185.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t183, block {
     final core::Set<core::int> #t186 = col::LinkedHashSet::•<core::int>();
@@ -695,7 +695,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t187 == null))
         for (final dynamic #t188 in #t187{core::Iterable<dynamic>}) {
           final core::int #t189 = #t188 as{TypeError,ForNonNullableByDefault} core::int;
-          #t186.{core::Set::add}(#t189){(core::int) → core::bool};
+          #t186.{core::Set::add}{Invariant}(#t189){(core::int) → core::bool};
         }
     }
   } =>#t186, block {
@@ -705,7 +705,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t191 == null))
         for (final dynamic #t192 in #t191{core::Iterable<dynamic>}) {
           final core::int #t193 = #t192 as{TypeError,ForNonNullableByDefault} core::int;
-          #t190.{core::Set::add}(#t193){(core::int) → core::bool};
+          #t190.{core::Set::add}{Invariant}(#t193){(core::int) → core::bool};
         }
     }
   } =>#t190, block {
@@ -715,7 +715,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t195 == null))
         for (final dynamic #t196 in #t195{core::Iterable<dynamic>}) {
           final core::int #t197 = #t196 as{TypeError,ForNonNullableByDefault} core::int;
-          #t194.{core::Set::add}(#t197){(core::int) → core::bool};
+          #t194.{core::Set::add}{Invariant}(#t197){(core::int) → core::bool};
         }
     }
   } =>#t194, block {
@@ -724,7 +724,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       final core::Map<core::int, core::int>? #t199 = w;
       if(!(#t199 == null))
         for (final core::MapEntry<core::int, core::int> #t200 in #t199{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t198.{core::Map::[]=}(#t200.{core::MapEntry::key}{core::int}, #t200.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t198.{core::Map::[]=}{Invariant}(#t200.{core::MapEntry::key}{core::int}, #t200.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t198];
 }

pkg/front_end/testcases/nnbd/issue43495.dart.strong.transformed.expect

@@ -179,7 +179,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t2 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t3 = #t2 as{TypeError,ForNonNullableByDefault} core::int;
-          #t1.{core::Set::add}(#t3){(core::int) → core::bool};
+          #t1.{core::Set::add}{Invariant}(#t3){(core::int) → core::bool};
         }
       }
     }
@@ -193,7 +193,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t5 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t6 = #t5 as{TypeError,ForNonNullableByDefault} core::int;
-          #t4.{core::Set::add}(#t6){(core::int) → core::bool};
+          #t4.{core::Set::add}{Invariant}(#t6){(core::int) → core::bool};
         }
       }
     }
@@ -207,7 +207,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t8 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t9 = #t8 as{TypeError,ForNonNullableByDefault} core::int;
-          #t7.{core::Set::add}(#t9){(core::int) → core::bool};
+          #t7.{core::Set::add}{Invariant}(#t9){(core::int) → core::bool};
         }
       }
     }
@@ -218,7 +218,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     <int, int>{...a}, // Error.
                   ^": null}, block {
     final core::Set<core::int> #t10 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t10.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:13:14: Error: Unexpected type 'Map<int, int>?' of a spread.  Expected 'dynamic' or an Iterable.
+    #t10.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:13:14: Error: Unexpected type 'Map<int, int>?' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
     <int>{...d}, // Error.
              ^"){(core::int) → core::bool};
@@ -232,7 +232,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t12 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t13 = #t12 as{TypeError,ForNonNullableByDefault} core::int;
-          #t11.{core::Set::add}(#t13){(core::int) → core::bool};
+          #t11.{core::Set::add}{Invariant}(#t13){(core::int) → core::bool};
         }
       }
     }
@@ -246,7 +246,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t15 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t16 = #t15 as{TypeError,ForNonNullableByDefault} core::int;
-          #t14.{core::Set::add}(#t16){(core::int) → core::bool};
+          #t14.{core::Set::add}{Invariant}(#t16){(core::int) → core::bool};
         }
       }
     }
@@ -260,14 +260,14 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t18 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t19 = #t18 as{TypeError,ForNonNullableByDefault} core::int;
-          #t17.{core::Set::add}(#t19){(core::int) → core::bool};
+          #t17.{core::Set::add}{Invariant}(#t19){(core::int) → core::bool};
         }
       }
     }
   } =>#t17, block {
     final core::Map<core::int, core::int> #t20 = <core::int, core::int>{};
     if(condition)
-      #t20.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:17:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t20.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:17:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {if (condition) ...d}, // Error.
                        ^", null){(core::int, core::int) → void};
   } =>#t20, block {
@@ -284,7 +284,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
             final dynamic #t22 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t23 = #t22 as{TypeError,ForNonNullableByDefault} core::int;
-              #t21.{core::Set::add}(#t23){(core::int) → core::bool};
+              #t21.{core::Set::add}{Invariant}(#t23){(core::int) → core::bool};
             }
           }
         }
@@ -304,7 +304,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
             final dynamic #t25 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t26 = #t25 as{TypeError,ForNonNullableByDefault} core::int;
-              #t24.{core::Set::add}(#t26){(core::int) → core::bool};
+              #t24.{core::Set::add}{Invariant}(#t26){(core::int) → core::bool};
             }
           }
         }
@@ -324,7 +324,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
             final dynamic #t28 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t29 = #t28 as{TypeError,ForNonNullableByDefault} core::int;
-              #t27.{core::Set::add}(#t29){(core::int) → core::bool};
+              #t27.{core::Set::add}{Invariant}(#t29){(core::int) → core::bool};
             }
           }
         }
@@ -336,7 +336,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       core::Iterator<dynamic> :sync-for-iterator = iterable.{core::Iterable::iterator}{core::Iterator<dynamic>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic e = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t30.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:21:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+        #t30.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:21:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (dynamic e in iterable) ...d}, // Error.
                                     ^", null){(core::int, core::int) → void};
       }
@@ -351,7 +351,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t32 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t33 = #t32 as{TypeError,ForNonNullableByDefault} core::int;
-          #t31.{core::Set::add}(#t33){(core::int) → core::bool};
+          #t31.{core::Set::add}{Invariant}(#t33){(core::int) → core::bool};
         }
       }
     }
@@ -365,7 +365,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t35 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t36 = #t35 as{TypeError,ForNonNullableByDefault} core::int;
-          #t34.{core::Set::add}(#t36){(core::int) → core::bool};
+          #t34.{core::Set::add}{Invariant}(#t36){(core::int) → core::bool};
         }
       }
     }
@@ -379,14 +379,14 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t38 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t39 = #t38 as{TypeError,ForNonNullableByDefault} core::int;
-          #t37.{core::Set::add}(#t39){(core::int) → core::bool};
+          #t37.{core::Set::add}{Invariant}(#t39){(core::int) → core::bool};
         }
       }
     }
   } =>#t37, block {
     final core::Map<core::int, core::int> #t40 = <core::int, core::int>{};
     for (core::int i = 0; i.{core::num::<}(42){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t40.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:25:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t40.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:25:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (int i = 0; i < 42; ++i) ...d}, // Error.
                                      ^", null){(core::int, core::int) → void};
   } =>#t40, block {
@@ -398,7 +398,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t43 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t44 = #t43 as{TypeError,ForNonNullableByDefault} core::int;
-          #t41.{core::Set::add}(#t44){(core::int) → core::bool};
+          #t41.{core::Set::add}{Invariant}(#t44){(core::int) → core::bool};
         }
       }
     }
@@ -411,7 +411,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t47 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t48 = #t47 as{TypeError,ForNonNullableByDefault} core::int;
-          #t45.{core::Set::add}(#t48){(core::int) → core::bool};
+          #t45.{core::Set::add}{Invariant}(#t48){(core::int) → core::bool};
         }
       }
     }
@@ -424,7 +424,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t51 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t52 = #t51 as{TypeError,ForNonNullableByDefault} core::int;
-          #t49.{core::Set::add}(#t52){(core::int) → core::bool};
+          #t49.{core::Set::add}{Invariant}(#t52){(core::int) → core::bool};
         }
       }
     }
@@ -435,7 +435,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t54{core::Map<core::int, 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> #t55 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t53.{core::Map::[]=}(#t55.{core::MapEntry::key}{core::int}, #t55.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t53.{core::Map::[]=}{Invariant}(#t55.{core::MapEntry::key}{core::int}, #t55.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
   } =>#t53, block {
@@ -448,7 +448,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t58 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t59 = #t58 as{TypeError,ForNonNullableByDefault} core::int;
-            #t56.{core::Set::add}(#t59){(core::int) → core::bool};
+            #t56.{core::Set::add}{Invariant}(#t59){(core::int) → core::bool};
           }
         }
       }
@@ -463,7 +463,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t62 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t63 = #t62 as{TypeError,ForNonNullableByDefault} core::int;
-            #t60.{core::Set::add}(#t63){(core::int) → core::bool};
+            #t60.{core::Set::add}{Invariant}(#t63){(core::int) → core::bool};
           }
         }
       }
@@ -478,7 +478,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t66 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t67 = #t66 as{TypeError,ForNonNullableByDefault} core::int;
-            #t64.{core::Set::add}(#t67){(core::int) → core::bool};
+            #t64.{core::Set::add}{Invariant}(#t67){(core::int) → core::bool};
           }
         }
       }
@@ -491,7 +491,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t69{core::Map<core::int, 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> #t70 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-          #t68.{core::Map::[]=}(#t70.{core::MapEntry::key}{core::int}, #t70.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t68.{core::Map::[]=}{Invariant}(#t70.{core::MapEntry::key}{core::int}, #t70.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
         }
       }
     }
@@ -509,7 +509,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
               final dynamic #t73 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t74 = #t73 as{TypeError,ForNonNullableByDefault} core::int;
-                #t71.{core::Set::add}(#t74){(core::int) → core::bool};
+                #t71.{core::Set::add}{Invariant}(#t74){(core::int) → core::bool};
               }
             }
           }
@@ -530,7 +530,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
               final dynamic #t77 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t78 = #t77 as{TypeError,ForNonNullableByDefault} core::int;
-                #t75.{core::Set::add}(#t78){(core::int) → core::bool};
+                #t75.{core::Set::add}{Invariant}(#t78){(core::int) → core::bool};
               }
             }
           }
@@ -551,7 +551,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
               final dynamic #t81 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t82 = #t81 as{TypeError,ForNonNullableByDefault} core::int;
-                #t79.{core::Set::add}(#t82){(core::int) → core::bool};
+                #t79.{core::Set::add}{Invariant}(#t82){(core::int) → core::bool};
               }
             }
           }
@@ -570,7 +570,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
             core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t84{core::Map<core::int, 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> #t85 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-              #t83.{core::Map::[]=}(#t85.{core::MapEntry::key}{core::int}, #t85.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+              #t83.{core::Map::[]=}{Invariant}(#t85.{core::MapEntry::key}{core::int}, #t85.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
             }
           }
         }
@@ -586,7 +586,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t88 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t89 = #t88 as{TypeError,ForNonNullableByDefault} core::int;
-            #t86.{core::Set::add}(#t89){(core::int) → core::bool};
+            #t86.{core::Set::add}{Invariant}(#t89){(core::int) → core::bool};
           }
         }
       }
@@ -601,7 +601,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t92 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t93 = #t92 as{TypeError,ForNonNullableByDefault} core::int;
-            #t90.{core::Set::add}(#t93){(core::int) → core::bool};
+            #t90.{core::Set::add}{Invariant}(#t93){(core::int) → core::bool};
           }
         }
       }
@@ -616,7 +616,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t96 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t97 = #t96 as{TypeError,ForNonNullableByDefault} core::int;
-            #t94.{core::Set::add}(#t97){(core::int) → core::bool};
+            #t94.{core::Set::add}{Invariant}(#t97){(core::int) → core::bool};
           }
         }
       }
@@ -629,7 +629,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t99{core::Map<core::int, 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> #t100 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-          #t98.{core::Map::[]=}(#t100.{core::MapEntry::key}{core::int}, #t100.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t98.{core::Map::[]=}{Invariant}(#t100.{core::MapEntry::key}{core::int}, #t100.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
         }
       }
     }
@@ -646,7 +646,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t102 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t103 = #t102 as{TypeError,ForNonNullableByDefault} core::int;
-          #t101.{core::Set::add}(#t103){(core::int) → core::bool};
+          #t101.{core::Set::add}{Invariant}(#t103){(core::int) → core::bool};
         }
       }
     }
@@ -660,7 +660,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t105 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t106 = #t105 as{TypeError,ForNonNullableByDefault} core::int;
-          #t104.{core::Set::add}(#t106){(core::int) → core::bool};
+          #t104.{core::Set::add}{Invariant}(#t106){(core::int) → core::bool};
         }
       }
     }
@@ -674,7 +674,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t108 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t109 = #t108 as{TypeError,ForNonNullableByDefault} core::int;
-          #t107.{core::Set::add}(#t109){(core::int) → core::bool};
+          #t107.{core::Set::add}{Invariant}(#t109){(core::int) → core::bool};
         }
       }
     }
@@ -684,7 +684,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     <int, int>{...x}, // Error.
                   ^": null}, block {
     final core::Set<core::int> #t110 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t110.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:55:14: Error: Unexpected type 'W' of a spread.  Expected 'dynamic' or an Iterable.
+    #t110.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:55:14: Error: Unexpected type 'W' of a spread.  Expected 'dynamic' or an Iterable.
     <int>{...w}, // Error.
              ^"){(core::int) → core::bool};
   } =>#t110, block {
@@ -697,7 +697,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t112 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t113 = #t112 as{TypeError,ForNonNullableByDefault} core::int;
-          #t111.{core::Set::add}(#t113){(core::int) → core::bool};
+          #t111.{core::Set::add}{Invariant}(#t113){(core::int) → core::bool};
         }
       }
     }
@@ -711,7 +711,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t115 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t116 = #t115 as{TypeError,ForNonNullableByDefault} core::int;
-          #t114.{core::Set::add}(#t116){(core::int) → core::bool};
+          #t114.{core::Set::add}{Invariant}(#t116){(core::int) → core::bool};
         }
       }
     }
@@ -725,14 +725,14 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t118 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t119 = #t118 as{TypeError,ForNonNullableByDefault} core::int;
-          #t117.{core::Set::add}(#t119){(core::int) → core::bool};
+          #t117.{core::Set::add}{Invariant}(#t119){(core::int) → core::bool};
         }
       }
     }
   } =>#t117, block {
     final core::Map<core::int, core::int> #t120 = <core::int, core::int>{};
     if(condition)
-      #t120.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:59:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:59:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {if (condition) ...w}, // Error.
                        ^", null){(core::int, core::int) → void};
   } =>#t120, block {
@@ -749,7 +749,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
             final dynamic #t122 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t123 = #t122 as{TypeError,ForNonNullableByDefault} core::int;
-              #t121.{core::Set::add}(#t123){(core::int) → core::bool};
+              #t121.{core::Set::add}{Invariant}(#t123){(core::int) → core::bool};
             }
           }
         }
@@ -769,7 +769,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
             final dynamic #t125 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t126 = #t125 as{TypeError,ForNonNullableByDefault} core::int;
-              #t124.{core::Set::add}(#t126){(core::int) → core::bool};
+              #t124.{core::Set::add}{Invariant}(#t126){(core::int) → core::bool};
             }
           }
         }
@@ -789,7 +789,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
             final dynamic #t128 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t129 = #t128 as{TypeError,ForNonNullableByDefault} core::int;
-              #t127.{core::Set::add}(#t129){(core::int) → core::bool};
+              #t127.{core::Set::add}{Invariant}(#t129){(core::int) → core::bool};
             }
           }
         }
@@ -801,7 +801,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       core::Iterator<dynamic> :sync-for-iterator = iterable.{core::Iterable::iterator}{core::Iterator<dynamic>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic e = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t130.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:63:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+        #t130.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:63:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (dynamic e in iterable) ...w}, // Error.
                                     ^", null){(core::int, core::int) → void};
       }
@@ -816,7 +816,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t132 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t133 = #t132 as{TypeError,ForNonNullableByDefault} core::int;
-          #t131.{core::Set::add}(#t133){(core::int) → core::bool};
+          #t131.{core::Set::add}{Invariant}(#t133){(core::int) → core::bool};
         }
       }
     }
@@ -830,7 +830,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t135 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t136 = #t135 as{TypeError,ForNonNullableByDefault} core::int;
-          #t134.{core::Set::add}(#t136){(core::int) → core::bool};
+          #t134.{core::Set::add}{Invariant}(#t136){(core::int) → core::bool};
         }
       }
     }
@@ -844,14 +844,14 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t138 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t139 = #t138 as{TypeError,ForNonNullableByDefault} core::int;
-          #t137.{core::Set::add}(#t139){(core::int) → core::bool};
+          #t137.{core::Set::add}{Invariant}(#t139){(core::int) → core::bool};
         }
       }
     }
   } =>#t137, block {
     final core::Map<core::int, core::int> #t140 = <core::int, core::int>{};
     for (core::int i = 0; i.{core::num::<}(42){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t140.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:67:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t140.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:67:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (int i = 0; i < 42; ++i) ...w}, // Error.
                                      ^", null){(core::int, core::int) → void};
   } =>#t140, block {
@@ -863,7 +863,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t143 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t144 = #t143 as{TypeError,ForNonNullableByDefault} core::int;
-          #t141.{core::Set::add}(#t144){(core::int) → core::bool};
+          #t141.{core::Set::add}{Invariant}(#t144){(core::int) → core::bool};
         }
       }
     }
@@ -876,7 +876,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t147 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t148 = #t147 as{TypeError,ForNonNullableByDefault} core::int;
-          #t145.{core::Set::add}(#t148){(core::int) → core::bool};
+          #t145.{core::Set::add}{Invariant}(#t148){(core::int) → core::bool};
         }
       }
     }
@@ -889,7 +889,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t151 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t152 = #t151 as{TypeError,ForNonNullableByDefault} core::int;
-          #t149.{core::Set::add}(#t152){(core::int) → core::bool};
+          #t149.{core::Set::add}{Invariant}(#t152){(core::int) → core::bool};
         }
       }
     }
@@ -900,7 +900,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t154{core::Map<core::int, 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> #t155 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t153.{core::Map::[]=}(#t155.{core::MapEntry::key}{core::int}, #t155.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t153.{core::Map::[]=}{Invariant}(#t155.{core::MapEntry::key}{core::int}, #t155.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
   } =>#t153, block {
@@ -913,7 +913,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t158 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t159 = #t158 as{TypeError,ForNonNullableByDefault} core::int;
-            #t156.{core::Set::add}(#t159){(core::int) → core::bool};
+            #t156.{core::Set::add}{Invariant}(#t159){(core::int) → core::bool};
           }
         }
       }
@@ -928,7 +928,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t162 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t163 = #t162 as{TypeError,ForNonNullableByDefault} core::int;
-            #t160.{core::Set::add}(#t163){(core::int) → core::bool};
+            #t160.{core::Set::add}{Invariant}(#t163){(core::int) → core::bool};
           }
         }
       }
@@ -943,7 +943,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t166 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t167 = #t166 as{TypeError,ForNonNullableByDefault} core::int;
-            #t164.{core::Set::add}(#t167){(core::int) → core::bool};
+            #t164.{core::Set::add}{Invariant}(#t167){(core::int) → core::bool};
           }
         }
       }
@@ -956,7 +956,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t169{core::Map<core::int, 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> #t170 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-          #t168.{core::Map::[]=}(#t170.{core::MapEntry::key}{core::int}, #t170.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t168.{core::Map::[]=}{Invariant}(#t170.{core::MapEntry::key}{core::int}, #t170.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
         }
       }
     }
@@ -974,7 +974,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
               final dynamic #t173 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t174 = #t173 as{TypeError,ForNonNullableByDefault} core::int;
-                #t171.{core::Set::add}(#t174){(core::int) → core::bool};
+                #t171.{core::Set::add}{Invariant}(#t174){(core::int) → core::bool};
               }
             }
           }
@@ -995,7 +995,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
               final dynamic #t177 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t178 = #t177 as{TypeError,ForNonNullableByDefault} core::int;
-                #t175.{core::Set::add}(#t178){(core::int) → core::bool};
+                #t175.{core::Set::add}{Invariant}(#t178){(core::int) → core::bool};
               }
             }
           }
@@ -1016,7 +1016,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
               final dynamic #t181 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t182 = #t181 as{TypeError,ForNonNullableByDefault} core::int;
-                #t179.{core::Set::add}(#t182){(core::int) → core::bool};
+                #t179.{core::Set::add}{Invariant}(#t182){(core::int) → core::bool};
               }
             }
           }
@@ -1035,7 +1035,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
             core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t184{core::Map<core::int, 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> #t185 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-              #t183.{core::Map::[]=}(#t185.{core::MapEntry::key}{core::int}, #t185.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+              #t183.{core::Map::[]=}{Invariant}(#t185.{core::MapEntry::key}{core::int}, #t185.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
             }
           }
         }
@@ -1051,7 +1051,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t188 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t189 = #t188 as{TypeError,ForNonNullableByDefault} core::int;
-            #t186.{core::Set::add}(#t189){(core::int) → core::bool};
+            #t186.{core::Set::add}{Invariant}(#t189){(core::int) → core::bool};
           }
         }
       }
@@ -1066,7 +1066,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t192 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t193 = #t192 as{TypeError,ForNonNullableByDefault} core::int;
-            #t190.{core::Set::add}(#t193){(core::int) → core::bool};
+            #t190.{core::Set::add}{Invariant}(#t193){(core::int) → core::bool};
           }
         }
       }
@@ -1081,7 +1081,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t196 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t197 = #t196 as{TypeError,ForNonNullableByDefault} core::int;
-            #t194.{core::Set::add}(#t197){(core::int) → core::bool};
+            #t194.{core::Set::add}{Invariant}(#t197){(core::int) → core::bool};
           }
         }
       }
@@ -1094,7 +1094,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t199{core::Map<core::int, 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> #t200 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-          #t198.{core::Map::[]=}(#t200.{core::MapEntry::key}{core::int}, #t200.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t198.{core::Map::[]=}{Invariant}(#t200.{core::MapEntry::key}{core::int}, #t200.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
         }
       }
     }

pkg/front_end/testcases/nnbd/issue43495.dart.weak.expect

@@ -175,7 +175,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {...a}, // Error.
         ^") {
       final core::int #t3 = #t2 as{TypeError,ForNonNullableByDefault} core::int;
-      #t1.{core::Set::add}(#t3){(core::int) → core::bool};
+      #t1.{core::Set::add}{Invariant}(#t3){(core::int) → core::bool};
     }
   } =>#t1, block {
     final core::Set<core::int> #t4 = col::LinkedHashSet::•<core::int>();
@@ -183,7 +183,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {...b}, // Error.
         ^") {
       final core::int #t6 = #t5 as{TypeError,ForNonNullableByDefault} core::int;
-      #t4.{core::Set::add}(#t6){(core::int) → core::bool};
+      #t4.{core::Set::add}{Invariant}(#t6){(core::int) → core::bool};
     }
   } =>#t4, block {
     final core::Set<core::int> #t7 = col::LinkedHashSet::•<core::int>();
@@ -191,7 +191,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {...c}, // Error.
         ^") {
       final core::int #t9 = #t8 as{TypeError,ForNonNullableByDefault} core::int;
-      #t7.{core::Set::add}(#t9){(core::int) → core::bool};
+      #t7.{core::Set::add}{Invariant}(#t9){(core::int) → core::bool};
     }
   } =>#t7, <core::int, core::int>{invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:11:9: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {...d}, // Error.
@@ -200,7 +200,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     <int, int>{...a}, // Error.
                   ^": null}, block {
     final core::Set<core::int> #t10 = col::LinkedHashSet::•<core::int>();
-    #t10.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:13:14: Error: Unexpected type 'Map<int, int>?' of a spread.  Expected 'dynamic' or an Iterable.
+    #t10.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:13:14: Error: Unexpected type 'Map<int, int>?' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
     <int>{...d}, // Error.
              ^"){(core::int) → core::bool};
@@ -211,7 +211,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {if (condition) ...a}, // Error.
                        ^") {
         final core::int #t13 = #t12 as{TypeError,ForNonNullableByDefault} core::int;
-        #t11.{core::Set::add}(#t13){(core::int) → core::bool};
+        #t11.{core::Set::add}{Invariant}(#t13){(core::int) → core::bool};
       }
   } =>#t11, block {
     final core::Set<core::int> #t14 = col::LinkedHashSet::•<core::int>();
@@ -220,7 +220,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {if (condition) ...b}, // Error.
                        ^") {
         final core::int #t16 = #t15 as{TypeError,ForNonNullableByDefault} core::int;
-        #t14.{core::Set::add}(#t16){(core::int) → core::bool};
+        #t14.{core::Set::add}{Invariant}(#t16){(core::int) → core::bool};
       }
   } =>#t14, block {
     final core::Set<core::int> #t17 = col::LinkedHashSet::•<core::int>();
@@ -229,12 +229,12 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {if (condition) ...c}, // Error.
                        ^") {
         final core::int #t19 = #t18 as{TypeError,ForNonNullableByDefault} core::int;
-        #t17.{core::Set::add}(#t19){(core::int) → core::bool};
+        #t17.{core::Set::add}{Invariant}(#t19){(core::int) → core::bool};
       }
   } =>#t17, block {
     final core::Map<core::int, core::int> #t20 = <core::int, core::int>{};
     if(condition)
-      #t20.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:17:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t20.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:17:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {if (condition) ...d}, // Error.
                        ^", null){(core::int, core::int) → void};
   } =>#t20, block {
@@ -244,7 +244,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (dynamic e in iterable) ...a}, // Error.
                                     ^") {
         final core::int #t23 = #t22 as{TypeError,ForNonNullableByDefault} core::int;
-        #t21.{core::Set::add}(#t23){(core::int) → core::bool};
+        #t21.{core::Set::add}{Invariant}(#t23){(core::int) → core::bool};
       }
   } =>#t21, block {
     final core::Set<core::int> #t24 = col::LinkedHashSet::•<core::int>();
@@ -253,7 +253,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (dynamic e in iterable) ...b}, // Error.
                                     ^") {
         final core::int #t26 = #t25 as{TypeError,ForNonNullableByDefault} core::int;
-        #t24.{core::Set::add}(#t26){(core::int) → core::bool};
+        #t24.{core::Set::add}{Invariant}(#t26){(core::int) → core::bool};
       }
   } =>#t24, block {
     final core::Set<core::int> #t27 = col::LinkedHashSet::•<core::int>();
@@ -262,12 +262,12 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (dynamic e in iterable) ...c}, // Error.
                                     ^") {
         final core::int #t29 = #t28 as{TypeError,ForNonNullableByDefault} core::int;
-        #t27.{core::Set::add}(#t29){(core::int) → core::bool};
+        #t27.{core::Set::add}{Invariant}(#t29){(core::int) → core::bool};
       }
   } =>#t27, block {
     final core::Map<core::int, core::int> #t30 = <core::int, core::int>{};
     for (dynamic e in iterable)
-      #t30.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:21:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t30.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:21:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (dynamic e in iterable) ...d}, // Error.
                                     ^", null){(core::int, core::int) → void};
   } =>#t30, block {
@@ -277,7 +277,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (int i = 0; i < 42; ++i) ...a}, // Error.
                                      ^") {
         final core::int #t33 = #t32 as{TypeError,ForNonNullableByDefault} core::int;
-        #t31.{core::Set::add}(#t33){(core::int) → core::bool};
+        #t31.{core::Set::add}{Invariant}(#t33){(core::int) → core::bool};
       }
   } =>#t31, block {
     final core::Set<core::int> #t34 = col::LinkedHashSet::•<core::int>();
@@ -286,7 +286,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (int i = 0; i < 42; ++i) ...b}, // Error.
                                      ^") {
         final core::int #t36 = #t35 as{TypeError,ForNonNullableByDefault} core::int;
-        #t34.{core::Set::add}(#t36){(core::int) → core::bool};
+        #t34.{core::Set::add}{Invariant}(#t36){(core::int) → core::bool};
       }
   } =>#t34, block {
     final core::Set<core::int> #t37 = col::LinkedHashSet::•<core::int>();
@@ -295,12 +295,12 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     {for (int i = 0; i < 42; ++i) ...c}, // Error.
                                      ^") {
         final core::int #t39 = #t38 as{TypeError,ForNonNullableByDefault} core::int;
-        #t37.{core::Set::add}(#t39){(core::int) → core::bool};
+        #t37.{core::Set::add}{Invariant}(#t39){(core::int) → core::bool};
       }
   } =>#t37, block {
     final core::Map<core::int, core::int> #t40 = <core::int, core::int>{};
     for (core::int i = 0; i.{core::num::<}(42){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t40.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:25:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t40.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:25:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (int i = 0; i < 42; ++i) ...d}, // Error.
                                      ^", null){(core::int, core::int) → void};
   } =>#t40, block {
@@ -309,7 +309,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     if(!(#t42 == null))
       for (final dynamic #t43 in #t42{core::Iterable<dynamic>}) {
         final core::int #t44 = #t43 as{TypeError,ForNonNullableByDefault} core::int;
-        #t41.{core::Set::add}(#t44){(core::int) → core::bool};
+        #t41.{core::Set::add}{Invariant}(#t44){(core::int) → core::bool};
       }
   } =>#t41, block {
     final core::Set<core::int> #t45 = col::LinkedHashSet::•<core::int>();
@@ -317,7 +317,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     if(!(#t46 == null))
       for (final dynamic #t47 in #t46{core::Iterable<dynamic>}) {
         final core::int #t48 = #t47 as{TypeError,ForNonNullableByDefault} core::int;
-        #t45.{core::Set::add}(#t48){(core::int) → core::bool};
+        #t45.{core::Set::add}{Invariant}(#t48){(core::int) → core::bool};
       }
   } =>#t45, block {
     final core::Set<core::int> #t49 = col::LinkedHashSet::•<core::int>();
@@ -325,14 +325,14 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     if(!(#t50 == null))
       for (final dynamic #t51 in #t50{core::Iterable<dynamic>}) {
         final core::int #t52 = #t51 as{TypeError,ForNonNullableByDefault} core::int;
-        #t49.{core::Set::add}(#t52){(core::int) → core::bool};
+        #t49.{core::Set::add}{Invariant}(#t52){(core::int) → core::bool};
       }
   } =>#t49, block {
     final core::Map<core::int, core::int> #t53 = <core::int, core::int>{};
     final core::Map<core::int, core::int>? #t54 = d;
     if(!(#t54 == null))
       for (final core::MapEntry<core::int, core::int> #t55 in #t54{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t53.{core::Map::[]=}(#t55.{core::MapEntry::key}{core::int}, #t55.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t53.{core::Map::[]=}{Invariant}(#t55.{core::MapEntry::key}{core::int}, #t55.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
   } =>#t53, block {
     final core::Set<core::int> #t56 = col::LinkedHashSet::•<core::int>();
     if(condition) {
@@ -340,7 +340,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t57 == null))
         for (final dynamic #t58 in #t57{core::Iterable<dynamic>}) {
           final core::int #t59 = #t58 as{TypeError,ForNonNullableByDefault} core::int;
-          #t56.{core::Set::add}(#t59){(core::int) → core::bool};
+          #t56.{core::Set::add}{Invariant}(#t59){(core::int) → core::bool};
         }
     }
   } =>#t56, block {
@@ -350,7 +350,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t61 == null))
         for (final dynamic #t62 in #t61{core::Iterable<dynamic>}) {
           final core::int #t63 = #t62 as{TypeError,ForNonNullableByDefault} core::int;
-          #t60.{core::Set::add}(#t63){(core::int) → core::bool};
+          #t60.{core::Set::add}{Invariant}(#t63){(core::int) → core::bool};
         }
     }
   } =>#t60, block {
@@ -360,7 +360,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t65 == null))
         for (final dynamic #t66 in #t65{core::Iterable<dynamic>}) {
           final core::int #t67 = #t66 as{TypeError,ForNonNullableByDefault} core::int;
-          #t64.{core::Set::add}(#t67){(core::int) → core::bool};
+          #t64.{core::Set::add}{Invariant}(#t67){(core::int) → core::bool};
         }
     }
   } =>#t64, block {
@@ -369,7 +369,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       final core::Map<core::int, core::int>? #t69 = d;
       if(!(#t69 == null))
         for (final core::MapEntry<core::int, core::int> #t70 in #t69{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t68.{core::Map::[]=}(#t70.{core::MapEntry::key}{core::int}, #t70.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t68.{core::Map::[]=}{Invariant}(#t70.{core::MapEntry::key}{core::int}, #t70.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t68, block {
     final core::Set<core::int> #t71 = col::LinkedHashSet::•<core::int>();
@@ -378,7 +378,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t72 == null))
         for (final dynamic #t73 in #t72{core::Iterable<dynamic>}) {
           final core::int #t74 = #t73 as{TypeError,ForNonNullableByDefault} core::int;
-          #t71.{core::Set::add}(#t74){(core::int) → core::bool};
+          #t71.{core::Set::add}{Invariant}(#t74){(core::int) → core::bool};
         }
     }
   } =>#t71, block {
@@ -388,7 +388,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t76 == null))
         for (final dynamic #t77 in #t76{core::Iterable<dynamic>}) {
           final core::int #t78 = #t77 as{TypeError,ForNonNullableByDefault} core::int;
-          #t75.{core::Set::add}(#t78){(core::int) → core::bool};
+          #t75.{core::Set::add}{Invariant}(#t78){(core::int) → core::bool};
         }
     }
   } =>#t75, block {
@@ -398,7 +398,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t80 == null))
         for (final dynamic #t81 in #t80{core::Iterable<dynamic>}) {
           final core::int #t82 = #t81 as{TypeError,ForNonNullableByDefault} core::int;
-          #t79.{core::Set::add}(#t82){(core::int) → core::bool};
+          #t79.{core::Set::add}{Invariant}(#t82){(core::int) → core::bool};
         }
     }
   } =>#t79, block {
@@ -407,7 +407,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       final core::Map<core::int, core::int>? #t84 = d;
       if(!(#t84 == null))
         for (final core::MapEntry<core::int, core::int> #t85 in #t84{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t83.{core::Map::[]=}(#t85.{core::MapEntry::key}{core::int}, #t85.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t83.{core::Map::[]=}{Invariant}(#t85.{core::MapEntry::key}{core::int}, #t85.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t83, block {
     final core::Set<core::int> #t86 = col::LinkedHashSet::•<core::int>();
@@ -416,7 +416,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t87 == null))
         for (final dynamic #t88 in #t87{core::Iterable<dynamic>}) {
           final core::int #t89 = #t88 as{TypeError,ForNonNullableByDefault} core::int;
-          #t86.{core::Set::add}(#t89){(core::int) → core::bool};
+          #t86.{core::Set::add}{Invariant}(#t89){(core::int) → core::bool};
         }
     }
   } =>#t86, block {
@@ -426,7 +426,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t91 == null))
         for (final dynamic #t92 in #t91{core::Iterable<dynamic>}) {
           final core::int #t93 = #t92 as{TypeError,ForNonNullableByDefault} core::int;
-          #t90.{core::Set::add}(#t93){(core::int) → core::bool};
+          #t90.{core::Set::add}{Invariant}(#t93){(core::int) → core::bool};
         }
     }
   } =>#t90, block {
@@ -436,7 +436,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       if(!(#t95 == null))
         for (final dynamic #t96 in #t95{core::Iterable<dynamic>}) {
           final core::int #t97 = #t96 as{TypeError,ForNonNullableByDefault} core::int;
-          #t94.{core::Set::add}(#t97){(core::int) → core::bool};
+          #t94.{core::Set::add}{Invariant}(#t97){(core::int) → core::bool};
         }
     }
   } =>#t94, block {
@@ -445,7 +445,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       final core::Map<core::int, core::int>? #t99 = d;
       if(!(#t99 == null))
         for (final core::MapEntry<core::int, core::int> #t100 in #t99{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t98.{core::Map::[]=}(#t100.{core::MapEntry::key}{core::int}, #t100.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t98.{core::Map::[]=}{Invariant}(#t100.{core::MapEntry::key}{core::int}, #t100.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t98];
 }
@@ -456,7 +456,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {...x}, // Error.
         ^") {
       final core::int #t103 = #t102 as{TypeError,ForNonNullableByDefault} core::int;
-      #t101.{core::Set::add}(#t103){(core::int) → core::bool};
+      #t101.{core::Set::add}{Invariant}(#t103){(core::int) → core::bool};
     }
   } =>#t101, block {
     final core::Set<core::int> #t104 = col::LinkedHashSet::•<core::int>();
@@ -464,7 +464,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {...y}, // Error.
         ^") {
       final core::int #t106 = #t105 as{TypeError,ForNonNullableByDefault} core::int;
-      #t104.{core::Set::add}(#t106){(core::int) → core::bool};
+      #t104.{core::Set::add}{Invariant}(#t106){(core::int) → core::bool};
     }
   } =>#t104, block {
     final core::Set<core::int> #t107 = col::LinkedHashSet::•<core::int>();
@@ -472,7 +472,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {...z}, // Error.
         ^") {
       final core::int #t109 = #t108 as{TypeError,ForNonNullableByDefault} core::int;
-      #t107.{core::Set::add}(#t109){(core::int) → core::bool};
+      #t107.{core::Set::add}{Invariant}(#t109){(core::int) → core::bool};
     }
   } =>#t107, <core::int, core::int>{invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:53:9: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {...w}, // Error.
@@ -480,7 +480,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     <int, int>{...x}, // Error.
                   ^": null}, block {
     final core::Set<core::int> #t110 = col::LinkedHashSet::•<core::int>();
-    #t110.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:55:14: Error: Unexpected type 'W' of a spread.  Expected 'dynamic' or an Iterable.
+    #t110.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:55:14: Error: Unexpected type 'W' of a spread.  Expected 'dynamic' or an Iterable.
     <int>{...w}, // Error.
              ^"){(core::int) → core::bool};
   } =>#t110, block {
@@ -490,7 +490,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {if (condition) ...x}, // Error.
                        ^") {
         final core::int #t113 = #t112 as{TypeError,ForNonNullableByDefault} core::int;
-        #t111.{core::Set::add}(#t113){(core::int) → core::bool};
+        #t111.{core::Set::add}{Invariant}(#t113){(core::int) → core::bool};
       }
   } =>#t111, block {
     final core::Set<core::int> #t114 = col::LinkedHashSet::•<core::int>();
@@ -499,7 +499,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {if (condition) ...y}, // Error.
                        ^") {
         final core::int #t116 = #t115 as{TypeError,ForNonNullableByDefault} core::int;
-        #t114.{core::Set::add}(#t116){(core::int) → core::bool};
+        #t114.{core::Set::add}{Invariant}(#t116){(core::int) → core::bool};
       }
   } =>#t114, block {
     final core::Set<core::int> #t117 = col::LinkedHashSet::•<core::int>();
@@ -508,12 +508,12 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {if (condition) ...z}, // Error.
                        ^") {
         final core::int #t119 = #t118 as{TypeError,ForNonNullableByDefault} core::int;
-        #t117.{core::Set::add}(#t119){(core::int) → core::bool};
+        #t117.{core::Set::add}{Invariant}(#t119){(core::int) → core::bool};
       }
   } =>#t117, block {
     final core::Map<core::int, core::int> #t120 = <core::int, core::int>{};
     if(condition)
-      #t120.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:59:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:59:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {if (condition) ...w}, // Error.
                        ^", null){(core::int, core::int) → void};
   } =>#t120, block {
@@ -523,7 +523,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (dynamic e in iterable) ...x}, // Error.
                                     ^") {
         final core::int #t123 = #t122 as{TypeError,ForNonNullableByDefault} core::int;
-        #t121.{core::Set::add}(#t123){(core::int) → core::bool};
+        #t121.{core::Set::add}{Invariant}(#t123){(core::int) → core::bool};
       }
   } =>#t121, block {
     final core::Set<core::int> #t124 = col::LinkedHashSet::•<core::int>();
@@ -532,7 +532,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (dynamic e in iterable) ...y}, // Error.
                                     ^") {
         final core::int #t126 = #t125 as{TypeError,ForNonNullableByDefault} core::int;
-        #t124.{core::Set::add}(#t126){(core::int) → core::bool};
+        #t124.{core::Set::add}{Invariant}(#t126){(core::int) → core::bool};
       }
   } =>#t124, block {
     final core::Set<core::int> #t127 = col::LinkedHashSet::•<core::int>();
@@ -541,12 +541,12 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (dynamic e in iterable) ...z}, // Error.
                                     ^") {
         final core::int #t129 = #t128 as{TypeError,ForNonNullableByDefault} core::int;
-        #t127.{core::Set::add}(#t129){(core::int) → core::bool};
+        #t127.{core::Set::add}{Invariant}(#t129){(core::int) → core::bool};
       }
   } =>#t127, block {
     final core::Map<core::int, core::int> #t130 = <core::int, core::int>{};
     for (dynamic e in iterable)
-      #t130.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:63:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t130.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:63:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (dynamic e in iterable) ...w}, // Error.
                                     ^", null){(core::int, core::int) → void};
   } =>#t130, block {
@@ -556,7 +556,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (int i = 0; i < 42; ++i) ...x}, // Error.
                                      ^") {
         final core::int #t133 = #t132 as{TypeError,ForNonNullableByDefault} core::int;
-        #t131.{core::Set::add}(#t133){(core::int) → core::bool};
+        #t131.{core::Set::add}{Invariant}(#t133){(core::int) → core::bool};
       }
   } =>#t131, block {
     final core::Set<core::int> #t134 = col::LinkedHashSet::•<core::int>();
@@ -565,7 +565,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (int i = 0; i < 42; ++i) ...y}, // Error.
                                      ^") {
         final core::int #t136 = #t135 as{TypeError,ForNonNullableByDefault} core::int;
-        #t134.{core::Set::add}(#t136){(core::int) → core::bool};
+        #t134.{core::Set::add}{Invariant}(#t136){(core::int) → core::bool};
       }
   } =>#t134, block {
     final core::Set<core::int> #t137 = col::LinkedHashSet::•<core::int>();
@@ -574,12 +574,12 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     {for (int i = 0; i < 42; ++i) ...z}, // Error.
                                      ^") {
         final core::int #t139 = #t138 as{TypeError,ForNonNullableByDefault} core::int;
-        #t137.{core::Set::add}(#t139){(core::int) → core::bool};
+        #t137.{core::Set::add}{Invariant}(#t139){(core::int) → core::bool};
       }
   } =>#t137, block {
     final core::Map<core::int, core::int> #t140 = <core::int, core::int>{};
     for (core::int i = 0; i.{core::num::<}(42){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t140.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:67:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t140.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:67:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (int i = 0; i < 42; ++i) ...w}, // Error.
                                      ^", null){(core::int, core::int) → void};
   } =>#t140, block {
@@ -588,7 +588,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     if(!(#t142 == null))
       for (final dynamic #t143 in #t142{core::Iterable<dynamic>}) {
         final core::int #t144 = #t143 as{TypeError,ForNonNullableByDefault} core::int;
-        #t141.{core::Set::add}(#t144){(core::int) → core::bool};
+        #t141.{core::Set::add}{Invariant}(#t144){(core::int) → core::bool};
       }
   } =>#t141, block {
     final core::Set<core::int> #t145 = col::LinkedHashSet::•<core::int>();
@@ -596,7 +596,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     if(!(#t146 == null))
       for (final dynamic #t147 in #t146{core::Iterable<dynamic>}) {
         final core::int #t148 = #t147 as{TypeError,ForNonNullableByDefault} core::int;
-        #t145.{core::Set::add}(#t148){(core::int) → core::bool};
+        #t145.{core::Set::add}{Invariant}(#t148){(core::int) → core::bool};
       }
   } =>#t145, block {
     final core::Set<core::int> #t149 = col::LinkedHashSet::•<core::int>();
@@ -604,14 +604,14 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     if(!(#t150 == null))
       for (final dynamic #t151 in #t150{core::Iterable<dynamic>}) {
         final core::int #t152 = #t151 as{TypeError,ForNonNullableByDefault} core::int;
-        #t149.{core::Set::add}(#t152){(core::int) → core::bool};
+        #t149.{core::Set::add}{Invariant}(#t152){(core::int) → core::bool};
       }
   } =>#t149, block {
     final core::Map<core::int, core::int> #t153 = <core::int, core::int>{};
     final core::Map<core::int, core::int>? #t154 = w;
     if(!(#t154 == null))
       for (final core::MapEntry<core::int, core::int> #t155 in #t154{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t153.{core::Map::[]=}(#t155.{core::MapEntry::key}{core::int}, #t155.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t153.{core::Map::[]=}{Invariant}(#t155.{core::MapEntry::key}{core::int}, #t155.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
   } =>#t153, block {
     final core::Set<core::int> #t156 = col::LinkedHashSet::•<core::int>();
     if(condition) {
@@ -619,7 +619,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t157 == null))
         for (final dynamic #t158 in #t157{core::Iterable<dynamic>}) {
           final core::int #t159 = #t158 as{TypeError,ForNonNullableByDefault} core::int;
-          #t156.{core::Set::add}(#t159){(core::int) → core::bool};
+          #t156.{core::Set::add}{Invariant}(#t159){(core::int) → core::bool};
         }
     }
   } =>#t156, block {
@@ -629,7 +629,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t161 == null))
         for (final dynamic #t162 in #t161{core::Iterable<dynamic>}) {
           final core::int #t163 = #t162 as{TypeError,ForNonNullableByDefault} core::int;
-          #t160.{core::Set::add}(#t163){(core::int) → core::bool};
+          #t160.{core::Set::add}{Invariant}(#t163){(core::int) → core::bool};
         }
     }
   } =>#t160, block {
@@ -639,7 +639,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t165 == null))
         for (final dynamic #t166 in #t165{core::Iterable<dynamic>}) {
           final core::int #t167 = #t166 as{TypeError,ForNonNullableByDefault} core::int;
-          #t164.{core::Set::add}(#t167){(core::int) → core::bool};
+          #t164.{core::Set::add}{Invariant}(#t167){(core::int) → core::bool};
         }
     }
   } =>#t164, block {
@@ -648,7 +648,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       final core::Map<core::int, core::int>? #t169 = w;
       if(!(#t169 == null))
         for (final core::MapEntry<core::int, core::int> #t170 in #t169{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t168.{core::Map::[]=}(#t170.{core::MapEntry::key}{core::int}, #t170.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t168.{core::Map::[]=}{Invariant}(#t170.{core::MapEntry::key}{core::int}, #t170.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t168, block {
     final core::Set<core::int> #t171 = col::LinkedHashSet::•<core::int>();
@@ -657,7 +657,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t172 == null))
         for (final dynamic #t173 in #t172{core::Iterable<dynamic>}) {
           final core::int #t174 = #t173 as{TypeError,ForNonNullableByDefault} core::int;
-          #t171.{core::Set::add}(#t174){(core::int) → core::bool};
+          #t171.{core::Set::add}{Invariant}(#t174){(core::int) → core::bool};
         }
     }
   } =>#t171, block {
@@ -667,7 +667,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t176 == null))
         for (final dynamic #t177 in #t176{core::Iterable<dynamic>}) {
           final core::int #t178 = #t177 as{TypeError,ForNonNullableByDefault} core::int;
-          #t175.{core::Set::add}(#t178){(core::int) → core::bool};
+          #t175.{core::Set::add}{Invariant}(#t178){(core::int) → core::bool};
         }
     }
   } =>#t175, block {
@@ -677,7 +677,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t180 == null))
         for (final dynamic #t181 in #t180{core::Iterable<dynamic>}) {
           final core::int #t182 = #t181 as{TypeError,ForNonNullableByDefault} core::int;
-          #t179.{core::Set::add}(#t182){(core::int) → core::bool};
+          #t179.{core::Set::add}{Invariant}(#t182){(core::int) → core::bool};
         }
     }
   } =>#t179, block {
@@ -686,7 +686,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       final core::Map<core::int, core::int>? #t184 = w;
       if(!(#t184 == null))
         for (final core::MapEntry<core::int, core::int> #t185 in #t184{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t183.{core::Map::[]=}(#t185.{core::MapEntry::key}{core::int}, #t185.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t183.{core::Map::[]=}{Invariant}(#t185.{core::MapEntry::key}{core::int}, #t185.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t183, block {
     final core::Set<core::int> #t186 = col::LinkedHashSet::•<core::int>();
@@ -695,7 +695,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t187 == null))
         for (final dynamic #t188 in #t187{core::Iterable<dynamic>}) {
           final core::int #t189 = #t188 as{TypeError,ForNonNullableByDefault} core::int;
-          #t186.{core::Set::add}(#t189){(core::int) → core::bool};
+          #t186.{core::Set::add}{Invariant}(#t189){(core::int) → core::bool};
         }
     }
   } =>#t186, block {
@@ -705,7 +705,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t191 == null))
         for (final dynamic #t192 in #t191{core::Iterable<dynamic>}) {
           final core::int #t193 = #t192 as{TypeError,ForNonNullableByDefault} core::int;
-          #t190.{core::Set::add}(#t193){(core::int) → core::bool};
+          #t190.{core::Set::add}{Invariant}(#t193){(core::int) → core::bool};
         }
     }
   } =>#t190, block {
@@ -715,7 +715,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       if(!(#t195 == null))
         for (final dynamic #t196 in #t195{core::Iterable<dynamic>}) {
           final core::int #t197 = #t196 as{TypeError,ForNonNullableByDefault} core::int;
-          #t194.{core::Set::add}(#t197){(core::int) → core::bool};
+          #t194.{core::Set::add}{Invariant}(#t197){(core::int) → core::bool};
         }
     }
   } =>#t194, block {
@@ -724,7 +724,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       final core::Map<core::int, core::int>? #t199 = w;
       if(!(#t199 == null))
         for (final core::MapEntry<core::int, core::int> #t200 in #t199{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-          #t198.{core::Map::[]=}(#t200.{core::MapEntry::key}{core::int}, #t200.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t198.{core::Map::[]=}{Invariant}(#t200.{core::MapEntry::key}{core::int}, #t200.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
     }
   } =>#t198];
 }

pkg/front_end/testcases/nnbd/issue43495.dart.weak.transformed.expect

@@ -179,7 +179,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t2 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t3 = #t2 as{TypeError,ForNonNullableByDefault} core::int;
-          #t1.{core::Set::add}(#t3){(core::int) → core::bool};
+          #t1.{core::Set::add}{Invariant}(#t3){(core::int) → core::bool};
         }
       }
     }
@@ -193,7 +193,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t5 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t6 = #t5 as{TypeError,ForNonNullableByDefault} core::int;
-          #t4.{core::Set::add}(#t6){(core::int) → core::bool};
+          #t4.{core::Set::add}{Invariant}(#t6){(core::int) → core::bool};
         }
       }
     }
@@ -207,7 +207,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t8 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t9 = #t8 as{TypeError,ForNonNullableByDefault} core::int;
-          #t7.{core::Set::add}(#t9){(core::int) → core::bool};
+          #t7.{core::Set::add}{Invariant}(#t9){(core::int) → core::bool};
         }
       }
     }
@@ -218,7 +218,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
     <int, int>{...a}, // Error.
                   ^": null}, block {
     final core::Set<core::int> #t10 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t10.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:13:14: Error: Unexpected type 'Map<int, int>?' of a spread.  Expected 'dynamic' or an Iterable.
+    #t10.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:13:14: Error: Unexpected type 'Map<int, int>?' of a spread.  Expected 'dynamic' or an Iterable.
  - 'Map' is from 'dart:core'.
     <int>{...d}, // Error.
              ^"){(core::int) → core::bool};
@@ -232,7 +232,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t12 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t13 = #t12 as{TypeError,ForNonNullableByDefault} core::int;
-          #t11.{core::Set::add}(#t13){(core::int) → core::bool};
+          #t11.{core::Set::add}{Invariant}(#t13){(core::int) → core::bool};
         }
       }
     }
@@ -246,7 +246,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t15 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t16 = #t15 as{TypeError,ForNonNullableByDefault} core::int;
-          #t14.{core::Set::add}(#t16){(core::int) → core::bool};
+          #t14.{core::Set::add}{Invariant}(#t16){(core::int) → core::bool};
         }
       }
     }
@@ -260,14 +260,14 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t18 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t19 = #t18 as{TypeError,ForNonNullableByDefault} core::int;
-          #t17.{core::Set::add}(#t19){(core::int) → core::bool};
+          #t17.{core::Set::add}{Invariant}(#t19){(core::int) → core::bool};
         }
       }
     }
   } =>#t17, block {
     final core::Map<core::int, core::int> #t20 = <core::int, core::int>{};
     if(condition)
-      #t20.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:17:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t20.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:17:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {if (condition) ...d}, // Error.
                        ^", null){(core::int, core::int) → void};
   } =>#t20, block {
@@ -284,7 +284,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
             final dynamic #t22 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t23 = #t22 as{TypeError,ForNonNullableByDefault} core::int;
-              #t21.{core::Set::add}(#t23){(core::int) → core::bool};
+              #t21.{core::Set::add}{Invariant}(#t23){(core::int) → core::bool};
             }
           }
         }
@@ -304,7 +304,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
             final dynamic #t25 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t26 = #t25 as{TypeError,ForNonNullableByDefault} core::int;
-              #t24.{core::Set::add}(#t26){(core::int) → core::bool};
+              #t24.{core::Set::add}{Invariant}(#t26){(core::int) → core::bool};
             }
           }
         }
@@ -324,7 +324,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
             final dynamic #t28 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t29 = #t28 as{TypeError,ForNonNullableByDefault} core::int;
-              #t27.{core::Set::add}(#t29){(core::int) → core::bool};
+              #t27.{core::Set::add}{Invariant}(#t29){(core::int) → core::bool};
             }
           }
         }
@@ -336,7 +336,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       core::Iterator<dynamic> :sync-for-iterator = iterable.{core::Iterable::iterator}{core::Iterator<dynamic>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic e = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t30.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:21:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+        #t30.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:21:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (dynamic e in iterable) ...d}, // Error.
                                     ^", null){(core::int, core::int) → void};
       }
@@ -351,7 +351,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t32 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t33 = #t32 as{TypeError,ForNonNullableByDefault} core::int;
-          #t31.{core::Set::add}(#t33){(core::int) → core::bool};
+          #t31.{core::Set::add}{Invariant}(#t33){(core::int) → core::bool};
         }
       }
     }
@@ -365,7 +365,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t35 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t36 = #t35 as{TypeError,ForNonNullableByDefault} core::int;
-          #t34.{core::Set::add}(#t36){(core::int) → core::bool};
+          #t34.{core::Set::add}{Invariant}(#t36){(core::int) → core::bool};
         }
       }
     }
@@ -379,14 +379,14 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t38 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t39 = #t38 as{TypeError,ForNonNullableByDefault} core::int;
-          #t37.{core::Set::add}(#t39){(core::int) → core::bool};
+          #t37.{core::Set::add}{Invariant}(#t39){(core::int) → core::bool};
         }
       }
     }
   } =>#t37, block {
     final core::Map<core::int, core::int> #t40 = <core::int, core::int>{};
     for (core::int i = 0; i.{core::num::<}(42){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t40.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:25:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t40.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:25:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (int i = 0; i < 42; ++i) ...d}, // Error.
                                      ^", null){(core::int, core::int) → void};
   } =>#t40, block {
@@ -398,7 +398,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t43 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t44 = #t43 as{TypeError,ForNonNullableByDefault} core::int;
-          #t41.{core::Set::add}(#t44){(core::int) → core::bool};
+          #t41.{core::Set::add}{Invariant}(#t44){(core::int) → core::bool};
         }
       }
     }
@@ -411,7 +411,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t47 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t48 = #t47 as{TypeError,ForNonNullableByDefault} core::int;
-          #t45.{core::Set::add}(#t48){(core::int) → core::bool};
+          #t45.{core::Set::add}{Invariant}(#t48){(core::int) → core::bool};
         }
       }
     }
@@ -424,7 +424,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         final dynamic #t51 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t52 = #t51 as{TypeError,ForNonNullableByDefault} core::int;
-          #t49.{core::Set::add}(#t52){(core::int) → core::bool};
+          #t49.{core::Set::add}{Invariant}(#t52){(core::int) → core::bool};
         }
       }
     }
@@ -435,7 +435,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t54{core::Map<core::int, 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> #t55 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t53.{core::Map::[]=}(#t55.{core::MapEntry::key}{core::int}, #t55.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t53.{core::Map::[]=}{Invariant}(#t55.{core::MapEntry::key}{core::int}, #t55.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
   } =>#t53, block {
@@ -448,7 +448,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t58 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t59 = #t58 as{TypeError,ForNonNullableByDefault} core::int;
-            #t56.{core::Set::add}(#t59){(core::int) → core::bool};
+            #t56.{core::Set::add}{Invariant}(#t59){(core::int) → core::bool};
           }
         }
       }
@@ -463,7 +463,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t62 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t63 = #t62 as{TypeError,ForNonNullableByDefault} core::int;
-            #t60.{core::Set::add}(#t63){(core::int) → core::bool};
+            #t60.{core::Set::add}{Invariant}(#t63){(core::int) → core::bool};
           }
         }
       }
@@ -478,7 +478,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t66 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t67 = #t66 as{TypeError,ForNonNullableByDefault} core::int;
-            #t64.{core::Set::add}(#t67){(core::int) → core::bool};
+            #t64.{core::Set::add}{Invariant}(#t67){(core::int) → core::bool};
           }
         }
       }
@@ -491,7 +491,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t69{core::Map<core::int, 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> #t70 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-          #t68.{core::Map::[]=}(#t70.{core::MapEntry::key}{core::int}, #t70.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t68.{core::Map::[]=}{Invariant}(#t70.{core::MapEntry::key}{core::int}, #t70.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
         }
       }
     }
@@ -509,7 +509,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
               final dynamic #t73 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t74 = #t73 as{TypeError,ForNonNullableByDefault} core::int;
-                #t71.{core::Set::add}(#t74){(core::int) → core::bool};
+                #t71.{core::Set::add}{Invariant}(#t74){(core::int) → core::bool};
               }
             }
           }
@@ -530,7 +530,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
               final dynamic #t77 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t78 = #t77 as{TypeError,ForNonNullableByDefault} core::int;
-                #t75.{core::Set::add}(#t78){(core::int) → core::bool};
+                #t75.{core::Set::add}{Invariant}(#t78){(core::int) → core::bool};
               }
             }
           }
@@ -551,7 +551,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
               final dynamic #t81 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t82 = #t81 as{TypeError,ForNonNullableByDefault} core::int;
-                #t79.{core::Set::add}(#t82){(core::int) → core::bool};
+                #t79.{core::Set::add}{Invariant}(#t82){(core::int) → core::bool};
               }
             }
           }
@@ -570,7 +570,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
             core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t84{core::Map<core::int, 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> #t85 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-              #t83.{core::Map::[]=}(#t85.{core::MapEntry::key}{core::int}, #t85.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+              #t83.{core::Map::[]=}{Invariant}(#t85.{core::MapEntry::key}{core::int}, #t85.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
             }
           }
         }
@@ -586,7 +586,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t88 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t89 = #t88 as{TypeError,ForNonNullableByDefault} core::int;
-            #t86.{core::Set::add}(#t89){(core::int) → core::bool};
+            #t86.{core::Set::add}{Invariant}(#t89){(core::int) → core::bool};
           }
         }
       }
@@ -601,7 +601,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t92 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t93 = #t92 as{TypeError,ForNonNullableByDefault} core::int;
-            #t90.{core::Set::add}(#t93){(core::int) → core::bool};
+            #t90.{core::Set::add}{Invariant}(#t93){(core::int) → core::bool};
           }
         }
       }
@@ -616,7 +616,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
           final dynamic #t96 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t97 = #t96 as{TypeError,ForNonNullableByDefault} core::int;
-            #t94.{core::Set::add}(#t97){(core::int) → core::bool};
+            #t94.{core::Set::add}{Invariant}(#t97){(core::int) → core::bool};
           }
         }
       }
@@ -629,7 +629,7 @@ static method foo(core::bool condition, core::Iterable<dynamic> iterable, core::
         core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t99{core::Map<core::int, 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> #t100 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-          #t98.{core::Map::[]=}(#t100.{core::MapEntry::key}{core::int}, #t100.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t98.{core::Map::[]=}{Invariant}(#t100.{core::MapEntry::key}{core::int}, #t100.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
         }
       }
     }
@@ -646,7 +646,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t102 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t103 = #t102 as{TypeError,ForNonNullableByDefault} core::int;
-          #t101.{core::Set::add}(#t103){(core::int) → core::bool};
+          #t101.{core::Set::add}{Invariant}(#t103){(core::int) → core::bool};
         }
       }
     }
@@ -660,7 +660,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t105 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t106 = #t105 as{TypeError,ForNonNullableByDefault} core::int;
-          #t104.{core::Set::add}(#t106){(core::int) → core::bool};
+          #t104.{core::Set::add}{Invariant}(#t106){(core::int) → core::bool};
         }
       }
     }
@@ -674,7 +674,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t108 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t109 = #t108 as{TypeError,ForNonNullableByDefault} core::int;
-          #t107.{core::Set::add}(#t109){(core::int) → core::bool};
+          #t107.{core::Set::add}{Invariant}(#t109){(core::int) → core::bool};
         }
       }
     }
@@ -684,7 +684,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
     <int, int>{...x}, // Error.
                   ^": null}, block {
     final core::Set<core::int> #t110 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t110.{core::Set::add}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:55:14: Error: Unexpected type 'W' of a spread.  Expected 'dynamic' or an Iterable.
+    #t110.{core::Set::add}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:55:14: Error: Unexpected type 'W' of a spread.  Expected 'dynamic' or an Iterable.
     <int>{...w}, // Error.
              ^"){(core::int) → core::bool};
   } =>#t110, block {
@@ -697,7 +697,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t112 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t113 = #t112 as{TypeError,ForNonNullableByDefault} core::int;
-          #t111.{core::Set::add}(#t113){(core::int) → core::bool};
+          #t111.{core::Set::add}{Invariant}(#t113){(core::int) → core::bool};
         }
       }
     }
@@ -711,7 +711,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t115 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t116 = #t115 as{TypeError,ForNonNullableByDefault} core::int;
-          #t114.{core::Set::add}(#t116){(core::int) → core::bool};
+          #t114.{core::Set::add}{Invariant}(#t116){(core::int) → core::bool};
         }
       }
     }
@@ -725,14 +725,14 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t118 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t119 = #t118 as{TypeError,ForNonNullableByDefault} core::int;
-          #t117.{core::Set::add}(#t119){(core::int) → core::bool};
+          #t117.{core::Set::add}{Invariant}(#t119){(core::int) → core::bool};
         }
       }
     }
   } =>#t117, block {
     final core::Map<core::int, core::int> #t120 = <core::int, core::int>{};
     if(condition)
-      #t120.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:59:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t120.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:59:24: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {if (condition) ...w}, // Error.
                        ^", null){(core::int, core::int) → void};
   } =>#t120, block {
@@ -749,7 +749,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
             final dynamic #t122 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t123 = #t122 as{TypeError,ForNonNullableByDefault} core::int;
-              #t121.{core::Set::add}(#t123){(core::int) → core::bool};
+              #t121.{core::Set::add}{Invariant}(#t123){(core::int) → core::bool};
             }
           }
         }
@@ -769,7 +769,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
             final dynamic #t125 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t126 = #t125 as{TypeError,ForNonNullableByDefault} core::int;
-              #t124.{core::Set::add}(#t126){(core::int) → core::bool};
+              #t124.{core::Set::add}{Invariant}(#t126){(core::int) → core::bool};
             }
           }
         }
@@ -789,7 +789,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
             final dynamic #t128 = :sync-for-iterator.{core::Iterator::current}{Never};
             {
               final core::int #t129 = #t128 as{TypeError,ForNonNullableByDefault} core::int;
-              #t127.{core::Set::add}(#t129){(core::int) → core::bool};
+              #t127.{core::Set::add}{Invariant}(#t129){(core::int) → core::bool};
             }
           }
         }
@@ -801,7 +801,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       core::Iterator<dynamic> :sync-for-iterator = iterable.{core::Iterable::iterator}{core::Iterator<dynamic>};
       for (; :sync-for-iterator.{core::Iterator::moveNext}(){() → core::bool}; ) {
         dynamic e = :sync-for-iterator.{core::Iterator::current}{dynamic};
-        #t130.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:63:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+        #t130.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:63:37: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (dynamic e in iterable) ...w}, // Error.
                                     ^", null){(core::int, core::int) → void};
       }
@@ -816,7 +816,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t132 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t133 = #t132 as{TypeError,ForNonNullableByDefault} core::int;
-          #t131.{core::Set::add}(#t133){(core::int) → core::bool};
+          #t131.{core::Set::add}{Invariant}(#t133){(core::int) → core::bool};
         }
       }
     }
@@ -830,7 +830,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t135 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t136 = #t135 as{TypeError,ForNonNullableByDefault} core::int;
-          #t134.{core::Set::add}(#t136){(core::int) → core::bool};
+          #t134.{core::Set::add}{Invariant}(#t136){(core::int) → core::bool};
         }
       }
     }
@@ -844,14 +844,14 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t138 = :sync-for-iterator.{core::Iterator::current}{Never};
         {
           final core::int #t139 = #t138 as{TypeError,ForNonNullableByDefault} core::int;
-          #t137.{core::Set::add}(#t139){(core::int) → core::bool};
+          #t137.{core::Set::add}{Invariant}(#t139){(core::int) → core::bool};
         }
       }
     }
   } =>#t137, block {
     final core::Map<core::int, core::int> #t140 = <core::int, core::int>{};
     for (core::int i = 0; i.{core::num::<}(42){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t140.{core::Map::[]=}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:67:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
+      #t140.{core::Map::[]=}{Invariant}(invalid-expression "pkg/front_end/testcases/nnbd/issue43495.dart:67:38: Error: An expression whose value can be 'null' must be null-checked before it can be dereferenced.
     {for (int i = 0; i < 42; ++i) ...w}, // Error.
                                      ^", null){(core::int, core::int) → void};
   } =>#t140, block {
@@ -863,7 +863,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t143 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t144 = #t143 as{TypeError,ForNonNullableByDefault} core::int;
-          #t141.{core::Set::add}(#t144){(core::int) → core::bool};
+          #t141.{core::Set::add}{Invariant}(#t144){(core::int) → core::bool};
         }
       }
     }
@@ -876,7 +876,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t147 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t148 = #t147 as{TypeError,ForNonNullableByDefault} core::int;
-          #t145.{core::Set::add}(#t148){(core::int) → core::bool};
+          #t145.{core::Set::add}{Invariant}(#t148){(core::int) → core::bool};
         }
       }
     }
@@ -889,7 +889,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         final dynamic #t151 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t152 = #t151 as{TypeError,ForNonNullableByDefault} core::int;
-          #t149.{core::Set::add}(#t152){(core::int) → core::bool};
+          #t149.{core::Set::add}{Invariant}(#t152){(core::int) → core::bool};
         }
       }
     }
@@ -900,7 +900,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t154{core::Map<core::int, 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> #t155 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t153.{core::Map::[]=}(#t155.{core::MapEntry::key}{core::int}, #t155.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t153.{core::Map::[]=}{Invariant}(#t155.{core::MapEntry::key}{core::int}, #t155.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
   } =>#t153, block {
@@ -913,7 +913,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t158 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t159 = #t158 as{TypeError,ForNonNullableByDefault} core::int;
-            #t156.{core::Set::add}(#t159){(core::int) → core::bool};
+            #t156.{core::Set::add}{Invariant}(#t159){(core::int) → core::bool};
           }
         }
       }
@@ -928,7 +928,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t162 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t163 = #t162 as{TypeError,ForNonNullableByDefault} core::int;
-            #t160.{core::Set::add}(#t163){(core::int) → core::bool};
+            #t160.{core::Set::add}{Invariant}(#t163){(core::int) → core::bool};
           }
         }
       }
@@ -943,7 +943,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t166 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t167 = #t166 as{TypeError,ForNonNullableByDefault} core::int;
-            #t164.{core::Set::add}(#t167){(core::int) → core::bool};
+            #t164.{core::Set::add}{Invariant}(#t167){(core::int) → core::bool};
           }
         }
       }
@@ -956,7 +956,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t169{core::Map<core::int, 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> #t170 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-          #t168.{core::Map::[]=}(#t170.{core::MapEntry::key}{core::int}, #t170.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t168.{core::Map::[]=}{Invariant}(#t170.{core::MapEntry::key}{core::int}, #t170.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
         }
       }
     }
@@ -974,7 +974,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
               final dynamic #t173 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t174 = #t173 as{TypeError,ForNonNullableByDefault} core::int;
-                #t171.{core::Set::add}(#t174){(core::int) → core::bool};
+                #t171.{core::Set::add}{Invariant}(#t174){(core::int) → core::bool};
               }
             }
           }
@@ -995,7 +995,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
               final dynamic #t177 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t178 = #t177 as{TypeError,ForNonNullableByDefault} core::int;
-                #t175.{core::Set::add}(#t178){(core::int) → core::bool};
+                #t175.{core::Set::add}{Invariant}(#t178){(core::int) → core::bool};
               }
             }
           }
@@ -1016,7 +1016,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
               final dynamic #t181 = :sync-for-iterator.{core::Iterator::current}{dynamic};
               {
                 final core::int #t182 = #t181 as{TypeError,ForNonNullableByDefault} core::int;
-                #t179.{core::Set::add}(#t182){(core::int) → core::bool};
+                #t179.{core::Set::add}{Invariant}(#t182){(core::int) → core::bool};
               }
             }
           }
@@ -1035,7 +1035,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
             core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t184{core::Map<core::int, 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> #t185 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-              #t183.{core::Map::[]=}(#t185.{core::MapEntry::key}{core::int}, #t185.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+              #t183.{core::Map::[]=}{Invariant}(#t185.{core::MapEntry::key}{core::int}, #t185.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
             }
           }
         }
@@ -1051,7 +1051,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t188 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t189 = #t188 as{TypeError,ForNonNullableByDefault} core::int;
-            #t186.{core::Set::add}(#t189){(core::int) → core::bool};
+            #t186.{core::Set::add}{Invariant}(#t189){(core::int) → core::bool};
           }
         }
       }
@@ -1066,7 +1066,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t192 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t193 = #t192 as{TypeError,ForNonNullableByDefault} core::int;
-            #t190.{core::Set::add}(#t193){(core::int) → core::bool};
+            #t190.{core::Set::add}{Invariant}(#t193){(core::int) → core::bool};
           }
         }
       }
@@ -1081,7 +1081,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
           final dynamic #t196 = :sync-for-iterator.{core::Iterator::current}{dynamic};
           {
             final core::int #t197 = #t196 as{TypeError,ForNonNullableByDefault} core::int;
-            #t194.{core::Set::add}(#t197){(core::int) → core::bool};
+            #t194.{core::Set::add}{Invariant}(#t197){(core::int) → core::bool};
           }
         }
       }
@@ -1094,7 +1094,7 @@ static method bar<X extends core::List<core::int>?, Y extends core::Set<core::in
         core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t199{core::Map<core::int, 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> #t200 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-          #t198.{core::Map::[]=}(#t200.{core::MapEntry::key}{core::int}, #t200.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+          #t198.{core::Map::[]=}{Invariant}(#t200.{core::MapEntry::key}{core::int}, #t200.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
         }
       }
     }

pkg/front_end/testcases/nnbd/later.dart.strong.expect

@@ -113,7 +113,7 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
   block {
     final core::List<core::int> #t1 = <core::int>[];
     for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t1.{core::List::add}(i){(core::int) → void};
+      #t1.{core::List::add}{Invariant}(i){(core::int) → void};
   } =>#t1;
 }
 static method hest() → dynamic async {

pkg/front_end/testcases/nnbd/later.dart.strong.transformed.expect

@@ -120,7 +120,7 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
   block {
     final core::List<core::int> #t1 = core::_GrowableList::•<core::int>(0);
     for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t1.{core::List::add}(i){(core::int) → void};
+      #t1.{core::List::add}{Invariant}(i){(core::int) → void};
   } =>#t1;
 }
 static method hest() → dynamic /* originally async */ {

pkg/front_end/testcases/nnbd/later.dart.weak.expect

@@ -113,7 +113,7 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
   block {
     final core::List<core::int> #t1 = <core::int>[];
     for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t1.{core::List::add}(i){(core::int) → void};
+      #t1.{core::List::add}{Invariant}(i){(core::int) → void};
   } =>#t1;
 }
 static method hest() → dynamic async {

pkg/front_end/testcases/nnbd/later.dart.weak.transformed.expect

@@ -120,7 +120,7 @@ No types are needed, the first is given by 'on', the second is always 'StackTrac
   block {
     final core::List<core::int> #t1 = core::_GrowableList::•<core::int>(0);
     for (core::int i = 0; i.{core::num::<}(10){(core::num) → core::bool}; i = i.{core::num::+}(1){(core::num) → core::int})
-      #t1.{core::List::add}(i){(core::int) → void};
+      #t1.{core::List::add}{Invariant}(i){(core::int) → void};
   } =>#t1;
 }
 static method hest() → dynamic /* originally async */ {

pkg/front_end/testcases/nnbd/spread_if_null.dart.strong.expect

@@ -9,60 +9,60 @@ static method main() → dynamic {
     final core::List<core::int> #t1 = <core::int>[1, 2];
     final core::Iterable<core::int>? #t2 = list;
     if(!(#t2 == null))
-      #t1.{core::List::addAll}(#t2{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t1.{core::List::add}(3){(core::int) → void};
+      #t1.{core::List::addAll}{Invariant}(#t2{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t1.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t1);
   core::print( block {
     final core::List<core::int> #t3 = <core::int>[1, 2];
     final core::Iterable<core::int>? #t4 = null;
     if(!(#t4 == null))
-      #t3.{core::List::addAll}(#t4{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t3.{core::List::add}(3){(core::int) → void};
+      #t3.{core::List::addAll}{Invariant}(#t4{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t3.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t3);
   core::List<core::int> list1 = block {
     final core::List<core::int> #t5 = <core::int>[];
     final core::Iterable<core::int>? #t6 = list;
     if(!(#t6 == null))
-      #t5.{core::List::addAll}(#t6{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+      #t5.{core::List::addAll}{Invariant}(#t6{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
   } =>#t5;
   core::List<Never> list2 = block {
     final core::List<Never> #t7 = <Never>[];
     final core::Iterable<Never>? #t8 = null;
     if(!(#t8 == null))
-      #t7.{core::List::addAll}(#t8{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t7.{core::List::addAll}{Invariant}(#t8{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t7;
   core::List<core::int> list3 = block {
     final core::List<core::int> #t9 = <core::int>[1, 2];
     final core::Iterable<core::int>? #t10 = list;
     if(!(#t10 == null))
-      #t9.{core::List::addAll}(#t10{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t9.{core::List::add}(3){(core::int) → void};
+      #t9.{core::List::addAll}{Invariant}(#t10{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t9.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t9;
   core::List<core::int> list4 = block {
     final core::List<core::int> #t11 = <core::int>[1, 2];
     final core::Iterable<core::int>? #t12 = null;
     if(!(#t12 == null))
-      #t11.{core::List::addAll}(#t12{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t11.{core::List::add}(3){(core::int) → void};
+      #t11.{core::List::addAll}{Invariant}(#t12{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t11.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t11;
   core::Set<core::int>? set = null;
   core::print( block {
     final core::Set<core::int> #t13 = col::LinkedHashSet::•<core::int>();
-    #t13.{core::Set::add}(1){(core::int) → core::bool};
-    #t13.{core::Set::add}(2){(core::int) → core::bool};
+    #t13.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t13.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t14 = set;
     if(!(#t14 == null))
-      #t13.{core::Set::addAll}(#t14{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t13.{core::Set::add}(3){(core::int) → core::bool};
+      #t13.{core::Set::addAll}{Invariant}(#t14{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t13.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t13);
   core::print( block {
     final core::Set<core::int> #t15 = col::LinkedHashSet::•<core::int>();
-    #t15.{core::Set::add}(1){(core::int) → core::bool};
-    #t15.{core::Set::add}(2){(core::int) → core::bool};
+    #t15.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t15.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t16 = null;
     if(!(#t16 == null))
-      #t15.{core::Set::addAll}(#t16{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t15.{core::Set::add}(3){(core::int) → core::bool};
+      #t15.{core::Set::addAll}{Invariant}(#t16{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t15.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t15);
   core::Set<core::int> set1 = block {
     final core::Set<core::int> #t17 = col::LinkedHashSet::•<core::int>();
@@ -70,73 +70,73 @@ static method main() → dynamic {
     if(!(#t18 == null))
       for (final dynamic #t19 in #t18{core::Iterable<dynamic>}) {
         final core::int #t20 = #t19 as{TypeError,ForNonNullableByDefault} core::int;
-        #t17.{core::Set::add}(#t20){(core::int) → core::bool};
+        #t17.{core::Set::add}{Invariant}(#t20){(core::int) → core::bool};
       }
   } =>#t17;
   core::Set<core::int> set3 = block {
     final core::Set<core::int> #t21 = col::LinkedHashSet::•<core::int>();
-    #t21.{core::Set::add}(1){(core::int) → core::bool};
-    #t21.{core::Set::add}(2){(core::int) → core::bool};
+    #t21.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t21.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t22 = set;
     if(!(#t22 == null))
-      #t21.{core::Set::addAll}(#t22{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t21.{core::Set::add}(3){(core::int) → core::bool};
+      #t21.{core::Set::addAll}{Invariant}(#t22{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t21.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t21;
   core::Set<core::int> set4 = block {
     final core::Set<core::int> #t23 = col::LinkedHashSet::•<core::int>();
-    #t23.{core::Set::add}(1){(core::int) → core::bool};
-    #t23.{core::Set::add}(2){(core::int) → core::bool};
+    #t23.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t23.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t24 = null;
     if(!(#t24 == null))
-      #t23.{core::Set::addAll}(#t24{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t23.{core::Set::add}(3){(core::int) → core::bool};
+      #t23.{core::Set::addAll}{Invariant}(#t24{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t23.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t23;
   core::Map<core::int, core::int>? map = null;
   core::print( block {
     final core::Map<core::int, core::int> #t25 = <core::int, core::int>{};
-    #t25.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t25.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t26 = map;
     if(!(#t26 == null))
       for (final core::MapEntry<core::int, core::int> #t27 in #t26{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t25.{core::Map::[]=}(#t27.{core::MapEntry::key}{core::int}, #t27.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
-    #t25.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+        #t25.{core::Map::[]=}{Invariant}(#t27.{core::MapEntry::key}{core::int}, #t27.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t25);
   core::print( block {
     final core::Map<core::int, core::int> #t28 = <core::int, core::int>{};
-    #t28.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t28.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t29 = null;
     if(!(#t29 == null))
       for (final core::MapEntry<core::int, core::int> #t30 in #t29{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t28.{core::Map::[]=}(#t30.{core::MapEntry::key}{core::int}, #t30.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
-    #t28.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+        #t28.{core::Map::[]=}{Invariant}(#t30.{core::MapEntry::key}{core::int}, #t30.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t28);
   core::Map<core::int, core::int> map1 = block {
     final core::Map<core::int, core::int> #t31 = <core::int, core::int>{};
     final core::Map<core::int, core::int>? #t32 = map;
     if(!(#t32 == null))
       for (final core::MapEntry<core::int, core::int> #t33 in #t32{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t31.{core::Map::[]=}(#t33.{core::MapEntry::key}{core::int}, #t33.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t31.{core::Map::[]=}{Invariant}(#t33.{core::MapEntry::key}{core::int}, #t33.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
   } =>#t31;
   core::Map<core::int, core::int> map3 = block {
     final core::Map<core::int, core::int> #t34 = <core::int, core::int>{};
-    #t34.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t34.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t35 = map;
     if(!(#t35 == null))
       for (final core::MapEntry<core::int, core::int> #t36 in #t35{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t34.{core::Map::[]=}(#t36.{core::MapEntry::key}{core::int}, #t36.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
-    #t34.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+        #t34.{core::Map::[]=}{Invariant}(#t36.{core::MapEntry::key}{core::int}, #t36.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t34;
   core::Map<core::int, core::int> map4 = block {
     final core::Map<core::int, core::int> #t37 = <core::int, core::int>{};
-    #t37.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t37.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t38 = null;
     if(!(#t38 == null))
       for (final core::MapEntry<core::int, core::int> #t39 in #t38{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t37.{core::Map::[]=}(#t39.{core::MapEntry::key}{core::int}, #t39.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
-    #t37.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+        #t37.{core::Map::[]=}{Invariant}(#t39.{core::MapEntry::key}{core::int}, #t39.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t37;
 }

pkg/front_end/testcases/nnbd/spread_if_null.dart.strong.transformed.expect

@@ -9,60 +9,60 @@ static method main() → dynamic {
     final core::List<core::int> #t1 = core::_GrowableList::_literal2<core::int>(1, 2);
     final core::Iterable<core::int>? #t2 = list;
     if(!(#t2 == null))
-      #t1.{core::List::addAll}(#t2{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t1.{core::List::add}(3){(core::int) → void};
+      #t1.{core::List::addAll}{Invariant}(#t2{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t1.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t1);
   core::print( block {
     final core::List<core::int> #t3 = core::_GrowableList::_literal2<core::int>(1, 2);
     final core::Iterable<core::int>? #t4 = null;
     if(!(#t4 == null))
-      #t3.{core::List::addAll}(#t4{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t3.{core::List::add}(3){(core::int) → void};
+      #t3.{core::List::addAll}{Invariant}(#t4{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t3.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t3);
   core::List<core::int> list1 = block {
     final core::List<core::int> #t5 = core::_GrowableList::•<core::int>(0);
     final core::Iterable<core::int>? #t6 = list;
     if(!(#t6 == null))
-      #t5.{core::List::addAll}(#t6{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+      #t5.{core::List::addAll}{Invariant}(#t6{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
   } =>#t5;
   core::List<Never> list2 = block {
     final core::List<Never> #t7 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t8 = null;
     if(!(#t8 == null))
-      #t7.{core::List::addAll}(#t8{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t7.{core::List::addAll}{Invariant}(#t8{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t7;
   core::List<core::int> list3 = block {
     final core::List<core::int> #t9 = core::_GrowableList::_literal2<core::int>(1, 2);
     final core::Iterable<core::int>? #t10 = list;
     if(!(#t10 == null))
-      #t9.{core::List::addAll}(#t10{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t9.{core::List::add}(3){(core::int) → void};
+      #t9.{core::List::addAll}{Invariant}(#t10{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t9.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t9;
   core::List<core::int> list4 = block {
     final core::List<core::int> #t11 = core::_GrowableList::_literal2<core::int>(1, 2);
     final core::Iterable<core::int>? #t12 = null;
     if(!(#t12 == null))
-      #t11.{core::List::addAll}(#t12{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t11.{core::List::add}(3){(core::int) → void};
+      #t11.{core::List::addAll}{Invariant}(#t12{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t11.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t11;
   core::Set<core::int>? set = null;
   core::print( block {
     final core::Set<core::int> #t13 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t13.{core::Set::add}(1){(core::int) → core::bool};
-    #t13.{core::Set::add}(2){(core::int) → core::bool};
+    #t13.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t13.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t14 = set;
     if(!(#t14 == null))
-      #t13.{core::Set::addAll}(#t14{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t13.{core::Set::add}(3){(core::int) → core::bool};
+      #t13.{core::Set::addAll}{Invariant}(#t14{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t13.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t13);
   core::print( block {
     final core::Set<core::int> #t15 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t15.{core::Set::add}(1){(core::int) → core::bool};
-    #t15.{core::Set::add}(2){(core::int) → core::bool};
+    #t15.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t15.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t16 = null;
     if(!(#t16 == null))
-      #t15.{core::Set::addAll}(#t16{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t15.{core::Set::add}(3){(core::int) → core::bool};
+      #t15.{core::Set::addAll}{Invariant}(#t16{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t15.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t15);
   core::Set<core::int> set1 = block {
     final core::Set<core::int> #t17 = new col::_CompactLinkedHashSet::•<core::int>();
@@ -73,57 +73,57 @@ static method main() → dynamic {
         final dynamic #t19 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t20 = #t19 as{TypeError,ForNonNullableByDefault} core::int;
-          #t17.{core::Set::add}(#t20){(core::int) → core::bool};
+          #t17.{core::Set::add}{Invariant}(#t20){(core::int) → core::bool};
         }
       }
     }
   } =>#t17;
   core::Set<core::int> set3 = block {
     final core::Set<core::int> #t21 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t21.{core::Set::add}(1){(core::int) → core::bool};
-    #t21.{core::Set::add}(2){(core::int) → core::bool};
+    #t21.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t21.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t22 = set;
     if(!(#t22 == null))
-      #t21.{core::Set::addAll}(#t22{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t21.{core::Set::add}(3){(core::int) → core::bool};
+      #t21.{core::Set::addAll}{Invariant}(#t22{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t21.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t21;
   core::Set<core::int> set4 = block {
     final core::Set<core::int> #t23 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t23.{core::Set::add}(1){(core::int) → core::bool};
-    #t23.{core::Set::add}(2){(core::int) → core::bool};
+    #t23.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t23.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t24 = null;
     if(!(#t24 == null))
-      #t23.{core::Set::addAll}(#t24{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t23.{core::Set::add}(3){(core::int) → core::bool};
+      #t23.{core::Set::addAll}{Invariant}(#t24{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t23.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t23;
   core::Map<core::int, core::int>? map = null;
   core::print( block {
     final core::Map<core::int, core::int> #t25 = <core::int, core::int>{};
-    #t25.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t25.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t26 = map;
     if(!(#t26 == null)) {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t26{core::Map<core::int, 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> #t27 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t25.{core::Map::[]=}(#t27.{core::MapEntry::key}{core::int}, #t27.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t25.{core::Map::[]=}{Invariant}(#t27.{core::MapEntry::key}{core::int}, #t27.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
-    #t25.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t25);
   core::print( block {
     final core::Map<core::int, core::int> #t28 = <core::int, core::int>{};
-    #t28.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t28.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t29 = null;
     if(!(#t29 == null)) {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t29{core::Map<core::int, 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> #t30 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t28.{core::Map::[]=}(#t30.{core::MapEntry::key}{core::int}, #t30.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t28.{core::Map::[]=}{Invariant}(#t30.{core::MapEntry::key}{core::int}, #t30.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
-    #t28.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t28);
   core::Map<core::int, core::int> map1 = block {
     final core::Map<core::int, core::int> #t31 = <core::int, core::int>{};
@@ -132,36 +132,36 @@ static method main() → dynamic {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t32{core::Map<core::int, 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> #t33 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t31.{core::Map::[]=}(#t33.{core::MapEntry::key}{core::int}, #t33.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t31.{core::Map::[]=}{Invariant}(#t33.{core::MapEntry::key}{core::int}, #t33.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
   } =>#t31;
   core::Map<core::int, core::int> map3 = block {
     final core::Map<core::int, core::int> #t34 = <core::int, core::int>{};
-    #t34.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t34.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t35 = map;
     if(!(#t35 == null)) {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t35{core::Map<core::int, 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> #t36 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t34.{core::Map::[]=}(#t36.{core::MapEntry::key}{core::int}, #t36.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t34.{core::Map::[]=}{Invariant}(#t36.{core::MapEntry::key}{core::int}, #t36.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
-    #t34.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t34;
   core::Map<core::int, core::int> map4 = block {
     final core::Map<core::int, core::int> #t37 = <core::int, core::int>{};
-    #t37.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t37.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t38 = null;
     if(!(#t38 == null)) {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t38{core::Map<core::int, 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> #t39 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t37.{core::Map::[]=}(#t39.{core::MapEntry::key}{core::int}, #t39.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t37.{core::Map::[]=}{Invariant}(#t39.{core::MapEntry::key}{core::int}, #t39.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
-    #t37.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t37;
 }

pkg/front_end/testcases/nnbd/spread_if_null.dart.weak.expect

@@ -9,60 +9,60 @@ static method main() → dynamic {
     final core::List<core::int> #t1 = <core::int>[1, 2];
     final core::Iterable<core::int>? #t2 = list;
     if(!(#t2 == null))
-      #t1.{core::List::addAll}(#t2{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t1.{core::List::add}(3){(core::int) → void};
+      #t1.{core::List::addAll}{Invariant}(#t2{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t1.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t1);
   core::print( block {
     final core::List<core::int> #t3 = <core::int>[1, 2];
     final core::Iterable<core::int>? #t4 = null;
     if(!(#t4 == null))
-      #t3.{core::List::addAll}(#t4{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t3.{core::List::add}(3){(core::int) → void};
+      #t3.{core::List::addAll}{Invariant}(#t4{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t3.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t3);
   core::List<core::int> list1 = block {
     final core::List<core::int> #t5 = <core::int>[];
     final core::Iterable<core::int>? #t6 = list;
     if(!(#t6 == null))
-      #t5.{core::List::addAll}(#t6{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+      #t5.{core::List::addAll}{Invariant}(#t6{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
   } =>#t5;
   core::List<Never> list2 = block {
     final core::List<Never> #t7 = <Never>[];
     final core::Iterable<Never>? #t8 = null;
     if(!(#t8 == null))
-      #t7.{core::List::addAll}(#t8{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t7.{core::List::addAll}{Invariant}(#t8{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t7;
   core::List<core::int> list3 = block {
     final core::List<core::int> #t9 = <core::int>[1, 2];
     final core::Iterable<core::int>? #t10 = list;
     if(!(#t10 == null))
-      #t9.{core::List::addAll}(#t10{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t9.{core::List::add}(3){(core::int) → void};
+      #t9.{core::List::addAll}{Invariant}(#t10{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t9.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t9;
   core::List<core::int> list4 = block {
     final core::List<core::int> #t11 = <core::int>[1, 2];
     final core::Iterable<core::int>? #t12 = null;
     if(!(#t12 == null))
-      #t11.{core::List::addAll}(#t12{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t11.{core::List::add}(3){(core::int) → void};
+      #t11.{core::List::addAll}{Invariant}(#t12{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t11.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t11;
   core::Set<core::int>? set = null;
   core::print( block {
     final core::Set<core::int> #t13 = col::LinkedHashSet::•<core::int>();
-    #t13.{core::Set::add}(1){(core::int) → core::bool};
-    #t13.{core::Set::add}(2){(core::int) → core::bool};
+    #t13.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t13.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t14 = set;
     if(!(#t14 == null))
-      #t13.{core::Set::addAll}(#t14{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t13.{core::Set::add}(3){(core::int) → core::bool};
+      #t13.{core::Set::addAll}{Invariant}(#t14{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t13.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t13);
   core::print( block {
     final core::Set<core::int> #t15 = col::LinkedHashSet::•<core::int>();
-    #t15.{core::Set::add}(1){(core::int) → core::bool};
-    #t15.{core::Set::add}(2){(core::int) → core::bool};
+    #t15.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t15.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t16 = null;
     if(!(#t16 == null))
-      #t15.{core::Set::addAll}(#t16{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t15.{core::Set::add}(3){(core::int) → core::bool};
+      #t15.{core::Set::addAll}{Invariant}(#t16{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t15.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t15);
   core::Set<core::int> set1 = block {
     final core::Set<core::int> #t17 = col::LinkedHashSet::•<core::int>();
@@ -70,73 +70,73 @@ static method main() → dynamic {
     if(!(#t18 == null))
       for (final dynamic #t19 in #t18{core::Iterable<dynamic>}) {
         final core::int #t20 = #t19 as{TypeError,ForNonNullableByDefault} core::int;
-        #t17.{core::Set::add}(#t20){(core::int) → core::bool};
+        #t17.{core::Set::add}{Invariant}(#t20){(core::int) → core::bool};
       }
   } =>#t17;
   core::Set<core::int> set3 = block {
     final core::Set<core::int> #t21 = col::LinkedHashSet::•<core::int>();
-    #t21.{core::Set::add}(1){(core::int) → core::bool};
-    #t21.{core::Set::add}(2){(core::int) → core::bool};
+    #t21.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t21.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t22 = set;
     if(!(#t22 == null))
-      #t21.{core::Set::addAll}(#t22{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t21.{core::Set::add}(3){(core::int) → core::bool};
+      #t21.{core::Set::addAll}{Invariant}(#t22{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t21.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t21;
   core::Set<core::int> set4 = block {
     final core::Set<core::int> #t23 = col::LinkedHashSet::•<core::int>();
-    #t23.{core::Set::add}(1){(core::int) → core::bool};
-    #t23.{core::Set::add}(2){(core::int) → core::bool};
+    #t23.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t23.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t24 = null;
     if(!(#t24 == null))
-      #t23.{core::Set::addAll}(#t24{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t23.{core::Set::add}(3){(core::int) → core::bool};
+      #t23.{core::Set::addAll}{Invariant}(#t24{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t23.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t23;
   core::Map<core::int, core::int>? map = null;
   core::print( block {
     final core::Map<core::int, core::int> #t25 = <core::int, core::int>{};
-    #t25.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t25.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t26 = map;
     if(!(#t26 == null))
       for (final core::MapEntry<core::int, core::int> #t27 in #t26{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t25.{core::Map::[]=}(#t27.{core::MapEntry::key}{core::int}, #t27.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
-    #t25.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+        #t25.{core::Map::[]=}{Invariant}(#t27.{core::MapEntry::key}{core::int}, #t27.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t25);
   core::print( block {
     final core::Map<core::int, core::int> #t28 = <core::int, core::int>{};
-    #t28.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t28.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t29 = null;
     if(!(#t29 == null))
       for (final core::MapEntry<core::int, core::int> #t30 in #t29{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t28.{core::Map::[]=}(#t30.{core::MapEntry::key}{core::int}, #t30.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
-    #t28.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+        #t28.{core::Map::[]=}{Invariant}(#t30.{core::MapEntry::key}{core::int}, #t30.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t28);
   core::Map<core::int, core::int> map1 = block {
     final core::Map<core::int, core::int> #t31 = <core::int, core::int>{};
     final core::Map<core::int, core::int>? #t32 = map;
     if(!(#t32 == null))
       for (final core::MapEntry<core::int, core::int> #t33 in #t32{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t31.{core::Map::[]=}(#t33.{core::MapEntry::key}{core::int}, #t33.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t31.{core::Map::[]=}{Invariant}(#t33.{core::MapEntry::key}{core::int}, #t33.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
   } =>#t31;
   core::Map<core::int, core::int> map3 = block {
     final core::Map<core::int, core::int> #t34 = <core::int, core::int>{};
-    #t34.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t34.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t35 = map;
     if(!(#t35 == null))
       for (final core::MapEntry<core::int, core::int> #t36 in #t35{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t34.{core::Map::[]=}(#t36.{core::MapEntry::key}{core::int}, #t36.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
-    #t34.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+        #t34.{core::Map::[]=}{Invariant}(#t36.{core::MapEntry::key}{core::int}, #t36.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t34;
   core::Map<core::int, core::int> map4 = block {
     final core::Map<core::int, core::int> #t37 = <core::int, core::int>{};
-    #t37.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t37.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t38 = null;
     if(!(#t38 == null))
       for (final core::MapEntry<core::int, core::int> #t39 in #t38{core::Map<core::int, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::int, core::int>>})
-        #t37.{core::Map::[]=}(#t39.{core::MapEntry::key}{core::int}, #t39.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
-    #t37.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+        #t37.{core::Map::[]=}{Invariant}(#t39.{core::MapEntry::key}{core::int}, #t39.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t37;
 }

pkg/front_end/testcases/nnbd/spread_if_null.dart.weak.transformed.expect

@@ -9,60 +9,60 @@ static method main() → dynamic {
     final core::List<core::int> #t1 = core::_GrowableList::_literal2<core::int>(1, 2);
     final core::Iterable<core::int>? #t2 = list;
     if(!(#t2 == null))
-      #t1.{core::List::addAll}(#t2{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t1.{core::List::add}(3){(core::int) → void};
+      #t1.{core::List::addAll}{Invariant}(#t2{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t1.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t1);
   core::print( block {
     final core::List<core::int> #t3 = core::_GrowableList::_literal2<core::int>(1, 2);
     final core::Iterable<core::int>? #t4 = null;
     if(!(#t4 == null))
-      #t3.{core::List::addAll}(#t4{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t3.{core::List::add}(3){(core::int) → void};
+      #t3.{core::List::addAll}{Invariant}(#t4{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t3.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t3);
   core::List<core::int> list1 = block {
     final core::List<core::int> #t5 = core::_GrowableList::•<core::int>(0);
     final core::Iterable<core::int>? #t6 = list;
     if(!(#t6 == null))
-      #t5.{core::List::addAll}(#t6{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+      #t5.{core::List::addAll}{Invariant}(#t6{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
   } =>#t5;
   core::List<Never> list2 = block {
     final core::List<Never> #t7 = core::_GrowableList::•<Never>(0);
     final core::Iterable<Never>? #t8 = null;
     if(!(#t8 == null))
-      #t7.{core::List::addAll}(#t8{core::Iterable<Never>}){(core::Iterable<Never>) → void};
+      #t7.{core::List::addAll}{Invariant}(#t8{core::Iterable<Never>}){(core::Iterable<Never>) → void};
   } =>#t7;
   core::List<core::int> list3 = block {
     final core::List<core::int> #t9 = core::_GrowableList::_literal2<core::int>(1, 2);
     final core::Iterable<core::int>? #t10 = list;
     if(!(#t10 == null))
-      #t9.{core::List::addAll}(#t10{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t9.{core::List::add}(3){(core::int) → void};
+      #t9.{core::List::addAll}{Invariant}(#t10{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t9.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t9;
   core::List<core::int> list4 = block {
     final core::List<core::int> #t11 = core::_GrowableList::_literal2<core::int>(1, 2);
     final core::Iterable<core::int>? #t12 = null;
     if(!(#t12 == null))
-      #t11.{core::List::addAll}(#t12{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t11.{core::List::add}(3){(core::int) → void};
+      #t11.{core::List::addAll}{Invariant}(#t12{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t11.{core::List::add}{Invariant}(3){(core::int) → void};
   } =>#t11;
   core::Set<core::int>? set = null;
   core::print( block {
     final core::Set<core::int> #t13 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t13.{core::Set::add}(1){(core::int) → core::bool};
-    #t13.{core::Set::add}(2){(core::int) → core::bool};
+    #t13.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t13.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t14 = set;
     if(!(#t14 == null))
-      #t13.{core::Set::addAll}(#t14{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t13.{core::Set::add}(3){(core::int) → core::bool};
+      #t13.{core::Set::addAll}{Invariant}(#t14{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t13.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t13);
   core::print( block {
     final core::Set<core::int> #t15 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t15.{core::Set::add}(1){(core::int) → core::bool};
-    #t15.{core::Set::add}(2){(core::int) → core::bool};
+    #t15.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t15.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t16 = null;
     if(!(#t16 == null))
-      #t15.{core::Set::addAll}(#t16{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t15.{core::Set::add}(3){(core::int) → core::bool};
+      #t15.{core::Set::addAll}{Invariant}(#t16{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t15.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t15);
   core::Set<core::int> set1 = block {
     final core::Set<core::int> #t17 = new col::_CompactLinkedHashSet::•<core::int>();
@@ -73,57 +73,57 @@ static method main() → dynamic {
         final dynamic #t19 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::int #t20 = #t19 as{TypeError,ForNonNullableByDefault} core::int;
-          #t17.{core::Set::add}(#t20){(core::int) → core::bool};
+          #t17.{core::Set::add}{Invariant}(#t20){(core::int) → core::bool};
         }
       }
     }
   } =>#t17;
   core::Set<core::int> set3 = block {
     final core::Set<core::int> #t21 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t21.{core::Set::add}(1){(core::int) → core::bool};
-    #t21.{core::Set::add}(2){(core::int) → core::bool};
+    #t21.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t21.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t22 = set;
     if(!(#t22 == null))
-      #t21.{core::Set::addAll}(#t22{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t21.{core::Set::add}(3){(core::int) → core::bool};
+      #t21.{core::Set::addAll}{Invariant}(#t22{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t21.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t21;
   core::Set<core::int> set4 = block {
     final core::Set<core::int> #t23 = new col::_CompactLinkedHashSet::•<core::int>();
-    #t23.{core::Set::add}(1){(core::int) → core::bool};
-    #t23.{core::Set::add}(2){(core::int) → core::bool};
+    #t23.{core::Set::add}{Invariant}(1){(core::int) → core::bool};
+    #t23.{core::Set::add}{Invariant}(2){(core::int) → core::bool};
     final core::Iterable<core::int>? #t24 = null;
     if(!(#t24 == null))
-      #t23.{core::Set::addAll}(#t24{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
-    #t23.{core::Set::add}(3){(core::int) → core::bool};
+      #t23.{core::Set::addAll}{Invariant}(#t24{core::Iterable<core::int>}){(core::Iterable<core::int>) → void};
+    #t23.{core::Set::add}{Invariant}(3){(core::int) → core::bool};
   } =>#t23;
   core::Map<core::int, core::int>? map = null;
   core::print( block {
     final core::Map<core::int, core::int> #t25 = <core::int, core::int>{};
-    #t25.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t25.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t26 = map;
     if(!(#t26 == null)) {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t26{core::Map<core::int, 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> #t27 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t25.{core::Map::[]=}(#t27.{core::MapEntry::key}{core::int}, #t27.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t25.{core::Map::[]=}{Invariant}(#t27.{core::MapEntry::key}{core::int}, #t27.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
-    #t25.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+    #t25.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t25);
   core::print( block {
     final core::Map<core::int, core::int> #t28 = <core::int, core::int>{};
-    #t28.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t28.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t29 = null;
     if(!(#t29 == null)) {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t29{core::Map<core::int, 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> #t30 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t28.{core::Map::[]=}(#t30.{core::MapEntry::key}{core::int}, #t30.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t28.{core::Map::[]=}{Invariant}(#t30.{core::MapEntry::key}{core::int}, #t30.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
-    #t28.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+    #t28.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t28);
   core::Map<core::int, core::int> map1 = block {
     final core::Map<core::int, core::int> #t31 = <core::int, core::int>{};
@@ -132,36 +132,36 @@ static method main() → dynamic {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t32{core::Map<core::int, 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> #t33 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t31.{core::Map::[]=}(#t33.{core::MapEntry::key}{core::int}, #t33.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t31.{core::Map::[]=}{Invariant}(#t33.{core::MapEntry::key}{core::int}, #t33.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
   } =>#t31;
   core::Map<core::int, core::int> map3 = block {
     final core::Map<core::int, core::int> #t34 = <core::int, core::int>{};
-    #t34.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t34.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t35 = map;
     if(!(#t35 == null)) {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t35{core::Map<core::int, 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> #t36 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t34.{core::Map::[]=}(#t36.{core::MapEntry::key}{core::int}, #t36.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t34.{core::Map::[]=}{Invariant}(#t36.{core::MapEntry::key}{core::int}, #t36.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
-    #t34.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+    #t34.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t34;
   core::Map<core::int, core::int> map4 = block {
     final core::Map<core::int, core::int> #t37 = <core::int, core::int>{};
-    #t37.{core::Map::[]=}(1, 1){(core::int, core::int) → void};
-    #t37.{core::Map::[]=}(2, 2){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(1, 1){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(2, 2){(core::int, core::int) → void};
     final core::Map<core::int, core::int>? #t38 = null;
     if(!(#t38 == null)) {
       core::Iterator<core::MapEntry<core::int, core::int>> :sync-for-iterator = #t38{core::Map<core::int, 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> #t39 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::int, core::int>};
-        #t37.{core::Map::[]=}(#t39.{core::MapEntry::key}{core::int}, #t39.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
+        #t37.{core::Map::[]=}{Invariant}(#t39.{core::MapEntry::key}{core::int}, #t39.{core::MapEntry::value}{core::int}){(core::int, core::int) → void};
       }
     }
-    #t37.{core::Map::[]=}(3, 3){(core::int, core::int) → void};
+    #t37.{core::Map::[]=}{Invariant}(3, 3){(core::int, core::int) → void};
   } =>#t37;
 }

pkg/front_end/testcases/nnbd/strictly_non_nullable_warnings.dart.strong.expect

@@ -141,7 +141,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
     final core::List<core::String> #t5 = <core::String>[];
     final core::Iterable<core::String>? #t6 = l;
     if(!(#t6 == null))
-      #t5.{core::List::addAll}(#t6{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
+      #t5.{core::List::addAll}{Invariant}(#t6{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
   } =>#t5;
   core::Set<core::String> a = block {
     final core::Set<core::String> #t7 = col::LinkedHashSet::•<core::String>();
@@ -149,28 +149,28 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
     if(!(#t8 == null))
       for (final dynamic #t9 in #t8{core::Iterable<dynamic>}) {
         final core::String #t10 = #t9 as{TypeError,ForNonNullableByDefault} core::String;
-        #t7.{core::Set::add}(#t10){(core::String) → core::bool};
+        #t7.{core::Set::add}{Invariant}(#t10){(core::String) → core::bool};
       }
   } =>#t7;
   block {
     final core::Set<core::String> #t11 = col::LinkedHashSet::•<core::String>();
     final core::Iterable<core::String>? #t12 = l;
     if(!(#t12 == null))
-      #t11.{core::Set::addAll}(#t12{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
+      #t11.{core::Set::addAll}{Invariant}(#t12{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
   } =>#t11;
   core::Map<core::String, core::int> b = block {
     final core::Map<core::String, core::int> #t13 = <core::String, core::int>{};
     final core::Map<core::String, core::int>? #t14 = m;
     if(!(#t14 == null))
       for (final core::MapEntry<core::String, core::int> #t15 in #t14{core::Map<core::String, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, core::int>>})
-        #t13.{core::Map::[]=}(#t15.{core::MapEntry::key}{core::String}, #t15.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
+        #t13.{core::Map::[]=}{Invariant}(#t15.{core::MapEntry::key}{core::String}, #t15.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
   } =>#t13;
   block {
     final core::Map<core::String, core::int> #t16 = <core::String, core::int>{};
     final core::Map<core::String, core::int>? #t17 = m;
     if(!(#t17 == null))
       for (final core::MapEntry<core::String, core::int> #t18 in #t17{core::Map<core::String, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, core::int>>})
-        #t16.{core::Map::[]=}(#t18.{core::MapEntry::key}{core::String}, #t18.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
+        #t16.{core::Map::[]=}{Invariant}(#t18.{core::MapEntry::key}{core::String}, #t18.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
   } =>#t16;
   s!;
   let final core::String #t19 = s in #t19 == null ?{core::String?} null : #t19.{core::String::substring}(0, 0){(core::int, [core::int?]) → core::String};

pkg/front_end/testcases/nnbd/strictly_non_nullable_warnings.dart.strong.transformed.expect

@@ -141,7 +141,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
     final core::List<core::String> #t5 = core::_GrowableList::•<core::String>(0);
     final core::Iterable<core::String>? #t6 = l;
     if(!(#t6 == null))
-      #t5.{core::List::addAll}(#t6{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
+      #t5.{core::List::addAll}{Invariant}(#t6{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
   } =>#t5;
   core::Set<core::String> a = block {
     final core::Set<core::String> #t7 = new col::_CompactLinkedHashSet::•<core::String>();
@@ -152,7 +152,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
         final dynamic #t9 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::String #t10 = #t9 as{TypeError,ForNonNullableByDefault} core::String;
-          #t7.{core::Set::add}(#t10){(core::String) → core::bool};
+          #t7.{core::Set::add}{Invariant}(#t10){(core::String) → core::bool};
         }
       }
     }
@@ -161,7 +161,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
     final core::Set<core::String> #t11 = new col::_CompactLinkedHashSet::•<core::String>();
     final core::Iterable<core::String>? #t12 = l;
     if(!(#t12 == null))
-      #t11.{core::Set::addAll}(#t12{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
+      #t11.{core::Set::addAll}{Invariant}(#t12{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
   } =>#t11;
   core::Map<core::String, core::int> b = block {
     final core::Map<core::String, core::int> #t13 = <core::String, core::int>{};
@@ -170,7 +170,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
       core::Iterator<core::MapEntry<core::String, core::int>> :sync-for-iterator = #t14{core::Map<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> #t15 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String, core::int>};
-        #t13.{core::Map::[]=}(#t15.{core::MapEntry::key}{core::String}, #t15.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
+        #t13.{core::Map::[]=}{Invariant}(#t15.{core::MapEntry::key}{core::String}, #t15.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
       }
     }
   } =>#t13;
@@ -181,7 +181,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
       core::Iterator<core::MapEntry<core::String, core::int>> :sync-for-iterator = #t17{core::Map<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> #t18 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String, core::int>};
-        #t16.{core::Map::[]=}(#t18.{core::MapEntry::key}{core::String}, #t18.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
+        #t16.{core::Map::[]=}{Invariant}(#t18.{core::MapEntry::key}{core::String}, #t18.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
       }
     }
   } =>#t16;

pkg/front_end/testcases/nnbd/strictly_non_nullable_warnings.dart.weak.expect

@@ -141,7 +141,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
     final core::List<core::String> #t5 = <core::String>[];
     final core::Iterable<core::String>? #t6 = l;
     if(!(#t6 == null))
-      #t5.{core::List::addAll}(#t6{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
+      #t5.{core::List::addAll}{Invariant}(#t6{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
   } =>#t5;
   core::Set<core::String> a = block {
     final core::Set<core::String> #t7 = col::LinkedHashSet::•<core::String>();
@@ -149,28 +149,28 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
     if(!(#t8 == null))
       for (final dynamic #t9 in #t8{core::Iterable<dynamic>}) {
         final core::String #t10 = #t9 as{TypeError,ForNonNullableByDefault} core::String;
-        #t7.{core::Set::add}(#t10){(core::String) → core::bool};
+        #t7.{core::Set::add}{Invariant}(#t10){(core::String) → core::bool};
       }
   } =>#t7;
   block {
     final core::Set<core::String> #t11 = col::LinkedHashSet::•<core::String>();
     final core::Iterable<core::String>? #t12 = l;
     if(!(#t12 == null))
-      #t11.{core::Set::addAll}(#t12{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
+      #t11.{core::Set::addAll}{Invariant}(#t12{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
   } =>#t11;
   core::Map<core::String, core::int> b = block {
     final core::Map<core::String, core::int> #t13 = <core::String, core::int>{};
     final core::Map<core::String, core::int>? #t14 = m;
     if(!(#t14 == null))
       for (final core::MapEntry<core::String, core::int> #t15 in #t14{core::Map<core::String, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, core::int>>})
-        #t13.{core::Map::[]=}(#t15.{core::MapEntry::key}{core::String}, #t15.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
+        #t13.{core::Map::[]=}{Invariant}(#t15.{core::MapEntry::key}{core::String}, #t15.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
   } =>#t13;
   block {
     final core::Map<core::String, core::int> #t16 = <core::String, core::int>{};
     final core::Map<core::String, core::int>? #t17 = m;
     if(!(#t17 == null))
       for (final core::MapEntry<core::String, core::int> #t18 in #t17{core::Map<core::String, core::int>}.{core::Map::entries}{core::Iterable<core::MapEntry<core::String, core::int>>})
-        #t16.{core::Map::[]=}(#t18.{core::MapEntry::key}{core::String}, #t18.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
+        #t16.{core::Map::[]=}{Invariant}(#t18.{core::MapEntry::key}{core::String}, #t18.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
   } =>#t16;
   s!;
   let final core::String #t19 = s in #t19 == null ?{core::String?} null : #t19.{core::String::substring}(0, 0){(core::int, [core::int?]) → core::String};

pkg/front_end/testcases/nnbd/strictly_non_nullable_warnings.dart.weak.transformed.expect

@@ -141,7 +141,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
     final core::List<core::String> #t5 = core::_GrowableList::•<core::String>(0);
     final core::Iterable<core::String>? #t6 = l;
     if(!(#t6 == null))
-      #t5.{core::List::addAll}(#t6{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
+      #t5.{core::List::addAll}{Invariant}(#t6{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
   } =>#t5;
   core::Set<core::String> a = block {
     final core::Set<core::String> #t7 = new col::_CompactLinkedHashSet::•<core::String>();
@@ -152,7 +152,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
         final dynamic #t9 = :sync-for-iterator.{core::Iterator::current}{dynamic};
         {
           final core::String #t10 = #t9 as{TypeError,ForNonNullableByDefault} core::String;
-          #t7.{core::Set::add}(#t10){(core::String) → core::bool};
+          #t7.{core::Set::add}{Invariant}(#t10){(core::String) → core::bool};
         }
       }
     }
@@ -161,7 +161,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
     final core::Set<core::String> #t11 = new col::_CompactLinkedHashSet::•<core::String>();
     final core::Iterable<core::String>? #t12 = l;
     if(!(#t12 == null))
-      #t11.{core::Set::addAll}(#t12{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
+      #t11.{core::Set::addAll}{Invariant}(#t12{core::Iterable<core::String>}){(core::Iterable<core::String>) → void};
   } =>#t11;
   core::Map<core::String, core::int> b = block {
     final core::Map<core::String, core::int> #t13 = <core::String, core::int>{};
@@ -170,7 +170,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
       core::Iterator<core::MapEntry<core::String, core::int>> :sync-for-iterator = #t14{core::Map<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> #t15 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String, core::int>};
-        #t13.{core::Map::[]=}(#t15.{core::MapEntry::key}{core::String}, #t15.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
+        #t13.{core::Map::[]=}{Invariant}(#t15.{core::MapEntry::key}{core::String}, #t15.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
       }
     }
   } =>#t13;
@@ -181,7 +181,7 @@ static method warning(core::String s, core::List<core::String> l, core::Map<core
       core::Iterator<core::MapEntry<core::String, core::int>> :sync-for-iterator = #t17{core::Map<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> #t18 = :sync-for-iterator.{core::Iterator::current}{core::MapEntry<core::String, core::int>};
-        #t16.{core::Map::[]=}(#t18.{core::MapEntry::key}{core::String}, #t18.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
+        #t16.{core::Map::[]=}{Invariant}(#t18.{core::MapEntry::key}{core::String}, #t18.{core::MapEntry::value}{core::int}){(core::String, core::int) → void};
       }
     }
   } =>#t16;

pkg/front_end/testcases/nnbd/tearoff_from_nullable_receiver.dart.strong.expect

@@ -81,8 +81,8 @@ static method foo<T extends self::C?>(self::C? c, self::foo::T% t, self::foo::T?
                           ^" in nt as{TypeError,ForNonNullableByDefault} () →? core::int);
 }
 static method bar<T extends self::C>(self::C c, self::bar::T t) → dynamic {
-  self::functionContext(let final self::C #t9 = c in #t9 == null ?{() → core::int} null : #t9.{self::C::call});
-  self::nullableFunctionContext(let final self::C #t10 = c in #t10 == null ?{() → core::int} null : #t10.{self::C::call});
+  self::functionContext(let final self::C #t9 = c in #t9 == null ?{() → core::int} null : #t9.{self::C::call}{() → core::int});
+  self::nullableFunctionContext(let final self::C #t10 = c in #t10 == null ?{() → core::int} null : #t10.{self::C::call}{() → core::int});
   self::functionContext(let final Never #t11 = invalid-expression "pkg/front_end/testcases/nnbd/tearoff_from_nullable_receiver.dart:27:19: Error: The argument type 'T' can't be assigned to the parameter type 'int Function()'.
   functionContext(t); // Shouldn't result in a compile-time error.
                   ^" in t as{TypeError,ForNonNullableByDefault} () → core::int);

pkg/front_end/testcases/nnbd/tearoff_from_nullable_receiver.dart.strong.transformed.expect

@@ -81,8 +81,8 @@ static method foo<T extends self::C?>(self::C? c, self::foo::T% t, self::foo::T?
                           ^" in nt as{TypeError,ForNonNullableByDefault} () →? core::int);
 }
 static method bar<T extends self::C>(self::C c, self::bar::T t) → dynamic {
-  self::functionContext(let final self::C #t10 = c in #t10 == null ?{() → core::int} null : #t10.{self::C::call});
-  self::nullableFunctionContext(let final self::C #t11 = c in #t11 == null ?{() → core::int} null : #t11.{self::C::call});
+  self::functionContext(let final self::C #t10 = c in #t10 == null ?{() → core::int} null : #t10.{self::C::call}{() → core::int});
+  self::nullableFunctionContext(let final self::C #t11 = c in #t11 == null ?{() → core::int} null : #t11.{self::C::call}{() → core::int});
   self::functionContext(let final Never #t12 = invalid-expression "pkg/front_end/testcases/nnbd/tearoff_from_nullable_receiver.dart:27:19: Error: The argument type 'T' can't be assigned to the parameter type 'int Function()'.
   functionContext(t); // Shouldn't result in a compile-time error.
                   ^" in t as{TypeError,ForNonNullableByDefault} () → core::int);

pkg/front_end/testcases/nnbd/tearoff_from_nullable_receiver.dart.weak.expect

@@ -81,8 +81,8 @@ static method foo<T extends self::C?>(self::C? c, self::foo::T% t, self::foo::T?
                           ^" in nt as{TypeError,ForNonNullableByDefault} () →? core::int);
 }
 static method bar<T extends self::C>(self::C c, self::bar::T t) → dynamic {
-  self::functionContext(let final self::C #t9 = c in #t9 == null ?{() → core::int} null : #t9.{self::C::call});
-  self::nullableFunctionContext(let final self::C #t10 = c in #t10 == null ?{() → core::int} null : #t10.{self::C::call});
+  self::functionContext(let final self::C #t9 = c in #t9 == null ?{() → core::int} null : #t9.{self::C::call}{() → core::int});
+  self::nullableFunctionContext(let final self::C #t10 = c in #t10 == null ?{() → core::int} null : #t10.{self::C::call}{() → core::int});
   self::functionContext(let final Never #t11 = invalid-expression "pkg/front_end/testcases/nnbd/tearoff_from_nullable_receiver.dart:27:19: Error: The argument type 'T' can't be assigned to the parameter type 'int Function()'.
   functionContext(t); // Shouldn't result in a compile-time error.
                   ^" in t as{TypeError,ForNonNullableByDefault} () → core::int);

pkg/front_end/testcases/nnbd/tearoff_from_nullable_receiver.dart.weak.transformed.expect

@@ -81,8 +81,8 @@ static method foo<T extends self::C?>(self::C? c, self::foo::T% t, self::foo::T?
                           ^" in nt as{TypeError,ForNonNullableByDefault} () →? core::int);
 }
 static method bar<T extends self::C>(self::C c, self::bar::T t) → dynamic {
-  self::functionContext(let final self::C #t9 = c in #t9 == null ?{() → core::int} null : #t9.{self::C::call});
-  self::nullableFunctionContext(let final self::C #t10 = c in #t10 == null ?{() → core::int} null : #t10.{self::C::call});
+  self::functionContext(let final self::C #t9 = c in #t9 == null ?{() → core::int} null : #t9.{self::C::call}{() → core::int});
+  self::nullableFunctionContext(let final self::C #t10 = c in #t10 == null ?{() → core::int} null : #t10.{self::C::call}{() → core::int});
   self::functionContext(let final Never #t11 = invalid-expression "pkg/front_end/testcases/nnbd/tearoff_from_nullable_receiver.dart:27:19: Error: The argument type 'T' can't be assigned to the parameter type 'int Function()'.
   functionContext(t); // Shouldn't result in a compile-time error.
                   ^" in t as{TypeError,ForNonNullableByDefault} () → core::int);

pkg/front_end/testcases/nnbd_mixed/infer_constraints_from_opt_in.dart.weak.expect

@@ -37,83 +37,83 @@ static method main() → dynamic {
   core::List<Null>* local1i = <Null>[null];
   core::Set<inf::C<dynamic>*>* local2a = block {
     final core::Set<inf::C<dynamic>*>* #t1 = col::LinkedHashSet::•<inf::C<dynamic>*>();
-    #t1.{core::Set::add}(inf::field1){(inf::C<dynamic>*) →* core::bool*};
-    #t1.{core::Set::add}(null){(inf::C<dynamic>*) →* core::bool*};
+    #t1.{core::Set::add}{Invariant}(inf::field1){(inf::C<dynamic>*) →* core::bool*};
+    #t1.{core::Set::add}{Invariant}(null){(inf::C<dynamic>*) →* core::bool*};
   } =>#t1;
   core::Set<inf::C<dynamic>*>* local2b = block {
     final core::Set<inf::C<dynamic>*>* #t2 = col::LinkedHashSet::•<inf::C<dynamic>*>();
-    #t2.{core::Set::add}(inf::field2){(inf::C<dynamic>*) →* core::bool*};
-    #t2.{core::Set::add}(null){(inf::C<dynamic>*) →* core::bool*};
+    #t2.{core::Set::add}{Invariant}(inf::field2){(inf::C<dynamic>*) →* core::bool*};
+    #t2.{core::Set::add}{Invariant}(null){(inf::C<dynamic>*) →* core::bool*};
   } =>#t2;
   core::Set<inf::C<core::int*>*>* local2c = block {
     final core::Set<inf::C<core::int*>*>* #t3 = col::LinkedHashSet::•<inf::C<core::int*>*>();
-    #t3.{core::Set::add}(inf::field3){(inf::C<core::int*>*) →* core::bool*};
-    #t3.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t3.{core::Set::add}{Invariant}(inf::field3){(inf::C<core::int*>*) →* core::bool*};
+    #t3.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
   } =>#t3;
   core::Set<inf::C<core::int*>*>* local2d = block {
     final core::Set<inf::C<core::int*>*>* #t4 = col::LinkedHashSet::•<inf::C<core::int*>*>();
-    #t4.{core::Set::add}(inf::field4){(inf::C<core::int*>*) →* core::bool*};
-    #t4.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t4.{core::Set::add}{Invariant}(inf::field4){(inf::C<core::int*>*) →* core::bool*};
+    #t4.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
   } =>#t4;
   core::Set<inf::C<core::int*>*>* local2e = block {
     final core::Set<inf::C<core::int*>*>* #t5 = col::LinkedHashSet::•<inf::C<core::int*>*>();
-    #t5.{core::Set::add}(inf::field5){(inf::C<core::int*>*) →* core::bool*};
-    #t5.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t5.{core::Set::add}{Invariant}(inf::field5){(inf::C<core::int*>*) →* core::bool*};
+    #t5.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
   } =>#t5;
   core::Set<inf::C<core::int*>*>* local2f = block {
     final core::Set<inf::C<core::int*>*>* #t6 = col::LinkedHashSet::•<inf::C<core::int*>*>();
-    #t6.{core::Set::add}(inf::field6){(inf::C<core::int*>*) →* core::bool*};
-    #t6.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t6.{core::Set::add}{Invariant}(inf::field6){(inf::C<core::int*>*) →* core::bool*};
+    #t6.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
   } =>#t6;
   core::Set<core::int*>* local2g = block {
     final core::Set<core::int*>* #t7 = col::LinkedHashSet::•<core::int*>();
-    #t7.{core::Set::add}(inf::field7){(core::int*) →* core::bool*};
-    #t7.{core::Set::add}(null){(core::int*) →* core::bool*};
+    #t7.{core::Set::add}{Invariant}(inf::field7){(core::int*) →* core::bool*};
+    #t7.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
   } =>#t7;
   core::Set<core::int*>* local2h = block {
     final core::Set<core::int*>* #t8 = col::LinkedHashSet::•<core::int*>();
-    #t8.{core::Set::add}(inf::field8){(core::int*) →* core::bool*};
-    #t8.{core::Set::add}(null){(core::int*) →* core::bool*};
+    #t8.{core::Set::add}{Invariant}(inf::field8){(core::int*) →* core::bool*};
+    #t8.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
   } =>#t8;
   core::Set<inf::C<dynamic>*>* local3a = block {
     final core::Set<inf::C<dynamic>*>* #t9 = col::LinkedHashSet::•<inf::C<dynamic>*>();
-    #t9.{core::Set::add}(null){(inf::C<dynamic>*) →* core::bool*};
-    #t9.{core::Set::add}(inf::field1){(inf::C<dynamic>*) →* core::bool*};
+    #t9.{core::Set::add}{Invariant}(null){(inf::C<dynamic>*) →* core::bool*};
+    #t9.{core::Set::add}{Invariant}(inf::field1){(inf::C<dynamic>*) →* core::bool*};
   } =>#t9;
   core::Set<inf::C<dynamic>*>* local3b = block {
     final core::Set<inf::C<dynamic>*>* #t10 = col::LinkedHashSet::•<inf::C<dynamic>*>();
-    #t10.{core::Set::add}(null){(inf::C<dynamic>*) →* core::bool*};
-    #t10.{core::Set::add}(inf::field2){(inf::C<dynamic>*) →* core::bool*};
+    #t10.{core::Set::add}{Invariant}(null){(inf::C<dynamic>*) →* core::bool*};
+    #t10.{core::Set::add}{Invariant}(inf::field2){(inf::C<dynamic>*) →* core::bool*};
   } =>#t10;
   core::Set<inf::C<core::int*>*>* local3c = block {
     final core::Set<inf::C<core::int*>*>* #t11 = col::LinkedHashSet::•<inf::C<core::int*>*>();
-    #t11.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
-    #t11.{core::Set::add}(inf::field3){(inf::C<core::int*>*) →* core::bool*};
+    #t11.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t11.{core::Set::add}{Invariant}(inf::field3){(inf::C<core::int*>*) →* core::bool*};
   } =>#t11;
   core::Set<inf::C<core::int*>*>* local3d = block {
     final core::Set<inf::C<core::int*>*>* #t12 = col::LinkedHashSet::•<inf::C<core::int*>*>();
-    #t12.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
-    #t12.{core::Set::add}(inf::field4){(inf::C<core::int*>*) →* core::bool*};
+    #t12.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t12.{core::Set::add}{Invariant}(inf::field4){(inf::C<core::int*>*) →* core::bool*};
   } =>#t12;
   core::Set<inf::C<core::int*>*>* local3e = block {
     final core::Set<inf::C<core::int*>*>* #t13 = col::LinkedHashSet::•<inf::C<core::int*>*>();
-    #t13.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
-    #t13.{core::Set::add}(inf::field5){(inf::C<core::int*>*) →* core::bool*};
+    #t13.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t13.{core::Set::add}{Invariant}(inf::field5){(inf::C<core::int*>*) →* core::bool*};
   } =>#t13;
   core::Set<inf::C<core::int*>*>* local3f = block {
     final core::Set<inf::C<core::int*>*>* #t14 = col::LinkedHashSet::•<inf::C<core::int*>*>();
-    #t14.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
-    #t14.{core::Set::add}(inf::field6){(inf::C<core::int*>*) →* core::bool*};
+    #t14.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t14.{core::Set::add}{Invariant}(inf::field6){(inf::C<core::int*>*) →* core::bool*};
   } =>#t14;
   core::Set<core::int*>* local3g = block {
     final core::Set<core::int*>* #t15 = col::LinkedHashSet::•<core::int*>();
-    #t15.{core::Set::add}(null){(core::int*) →* core::bool*};
-    #t15.{core::Set::add}(inf::field7){(core::int*) →* core::bool*};
+    #t15.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+    #t15.{core::Set::add}{Invariant}(inf::field7){(core::int*) →* core::bool*};
   } =>#t15;
   core::Set<core::int*>* local3h = block {
     final core::Set<core::int*>* #t16 = col::LinkedHashSet::•<core::int*>();
-    #t16.{core::Set::add}(null){(core::int*) →* core::bool*};
-    #t16.{core::Set::add}(inf::field8){(core::int*) →* core::bool*};
+    #t16.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+    #t16.{core::Set::add}{Invariant}(inf::field8){(core::int*) →* core::bool*};
   } =>#t16;
 }
 
@@ -167,82 +167,82 @@ static method method() → dynamic {
   core::List<Null> local1i = <Null>[null];
   core::Set<inf::C<dynamic>?> local2a = block {
     final core::Set<inf::C<dynamic>?> #t17 = col::LinkedHashSet::•<inf::C<dynamic>?>();
-    #t17.{core::Set::add}(inf::field1){(inf::C<dynamic>?) → core::bool};
-    #t17.{core::Set::add}(null){(inf::C<dynamic>?) → core::bool};
+    #t17.{core::Set::add}{Invariant}(inf::field1){(inf::C<dynamic>?) → core::bool};
+    #t17.{core::Set::add}{Invariant}(null){(inf::C<dynamic>?) → core::bool};
   } =>#t17;
   core::Set<inf::C<dynamic>?> local2b = block {
     final core::Set<inf::C<dynamic>?> #t18 = col::LinkedHashSet::•<inf::C<dynamic>?>();
-    #t18.{core::Set::add}(inf::field2){(inf::C<dynamic>?) → core::bool};
-    #t18.{core::Set::add}(null){(inf::C<dynamic>?) → core::bool};
+    #t18.{core::Set::add}{Invariant}(inf::field2){(inf::C<dynamic>?) → core::bool};
+    #t18.{core::Set::add}{Invariant}(null){(inf::C<dynamic>?) → core::bool};
   } =>#t18;
   core::Set<inf::C<core::int>?> local2c = block {
     final core::Set<inf::C<core::int>?> #t19 = col::LinkedHashSet::•<inf::C<core::int>?>();
-    #t19.{core::Set::add}(inf::field3){(inf::C<core::int>?) → core::bool};
-    #t19.{core::Set::add}(null){(inf::C<core::int>?) → core::bool};
+    #t19.{core::Set::add}{Invariant}(inf::field3){(inf::C<core::int>?) → core::bool};
+    #t19.{core::Set::add}{Invariant}(null){(inf::C<core::int>?) → core::bool};
   } =>#t19;
   core::Set<inf::C<core::int>?> local2d = block {
     final core::Set<inf::C<core::int>?> #t20 = col::LinkedHashSet::•<inf::C<core::int>?>();
-    #t20.{core::Set::add}(inf::field4){(inf::C<core::int>?) → core::bool};
-    #t20.{core::Set::add}(null){(inf::C<core::int>?) → core::bool};
+    #t20.{core::Set::add}{Invariant}(inf::field4){(inf::C<core::int>?) → core::bool};
+    #t20.{core::Set::add}{Invariant}(null){(inf::C<core::int>?) → core::bool};
   } =>#t20;
   core::Set<inf::C<core::int?>?> local2e = block {
     final core::Set<inf::C<core::int?>?> #t21 = col::LinkedHashSet::•<inf::C<core::int?>?>();
-    #t21.{core::Set::add}(inf::field5){(inf::C<core::int?>?) → core::bool};
-    #t21.{core::Set::add}(null){(inf::C<core::int?>?) → core::bool};
+    #t21.{core::Set::add}{Invariant}(inf::field5){(inf::C<core::int?>?) → core::bool};
+    #t21.{core::Set::add}{Invariant}(null){(inf::C<core::int?>?) → core::bool};
   } =>#t21;
   core::Set<inf::C<core::int?>?> local2f = block {
     final core::Set<inf::C<core::int?>?> #t22 = col::LinkedHashSet::•<inf::C<core::int?>?>();
-    #t22.{core::Set::add}(inf::field6){(inf::C<core::int?>?) → core::bool};
-    #t22.{core::Set::add}(null){(inf::C<core::int?>?) → core::bool};
+    #t22.{core::Set::add}{Invariant}(inf::field6){(inf::C<core::int?>?) → core::bool};
+    #t22.{core::Set::add}{Invariant}(null){(inf::C<core::int?>?) → core::bool};
   } =>#t22;
   core::Set<core::int?> local2g = block {
     final core::Set<core::int?> #t23 = col::LinkedHashSet::•<core::int?>();
-    #t23.{core::Set::add}(inf::field7){(core::int?) → core::bool};
-    #t23.{core::Set::add}(null){(core::int?) → core::bool};
+    #t23.{core::Set::add}{Invariant}(inf::field7){(core::int?) → core::bool};
+    #t23.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
   } =>#t23;
   core::Set<core::int?> local2h = block {
     final core::Set<core::int?> #t24 = col::LinkedHashSet::•<core::int?>();
-    #t24.{core::Set::add}(inf::field8){(core::int?) → core::bool};
-    #t24.{core::Set::add}(null){(core::int?) → core::bool};
+    #t24.{core::Set::add}{Invariant}(inf::field8){(core::int?) → core::bool};
+    #t24.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
   } =>#t24;
   core::Set<inf::C<dynamic>?> local3a = block {
     final core::Set<inf::C<dynamic>?> #t25 = col::LinkedHashSet::•<inf::C<dynamic>?>();
-    #t25.{core::Set::add}(null){(inf::C<dynamic>?) → core::bool};
-    #t25.{core::Set::add}(inf::field1){(inf::C<dynamic>?) → core::bool};
+    #t25.{core::Set::add}{Invariant}(null){(inf::C<dynamic>?) → core::bool};
+    #t25.{core::Set::add}{Invariant}(inf::field1){(inf::C<dynamic>?) → core::bool};
   } =>#t25;
   core::Set<inf::C<dynamic>?> local3b = block {
     final core::Set<inf::C<dynamic>?> #t26 = col::LinkedHashSet::•<inf::C<dynamic>?>();
-    #t26.{core::Set::add}(null){(inf::C<dynamic>?) → core::bool};
-    #t26.{core::Set::add}(inf::field2){(inf::C<dynamic>?) → core::bool};
+    #t26.{core::Set::add}{Invariant}(null){(inf::C<dynamic>?) → core::bool};
+    #t26.{core::Set::add}{Invariant}(inf::field2){(inf::C<dynamic>?) → core::bool};
   } =>#t26;
   core::Set<inf::C<core::int>?> local3c = block {
     final core::Set<inf::C<core::int>?> #t27 = col::LinkedHashSet::•<inf::C<core::int>?>();
-    #t27.{core::Set::add}(null){(inf::C<core::int>?) → core::bool};
-    #t27.{core::Set::add}(inf::field3){(inf::C<core::int>?) → core::bool};
+    #t27.{core::Set::add}{Invariant}(null){(inf::C<core::int>?) → core::bool};
+    #t27.{core::Set::add}{Invariant}(inf::field3){(inf::C<core::int>?) → core::bool};
   } =>#t27;
   core::Set<inf::C<core::int>?> local3d = block {
     final core::Set<inf::C<core::int>?> #t28 = col::LinkedHashSet::•<inf::C<core::int>?>();
-    #t28.{core::Set::add}(null){(inf::C<core::int>?) → core::bool};
-    #t28.{core::Set::add}(inf::field4){(inf::C<core::int>?) → core::bool};
+    #t28.{core::Set::add}{Invariant}(null){(inf::C<core::int>?) → core::bool};
+    #t28.{core::Set::add}{Invariant}(inf::field4){(inf::C<core::int>?) → core::bool};
   } =>#t28;
   core::Set<inf::C<core::int?>?> local3e = block {
     final core::Set<inf::C<core::int?>?> #t29 = col::LinkedHashSet::•<inf::C<core::int?>?>();
-    #t29.{core::Set::add}(null){(inf::C<core::int?>?) → core::bool};
-    #t29.{core::Set::add}(inf::field5){(inf::C<core::int?>?) → core::bool};
+    #t29.{core::Set::add}{Invariant}(null){(inf::C<core::int?>?) → core::bool};
+    #t29.{core::Set::add}{Invariant}(inf::field5){(inf::C<core::int?>?) → core::bool};
   } =>#t29;
   core::Set<inf::C<core::int?>?> local3f = block {
     final core::Set<inf::C<core::int?>?> #t30 = col::LinkedHashSet::•<inf::C<core::int?>?>();
-    #t30.{core::Set::add}(null){(inf::C<core::int?>?) → core::bool};
-    #t30.{core::Set::add}(inf::field6){(inf::C<core::int?>?) → core::bool};
+    #t30.{core::Set::add}{Invariant}(null){(inf::C<core::int?>?) → core::bool};
+    #t30.{core::Set::add}{Invariant}(inf::field6){(inf::C<core::int?>?) → core::bool};
   } =>#t30;
   core::Set<core::int?> local3g = block {
     final core::Set<core::int?> #t31 = col::LinkedHashSet::•<core::int?>();
-    #t31.{core::Set::add}(null){(core::int?) → core::bool};
-    #t31.{core::Set::add}(inf::field7){(core::int?) → core::bool};
+    #t31.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
+    #t31.{core::Set::add}{Invariant}(inf::field7){(core::int?) → core::bool};
   } =>#t31;
   core::Set<core::int?> local3h = block {
     final core::Set<core::int?> #t32 = col::LinkedHashSet::•<core::int?>();
-    #t32.{core::Set::add}(null){(core::int?) → core::bool};
-    #t32.{core::Set::add}(inf::field8){(core::int?) → core::bool};
+    #t32.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
+    #t32.{core::Set::add}{Invariant}(inf::field8){(core::int?) → core::bool};
   } =>#t32;
 }

pkg/front_end/testcases/nnbd_mixed/infer_constraints_from_opt_in.dart.weak.transformed.expect

@@ -37,83 +37,83 @@ static method main() → dynamic {
   core::List<Null>* local1i = core::_GrowableList::_literal1<Null>(null);
   core::Set<inf::C<dynamic>*>* local2a = block {
     final core::Set<inf::C<dynamic>*>* #t1 = new col::_CompactLinkedHashSet::•<inf::C<dynamic>*>();
-    #t1.{core::Set::add}(inf::field1){(inf::C<dynamic>*) →* core::bool*};
-    #t1.{core::Set::add}(null){(inf::C<dynamic>*) →* core::bool*};
+    #t1.{core::Set::add}{Invariant}(inf::field1){(inf::C<dynamic>*) →* core::bool*};
+    #t1.{core::Set::add}{Invariant}(null){(inf::C<dynamic>*) →* core::bool*};
   } =>#t1;
   core::Set<inf::C<dynamic>*>* local2b = block {
     final core::Set<inf::C<dynamic>*>* #t2 = new col::_CompactLinkedHashSet::•<inf::C<dynamic>*>();
-    #t2.{core::Set::add}(inf::field2){(inf::C<dynamic>*) →* core::bool*};
-    #t2.{core::Set::add}(null){(inf::C<dynamic>*) →* core::bool*};
+    #t2.{core::Set::add}{Invariant}(inf::field2){(inf::C<dynamic>*) →* core::bool*};
+    #t2.{core::Set::add}{Invariant}(null){(inf::C<dynamic>*) →* core::bool*};
   } =>#t2;
   core::Set<inf::C<core::int*>*>* local2c = block {
     final core::Set<inf::C<core::int*>*>* #t3 = new col::_CompactLinkedHashSet::•<inf::C<core::int*>*>();
-    #t3.{core::Set::add}(inf::field3){(inf::C<core::int*>*) →* core::bool*};
-    #t3.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t3.{core::Set::add}{Invariant}(inf::field3){(inf::C<core::int*>*) →* core::bool*};
+    #t3.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
   } =>#t3;
   core::Set<inf::C<core::int*>*>* local2d = block {
     final core::Set<inf::C<core::int*>*>* #t4 = new col::_CompactLinkedHashSet::•<inf::C<core::int*>*>();
-    #t4.{core::Set::add}(inf::field4){(inf::C<core::int*>*) →* core::bool*};
-    #t4.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t4.{core::Set::add}{Invariant}(inf::field4){(inf::C<core::int*>*) →* core::bool*};
+    #t4.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
   } =>#t4;
   core::Set<inf::C<core::int*>*>* local2e = block {
     final core::Set<inf::C<core::int*>*>* #t5 = new col::_CompactLinkedHashSet::•<inf::C<core::int*>*>();
-    #t5.{core::Set::add}(inf::field5){(inf::C<core::int*>*) →* core::bool*};
-    #t5.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t5.{core::Set::add}{Invariant}(inf::field5){(inf::C<core::int*>*) →* core::bool*};
+    #t5.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
   } =>#t5;
   core::Set<inf::C<core::int*>*>* local2f = block {
     final core::Set<inf::C<core::int*>*>* #t6 = new col::_CompactLinkedHashSet::•<inf::C<core::int*>*>();
-    #t6.{core::Set::add}(inf::field6){(inf::C<core::int*>*) →* core::bool*};
-    #t6.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t6.{core::Set::add}{Invariant}(inf::field6){(inf::C<core::int*>*) →* core::bool*};
+    #t6.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
   } =>#t6;
   core::Set<core::int*>* local2g = block {
     final core::Set<core::int*>* #t7 = new col::_CompactLinkedHashSet::•<core::int*>();
-    #t7.{core::Set::add}(inf::field7){(core::int*) →* core::bool*};
-    #t7.{core::Set::add}(null){(core::int*) →* core::bool*};
+    #t7.{core::Set::add}{Invariant}(inf::field7){(core::int*) →* core::bool*};
+    #t7.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
   } =>#t7;
   core::Set<core::int*>* local2h = block {
     final core::Set<core::int*>* #t8 = new col::_CompactLinkedHashSet::•<core::int*>();
-    #t8.{core::Set::add}(inf::field8){(core::int*) →* core::bool*};
-    #t8.{core::Set::add}(null){(core::int*) →* core::bool*};
+    #t8.{core::Set::add}{Invariant}(inf::field8){(core::int*) →* core::bool*};
+    #t8.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
   } =>#t8;
   core::Set<inf::C<dynamic>*>* local3a = block {
     final core::Set<inf::C<dynamic>*>* #t9 = new col::_CompactLinkedHashSet::•<inf::C<dynamic>*>();
-    #t9.{core::Set::add}(null){(inf::C<dynamic>*) →* core::bool*};
-    #t9.{core::Set::add}(inf::field1){(inf::C<dynamic>*) →* core::bool*};
+    #t9.{core::Set::add}{Invariant}(null){(inf::C<dynamic>*) →* core::bool*};
+    #t9.{core::Set::add}{Invariant}(inf::field1){(inf::C<dynamic>*) →* core::bool*};
   } =>#t9;
   core::Set<inf::C<dynamic>*>* local3b = block {
     final core::Set<inf::C<dynamic>*>* #t10 = new col::_CompactLinkedHashSet::•<inf::C<dynamic>*>();
-    #t10.{core::Set::add}(null){(inf::C<dynamic>*) →* core::bool*};
-    #t10.{core::Set::add}(inf::field2){(inf::C<dynamic>*) →* core::bool*};
+    #t10.{core::Set::add}{Invariant}(null){(inf::C<dynamic>*) →* core::bool*};
+    #t10.{core::Set::add}{Invariant}(inf::field2){(inf::C<dynamic>*) →* core::bool*};
   } =>#t10;
   core::Set<inf::C<core::int*>*>* local3c = block {
     final core::Set<inf::C<core::int*>*>* #t11 = new col::_CompactLinkedHashSet::•<inf::C<core::int*>*>();
-    #t11.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
-    #t11.{core::Set::add}(inf::field3){(inf::C<core::int*>*) →* core::bool*};
+    #t11.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t11.{core::Set::add}{Invariant}(inf::field3){(inf::C<core::int*>*) →* core::bool*};
   } =>#t11;
   core::Set<inf::C<core::int*>*>* local3d = block {
     final core::Set<inf::C<core::int*>*>* #t12 = new col::_CompactLinkedHashSet::•<inf::C<core::int*>*>();
-    #t12.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
-    #t12.{core::Set::add}(inf::field4){(inf::C<core::int*>*) →* core::bool*};
+    #t12.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t12.{core::Set::add}{Invariant}(inf::field4){(inf::C<core::int*>*) →* core::bool*};
   } =>#t12;
   core::Set<inf::C<core::int*>*>* local3e = block {
     final core::Set<inf::C<core::int*>*>* #t13 = new col::_CompactLinkedHashSet::•<inf::C<core::int*>*>();
-    #t13.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
-    #t13.{core::Set::add}(inf::field5){(inf::C<core::int*>*) →* core::bool*};
+    #t13.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t13.{core::Set::add}{Invariant}(inf::field5){(inf::C<core::int*>*) →* core::bool*};
   } =>#t13;
   core::Set<inf::C<core::int*>*>* local3f = block {
     final core::Set<inf::C<core::int*>*>* #t14 = new col::_CompactLinkedHashSet::•<inf::C<core::int*>*>();
-    #t14.{core::Set::add}(null){(inf::C<core::int*>*) →* core::bool*};
-    #t14.{core::Set::add}(inf::field6){(inf::C<core::int*>*) →* core::bool*};
+    #t14.{core::Set::add}{Invariant}(null){(inf::C<core::int*>*) →* core::bool*};
+    #t14.{core::Set::add}{Invariant}(inf::field6){(inf::C<core::int*>*) →* core::bool*};
   } =>#t14;
   core::Set<core::int*>* local3g = block {
     final core::Set<core::int*>* #t15 = new col::_CompactLinkedHashSet::•<core::int*>();
-    #t15.{core::Set::add}(null){(core::int*) →* core::bool*};
-    #t15.{core::Set::add}(inf::field7){(core::int*) →* core::bool*};
+    #t15.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+    #t15.{core::Set::add}{Invariant}(inf::field7){(core::int*) →* core::bool*};
   } =>#t15;
   core::Set<core::int*>* local3h = block {
     final core::Set<core::int*>* #t16 = new col::_CompactLinkedHashSet::•<core::int*>();
-    #t16.{core::Set::add}(null){(core::int*) →* core::bool*};
-    #t16.{core::Set::add}(inf::field8){(core::int*) →* core::bool*};
+    #t16.{core::Set::add}{Invariant}(null){(core::int*) →* core::bool*};
+    #t16.{core::Set::add}{Invariant}(inf::field8){(core::int*) →* core::bool*};
   } =>#t16;
 }
 
@@ -167,82 +167,82 @@ static method method() → dynamic {
   core::List<Null> local1i = core::_GrowableList::_literal1<Null>(null);
   core::Set<inf::C<dynamic>?> local2a = block {
     final core::Set<inf::C<dynamic>?> #t17 = new col::_CompactLinkedHashSet::•<inf::C<dynamic>?>();
-    #t17.{core::Set::add}(inf::field1){(inf::C<dynamic>?) → core::bool};
-    #t17.{core::Set::add}(null){(inf::C<dynamic>?) → core::bool};
+    #t17.{core::Set::add}{Invariant}(inf::field1){(inf::C<dynamic>?) → core::bool};
+    #t17.{core::Set::add}{Invariant}(null){(inf::C<dynamic>?) → core::bool};
   } =>#t17;
   core::Set<inf::C<dynamic>?> local2b = block {
     final core::Set<inf::C<dynamic>?> #t18 = new col::_CompactLinkedHashSet::•<inf::C<dynamic>?>();
-    #t18.{core::Set::add}(inf::field2){(inf::C<dynamic>?) → core::bool};
-    #t18.{core::Set::add}(null){(inf::C<dynamic>?) → core::bool};
+    #t18.{core::Set::add}{Invariant}(inf::field2){(inf::C<dynamic>?) → core::bool};
+    #t18.{core::Set::add}{Invariant}(null){(inf::C<dynamic>?) → core::bool};
   } =>#t18;
   core::Set<inf::C<core::int>?> local2c = block {
     final core::Set<inf::C<core::int>?> #t19 = new col::_CompactLinkedHashSet::•<inf::C<core::int>?>();
-    #t19.{core::Set::add}(inf::field3){(inf::C<core::int>?) → core::bool};
-    #t19.{core::Set::add}(null){(inf::C<core::int>?) → core::bool};
+    #t19.{core::Set::add}{Invariant}(inf::field3){(inf::C<core::int>?) → core::bool};
+    #t19.{core::Set::add}{Invariant}(null){(inf::C<core::int>?) → core::bool};
   } =>#t19;
   core::Set<inf::C<core::int>?> local2d = block {
     final core::Set<inf::C<core::int>?> #t20 = new col::_CompactLinkedHashSet::•<inf::C<core::int>?>();
-    #t20.{core::Set::add}(inf::field4){(inf::C<core::int>?) → core::bool};
-    #t20.{core::Set::add}(null){(inf::C<core::int>?) → core::bool};
+    #t20.{core::Set::add}{Invariant}(inf::field4){(inf::C<core::int>?) → core::bool};
+    #t20.{core::Set::add}{Invariant}(null){(inf::C<core::int>?) → core::bool};
   } =>#t20;
   core::Set<inf::C<core::int?>?> local2e = block {
     final core::Set<inf::C<core::int?>?> #t21 = new col::_CompactLinkedHashSet::•<inf::C<core::int?>?>();
-    #t21.{core::Set::add}(inf::field5){(inf::C<core::int?>?) → core::bool};
-    #t21.{core::Set::add}(null){(inf::C<core::int?>?) → core::bool};
+    #t21.{core::Set::add}{Invariant}(inf::field5){(inf::C<core::int?>?) → core::bool};
+    #t21.{core::Set::add}{Invariant}(null){(inf::C<core::int?>?) → core::bool};
   } =>#t21;
   core::Set<inf::C<core::int?>?> local2f = block {
     final core::Set<inf::C<core::int?>?> #t22 = new col::_CompactLinkedHashSet::•<inf::C<core::int?>?>();
-    #t22.{core::Set::add}(inf::field6){(inf::C<core::int?>?) → core::bool};
-    #t22.{core::Set::add}(null){(inf::C<core::int?>?) → core::bool};
+    #t22.{core::Set::add}{Invariant}(inf::field6){(inf::C<core::int?>?) → core::bool};
+    #t22.{core::Set::add}{Invariant}(null){(inf::C<core::int?>?) → core::bool};
   } =>#t22;
   core::Set<core::int?> local2g = block {
     final core::Set<core::int?> #t23 = new col::_CompactLinkedHashSet::•<core::int?>();
-    #t23.{core::Set::add}(inf::field7){(core::int?) → core::bool};
-    #t23.{core::Set::add}(null){(core::int?) → core::bool};
+    #t23.{core::Set::add}{Invariant}(inf::field7){(core::int?) → core::bool};
+    #t23.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
   } =>#t23;
   core::Set<core::int?> local2h = block {
     final core::Set<core::int?> #t24 = new col::_CompactLinkedHashSet::•<core::int?>();
-    #t24.{core::Set::add}(inf::field8){(core::int?) → core::bool};
-    #t24.{core::Set::add}(null){(core::int?) → core::bool};
+    #t24.{core::Set::add}{Invariant}(inf::field8){(core::int?) → core::bool};
+    #t24.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
   } =>#t24;
   core::Set<inf::C<dynamic>?> local3a = block {
     final core::Set<inf::C<dynamic>?> #t25 = new col::_CompactLinkedHashSet::•<inf::C<dynamic>?>();
-    #t25.{core::Set::add}(null){(inf::C<dynamic>?) → core::bool};
-    #t25.{core::Set::add}(inf::field1){(inf::C<dynamic>?) → core::bool};
+    #t25.{core::Set::add}{Invariant}(null){(inf::C<dynamic>?) → core::bool};
+    #t25.{core::Set::add}{Invariant}(inf::field1){(inf::C<dynamic>?) → core::bool};
   } =>#t25;
   core::Set<inf::C<dynamic>?> local3b = block {
     final core::Set<inf::C<dynamic>?> #t26 = new col::_CompactLinkedHashSet::•<inf::C<dynamic>?>();
-    #t26.{core::Set::add}(null){(inf::C<dynamic>?) → core::bool};
-    #t26.{core::Set::add}(inf::field2){(inf::C<dynamic>?) → core::bool};
+    #t26.{core::Set::add}{Invariant}(null){(inf::C<dynamic>?) → core::bool};
+    #t26.{core::Set::add}{Invariant}(inf::field2){(inf::C<dynamic>?) → core::bool};
   } =>#t26;
   core::Set<inf::C<core::int>?> local3c = block {
     final core::Set<inf::C<core::int>?> #t27 = new col::_CompactLinkedHashSet::•<inf::C<core::int>?>();
-    #t27.{core::Set::add}(null){(inf::C<core::int>?) → core::bool};
-    #t27.{core::Set::add}(inf::field3){(inf::C<core::int>?) → core::bool};
+    #t27.{core::Set::add}{Invariant}(null){(inf::C<core::int>?) → core::bool};
+    #t27.{core::Set::add}{Invariant}(inf::field3){(inf::C<core::int>?) → core::bool};
   } =>#t27;
   core::Set<inf::C<core::int>?> local3d = block {
     final core::Set<inf::C<core::int>?> #t28 = new col::_CompactLinkedHashSet::•<inf::C<core::int>?>();
-    #t28.{core::Set::add}(null){(inf::C<core::int>?) → core::bool};
-    #t28.{core::Set::add}(inf::field4){(inf::C<core::int>?) → core::bool};
+    #t28.{core::Set::add}{Invariant}(null){(inf::C<core::int>?) → core::bool};
+    #t28.{core::Set::add}{Invariant}(inf::field4){(inf::C<core::int>?) → core::bool};
   } =>#t28;
   core::Set<inf::C<core::int?>?> local3e = block {
     final core::Set<inf::C<core::int?>?> #t29 = new col::_CompactLinkedHashSet::•<inf::C<core::int?>?>();
-    #t29.{core::Set::add}(null){(inf::C<core::int?>?) → core::bool};
-    #t29.{core::Set::add}(inf::field5){(inf::C<core::int?>?) → core::bool};
+    #t29.{core::Set::add}{Invariant}(null){(inf::C<core::int?>?) → core::bool};
+    #t29.{core::Set::add}{Invariant}(inf::field5){(inf::C<core::int?>?) → core::bool};
   } =>#t29;
   core::Set<inf::C<core::int?>?> local3f = block {
     final core::Set<inf::C<core::int?>?> #t30 = new col::_CompactLinkedHashSet::•<inf::C<core::int?>?>();
-    #t30.{core::Set::add}(null){(inf::C<core::int?>?) → core::bool};
-    #t30.{core::Set::add}(inf::field6){(inf::C<core::int?>?) → core::bool};
+    #t30.{core::Set::add}{Invariant}(null){(inf::C<core::int?>?) → core::bool};
+    #t30.{core::Set::add}{Invariant}(inf::field6){(inf::C<core::int?>?) → core::bool};
   } =>#t30;
   core::Set<core::int?> local3g = block {
     final core::Set<core::int?> #t31 = new col::_CompactLinkedHashSet::•<core::int?>();
-    #t31.{core::Set::add}(null){(core::int?) → core::bool};
-    #t31.{core::Set::add}(inf::field7){(core::int?) → core::bool};
+    #t31.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
+    #t31.{core::Set::add}{Invariant}(inf::field7){(core::int?) → core::bool};
   } =>#t31;
   core::Set<core::int?> local3h = block {
     final core::Set<core::int?> #t32 = new col::_CompactLinkedHashSet::•<core::int?>();
-    #t32.{core::Set::add}(null){(core::int?) → core::bool};
-    #t32.{core::Set::add}(inf::field8){(core::int?) → core::bool};
+    #t32.{core::Set::add}{Invariant}(null){(core::int?) → core::bool};
+    #t32.{core::Set::add}{Invariant}(inf::field8){(core::int?) → core::bool};
   } =>#t32;
 }

pkg/front_end/testcases/nnbd_mixed/regress_null_aware.dart.weak.expect

@@ -13,7 +13,7 @@ class Class extends core::Object {
       final core::List<core::String*>* #t1 = <core::String*>[node];
       final core::Iterable<core::String*>* #t2 = let final core::Iterable<core::String*>* #t3 = let final core::Set<core::String*>* #t4 = this.{self::Class::map}{core::Map<core::String*, core::Set<core::String*>*>*}.{core::Map::[]}(node){(core::Object*) →* core::Set<core::String*>*} in #t4 == null ?{core::Iterable<core::String*>*} null : #t4.{core::Iterable::expand}<core::String*>((core::String* node) → core::List<core::String*>* => this.{self::Class::method}(node, set){(core::String*, core::Set<core::String*>*) →* core::List<core::String*>*}){((core::String*) →* core::Iterable<core::String*>*) →* core::Iterable<core::String*>*} in #t3 == null ?{core::List<core::String*>*} null : #t3.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
       if(!(#t2 == null))
-        #t1.{core::List::addAll}(#t2){(core::Iterable<core::String*>*) →* void};
+        #t1.{core::List::addAll}{Invariant}(#t2){(core::Iterable<core::String*>*) →* void};
     } =>#t1 : <core::String*>[];
   abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
   abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf

pkg/front_end/testcases/nnbd_mixed/regress_null_aware.dart.weak.transformed.expect

@@ -13,7 +13,7 @@ class Class extends core::Object {
       final core::List<core::String*>* #t1 = core::_GrowableList::_literal1<core::String*>(node);
       final core::Iterable<core::String*>* #t2 = let final core::Iterable<core::String*>* #t3 = let final core::Set<core::String*>* #t4 = this.{self::Class::map}{core::Map<core::String*, core::Set<core::String*>*>*}.{core::Map::[]}(node){(core::Object*) →* core::Set<core::String*>*} in #t4 == null ?{core::Iterable<core::String*>*} null : #t4.{core::Iterable::expand}<core::String*>((core::String* node) → core::List<core::String*>* => this.{self::Class::method}(node, set){(core::String*, core::Set<core::String*>*) →* core::List<core::String*>*}){((core::String*) →* core::Iterable<core::String*>*) →* core::Iterable<core::String*>*} in #t3 == null ?{core::List<core::String*>*} null : #t3.{core::Iterable::toList}(){({growable: core::bool*}) →* core::List<core::String*>*};
       if(!(#t2 == null))
-        #t1.{core::List::addAll}(#t2){(core::Iterable<core::String*>*) →* void};
+        #t1.{core::List::addAll}{Invariant}(#t2){(core::Iterable<core::String*>*) →* void};
     } =>#t1 : core::_GrowableList::•<core::String*>(0);
   abstract member-signature get _identityHashCode() → core::int*; -> core::Object::_identityHashCode
   abstract member-signature method _instanceOf(dynamic instantiatorTypeArguments, dynamic functionTypeArguments, dynamic type) → core::bool*; -> core::Object::_instanceOf

pkg/front_end/testcases/none/property_get.dart.strong.expect

@@ -84,7 +84,7 @@ static method test<T1 extends core::Function, T2 extends () → core::int>(self:
   core::print(invalid-expression "pkg/front_end/testcases/none/property_get.dart:63:36: Error: Not a constant expression.
   const dynamic instance_tearOff = nonNullableClass1.method;
                                    ^^^^^^^^^^^^^^^^^");
-  core::Function f1 = let final self::Class2<core::String> #t5 = nonNullableClass2 in #t5 == null ?{() → core::int} null : #t5.{self::Class2::call};
+  core::Function f1 = let final self::Class2<core::String> #t5 = nonNullableClass2 in #t5 == null ?{() → core::int} null : #t5.{self::Class2::call}{() → core::int};
   core::Function? f2 = let final Never #t6 = invalid-expression "pkg/front_end/testcases/none/property_get.dart:67:18: Error: Can't tear off method 'call' from a potentially null value.
   Function? f2 = nullableClass2;
                  ^" in nullableClass2 as{TypeError} core::Function?;

pkg/front_end/testcases/none/property_get.dart.weak.expect

@@ -85,7 +85,7 @@ static method test<T1 extends core::Function, T2 extends () → core::int>(self:
   core::print(invalid-expression "pkg/front_end/testcases/none/property_get.dart:63:36: Error: Not a constant expression.
   const dynamic instance_tearOff = nonNullableClass1.method;
                                    ^^^^^^^^^^^^^^^^^");
-  core::Function f1 = let final self::Class2<core::String> #t5 = nonNullableClass2 in #t5 == null ?{() → core::int} null : #t5.{self::Class2::call};
+  core::Function f1 = let final self::Class2<core::String> #t5 = nonNullableClass2 in #t5 == null ?{() → core::int} null : #t5.{self::Class2::call}{() → core::int};
   core::Function? f2 = let final Never #t6 = invalid-expression "pkg/front_end/testcases/none/property_get.dart:67:18: Error: Can't tear off method 'call' from a potentially null value.
   Function? f2 = nullableClass2;
                  ^" in nullableClass2 as{TypeError} core::Function?;