diff --git a/pkg/analyzer/test/src/dart/resolution/local_variable_test.dart b/pkg/analyzer/test/src/dart/resolution/local_variable_test.dart
index 213fbbb..ddad876 100644
--- a/pkg/analyzer/test/src/dart/resolution/local_variable_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/local_variable_test.dart
@@ -11,7 +11,6 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(LocalVariableResolutionTest);
-    defineReflectiveTests(LocalVariableResolutionWithNullSafetyTest);
   });
 }
 
@@ -95,11 +94,7 @@
     expect(x.isLate, isFalse);
     expect(x.isStatic, isFalse);
   }
-}
 
-@reflectiveTest
-class LocalVariableResolutionWithNullSafetyTest
-    extends LocalVariableResolutionTest with WithNullSafetyMixin {
   test_element_late() async {
     await assertErrorsInCode(r'''
 void f() {
diff --git a/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
index 094323e..2c5f443 100644
--- a/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/postfix_expression_test.dart
@@ -12,13 +12,298 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(PostfixExpressionResolutionTest);
-    defineReflectiveTests(PostfixExpressionResolutionWithNullSafetyTest);
+    defineReflectiveTests(PostfixExpressionResolutionWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class PostfixExpressionResolutionTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with PostfixExpressionResolutionTestCases {
+  test_inc_propertyAccess_nullShorting() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  int foo = 0;
+}
+
+void f(A? a) {
+  a?.foo++;
+}
+''');
+
+    assertPostfixExpression(
+      findNode.postfix('foo++'),
+      readElement: findElement.getter('foo'),
+      readType: 'int',
+      writeElement: findElement.setter('foo'),
+      writeType: 'int',
+      element: numElement.getMethod('+'),
+      type: 'int?',
+    );
+  }
+
+  test_inc_simpleIdentifier_parameter_depromote() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  Object operator +(int _) => this;
+}
+
+void f(Object x) {
+  if (x is A) {
+    x++;
+    x; // ref
+  }
+}
+''');
+
+    if (hasAssignmentLeftResolution) {
+      assertType(findNode.simple('x++;'), 'A');
+    }
+
+    assertPostfixExpression(
+      findNode.postfix('x++'),
+      readElement: findElement.parameter('x'),
+      readType: 'A',
+      writeElement: findElement.parameter('x'),
+      writeType: 'Object',
+      element: findElement.method('+'),
+      type: 'A',
+    );
+
+    assertType(findNode.simple('x; // ref'), 'Object');
+  }
+
+  test_nullCheck() async {
+    await assertNoErrorsInCode(r'''
+void f(int? x) {
+  x!;
+}
+''');
+
+    assertPostfixExpression(
+      findNode.postfix('x!'),
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: null,
+      type: 'int',
+    );
+  }
+
+  test_nullCheck_functionExpressionInvocation_rewrite() async {
+    await assertNoErrorsInCode(r'''
+void f(Function f2) {
+  f2(42)!;
+}
+''');
+  }
+
+  test_nullCheck_indexExpression() async {
+    await assertNoErrorsInCode(r'''
+void f(Map<String, int> a) {
+  int v = a['foo']!;
+  v;
+}
+''');
+
+    assertIndexExpression(
+      findNode.index('a['),
+      readElement: elementMatcher(
+        mapElement.getMethod('[]'),
+        substitution: {'K': 'String', 'V': 'int'},
+      ),
+      writeElement: null,
+      type: 'int?',
+    );
+
+    assertPostfixExpression(
+      findNode.postfix(']!'),
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: null,
+      type: 'int',
+    );
+  }
+
+  test_nullCheck_null() async {
+    await assertErrorsInCode('''
+void f(Null x) {
+  x!;
+}
+''', [
+      error(HintCode.NULL_CHECK_ALWAYS_FAILS, 19, 2),
+    ]);
+
+    assertType(findNode.postfix('x!'), 'Never');
+  }
+
+  test_nullCheck_nullableContext() async {
+    await assertNoErrorsInCode(r'''
+T f<T>(T t) => t;
+
+int g() => f(null)!;
+''');
+
+    assertMethodInvocation2(
+      findNode.methodInvocation('f(null)'),
+      element: findElement.topFunction('f'),
+      typeArgumentTypes: ['int?'],
+      invokeType: 'int? Function(int?)',
+      type: 'int?',
+    );
+
+    assertPostfixExpression(
+      findNode.postfix('f(null)!'),
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: null,
+      type: 'int',
+    );
+  }
+
+  /// See https://github.com/dart-lang/language/issues/1163
+  test_nullCheck_participatesNullShorting() async {
+    await assertErrorsInCode('''
+class A {
+  int zero;
+  int? zeroOrNull;
+
+  A(this.zero, [this.zeroOrNull]);
+}
+
+void test1(A? a) => a?.zero!;
+void test2(A? a) => a?.zeroOrNull!;
+void test3(A? a) => a?.zero!.isEven;
+void test4(A? a) => a?.zeroOrNull!.isEven;
+
+class Foo {
+  Bar? bar;
+
+  Foo(this.bar);
+
+  Bar? operator [](int? index) => null;
+}
+
+class Bar {
+  int baz;
+
+  Bar(this.baz);
+
+  int operator [](int index) => index;
+}
+
+void test5(Foo? foo) => foo?.bar!;
+void test6(Foo? foo) => foo?.bar!.baz;
+void test7(Foo? foo, int a) => foo?.bar![a];
+void test8(Foo? foo, int? a) => foo?[a]!;
+void test9(Foo? foo, int? a) => foo?[a]!.baz;
+void test10(Foo? foo, int? a, int b) => foo?[a]![b];
+''', [
+      error(StaticWarningCode.UNNECESSARY_NON_NULL_ASSERTION, 107, 1),
+      error(StaticWarningCode.UNNECESSARY_NON_NULL_ASSERTION, 173, 1),
+    ]);
+
+    void assertTestType(int index, String expected) {
+      var function = findNode.functionDeclaration('test$index(');
+      var body = function.functionExpression.body as ExpressionFunctionBody;
+      assertType(body.expression, expected);
+    }
+
+    assertTestType(1, 'int?');
+    assertTestType(2, 'int?');
+    assertTestType(3, 'bool?');
+    assertTestType(4, 'bool?');
+
+    assertTestType(5, 'Bar?');
+    assertTestType(6, 'int?');
+    assertTestType(7, 'int?');
+    assertTestType(8, 'Bar?');
+    assertTestType(9, 'int?');
+    assertTestType(10, 'int?');
+  }
+
+  test_nullCheck_superExpression() async {
+    await assertErrorsInCode(r'''
+class A {
+  int foo() => 0;
+}
+
+class B extends A {
+  void bar() {
+    super!.foo();
+  }
+}
+''', [
+      error(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 70, 6),
+    ]);
+
+    assertTypeDynamic(findNode.super_('super!'));
+
+    assertPostfixExpression(
+      findNode.postfix('super!'),
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: null,
+      type: 'dynamic',
+    );
+
+    assertMethodInvocation2(
+      findNode.methodInvocation('foo();'),
+      element: null,
+      typeArgumentTypes: [],
+      invokeType: 'dynamic',
+      type: 'dynamic',
+    );
+  }
+
+  test_nullCheck_typeParameter() async {
+    await assertNoErrorsInCode(r'''
+void f<T>(T? x) {
+  x!;
+}
+''');
+
+    var postfixExpression = findNode.postfix('x!');
+    assertPostfixExpression(
+      postfixExpression,
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: null,
+      type: 'T & Object',
+    );
+  }
+
+  test_nullCheck_typeParameter_already_promoted() async {
+    await assertNoErrorsInCode('''
+void f<T>(T? x) {
+  if (x is num?) {
+    x!;
+  }
+}
+''');
+
+    var postfixExpression = findNode.postfix('x!');
+    assertPostfixExpression(
+      postfixExpression,
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: null,
+      type: 'T & num',
+    );
+  }
+}
+
+mixin PostfixExpressionResolutionTestCases on PubPackageResolutionTest {
   test_dec_simpleIdentifier_parameter_int() async {
     await assertNoErrorsInCode(r'''
 void f(int x) {
@@ -484,288 +769,6 @@
 }
 
 @reflectiveTest
-class PostfixExpressionResolutionWithNullSafetyTest
-    extends PostfixExpressionResolutionTest with WithNullSafetyMixin {
-  test_inc_propertyAccess_nullShorting() async {
-    await assertNoErrorsInCode(r'''
-class A {
-  int foo = 0;
-}
-
-void f(A? a) {
-  a?.foo++;
-}
-''');
-
-    assertPostfixExpression(
-      findNode.postfix('foo++'),
-      readElement: findElement.getter('foo'),
-      readType: 'int',
-      writeElement: findElement.setter('foo'),
-      writeType: 'int',
-      element: numElement.getMethod('+'),
-      type: 'int?',
-    );
-  }
-
-  test_inc_simpleIdentifier_parameter_depromote() async {
-    await assertNoErrorsInCode(r'''
-class A {
-  Object operator +(int _) => this;
-}
-
-void f(Object x) {
-  if (x is A) {
-    x++;
-    x; // ref
-  }
-}
-''');
-
-    if (hasAssignmentLeftResolution) {
-      assertType(findNode.simple('x++;'), 'A');
-    }
-
-    assertPostfixExpression(
-      findNode.postfix('x++'),
-      readElement: findElement.parameter('x'),
-      readType: 'A',
-      writeElement: findElement.parameter('x'),
-      writeType: 'Object',
-      element: findElement.method('+'),
-      type: 'A',
-    );
-
-    assertType(findNode.simple('x; // ref'), 'Object');
-  }
-
-  test_nullCheck() async {
-    await assertNoErrorsInCode(r'''
-void f(int? x) {
-  x!;
-}
-''');
-
-    assertPostfixExpression(
-      findNode.postfix('x!'),
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: null,
-      type: 'int',
-    );
-  }
-
-  test_nullCheck_functionExpressionInvocation_rewrite() async {
-    await assertNoErrorsInCode(r'''
-void f(Function f2) {
-  f2(42)!;
-}
-''');
-  }
-
-  test_nullCheck_indexExpression() async {
-    await assertNoErrorsInCode(r'''
-void f(Map<String, int> a) {
-  int v = a['foo']!;
-  v;
-}
-''');
-
-    assertIndexExpression(
-      findNode.index('a['),
-      readElement: elementMatcher(
-        mapElement.getMethod('[]'),
-        substitution: {'K': 'String', 'V': 'int'},
-      ),
-      writeElement: null,
-      type: 'int?',
-    );
-
-    assertPostfixExpression(
-      findNode.postfix(']!'),
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: null,
-      type: 'int',
-    );
-  }
-
-  test_nullCheck_null() async {
-    await assertErrorsInCode('''
-void f(Null x) {
-  x!;
-}
-''', [
-      error(HintCode.NULL_CHECK_ALWAYS_FAILS, 19, 2),
-    ]);
-
-    assertType(findNode.postfix('x!'), 'Never');
-  }
-
-  test_nullCheck_nullableContext() async {
-    await assertNoErrorsInCode(r'''
-T f<T>(T t) => t;
-
-int g() => f(null)!;
-''');
-
-    assertMethodInvocation2(
-      findNode.methodInvocation('f(null)'),
-      element: findElement.topFunction('f'),
-      typeArgumentTypes: ['int?'],
-      invokeType: 'int? Function(int?)',
-      type: 'int?',
-    );
-
-    assertPostfixExpression(
-      findNode.postfix('f(null)!'),
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: null,
-      type: 'int',
-    );
-  }
-
-  /// See https://github.com/dart-lang/language/issues/1163
-  test_nullCheck_participatesNullShorting() async {
-    await assertErrorsInCode('''
-class A {
-  int zero;
-  int? zeroOrNull;
-
-  A(this.zero, [this.zeroOrNull]);
-}
-
-void test1(A? a) => a?.zero!;
-void test2(A? a) => a?.zeroOrNull!;
-void test3(A? a) => a?.zero!.isEven;
-void test4(A? a) => a?.zeroOrNull!.isEven;
-
-class Foo {
-  Bar? bar;
-
-  Foo(this.bar);
-
-  Bar? operator [](int? index) => null;
-}
-
-class Bar {
-  int baz;
-
-  Bar(this.baz);
-
-  int operator [](int index) => index;
-}
-
-void test5(Foo? foo) => foo?.bar!;
-void test6(Foo? foo) => foo?.bar!.baz;
-void test7(Foo? foo, int a) => foo?.bar![a];
-void test8(Foo? foo, int? a) => foo?[a]!;
-void test9(Foo? foo, int? a) => foo?[a]!.baz;
-void test10(Foo? foo, int? a, int b) => foo?[a]![b];
-''', [
-      error(StaticWarningCode.UNNECESSARY_NON_NULL_ASSERTION, 107, 1),
-      error(StaticWarningCode.UNNECESSARY_NON_NULL_ASSERTION, 173, 1),
-    ]);
-
-    void assertTestType(int index, String expected) {
-      var function = findNode.functionDeclaration('test$index(');
-      var body = function.functionExpression.body as ExpressionFunctionBody;
-      assertType(body.expression, expected);
-    }
-
-    assertTestType(1, 'int?');
-    assertTestType(2, 'int?');
-    assertTestType(3, 'bool?');
-    assertTestType(4, 'bool?');
-
-    assertTestType(5, 'Bar?');
-    assertTestType(6, 'int?');
-    assertTestType(7, 'int?');
-    assertTestType(8, 'Bar?');
-    assertTestType(9, 'int?');
-    assertTestType(10, 'int?');
-  }
-
-  test_nullCheck_superExpression() async {
-    await assertErrorsInCode(r'''
-class A {
-  int foo() => 0;
-}
-
-class B extends A {
-  void bar() {
-    super!.foo();
-  }
-}
-''', [
-      error(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 70, 6),
-    ]);
-
-    assertTypeDynamic(findNode.super_('super!'));
-
-    assertPostfixExpression(
-      findNode.postfix('super!'),
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: null,
-      type: 'dynamic',
-    );
-
-    assertMethodInvocation2(
-      findNode.methodInvocation('foo();'),
-      element: null,
-      typeArgumentTypes: [],
-      invokeType: 'dynamic',
-      type: 'dynamic',
-    );
-  }
-
-  test_nullCheck_typeParameter() async {
-    await assertNoErrorsInCode(r'''
-void f<T>(T? x) {
-  x!;
-}
-''');
-
-    var postfixExpression = findNode.postfix('x!');
-    assertPostfixExpression(
-      postfixExpression,
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: null,
-      type: 'T & Object',
-    );
-  }
-
-  test_nullCheck_typeParameter_already_promoted() async {
-    await assertNoErrorsInCode('''
-void f<T>(T? x) {
-  if (x is num?) {
-    x!;
-  }
-}
-''');
-
-    var postfixExpression = findNode.postfix('x!');
-    assertPostfixExpression(
-      postfixExpression,
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: null,
-      type: 'T & num',
-    );
-  }
-}
+class PostfixExpressionResolutionWithoutNullSafetyTest
+    extends PubPackageResolutionTest
+    with PostfixExpressionResolutionTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/prefix_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/prefix_expression_test.dart
index 06fd33d..1fa6d56 100644
--- a/pkg/analyzer/test/src/dart/resolution/prefix_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/prefix_expression_test.dart
@@ -12,13 +12,140 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(PrefixExpressionResolutionTest);
-    defineReflectiveTests(PrefixExpressionResolutionWithNullSafetyTest);
+    defineReflectiveTests(PrefixExpressionResolutionWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class PrefixExpressionResolutionTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with PrefixExpressionResolutionTestCases {
+  test_bang_no_nullShorting() async {
+    await assertErrorsInCode(r'''
+class A {
+  bool get foo => true;
+}
+
+void f(A? a) {
+  !a?.foo;
+}
+''', [
+      error(CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE_AS_CONDITION,
+          55, 6),
+    ]);
+
+    assertPrefixExpression(
+      findNode.prefix('!a'),
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: boolElement.getMethod('!'),
+      type: 'bool',
+    );
+  }
+
+  test_minus_no_nullShorting() async {
+    await assertErrorsInCode(r'''
+class A {
+  int get foo => 0;
+}
+
+void f(A? a) {
+  -a?.foo;
+}
+''', [
+      error(CompileTimeErrorCode.UNCHECKED_METHOD_INVOCATION_OF_NULLABLE_VALUE,
+          50, 1),
+    ]);
+
+    assertPrefixExpression(
+      findNode.prefix('-a'),
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: intElement.getMethod('unary-'),
+      type: 'int',
+    );
+  }
+
+  test_plusPlus_depromote() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  Object operator +(int _) => this;
+}
+
+void f(Object x) {
+  if (x is A) {
+    ++x;
+  }
+}
+''');
+
+    assertPrefixExpression(
+      findNode.prefix('++x'),
+      readElement: findElement.parameter('x'),
+      readType: 'A',
+      writeElement: findElement.parameter('x'),
+      writeType: 'Object',
+      element: findElement.method('+'),
+      type: 'Object',
+    );
+
+    if (hasAssignmentLeftResolution) {
+      assertType(findNode.simple('x;'), 'A');
+    }
+  }
+
+  test_plusPlus_nullShorting() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  int foo = 0;
+}
+
+void f(A? a) {
+  ++a?.foo;
+}
+''');
+
+    assertPrefixExpression(
+      findNode.prefix('++a'),
+      readElement: findElement.getter('foo'),
+      readType: 'int',
+      writeElement: findElement.setter('foo'),
+      writeType: 'int',
+      element: numElement.getMethod('+'),
+      type: 'int?',
+    );
+  }
+
+  test_tilde_no_nullShorting() async {
+    await assertErrorsInCode(r'''
+class A {
+  int get foo => 0;
+}
+
+void f(A? a) {
+  ~a?.foo;
+}
+''', [
+      error(CompileTimeErrorCode.UNCHECKED_METHOD_INVOCATION_OF_NULLABLE_VALUE,
+          50, 1),
+    ]);
+
+    assertPrefixExpression(
+      findNode.prefix('~a'),
+      readElement: null,
+      readType: null,
+      writeElement: null,
+      writeType: null,
+      element: intElement.getMethod('~'),
+      type: 'int',
+    );
+  }
+}
+
+mixin PrefixExpressionResolutionTestCases on PubPackageResolutionTest {
   test_bang_bool_context() async {
     await assertNoErrorsInCode(r'''
 T f<T>() {
@@ -637,130 +764,6 @@
 }
 
 @reflectiveTest
-class PrefixExpressionResolutionWithNullSafetyTest
-    extends PrefixExpressionResolutionTest with WithNullSafetyMixin {
-  test_bang_no_nullShorting() async {
-    await assertErrorsInCode(r'''
-class A {
-  bool get foo => true;
-}
-
-void f(A? a) {
-  !a?.foo;
-}
-''', [
-      error(CompileTimeErrorCode.UNCHECKED_USE_OF_NULLABLE_VALUE_AS_CONDITION,
-          55, 6),
-    ]);
-
-    assertPrefixExpression(
-      findNode.prefix('!a'),
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: boolElement.getMethod('!'),
-      type: 'bool',
-    );
-  }
-
-  test_minus_no_nullShorting() async {
-    await assertErrorsInCode(r'''
-class A {
-  int get foo => 0;
-}
-
-void f(A? a) {
-  -a?.foo;
-}
-''', [
-      error(CompileTimeErrorCode.UNCHECKED_METHOD_INVOCATION_OF_NULLABLE_VALUE,
-          50, 1),
-    ]);
-
-    assertPrefixExpression(
-      findNode.prefix('-a'),
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: intElement.getMethod('unary-'),
-      type: 'int',
-    );
-  }
-
-  test_plusPlus_depromote() async {
-    await assertNoErrorsInCode(r'''
-class A {
-  Object operator +(int _) => this;
-}
-
-void f(Object x) {
-  if (x is A) {
-    ++x;
-  }
-}
-''');
-
-    assertPrefixExpression(
-      findNode.prefix('++x'),
-      readElement: findElement.parameter('x'),
-      readType: 'A',
-      writeElement: findElement.parameter('x'),
-      writeType: 'Object',
-      element: findElement.method('+'),
-      type: 'Object',
-    );
-
-    if (hasAssignmentLeftResolution) {
-      assertType(findNode.simple('x;'), 'A');
-    }
-  }
-
-  test_plusPlus_nullShorting() async {
-    await assertNoErrorsInCode(r'''
-class A {
-  int foo = 0;
-}
-
-void f(A? a) {
-  ++a?.foo;
-}
-''');
-
-    assertPrefixExpression(
-      findNode.prefix('++a'),
-      readElement: findElement.getter('foo'),
-      readType: 'int',
-      writeElement: findElement.setter('foo'),
-      writeType: 'int',
-      element: numElement.getMethod('+'),
-      type: 'int?',
-    );
-  }
-
-  test_tilde_no_nullShorting() async {
-    await assertErrorsInCode(r'''
-class A {
-  int get foo => 0;
-}
-
-void f(A? a) {
-  ~a?.foo;
-}
-''', [
-      error(CompileTimeErrorCode.UNCHECKED_METHOD_INVOCATION_OF_NULLABLE_VALUE,
-          50, 1),
-    ]);
-
-    assertPrefixExpression(
-      findNode.prefix('~a'),
-      readElement: null,
-      readType: null,
-      writeElement: null,
-      writeType: null,
-      element: intElement.getMethod('~'),
-      type: 'int',
-    );
-  }
-}
+class PrefixExpressionResolutionWithoutNullSafetyTest
+    extends PubPackageResolutionTest
+    with PrefixExpressionResolutionTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/property_access_test.dart b/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
index b95d627..e3ef89b 100644
--- a/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/property_access_test.dart
@@ -11,13 +11,168 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(PropertyAccessResolutionTest);
-    defineReflectiveTests(PropertyAccessResolutionWithNullSafetyTest);
+    defineReflectiveTests(PropertyAccessResolutionWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class PropertyAccessResolutionTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with PropertyAccessResolutionTestCases {
+  test_implicitCall_tearOff_nullable() async {
+    await assertErrorsInCode('''
+class A {
+  int call() => 0;
+}
+
+class B {
+  A? a;
+}
+
+int Function() foo() {
+  return B().a; // ref
+}
+''', [
+      error(CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION, 85, 5),
+    ]);
+
+    var identifier = findNode.simple('a; // ref');
+    assertElement(identifier, findElement.getter('a'));
+    assertType(identifier, 'A?');
+  }
+
+  test_nullShorting_cascade() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  int get foo => 0;
+  int get bar => 0;
+}
+
+void f(A? a) {
+  a?..foo..bar;
+}
+''');
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('..foo'),
+      element: findElement.getter('foo'),
+      type: 'int',
+    );
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('..bar'),
+      element: findElement.getter('bar'),
+      type: 'int',
+    );
+
+    assertType(findNode.cascade('a?'), 'A?');
+  }
+
+  test_nullShorting_cascade2() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  int? get foo => 0;
+}
+
+main() {
+  A a = A()..foo?.isEven;
+  a;
+}
+''');
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('..foo?'),
+      element: findElement.getter('foo'),
+      type: 'int?',
+    );
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('.isEven'),
+      element: intElement.getGetter('isEven'),
+      type: 'bool',
+    );
+
+    assertType(findNode.cascade('A()'), 'A');
+  }
+
+  test_nullShorting_cascade3() async {
+    await assertNoErrorsInCode(r'''
+class A {
+  A? get foo => this;
+  A? get bar => this;
+  A? get baz => this;
+}
+
+main() {
+  A a = A()..foo?.bar?.baz;
+  a;
+}
+''');
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('.foo'),
+      element: findElement.getter('foo'),
+      type: 'A?',
+    );
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('.bar'),
+      element: findElement.getter('bar'),
+      type: 'A?',
+    );
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('.baz'),
+      element: findElement.getter('baz'),
+      type: 'A?',
+    );
+
+    assertType(findNode.cascade('A()'), 'A');
+  }
+
+  test_nullShorting_cascade4() async {
+    await assertNoErrorsInCode(r'''
+A? get foo => A();
+
+class A {
+  A get bar => this;
+  A? get baz => this;
+  A get baq => this;
+}
+
+main() {
+  foo?.bar?..baz?.baq;
+}
+''');
+
+    assertSimpleIdentifier(
+      findNode.simple('foo?'),
+      element: findElement.topGet('foo'),
+      type: 'A?',
+    );
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('.bar'),
+      element: findElement.getter('bar'),
+      type: 'A?',
+    );
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('.baz'),
+      element: findElement.getter('baz'),
+      type: 'A?',
+    );
+
+    assertPropertyAccess2(
+      findNode.propertyAccess('.baq'),
+      element: findElement.getter('baq'),
+      type: 'A',
+    );
+
+    assertType(findNode.cascade('foo?'), 'A?');
+  }
+}
+
+mixin PropertyAccessResolutionTestCases on PubPackageResolutionTest {
   test_extensionOverride_read() async {
     await assertNoErrorsInCode('''
 class A {}
@@ -561,158 +716,6 @@
 }
 
 @reflectiveTest
-class PropertyAccessResolutionWithNullSafetyTest
-    extends PropertyAccessResolutionTest with WithNullSafetyMixin {
-  test_implicitCall_tearOff_nullable() async {
-    await assertErrorsInCode('''
-class A {
-  int call() => 0;
-}
-
-class B {
-  A? a;
-}
-
-int Function() foo() {
-  return B().a; // ref
-}
-''', [
-      error(CompileTimeErrorCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION, 85, 5),
-    ]);
-
-    var identifier = findNode.simple('a; // ref');
-    assertElement(identifier, findElement.getter('a'));
-    assertType(identifier, 'A?');
-  }
-
-  test_nullShorting_cascade() async {
-    await assertNoErrorsInCode(r'''
-class A {
-  int get foo => 0;
-  int get bar => 0;
-}
-
-void f(A? a) {
-  a?..foo..bar;
-}
-''');
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('..foo'),
-      element: findElement.getter('foo'),
-      type: 'int',
-    );
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('..bar'),
-      element: findElement.getter('bar'),
-      type: 'int',
-    );
-
-    assertType(findNode.cascade('a?'), 'A?');
-  }
-
-  test_nullShorting_cascade2() async {
-    await assertNoErrorsInCode(r'''
-class A {
-  int? get foo => 0;
-}
-
-main() {
-  A a = A()..foo?.isEven;
-  a;
-}
-''');
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('..foo?'),
-      element: findElement.getter('foo'),
-      type: 'int?',
-    );
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('.isEven'),
-      element: intElement.getGetter('isEven'),
-      type: 'bool',
-    );
-
-    assertType(findNode.cascade('A()'), 'A');
-  }
-
-  test_nullShorting_cascade3() async {
-    await assertNoErrorsInCode(r'''
-class A {
-  A? get foo => this;
-  A? get bar => this;
-  A? get baz => this;
-}
-
-main() {
-  A a = A()..foo?.bar?.baz;
-  a;
-}
-''');
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('.foo'),
-      element: findElement.getter('foo'),
-      type: 'A?',
-    );
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('.bar'),
-      element: findElement.getter('bar'),
-      type: 'A?',
-    );
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('.baz'),
-      element: findElement.getter('baz'),
-      type: 'A?',
-    );
-
-    assertType(findNode.cascade('A()'), 'A');
-  }
-
-  test_nullShorting_cascade4() async {
-    await assertNoErrorsInCode(r'''
-A? get foo => A();
-
-class A {
-  A get bar => this;
-  A? get baz => this;
-  A get baq => this;
-}
-
-main() {
-  foo?.bar?..baz?.baq;
-}
-''');
-
-    assertSimpleIdentifier(
-      findNode.simple('foo?'),
-      element: findElement.topGet('foo'),
-      type: 'A?',
-    );
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('.bar'),
-      element: findElement.getter('bar'),
-      type: 'A?',
-    );
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('.baz'),
-      element: findElement.getter('baz'),
-      type: 'A?',
-    );
-
-    assertPropertyAccess2(
-      findNode.propertyAccess('.baq'),
-      element: findElement.getter('baq'),
-      type: 'A',
-    );
-
-    assertType(findNode.cascade('foo?'), 'A?');
-  }
-}
+class PropertyAccessResolutionWithoutNullSafetyTest
+    extends PubPackageResolutionTest
+    with PropertyAccessResolutionTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/top_level_variable_test.dart b/pkg/analyzer/test/src/dart/resolution/top_level_variable_test.dart
index 1349f39..444c894 100644
--- a/pkg/analyzer/test/src/dart/resolution/top_level_variable_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/top_level_variable_test.dart
@@ -11,13 +11,32 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(TopLevelVariableTest);
-    defineReflectiveTests(TopLevelVariableWithNullSafetyTest);
+    defineReflectiveTests(TopLevelVariableWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class TopLevelVariableTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with TopLevelVariableTestCases {
+  test_type_inferred_nonNullify() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+// @dart = 2.7
+var a = 0;
+''');
+
+    await assertErrorsInCode('''
+import 'a.dart';
+
+var v = a;
+''', [
+      error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
+    ]);
+
+    assertType(findElement.topVar('v').type, 'int');
+  }
+}
+
+mixin TopLevelVariableTestCases on PubPackageResolutionTest {
   test_session_getterSetter() async {
     await resolveTestCode('''
 var v = 0;
@@ -65,22 +84,5 @@
 }
 
 @reflectiveTest
-class TopLevelVariableWithNullSafetyTest extends TopLevelVariableTest
-    with WithNullSafetyMixin {
-  test_type_inferred_nonNullify() async {
-    newFile('$testPackageLibPath/a.dart', content: r'''
-// @dart = 2.7
-var a = 0;
-''');
-
-    await assertErrorsInCode('''
-import 'a.dart';
-
-var v = a;
-''', [
-      error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
-    ]);
-
-    assertType(findElement.topVar('v').type, 'int');
-  }
-}
+class TopLevelVariableWithoutNullSafetyTest extends PubPackageResolutionTest
+    with TopLevelVariableTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/type_inference/conditional_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/type_inference/conditional_expression_test.dart
index 71d74e19..a1531fb 100644
--- a/pkg/analyzer/test/src/dart/resolution/type_inference/conditional_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/type_inference/conditional_expression_test.dart
@@ -9,27 +9,13 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ConditionalExpressionTest);
-    defineReflectiveTests(ConditionalExpressionWithNullSafetyTest);
+    defineReflectiveTests(ConditionalExpressionWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class ConditionalExpressionTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
-  test_upward() async {
-    await resolveTestCode('''
-void f(bool a, int b, int c) {
-  var d = a ? b : c;
-  print(d);
-}
-''');
-    assertType(findNode.simple('d)'), 'int');
-  }
-}
-
-@reflectiveTest
-class ConditionalExpressionWithNullSafetyTest extends ConditionalExpressionTest
-    with WithNullSafetyMixin {
+    with ConditionalExpressionTestCases {
   @failingTest
   test_downward() async {
     await resolveTestCode('''
@@ -51,3 +37,20 @@
     assertType(findNode.conditionalExpression('b ?'), 'int?');
   }
 }
+
+mixin ConditionalExpressionTestCases on PubPackageResolutionTest {
+  test_upward() async {
+    await resolveTestCode('''
+void f(bool a, int b, int c) {
+  var d = a ? b : c;
+  print(d);
+}
+''');
+    assertType(findNode.simple('d)'), 'int');
+  }
+}
+
+@reflectiveTest
+class ConditionalExpressionWithoutNullSafetyTest
+    extends PubPackageResolutionTest
+    with ConditionalExpressionTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/type_inference/function_expression_test.dart b/pkg/analyzer/test/src/dart/resolution/type_inference/function_expression_test.dart
index bcde92b..11676d2 100644
--- a/pkg/analyzer/test/src/dart/resolution/type_inference/function_expression_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/type_inference/function_expression_test.dart
@@ -10,13 +10,129 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(FunctionExpressionTest);
-    defineReflectiveTests(FunctionExpressionWithNullSafetyTest);
+    defineReflectiveTests(FunctionExpressionWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class FunctionExpressionTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with FunctionExpressionTestCases {
+  test_contextFunctionType_nonNullify() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+// @dart = 2.7
+
+int Function(int a) v;
+''');
+
+    await assertErrorsInCode('''
+import 'a.dart';
+
+T foo<T>() => throw 0;
+
+void f() {
+  v = (a) {
+    return foo();
+  };
+}
+''', [
+      error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
+    ]);
+    assertType(findElement.parameter('a').type, 'int');
+    _assertReturnType('(a) {', 'int');
+  }
+
+  test_contextFunctionType_nonNullify_returnType_takeActual() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+// @dart = 2.7
+
+void foo(int Function() x) {}
+''');
+    await assertErrorsInCode('''
+import 'a.dart';
+
+void test(int? a) {
+  foo(() => a);
+}
+''', [
+      error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
+    ]);
+    _assertReturnType('() => a', 'int?');
+  }
+
+  test_contextFunctionType_nonNullify_returnType_takeContext() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+// @dart = 2.7
+
+void foo(int Function() x) {}
+''');
+    await assertErrorsInCode('''
+import 'a.dart';
+
+void test(dynamic a) {
+  foo(() => a);
+}
+''', [
+      error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
+    ]);
+    _assertReturnType('() => a', 'int');
+  }
+
+  test_contextFunctionType_returnType_async_blockBody_objectQ() async {
+    await assertNoErrorsInCode('''
+T foo<T>() => throw 0;
+
+Object? Function() v = () async {
+  return foo();
+};
+''');
+    assertTypeArgumentTypes(
+      findNode.methodInvocation('foo();'),
+      ['FutureOr<Object?>'],
+    );
+    _assertReturnType('() async', 'Future<Object?>');
+  }
+
+  test_contextFunctionType_returnType_async_blockBody_objectQ2() async {
+    await assertNoErrorsInCode('''
+T foo<T>() => throw 0;
+
+Object? Function() v = () async {
+  return;
+};
+''');
+    _assertReturnType('() async', 'Future<Null>');
+  }
+
+  test_contextFunctionType_returnType_async_expressionBody_objectQ() async {
+    await assertNoErrorsInCode('''
+T foo<T>() => throw 0;
+
+Object? Function() v = () async => foo();
+''');
+    assertTypeArgumentTypes(
+      findNode.methodInvocation('foo();'),
+      ['FutureOr<Object?>'],
+    );
+    _assertReturnType('() async => foo', 'Future<Object?>');
+  }
+
+  test_optOut_downward_returnType_expressionBody_Null() async {
+    newFile('$testPackageLibPath/a.dart', content: r'''
+void foo(Map<String, String> Function() f) {}
+''');
+    await resolveTestCode('''
+// @dart = 2.5
+import 'a.dart';
+
+void main() {
+  foo(() => null);
+}
+''');
+    _assertReturnType('() =>', 'Null*');
+  }
+}
+
+mixin FunctionExpressionTestCases on PubPackageResolutionTest {
   test_contextFunctionType_returnType_async_blockBody_futureOrVoid() async {
     var expectedErrors = expectedErrorsByNullability(
       nullable: [
@@ -460,119 +576,5 @@
 }
 
 @reflectiveTest
-class FunctionExpressionWithNullSafetyTest extends FunctionExpressionTest
-    with WithNullSafetyMixin {
-  test_contextFunctionType_nonNullify() async {
-    newFile('$testPackageLibPath/a.dart', content: r'''
-// @dart = 2.7
-
-int Function(int a) v;
-''');
-
-    await assertErrorsInCode('''
-import 'a.dart';
-
-T foo<T>() => throw 0;
-
-void f() {
-  v = (a) {
-    return foo();
-  };
-}
-''', [
-      error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
-    ]);
-    assertType(findElement.parameter('a').type, 'int');
-    _assertReturnType('(a) {', 'int');
-  }
-
-  test_contextFunctionType_nonNullify_returnType_takeActual() async {
-    newFile('$testPackageLibPath/a.dart', content: r'''
-// @dart = 2.7
-
-void foo(int Function() x) {}
-''');
-    await assertErrorsInCode('''
-import 'a.dart';
-
-void test(int? a) {
-  foo(() => a);
-}
-''', [
-      error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
-    ]);
-    _assertReturnType('() => a', 'int?');
-  }
-
-  test_contextFunctionType_nonNullify_returnType_takeContext() async {
-    newFile('$testPackageLibPath/a.dart', content: r'''
-// @dart = 2.7
-
-void foo(int Function() x) {}
-''');
-    await assertErrorsInCode('''
-import 'a.dart';
-
-void test(dynamic a) {
-  foo(() => a);
-}
-''', [
-      error(HintCode.IMPORT_OF_LEGACY_LIBRARY_INTO_NULL_SAFE, 7, 8),
-    ]);
-    _assertReturnType('() => a', 'int');
-  }
-
-  test_contextFunctionType_returnType_async_blockBody_objectQ() async {
-    await assertNoErrorsInCode('''
-T foo<T>() => throw 0;
-
-Object? Function() v = () async {
-  return foo();
-};
-''');
-    assertTypeArgumentTypes(
-      findNode.methodInvocation('foo();'),
-      ['FutureOr<Object?>'],
-    );
-    _assertReturnType('() async', 'Future<Object?>');
-  }
-
-  test_contextFunctionType_returnType_async_blockBody_objectQ2() async {
-    await assertNoErrorsInCode('''
-T foo<T>() => throw 0;
-
-Object? Function() v = () async {
-  return;
-};
-''');
-    _assertReturnType('() async', 'Future<Null>');
-  }
-
-  test_contextFunctionType_returnType_async_expressionBody_objectQ() async {
-    await assertNoErrorsInCode('''
-T foo<T>() => throw 0;
-
-Object? Function() v = () async => foo();
-''');
-    assertTypeArgumentTypes(
-      findNode.methodInvocation('foo();'),
-      ['FutureOr<Object?>'],
-    );
-    _assertReturnType('() async => foo', 'Future<Object?>');
-  }
-
-  test_optOut_downward_returnType_expressionBody_Null() async {
-    newFile('$testPackageLibPath/a.dart', content: r'''
-void foo(Map<String, String> Function() f) {}
-''');
-    await resolveTestCode('''
-// @dart = 2.5
-import 'a.dart';
-
-void main() {
-  foo(() => null);
-}
-''');
-    _assertReturnType('() =>', 'Null*');
-  }
-}
+class FunctionExpressionWithoutNullSafetyTest extends PubPackageResolutionTest
+    with FunctionExpressionTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/type_inference/list_literal_test.dart b/pkg/analyzer/test/src/dart/resolution/type_inference/list_literal_test.dart
index 80aeb15..39f7df5 100644
--- a/pkg/analyzer/test/src/dart/resolution/type_inference/list_literal_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/type_inference/list_literal_test.dart
@@ -10,13 +10,98 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ListLiteralTest);
-    defineReflectiveTests(ListLiteralWithNullSafetyTest);
+    defineReflectiveTests(ListLiteralWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class ListLiteralTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with ListLiteralTestCases {
+  test_context_spread_nullAware() async {
+    await assertNoErrorsInCode('''
+T f<T>(T t) => t;
+
+main() {
+  <int>[...?f(null)];
+}
+''');
+
+    assertMethodInvocation2(
+      findNode.methodInvocation('f(null)'),
+      element: findElement.topFunction('f'),
+      typeArgumentTypes: ['Iterable<int>?'],
+      invokeType: 'Iterable<int>? Function(Iterable<int>?)',
+      type: 'Iterable<int>?',
+    );
+  }
+
+  test_nested_hasNull_1() async {
+    await assertNoErrorsInCode('''
+main() {
+  [[0], null];
+}
+''');
+    assertType(findNode.listLiteral('[0'), 'List<int>');
+    assertType(findNode.listLiteral('[[0'), 'List<List<int>?>');
+  }
+
+  test_nested_hasNull_2() async {
+    await assertNoErrorsInCode('''
+main() {
+  [[0], [1, null]];
+}
+''');
+    assertType(findNode.listLiteral('[0'), 'List<int>');
+    assertType(findNode.listLiteral('[1,'), 'List<int?>');
+    assertType(findNode.listLiteral('[[0'), 'List<List<int?>>');
+  }
+
+  test_noContext_noTypeArgs_spread_never() async {
+    await assertNoErrorsInCode('''
+void f(Never a) async {
+  // ignore:unused_local_variable
+  var v = [...a];
+}
+''');
+    assertType(findNode.listLiteral('['), 'List<Never>');
+  }
+
+  test_noContext_noTypeArgs_spread_nullAware_never() async {
+    await assertErrorsInCode('''
+void f(Never a) async {
+  // ignore:unused_local_variable
+  var v = [...?a];
+}
+''', [
+      error(StaticWarningCode.INVALID_NULL_AWARE_OPERATOR, 69, 4),
+    ]);
+    assertType(findNode.listLiteral('['), 'List<Never>');
+  }
+
+  test_noContext_noTypeArgs_spread_nullAware_typeParameter_implementsNever() async {
+    await assertErrorsInCode('''
+void f<T extends Never>(T a) async {
+  // ignore:unused_local_variable
+  var v = [...?a];
+}
+''', [
+      error(StaticWarningCode.INVALID_NULL_AWARE_OPERATOR, 82, 4),
+    ]);
+    assertType(findNode.listLiteral('['), 'List<Never>');
+  }
+
+  test_noContext_noTypeArgs_spread_typeParameter_implementsNever() async {
+    await assertNoErrorsInCode('''
+void f<T extends Never>(T a) async {
+  // ignore:unused_local_variable
+  var v = [...a];
+}
+''');
+    assertType(findNode.listLiteral('['), 'List<Never>');
+  }
+}
+
+mixin ListLiteralTestCases on PubPackageResolutionTest {
   test_context_noTypeArgs_expression_conflict() async {
     await assertErrorsInCode('''
 List<int> a = ['a'];
@@ -415,88 +500,5 @@
 }
 
 @reflectiveTest
-class ListLiteralWithNullSafetyTest extends ListLiteralTest
-    with WithNullSafetyMixin {
-  test_context_spread_nullAware() async {
-    await assertNoErrorsInCode('''
-T f<T>(T t) => t;
-
-main() {
-  <int>[...?f(null)];
-}
-''');
-
-    assertMethodInvocation2(
-      findNode.methodInvocation('f(null)'),
-      element: findElement.topFunction('f'),
-      typeArgumentTypes: ['Iterable<int>?'],
-      invokeType: 'Iterable<int>? Function(Iterable<int>?)',
-      type: 'Iterable<int>?',
-    );
-  }
-
-  test_nested_hasNull_1() async {
-    await assertNoErrorsInCode('''
-main() {
-  [[0], null];
-}
-''');
-    assertType(findNode.listLiteral('[0'), 'List<int>');
-    assertType(findNode.listLiteral('[[0'), 'List<List<int>?>');
-  }
-
-  test_nested_hasNull_2() async {
-    await assertNoErrorsInCode('''
-main() {
-  [[0], [1, null]];
-}
-''');
-    assertType(findNode.listLiteral('[0'), 'List<int>');
-    assertType(findNode.listLiteral('[1,'), 'List<int?>');
-    assertType(findNode.listLiteral('[[0'), 'List<List<int?>>');
-  }
-
-  test_noContext_noTypeArgs_spread_never() async {
-    await assertNoErrorsInCode('''
-void f(Never a) async {
-  // ignore:unused_local_variable
-  var v = [...a];
-}
-''');
-    assertType(findNode.listLiteral('['), 'List<Never>');
-  }
-
-  test_noContext_noTypeArgs_spread_nullAware_never() async {
-    await assertErrorsInCode('''
-void f(Never a) async {
-  // ignore:unused_local_variable
-  var v = [...?a];
-}
-''', [
-      error(StaticWarningCode.INVALID_NULL_AWARE_OPERATOR, 69, 4),
-    ]);
-    assertType(findNode.listLiteral('['), 'List<Never>');
-  }
-
-  test_noContext_noTypeArgs_spread_nullAware_typeParameter_implementsNever() async {
-    await assertErrorsInCode('''
-void f<T extends Never>(T a) async {
-  // ignore:unused_local_variable
-  var v = [...?a];
-}
-''', [
-      error(StaticWarningCode.INVALID_NULL_AWARE_OPERATOR, 82, 4),
-    ]);
-    assertType(findNode.listLiteral('['), 'List<Never>');
-  }
-
-  test_noContext_noTypeArgs_spread_typeParameter_implementsNever() async {
-    await assertNoErrorsInCode('''
-void f<T extends Never>(T a) async {
-  // ignore:unused_local_variable
-  var v = [...a];
-}
-''');
-    assertType(findNode.listLiteral('['), 'List<Never>');
-  }
-}
+class ListLiteralWithoutNullSafetyTest extends PubPackageResolutionTest
+    with ListLiteralTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/dart/resolution/type_inference/map_literal_test.dart b/pkg/analyzer/test/src/dart/resolution/type_inference/map_literal_test.dart
index e4af4f6..894f8a9 100644
--- a/pkg/analyzer/test/src/dart/resolution/type_inference/map_literal_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/type_inference/map_literal_test.dart
@@ -11,13 +11,121 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(MapLiteralTest);
-    defineReflectiveTests(MapLiteralWithNullSafetyTest);
+    defineReflectiveTests(MapLiteralWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
-class MapLiteralTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+class MapLiteralTest extends PubPackageResolutionTest with MapLiteralTestCases {
+  test_context_noTypeArgs_noEntries_typeParameterNullable() async {
+    await assertNoErrorsInCode('''
+class C<T extends Object?> {
+  Map<String, T> a = {}; // 1
+  Map<String, T>? b = {}; // 2
+  Map<String, T?> c = {}; // 3
+  Map<String, T?>? d = {}; // 4
+}
+''');
+    assertType(setOrMapLiteral('{}; // 1'), 'Map<String, T>');
+    assertType(setOrMapLiteral('{}; // 2'), 'Map<String, T>');
+    assertType(setOrMapLiteral('{}; // 3'), 'Map<String, T?>');
+    assertType(setOrMapLiteral('{}; // 4'), 'Map<String, T?>');
+  }
+
+  test_context_spread_nullAware() async {
+    await assertNoErrorsInCode('''
+T f<T>(T t) => t;
+
+main() {
+  <int, double>{...?f(null)};
+}
+''');
+
+    assertMethodInvocation2(
+      findNode.methodInvocation('f(null)'),
+      element: findElement.topFunction('f'),
+      typeArgumentTypes: ['Map<int, double>?'],
+      invokeType: 'Map<int, double>? Function(Map<int, double>?)',
+      type: 'Map<int, double>?',
+    );
+  }
+
+  test_noContext_noTypeArgs_spread_never() async {
+    await assertErrorsInCode('''
+void f(Never a, bool b) async {
+  // ignore:unused_local_variable
+  var v = {...a, if (b) throw 0: throw 0};
+}
+''', [
+      error(HintCode.DEAD_CODE, 87, 21),
+    ]);
+    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
+  }
+
+  test_noContext_noTypeArgs_spread_nullAware_never() async {
+    await assertErrorsInCode('''
+void f(Never a, bool b) async {
+  // ignore:unused_local_variable
+  var v = {...?a, if (b) throw 0: throw 0};
+}
+''', [
+      error(StaticWarningCode.INVALID_NULL_AWARE_OPERATOR, 77, 4),
+      error(HintCode.DEAD_CODE, 88, 21),
+    ]);
+    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
+  }
+
+  test_noContext_noTypeArgs_spread_nullAware_null() async {
+    await assertErrorsInCode('''
+void f(Null a, bool b) async {
+  // ignore:unused_local_variable
+  var v = {...?a, if (b) throw 0: throw 0};
+}
+''', [
+      error(HintCode.DEAD_CODE, 99, 9),
+    ]);
+    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
+  }
+
+  test_noContext_noTypeArgs_spread_nullAware_typeParameter_never() async {
+    await assertErrorsInCode('''
+void f<T extends Never>(T a, bool b) async {
+  // ignore:unused_local_variable
+  var v = {...?a, if (b) throw 0: throw 0};
+}
+''', [
+      error(StaticWarningCode.INVALID_NULL_AWARE_OPERATOR, 90, 4),
+      error(HintCode.DEAD_CODE, 101, 21),
+    ]);
+    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
+  }
+
+  test_noContext_noTypeArgs_spread_nullAware_typeParameter_null() async {
+    await assertErrorsInCode('''
+void f<T extends Null>(T a, bool b) async {
+  // ignore:unused_local_variable
+  var v = {...?a, if (b) throw 0: throw 0};
+}
+''', [
+      error(HintCode.DEAD_CODE, 112, 9),
+    ]);
+    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
+  }
+
+  test_noContext_noTypeArgs_spread_typeParameter_never() async {
+    await assertErrorsInCode('''
+void f<T extends Never>(T a, bool b) async {
+  // ignore:unused_local_variable
+  var v = {...a, if (b) throw 0: throw 0};
+}
+''', [
+      error(HintCode.DEAD_CODE, 100, 21),
+    ]);
+    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
+  }
+}
+
+mixin MapLiteralTestCases on PubPackageResolutionTest {
   AstNode setOrMapLiteral(String search) => findNode.setOrMapLiteral(search);
 
   test_context_noTypeArgs_entry_conflictingKey() async {
@@ -439,112 +547,5 @@
 }
 
 @reflectiveTest
-class MapLiteralWithNullSafetyTest extends MapLiteralTest
-    with WithNullSafetyMixin {
-  test_context_noTypeArgs_noEntries_typeParameterNullable() async {
-    await assertNoErrorsInCode('''
-class C<T extends Object?> {
-  Map<String, T> a = {}; // 1
-  Map<String, T>? b = {}; // 2
-  Map<String, T?> c = {}; // 3
-  Map<String, T?>? d = {}; // 4
-}
-''');
-    assertType(setOrMapLiteral('{}; // 1'), 'Map<String, T>');
-    assertType(setOrMapLiteral('{}; // 2'), 'Map<String, T>');
-    assertType(setOrMapLiteral('{}; // 3'), 'Map<String, T?>');
-    assertType(setOrMapLiteral('{}; // 4'), 'Map<String, T?>');
-  }
-
-  test_context_spread_nullAware() async {
-    await assertNoErrorsInCode('''
-T f<T>(T t) => t;
-
-main() {
-  <int, double>{...?f(null)};
-}
-''');
-
-    assertMethodInvocation2(
-      findNode.methodInvocation('f(null)'),
-      element: findElement.topFunction('f'),
-      typeArgumentTypes: ['Map<int, double>?'],
-      invokeType: 'Map<int, double>? Function(Map<int, double>?)',
-      type: 'Map<int, double>?',
-    );
-  }
-
-  test_noContext_noTypeArgs_spread_never() async {
-    await assertErrorsInCode('''
-void f(Never a, bool b) async {
-  // ignore:unused_local_variable
-  var v = {...a, if (b) throw 0: throw 0};
-}
-''', [
-      error(HintCode.DEAD_CODE, 87, 21),
-    ]);
-    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
-  }
-
-  test_noContext_noTypeArgs_spread_nullAware_never() async {
-    await assertErrorsInCode('''
-void f(Never a, bool b) async {
-  // ignore:unused_local_variable
-  var v = {...?a, if (b) throw 0: throw 0};
-}
-''', [
-      error(StaticWarningCode.INVALID_NULL_AWARE_OPERATOR, 77, 4),
-      error(HintCode.DEAD_CODE, 88, 21),
-    ]);
-    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
-  }
-
-  test_noContext_noTypeArgs_spread_nullAware_null() async {
-    await assertErrorsInCode('''
-void f(Null a, bool b) async {
-  // ignore:unused_local_variable
-  var v = {...?a, if (b) throw 0: throw 0};
-}
-''', [
-      error(HintCode.DEAD_CODE, 99, 9),
-    ]);
-    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
-  }
-
-  test_noContext_noTypeArgs_spread_nullAware_typeParameter_never() async {
-    await assertErrorsInCode('''
-void f<T extends Never>(T a, bool b) async {
-  // ignore:unused_local_variable
-  var v = {...?a, if (b) throw 0: throw 0};
-}
-''', [
-      error(StaticWarningCode.INVALID_NULL_AWARE_OPERATOR, 90, 4),
-      error(HintCode.DEAD_CODE, 101, 21),
-    ]);
-    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
-  }
-
-  test_noContext_noTypeArgs_spread_nullAware_typeParameter_null() async {
-    await assertErrorsInCode('''
-void f<T extends Null>(T a, bool b) async {
-  // ignore:unused_local_variable
-  var v = {...?a, if (b) throw 0: throw 0};
-}
-''', [
-      error(HintCode.DEAD_CODE, 112, 9),
-    ]);
-    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
-  }
-
-  test_noContext_noTypeArgs_spread_typeParameter_never() async {
-    await assertErrorsInCode('''
-void f<T extends Never>(T a, bool b) async {
-  // ignore:unused_local_variable
-  var v = {...a, if (b) throw 0: throw 0};
-}
-''', [
-      error(HintCode.DEAD_CODE, 100, 21),
-    ]);
-    assertType(setOrMapLiteral('{...'), 'Map<Never, Never>');
-  }
-}
+class MapLiteralWithoutNullSafetyTest extends PubPackageResolutionTest
+    with MapLiteralTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/diagnostics/abstract_class_member_test.dart b/pkg/analyzer/test/src/diagnostics/abstract_class_member_test.dart
index cba3c60..7879c8c 100644
--- a/pkg/analyzer/test/src/diagnostics/abstract_class_member_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/abstract_class_member_test.dart
@@ -10,13 +10,15 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AbstractClassMemberTest);
-    defineReflectiveTests(AbstractClassMemberWithNullSafetyTest);
+    defineReflectiveTests(AbstractClassMemberWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class AbstractClassMemberTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+    with AbstractClassMemberTestCases {}
+
+mixin AbstractClassMemberTestCases on PubPackageResolutionTest {
   test_abstract_field_dynamic() async {
     await assertErrorsInCode(
         '''
@@ -55,5 +57,5 @@
 }
 
 @reflectiveTest
-class AbstractClassMemberWithNullSafetyTest extends AbstractClassMemberTest
-    with WithNullSafetyMixin {}
+class AbstractClassMemberWithoutNullSafetyTest extends PubPackageResolutionTest
+    with AbstractClassMemberTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/diagnostics/assignment_to_final_test.dart b/pkg/analyzer/test/src/diagnostics/assignment_to_final_test.dart
index d45f72d..1ef0c33 100644
--- a/pkg/analyzer/test/src/diagnostics/assignment_to_final_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/assignment_to_final_test.dart
@@ -10,119 +10,13 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AssignmentToFinalTest);
-    defineReflectiveTests(AssignmentToFinalWithNullSafetyTest);
+    defineReflectiveTests(AssignmentToFinalWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
 class AssignmentToFinalTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
-  test_prefixedIdentifier_instanceField() async {
-    await assertNoErrorsInCode('''
-class A {
-  var x = 0;
-}
-
-void f(A a) {
-  a.x = 0;
-  a.x += 0;
-  ++a.x;
-  a.x++;
-}
-''');
-  }
-
-  test_prefixedIdentifier_instanceField_final() async {
-    await assertErrorsInCode('''
-class A {
-  final x = 0;
-}
-
-void f(A a) {
-  a.x = 0;
-  a.x += 0;
-  ++a.x;
-  a.x++;
-}
-''', [
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 46, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 57, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 71, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 78, 1),
-    ]);
-  }
-
-  test_simpleIdentifier_inheritedSetter_shadowedBy_topLevelGetter() async {
-    await assertErrorsInCode('''
-class A {
-  void set foo(int _) {}
-}
-
-int get foo => 0;
-
-class B extends A {
-  void bar() {
-    foo = 0;
-  }
-}
-''', [
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 96, 3),
-    ]);
-  }
-
-  test_simpleIdentifier_topLevelGetter() async {
-    await assertErrorsInCode('''
-int get x => 0;
-
-void f() {
-  x = 0;
-  x += 0;
-  ++x;
-  x++;
-}
-''', [
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 30, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 39, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 51, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 56, 1),
-    ]);
-  }
-
-  test_simpleIdentifier_topLevelVariable() async {
-    await assertNoErrorsInCode('''
-var x = 0;
-
-void f() {
-  x = 0;
-  x += 0;
-  ++x;
-  x++;
-}
-''');
-  }
-
-  test_simpleIdentifier_topLevelVariable_final() async {
-    await assertErrorsInCode('''
-final x = 0;
-
-void f() {
-  x = 0;
-  x += 0;
-  ++x;
-  x++;
-}
-''', [
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 27, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 36, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 48, 1),
-      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 53, 1),
-    ]);
-  }
-}
-
-@reflectiveTest
-class AssignmentToFinalWithNullSafetyTest extends AssignmentToFinalTest
-    with WithNullSafetyMixin {
+    with AssignmentToFinalTestCases {
   test_prefixedIdentifier_instanceField_abstract() async {
     await assertNoErrorsInCode('''
 abstract class A {
@@ -450,3 +344,111 @@
     ]);
   }
 }
+
+mixin AssignmentToFinalTestCases on PubPackageResolutionTest {
+  test_prefixedIdentifier_instanceField() async {
+    await assertNoErrorsInCode('''
+class A {
+  var x = 0;
+}
+
+void f(A a) {
+  a.x = 0;
+  a.x += 0;
+  ++a.x;
+  a.x++;
+}
+''');
+  }
+
+  test_prefixedIdentifier_instanceField_final() async {
+    await assertErrorsInCode('''
+class A {
+  final x = 0;
+}
+
+void f(A a) {
+  a.x = 0;
+  a.x += 0;
+  ++a.x;
+  a.x++;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 46, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 57, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 71, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 78, 1),
+    ]);
+  }
+
+  test_simpleIdentifier_inheritedSetter_shadowedBy_topLevelGetter() async {
+    await assertErrorsInCode('''
+class A {
+  void set foo(int _) {}
+}
+
+int get foo => 0;
+
+class B extends A {
+  void bar() {
+    foo = 0;
+  }
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 96, 3),
+    ]);
+  }
+
+  test_simpleIdentifier_topLevelGetter() async {
+    await assertErrorsInCode('''
+int get x => 0;
+
+void f() {
+  x = 0;
+  x += 0;
+  ++x;
+  x++;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 30, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 39, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 51, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 56, 1),
+    ]);
+  }
+
+  test_simpleIdentifier_topLevelVariable() async {
+    await assertNoErrorsInCode('''
+var x = 0;
+
+void f() {
+  x = 0;
+  x += 0;
+  ++x;
+  x++;
+}
+''');
+  }
+
+  test_simpleIdentifier_topLevelVariable_final() async {
+    await assertErrorsInCode('''
+final x = 0;
+
+void f() {
+  x = 0;
+  x += 0;
+  ++x;
+  x++;
+}
+''', [
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 27, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 36, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 48, 1),
+      error(CompileTimeErrorCode.ASSIGNMENT_TO_FINAL, 53, 1),
+    ]);
+  }
+}
+
+@reflectiveTest
+class AssignmentToFinalWithoutNullSafetyTest extends PubPackageResolutionTest
+    with AssignmentToFinalTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/analyzer/test/src/diagnostics/dead_code_test.dart b/pkg/analyzer/test/src/diagnostics/dead_code_test.dart
index 1fc2927..92f1995 100644
--- a/pkg/analyzer/test/src/diagnostics/dead_code_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/dead_code_test.dart
@@ -10,13 +10,139 @@
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(DeadCodeTest);
-    defineReflectiveTests(DeadCodeWithNullSafetyTest);
+    defineReflectiveTests(DeadCodeWithoutNullSafetyTest);
   });
 }
 
 @reflectiveTest
-class DeadCodeTest extends PubPackageResolutionTest
-    with WithoutNullSafetyMixin {
+class DeadCodeTest extends PubPackageResolutionTest with DeadCodeTestCases {
+  test_assert_dead_message() async {
+    // We don't warn if an assert statement is live but its message is dead,
+    // because this results in nuisance warnings for desirable assertions (e.g.
+    // a `!= null` assertion that is redundant with strong checking but still
+    // useful with weak checking).
+    await assertErrorsInCode('''
+void f(Object waldo) {
+  assert(waldo != null, "Where's Waldo?");
+}
+''', [
+      error(HintCode.UNNECESSARY_NULL_COMPARISON_TRUE, 38, 7),
+    ]);
+  }
+
+  test_flowEnd_tryStatement_body() async {
+    await assertErrorsInCode(r'''
+Never foo() => throw 0;
+
+main() {
+  try {
+    foo();
+    1;
+  } catch (_) {
+    2;
+  }
+  3;
+}
+''', [
+      error(HintCode.DEAD_CODE, 57, 2),
+    ]);
+  }
+
+  test_invokeNever_functionExpressionInvocation_getter_propertyAccess() async {
+    await assertErrorsInCode(r'''
+class A {
+  Never get f => throw 0;
+}
+void g(A a) {
+  a.f(0);
+  print(1);
+}
+''', [
+      error(HintCode.RECEIVER_OF_TYPE_NEVER, 54, 3),
+      error(HintCode.DEAD_CODE, 57, 16),
+    ]);
+  }
+
+  test_invokeNever_functionExpressionInvocation_parenthesizedExpression() async {
+    await assertErrorsInCode(r'''
+void g(Never f) {
+  (f)(0);
+  print(1);
+}
+''', [
+      error(HintCode.RECEIVER_OF_TYPE_NEVER, 20, 3),
+      error(HintCode.DEAD_CODE, 23, 16),
+    ]);
+  }
+
+  test_invokeNever_functionExpressionInvocation_simpleIdentifier() async {
+    await assertErrorsInCode(r'''
+void g(Never f) {
+  f(0);
+  print(1);
+}
+''', [
+      error(HintCode.RECEIVER_OF_TYPE_NEVER, 20, 1),
+      error(HintCode.DEAD_CODE, 21, 16),
+    ]);
+  }
+
+  test_returnTypeNever_function() async {
+    await assertErrorsInCode(r'''
+Never foo() => throw 0;
+
+main() {
+  foo();
+  1;
+}
+''', [
+      error(HintCode.DEAD_CODE, 45, 2),
+    ]);
+  }
+
+  test_returnTypeNever_getter() async {
+    await assertErrorsInCode(r'''
+Never get foo => throw 0;
+
+main() {
+  foo;
+  2;
+}
+''', [
+      error(HintCode.DEAD_CODE, 45, 2),
+    ]);
+  }
+
+  @FailingTest(reason: '@alwaysThrows is not supported in flow analysis')
+  @override
+  test_statementAfterAlwaysThrowsFunction() async {
+    return super.test_statementAfterAlwaysThrowsFunction();
+  }
+
+  @FailingTest(reason: '@alwaysThrows is not supported in flow analysis')
+  @override
+  test_statementAfterAlwaysThrowsMethod() async {
+    return super.test_statementAfterAlwaysThrowsMethod();
+  }
+
+  test_switchStatement_exhaustive() async {
+    await assertErrorsInCode(r'''
+enum Foo { a, b }
+
+int f(Foo foo) {
+  switch (foo) {
+    case Foo.a: return 0;
+    case Foo.b: return 1;
+  }
+  return -1;
+}
+''', [
+      error(HintCode.DEAD_CODE, 111, 10),
+    ]);
+  }
+}
+
+mixin DeadCodeTestCases on PubPackageResolutionTest {
   @override
   void setUp() {
     super.setUp();
@@ -846,129 +972,5 @@
 }
 
 @reflectiveTest
-class DeadCodeWithNullSafetyTest extends DeadCodeTest with WithNullSafetyMixin {
-  test_assert_dead_message() async {
-    // We don't warn if an assert statement is live but its message is dead,
-    // because this results in nuisance warnings for desirable assertions (e.g.
-    // a `!= null` assertion that is redundant with strong checking but still
-    // useful with weak checking).
-    await assertErrorsInCode('''
-void f(Object waldo) {
-  assert(waldo != null, "Where's Waldo?");
-}
-''', [
-      error(HintCode.UNNECESSARY_NULL_COMPARISON_TRUE, 38, 7),
-    ]);
-  }
-
-  test_flowEnd_tryStatement_body() async {
-    await assertErrorsInCode(r'''
-Never foo() => throw 0;
-
-main() {
-  try {
-    foo();
-    1;
-  } catch (_) {
-    2;
-  }
-  3;
-}
-''', [
-      error(HintCode.DEAD_CODE, 57, 2),
-    ]);
-  }
-
-  test_invokeNever_functionExpressionInvocation_getter_propertyAccess() async {
-    await assertErrorsInCode(r'''
-class A {
-  Never get f => throw 0;
-}
-void g(A a) {
-  a.f(0);
-  print(1);
-}
-''', [
-      error(HintCode.RECEIVER_OF_TYPE_NEVER, 54, 3),
-      error(HintCode.DEAD_CODE, 57, 16),
-    ]);
-  }
-
-  test_invokeNever_functionExpressionInvocation_parenthesizedExpression() async {
-    await assertErrorsInCode(r'''
-void g(Never f) {
-  (f)(0);
-  print(1);
-}
-''', [
-      error(HintCode.RECEIVER_OF_TYPE_NEVER, 20, 3),
-      error(HintCode.DEAD_CODE, 23, 16),
-    ]);
-  }
-
-  test_invokeNever_functionExpressionInvocation_simpleIdentifier() async {
-    await assertErrorsInCode(r'''
-void g(Never f) {
-  f(0);
-  print(1);
-}
-''', [
-      error(HintCode.RECEIVER_OF_TYPE_NEVER, 20, 1),
-      error(HintCode.DEAD_CODE, 21, 16),
-    ]);
-  }
-
-  test_returnTypeNever_function() async {
-    await assertErrorsInCode(r'''
-Never foo() => throw 0;
-
-main() {
-  foo();
-  1;
-}
-''', [
-      error(HintCode.DEAD_CODE, 45, 2),
-    ]);
-  }
-
-  test_returnTypeNever_getter() async {
-    await assertErrorsInCode(r'''
-Never get foo => throw 0;
-
-main() {
-  foo;
-  2;
-}
-''', [
-      error(HintCode.DEAD_CODE, 45, 2),
-    ]);
-  }
-
-  @FailingTest(reason: '@alwaysThrows is not supported in flow analysis')
-  @override
-  test_statementAfterAlwaysThrowsFunction() async {
-    return super.test_statementAfterAlwaysThrowsFunction();
-  }
-
-  @FailingTest(reason: '@alwaysThrows is not supported in flow analysis')
-  @override
-  test_statementAfterAlwaysThrowsMethod() async {
-    return super.test_statementAfterAlwaysThrowsMethod();
-  }
-
-  test_switchStatement_exhaustive() async {
-    await assertErrorsInCode(r'''
-enum Foo { a, b }
-
-int f(Foo foo) {
-  switch (foo) {
-    case Foo.a: return 0;
-    case Foo.b: return 1;
-  }
-  return -1;
-}
-''', [
-      error(HintCode.DEAD_CODE, 111, 10),
-    ]);
-  }
-}
+class DeadCodeWithoutNullSafetyTest extends PubPackageResolutionTest
+    with DeadCodeTestCases, WithoutNullSafetyMixin {}
diff --git a/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart b/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
index 12614bb..a6d071f 100644
--- a/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
+++ b/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
@@ -42,7 +42,7 @@
   /// Notice that the component has to include the platform, and that no other
   /// platform will be loaded.
   factory IncrementalKernelGenerator.fromComponent(
-      CompilerOptions options, Uri entryPoint, Component component,
+      CompilerOptions options, Uri entryPoint, Component? component,
       [bool? outlineOnly, IncrementalSerializer? incrementalSerializer]) {
     return new IncrementalCompiler.fromComponent(
         new CompilerContext(
@@ -72,7 +72,7 @@
 
   /// Returns a component whose libraries are the recompiled libraries,
   /// or - in the case of [fullComponent] - a full Component.
-  Future<Component> computeDelta({List<Uri> entryPoints, bool fullComponent});
+  Future<Component> computeDelta({List<Uri>? entryPoints, bool fullComponent});
 
   /// Returns [CoreTypes] used during compilation.
   /// Valid after [computeDelta] is called.
@@ -136,7 +136,7 @@
       List<TypeParameter> typeDefinitions,
       String syntheticProcedureName,
       Uri libraryUri,
-      [String className,
+      [String? className,
       bool isStatic = false]);
 
   /// Sets experimental features.
diff --git a/pkg/front_end/lib/src/api_unstable/bazel_worker.dart b/pkg/front_end/lib/src/api_unstable/bazel_worker.dart
index 46566f1..8cf810b 100644
--- a/pkg/front_end/lib/src/api_unstable/bazel_worker.dart
+++ b/pkg/front_end/lib/src/api_unstable/bazel_worker.dart
@@ -58,7 +58,7 @@
 /// Re-uses cached components from [oldState.workerInputCache], and reloads them
 /// as necessary based on [workerInputDigests].
 Future<InitializedCompilerState> initializeIncrementalCompiler(
-    InitializedCompilerState oldState,
+    InitializedCompilerState? oldState,
     Set<String> tags,
     Uri sdkSummary,
     Uri packagesFile,
@@ -99,7 +99,7 @@
 }
 
 Future<InitializedCompilerState> initializeCompiler(
-  InitializedCompilerState oldState,
+  InitializedCompilerState? oldState,
   Uri sdkSummary,
   Uri librariesSpecificationUri,
   Uri packagesFile,
diff --git a/pkg/vm/lib/incremental_compiler.dart b/pkg/vm/lib/incremental_compiler.dart
index 5179a44..a8d3271 100644
--- a/pkg/vm/lib/incremental_compiler.dart
+++ b/pkg/vm/lib/incremental_compiler.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Defines wrapper class around incremental compiler to support
 /// the flow, where incremental deltas can be rejected by VM.
 import 'dart:async';
@@ -20,23 +18,23 @@
 /// deltas and combines them together into resultant program until it is
 /// accepted.
 class IncrementalCompiler {
-  IncrementalKernelGenerator _generator;
-  IncrementalSerializer incrementalSerializer;
+  late IncrementalKernelGenerator _generator;
+  IncrementalSerializer? incrementalSerializer;
 
   // Component that reflect the state that was most recently accepted by the
   // client. Is [null], if no compilation results were accepted by the client.
-  Component _lastKnownGood;
-  List<Component> _pendingDeltas;
+  Component? _lastKnownGood;
+  late List<Component> _pendingDeltas;
   CompilerOptions _compilerOptions;
   bool initialized = false;
   bool fullComponent = false;
-  Uri initializeFromDillUri;
+  Uri? initializeFromDillUri;
   Uri _entryPoint;
   final bool forExpressionCompilationOnly;
 
   Uri get entryPoint => _entryPoint;
   IncrementalKernelGenerator get generator => _generator;
-  Component get lastKnownGoodComponent => _lastKnownGood;
+  Component? get lastKnownGoodComponent => _lastKnownGood;
 
   IncrementalCompiler(this._compilerOptions, this._entryPoint,
       {this.initializeFromDillUri, bool incrementalSerialization: true})
@@ -61,12 +59,12 @@
   ///
   /// If [entryPoint] is specified, that points to new entry point for the
   /// compilation. Otherwise, previously set entryPoint is used.
-  Future<Component> compile({Uri entryPoint}) async {
+  Future<Component> compile({Uri? entryPoint}) async {
     final task = new TimelineTask();
     try {
       task.start("IncrementalCompiler.compile");
       _entryPoint = entryPoint ?? _entryPoint;
-      List<Uri> entryPoints;
+      List<Uri>? entryPoints;
       if (entryPoint != null) entryPoints = [entryPoint];
       Component component = await _generator.computeDelta(
           entryPoints: entryPoints, fullComponent: fullComponent);
@@ -80,8 +78,9 @@
   }
 
   _combinePendingDeltas(bool includePlatform) {
-    Procedure mainMethod;
-    NonNullableByDefaultCompiledMode compilationMode;
+    Procedure? mainMethod;
+    NonNullableByDefaultCompiledMode compilationMode =
+        NonNullableByDefaultCompiledMode.Invalid;
     Map<Uri, Library> combined = <Uri, Library>{};
     Map<Uri, Source> uriToSource = new Map<Uri, Source>();
     for (Component delta in _pendingDeltas) {
@@ -104,8 +103,8 @@
       ..setMainMethodAndMode(mainMethod?.reference, true, compilationMode);
   }
 
-  CoreTypes getCoreTypes() => _generator.getCoreTypes();
-  ClassHierarchy getClassHierarchy() => _generator.getClassHierarchy();
+  CoreTypes? getCoreTypes() => _generator.getCoreTypes();
+  ClassHierarchy? getClassHierarchy() => _generator.getClassHierarchy();
 
   /// This lets incremental compiler know that results of last [compile] call
   /// were accepted, don't need to be included into subsequent [compile] calls
@@ -118,13 +117,14 @@
     Map<Uri, Library> combined = <Uri, Library>{};
     Map<Uri, Source> uriToSource = <Uri, Source>{};
 
-    if (_lastKnownGood != null) {
+    Component? lastKnownGood = _lastKnownGood;
+    if (lastKnownGood != null) {
       // TODO(aam): Figure out how to skip no-longer-used libraries from
       // [_lastKnownGood] libraries.
-      for (Library library in _lastKnownGood.libraries) {
+      for (Library library in lastKnownGood.libraries) {
         combined[library.importUri] = library;
       }
-      uriToSource.addAll(_lastKnownGood.uriToSource);
+      uriToSource.addAll(lastKnownGood.uriToSource);
     }
 
     Component candidate = _combinePendingDeltas(true);
@@ -133,13 +133,13 @@
     }
     uriToSource.addAll(candidate.uriToSource);
 
-    _lastKnownGood = new Component(
+    _lastKnownGood = lastKnownGood = new Component(
       libraries: combined.values.toList(),
       uriToSource: uriToSource,
     )..setMainMethodAndMode(
         candidate.mainMethod?.reference, true, candidate.mode);
     for (final repo in candidate.metadata.values) {
-      _lastKnownGood.addMetadataRepository(repo);
+      lastKnownGood.addMetadataRepository(repo);
     }
     _pendingDeltas.clear();
   }
@@ -182,12 +182,12 @@
     fullComponent = true;
   }
 
-  Future<Procedure> compileExpression(
+  Future<Procedure?> compileExpression(
       String expression,
       List<String> definitions,
       List<String> typeDefinitions,
       String libraryUri,
-      String klass,
+      String? klass,
       bool isStatic) {
     Map<String, DartType> completeDefinitions = {};
     for (String name in definitions) {
@@ -202,7 +202,6 @@
     }
 
     Uri library = Uri.parse(libraryUri);
-    if (library == null) return null;
 
     return _generator.compileExpression(expression, completeDefinitions,
         typeParameters, kDebugProcedureName, library, klass, isStatic);
diff --git a/pkg/vm/lib/kernel_front_end.dart b/pkg/vm/lib/kernel_front_end.dart
index 43d5a59..51ed004 100644
--- a/pkg/vm/lib/kernel_front_end.dart
+++ b/pkg/vm/lib/kernel_front_end.dart
@@ -2,10 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Defines the VM-specific translation of Dart source code to kernel binaries.
-library vm.kernel_front_end;
 
 import 'dart:async';
 import 'dart:io' show File, IOSink;
@@ -162,7 +159,7 @@
 /// Run kernel compiler tool with given [options] and [usage]
 /// and return exit code.
 Future<int> runCompiler(ArgResults options, String usage) async {
-  final String platformKernel = options['platform'];
+  final String? platformKernel = options['platform'];
 
   if (options['help']) {
     print(usage);
@@ -176,26 +173,26 @@
 
   final String input = options.rest.single;
   final String outputFileName = options['output'] ?? "$input.dill";
-  final String packages = options['packages'];
+  final String? packages = options['packages'];
   final String targetName = options['target'];
-  final String fileSystemScheme = options['filesystem-scheme'];
-  final String depfile = options['depfile'];
-  final String fromDillFile = options['from-dill'];
-  final List<String> fileSystemRoots = options['filesystem-root'];
+  final String? fileSystemScheme = options['filesystem-scheme'];
+  final String? depfile = options['depfile'];
+  final String? fromDillFile = options['from-dill'];
+  final List<String>? fileSystemRoots = options['filesystem-root'];
   final bool aot = options['aot'];
   final bool tfa = options['tfa'];
   final bool linkPlatform = options['link-platform'];
   final bool embedSources = options['embed-sources'];
   final bool enableAsserts = options['enable-asserts'];
-  final bool nullSafety = options['sound-null-safety'];
+  final bool? nullSafety = options['sound-null-safety'];
   final bool useProtobufTreeShakerV2 = options['protobuf-tree-shaker-v2'];
   final bool splitOutputByPackages = options['split-output-by-packages'];
-  final String manifestFilename = options['manifest'];
-  final String dataDir = options['component-name'] ?? options['data-dir'];
+  final String? manifestFilename = options['manifest'];
+  final String? dataDir = options['component-name'] ?? options['data-dir'];
 
   final bool minimalKernel = options['minimal-kernel'];
   final bool treeShakeWriteOnlyFields = options['tree-shake-write-only-fields'];
-  final List<String> experimentalFlags = options['enable-experiment'];
+  final List<String>? experimentalFlags = options['enable-experiment'];
   final Map<String, String> environmentDefines = {};
 
   if (!parseCommandLineDefines(options['define'], environmentDefines, usage)) {
@@ -217,7 +214,7 @@
   final fileSystem =
       createFrontEndFileSystem(fileSystemScheme, fileSystemRoots);
 
-  final Uri packagesUri = packages != null ? resolveInputUri(packages) : null;
+  final Uri? packagesUri = packages != null ? resolveInputUri(packages) : null;
 
   final platformKernelUri = Uri.base.resolveUri(new Uri.file(platformKernel));
   final List<Uri> additionalDills = <Uri>[];
@@ -232,7 +229,8 @@
 
   final verbosity = Verbosity.parseArgument(options['verbosity']);
   final errorPrinter = new ErrorPrinter(verbosity);
-  final errorDetector = new ErrorDetector(previousErrorHandler: errorPrinter);
+  final errorDetector =
+      new ErrorDetector(previousErrorHandler: errorPrinter.call);
 
   final CompilerOptions compilerOptions = new CompilerOptions()
     ..sdkSummary = platformKernelUri
@@ -280,19 +278,20 @@
 
   errorPrinter.printCompilationMessages();
 
-  if (errorDetector.hasCompilationErrors || (results.component == null)) {
+  final Component? component = results.component;
+  if (errorDetector.hasCompilationErrors || (component == null)) {
     return compileTimeErrorExitCode;
   }
 
   final IOSink sink = new File(outputFileName).openWrite();
   final BinaryPrinter printer = new BinaryPrinter(sink,
       libraryFilter: (lib) => !results.loadedLibraries.contains(lib));
-  printer.writeComponentFile(results.component);
+  printer.writeComponentFile(component);
   await sink.close();
 
   if (depfile != null) {
     await writeDepfile(
-        fileSystem, results.compiledSources, outputFileName, depfile);
+        fileSystem, results.compiledSources!, outputFileName, depfile);
   }
 
   if (splitOutputByPackages) {
@@ -314,14 +313,14 @@
 /// Results of [compileToKernel]: generated kernel [Component] and
 /// collection of compiled sources.
 class KernelCompilationResults {
-  final Component component;
+  final Component? component;
 
   /// Set of libraries loaded from .dill, with or without the SDK depending on
   /// the compilation settings.
   final Set<Library> loadedLibraries;
-  final ClassHierarchy classHierarchy;
-  final CoreTypes coreTypes;
-  final Iterable<Uri> compiledSources;
+  final ClassHierarchy? classHierarchy;
+  final CoreTypes? coreTypes;
+  final Iterable<Uri>? compiledSources;
 
   KernelCompilationResults(this.component, this.loadedLibraries,
       this.classHierarchy, this.coreTypes, this.compiledSources);
@@ -338,29 +337,30 @@
     List<String> deleteToStringPackageUris: const <String>[],
     bool aot: false,
     bool useGlobalTypeFlowAnalysis: false,
-    Map<String, String> environmentDefines,
+    required Map<String, String> environmentDefines,
     bool enableAsserts: true,
     bool useProtobufTreeShakerV2: false,
     bool minimalKernel: false,
     bool treeShakeWriteOnlyFields: false,
-    String fromDillFile: null}) async {
+    String? fromDillFile: null}) async {
   // Replace error handler to detect if there are compilation errors.
   final errorDetector =
       new ErrorDetector(previousErrorHandler: options.onDiagnostic);
-  options.onDiagnostic = errorDetector;
+  options.onDiagnostic = errorDetector.call;
 
+  final target = options.target!;
   options.environmentDefines =
-      options.target.updateEnvironmentDefines(environmentDefines);
+      target.updateEnvironmentDefines(environmentDefines);
 
-  CompilerResult compilerResult;
+  CompilerResult? compilerResult;
   if (fromDillFile != null) {
     compilerResult =
         await loadKernel(options.fileSystem, resolveInputUri(fromDillFile));
   } else {
     compilerResult = await kernelForProgram(source, options);
   }
-  Component component = compilerResult?.component;
-  Iterable<Uri> compiledSources = component?.uriToSource?.keys;
+  final Component? component = compilerResult?.component;
+  Iterable<Uri>? compiledSources = component?.uriToSource.keys;
 
   Set<Library> loadedLibraries = createLoadedLibrariesSet(
       compilerResult?.loadedComponents, compilerResult?.sdkComponent,
@@ -373,13 +373,8 @@
 
   // Run global transformations only if component is correct.
   if ((aot || minimalKernel) && component != null) {
-    await runGlobalTransformations(
-        options.target,
-        component,
-        useGlobalTypeFlowAnalysis,
-        enableAsserts,
-        useProtobufTreeShakerV2,
-        errorDetector,
+    await runGlobalTransformations(target, component, useGlobalTypeFlowAnalysis,
+        enableAsserts, useProtobufTreeShakerV2, errorDetector,
         minimalKernel: minimalKernel,
         treeShakeWriteOnlyFields: treeShakeWriteOnlyFields);
 
@@ -387,7 +382,7 @@
       // compiledSources is component.uriToSource.keys.
       // Make a copy of compiledSources to detach it from
       // component.uriToSource which is cleared below.
-      compiledSources = compiledSources.toList();
+      compiledSources = compiledSources!.toList();
 
       component.metadata.clear();
       component.uriToSource.clear();
@@ -406,7 +401,7 @@
 }
 
 Set<Library> createLoadedLibrariesSet(
-    List<Component> loadedComponents, Component sdkComponent,
+    List<Component>? loadedComponents, Component? sdkComponent,
     {bool includePlatform: false}) {
   final Set<Library> loadedLibraries = {};
   if (loadedComponents != null) {
@@ -481,8 +476,11 @@
 
 /// Runs given [action] with [CompilerContext]. This is needed to
 /// be able to report compile-time errors.
-Future<T> runWithFrontEndCompilerContext<T>(Uri source,
-    CompilerOptions compilerOptions, Component component, T action()) async {
+Future<T> runWithFrontEndCompilerContext<T>(
+    Uri source,
+    CompilerOptions compilerOptions,
+    Component component,
+    Future<T> action()) async {
   final processedOptions =
       new ProcessedOptions(options: compilerOptions, inputs: [source]);
 
@@ -498,7 +496,7 @@
 }
 
 class ErrorDetector {
-  final DiagnosticMessageHandler previousErrorHandler;
+  final DiagnosticMessageHandler? previousErrorHandler;
   bool hasCompilationErrors = false;
 
   ErrorDetector({this.previousErrorHandler});
@@ -514,8 +512,9 @@
 
 class ErrorPrinter {
   final Verbosity verbosity;
-  final DiagnosticMessageHandler previousErrorHandler;
-  final compilationMessages = <Uri, List<DiagnosticMessage>>{};
+  final DiagnosticMessageHandler? previousErrorHandler;
+  final Map<Uri?, List<DiagnosticMessage>> compilationMessages =
+      <Uri?, List<DiagnosticMessage>>{};
 
   ErrorPrinter(this.verbosity, {this.previousErrorHandler});
 
@@ -539,8 +538,8 @@
         }
         return 0;
       });
-    for (final Uri sourceUri in sortedUris) {
-      for (final DiagnosticMessage message in compilationMessages[sourceUri]) {
+    for (final Uri? sourceUri in sortedUris) {
+      for (final DiagnosticMessage message in compilationMessages[sourceUri]!) {
         if (Verbosity.shouldPrint(verbosity, message)) {
           printDiagnosticMessage(message, print);
         }
@@ -576,7 +575,7 @@
 }
 
 /// Create front-end target with given name.
-Target createFrontEndTarget(String targetName,
+Target? createFrontEndTarget(String targetName,
     {bool trackWidgetCreation = false, bool nullSafety = false}) {
   // Make sure VM-specific targets are available.
   installAdditionalTargets();
@@ -591,9 +590,8 @@
 /// If requested, create a virtual mutli-root file system and/or an http aware
 /// file system.
 FileSystem createFrontEndFileSystem(
-    String multiRootFileSystemScheme, List<String> multiRootFileSystemRoots,
-    {bool allowHttp}) {
-  allowHttp ??= false;
+    String? multiRootFileSystemScheme, List<String>? multiRootFileSystemRoots,
+    {bool allowHttp = false}) {
   FileSystem fileSystem = StandardFileSystem.instance;
   if (allowHttp) {
     fileSystem = HttpAwareFileSystem(fileSystem);
@@ -615,7 +613,7 @@
 Future<Uri> asFileUri(FileSystem fileSystem, Uri uri) async {
   FileSystemEntity fse = fileSystem.entityForUri(uri);
   if (fse is MultiRootFileSystemEntity) {
-    fse = await (fse as MultiRootFileSystemEntity).delegate;
+    fse = await fse.delegate;
   }
   return fse.uri;
 }
@@ -645,8 +643,9 @@
 Future writeOutputSplitByPackages(Uri source, CompilerOptions compilerOptions,
     KernelCompilationResults compilationResults, String outputFileName) async {
   final packages = <String>[];
-  await runWithFrontEndCompilerContext(
-      source, compilerOptions, compilationResults.component, () async {
+  final Component component = compilationResults.component!;
+  await runWithFrontEndCompilerContext(source, compilerOptions, component,
+      () async {
     // When loading a kernel file list, flutter_runner and dart_runner expect
     // 'main' to be last.
     await forEachPackage(compilationResults,
@@ -655,12 +654,10 @@
       final String filename = '$outputFileName-$package.dilp';
       final IOSink sink = new File(filename).openWrite();
 
-      Component partComponent = compilationResults.component;
-
       final BinaryPrinter printer = new BinaryPrinter(sink,
           libraryFilter: (lib) =>
               packageFor(lib, compilationResults.loadedLibraries) == package);
-      printer.writeComponentFile(partComponent);
+      printer.writeComponentFile(component);
 
       await sink.close();
     }, mainFirst: false);
@@ -673,7 +670,7 @@
   await packagesList.close();
 }
 
-String packageFor(Library lib, Set<Library> loadedLibraries) {
+String? packageFor(Library lib, Set<Library> loadedLibraries) {
   // Core libraries are not written into any package kernel binaries.
   if (loadedLibraries.contains(lib)) return null;
 
@@ -701,23 +698,25 @@
   }
 }
 
-Future<Null> forEachPackage<T>(KernelCompilationResults results,
-    T action(String package, List<Library> libraries),
-    {bool mainFirst}) async {
-  final Component component = results.component;
+Future<void> forEachPackage(KernelCompilationResults results,
+    Future<void> action(String package, List<Library> libraries),
+    {required bool mainFirst}) async {
+  final Component component = results.component!;
   final Set<Library> loadedLibraries = results.loadedLibraries;
   sortComponent(component);
 
-  final packages = new Map<String, List<Library>>();
+  final Map<String, List<Library>> packages = <String, List<Library>>{};
   packages['main'] = <Library>[]; // Always create 'main'.
   for (Library lib in component.libraries) {
-    packages
-        .putIfAbsent(packageFor(lib, loadedLibraries), () => <Library>[])
-        .add(lib);
+    final String? package = packageFor(lib, loadedLibraries);
+    // Ignore external libraries.
+    if (package == null) {
+      continue;
+    }
+    packages.putIfAbsent(package, () => <Library>[]).add(lib);
   }
-  packages.remove(null); // Ignore external libraries.
 
-  final mainLibraries = packages.remove('main');
+  final mainLibraries = packages.remove('main')!;
   if (mainFirst) {
     await action('main', mainLibraries);
   }
@@ -728,7 +727,7 @@
   component.setMainMethodAndMode(null, true, compilationMode);
   component.problemsAsJson = null;
   for (String package in packages.keys) {
-    await action(package, packages[package]);
+    await action(package, packages[package]!);
   }
   component.setMainMethodAndMode(mainMethod?.reference, true, compilationMode);
   component.problemsAsJson = problemsAsJson;
@@ -750,8 +749,8 @@
   file.write(_escapePath(output));
   file.write(':');
   for (Uri dep in compiledSources) {
-    // Skip empty or corelib dependencies.
-    if (dep == null || dep.scheme == 'org-dartlang-sdk') continue;
+    // Skip corelib dependencies.
+    if (dep.scheme == 'org-dartlang-sdk') continue;
     Uri uri = await asFileUri(fileSystem, dep);
     file.write(' ');
     file.write(_escapePath(uri.toFilePath()));
@@ -761,7 +760,7 @@
 }
 
 Future<void> createFarManifest(
-    String output, String dataDir, String packageManifestFilename) async {
+    String output, String? dataDir, String packageManifestFilename) async {
   List<String> packages = await File('$output-packages').readAsLines();
 
   // Make sure the 'main' package is the last (convention with package loader).
@@ -791,7 +790,7 @@
     'typed_data',
     'vector_math'
   ]) {
-    Digest digest;
+    Digest? digest;
     if (packages.contains(package)) {
       final filenameInBuild = '$output-$package.dilp';
       final bytes = await File(filenameInBuild).readAsBytes();
@@ -813,11 +812,20 @@
 
   CompilerResultLoadedFromKernel(this.component);
 
-  List<int> get summary => null;
+  @override
+  List<int>? get summary => null;
+
+  @override
   List<Component> get loadedComponents => const <Component>[];
+
+  @override
   List<Uri> get deps => const <Uri>[];
-  CoreTypes get coreTypes => null;
-  ClassHierarchy get classHierarchy => null;
+
+  @override
+  CoreTypes? get coreTypes => null;
+
+  @override
+  ClassHierarchy? get classHierarchy => null;
 }
 
 Future<CompilerResult> loadKernel(
diff --git a/pkg/vm/lib/target/dart_runner.dart b/pkg/vm/lib/target/dart_runner.dart
index c1df052..995d484 100644
--- a/pkg/vm/lib/target/dart_runner.dart
+++ b/pkg/vm/lib/target/dart_runner.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/target/targets.dart';
 import 'package:vm/target/vm.dart' show VmTarget;
 
diff --git a/pkg/vm/lib/target/flutter.dart b/pkg/vm/lib/target/flutter.dart
index 3ffdc12..1eadf20 100644
--- a/pkg/vm/lib/target/flutter.dart
+++ b/pkg/vm/lib/target/flutter.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/ast.dart' show Component, Library;
 import 'package:kernel/core_types.dart' show CoreTypes;
 import 'package:kernel/target/changed_structure_notifier.dart';
@@ -14,7 +12,7 @@
 class FlutterTarget extends VmTarget {
   FlutterTarget(TargetFlags flags) : super(flags);
 
-  WidgetCreatorTracker _widgetTracker;
+  late final WidgetCreatorTracker _widgetTracker = WidgetCreatorTracker();
 
   @override
   String get name => 'flutter';
@@ -57,15 +55,12 @@
       CoreTypes coreTypes,
       List<Library> libraries,
       DiagnosticReporter diagnosticReporter,
-      {void Function(String msg) logger,
-      ChangedStructureNotifier changedStructureNotifier}) {
+      {void Function(String msg)? logger,
+      ChangedStructureNotifier? changedStructureNotifier}) {
     super.performPreConstantEvaluationTransformations(
         component, coreTypes, libraries, diagnosticReporter,
         logger: logger, changedStructureNotifier: changedStructureNotifier);
     if (flags.trackWidgetCreation) {
-      if (_widgetTracker == null) {
-        _widgetTracker = WidgetCreatorTracker();
-      }
       _widgetTracker.transform(component, libraries, changedStructureNotifier);
     }
   }
diff --git a/pkg/vm/lib/target/flutter_runner.dart b/pkg/vm/lib/target/flutter_runner.dart
index a9c41ac..addd766 100644
--- a/pkg/vm/lib/target/flutter_runner.dart
+++ b/pkg/vm/lib/target/flutter_runner.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/target/targets.dart';
 import 'package:vm/target/vm.dart' show VmTarget;
 
diff --git a/pkg/vm/lib/target/install.dart b/pkg/vm/lib/target/install.dart
index d691d28..b22d469 100644
--- a/pkg/vm/lib/target/install.dart
+++ b/pkg/vm/lib/target/install.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/target/targets.dart' show targets, TargetFlags;
 import 'package:vm/target/dart_runner.dart' show DartRunnerTarget;
 import 'package:vm/target/flutter.dart' show FlutterTarget;
diff --git a/pkg/vm/lib/target/vm.dart b/pkg/vm/lib/target/vm.dart
index 20cd144..ec6e1b1 100644
--- a/pkg/vm/lib/target/vm.dart
+++ b/pkg/vm/lib/target/vm.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/ast.dart';
 import 'package:kernel/clone.dart';
 import 'package:kernel/class_hierarchy.dart';
@@ -34,14 +32,14 @@
 class VmTarget extends Target {
   final TargetFlags flags;
 
-  Class _growableList;
-  Class _immutableList;
-  Class _internalLinkedHashMap;
-  Class _immutableMap;
-  Class _oneByteString;
-  Class _twoByteString;
-  Class _smi;
-  Class _double; // _Double, not double.
+  Class? _growableList;
+  Class? _immutableList;
+  Class? _internalLinkedHashMap;
+  Class? _immutableMap;
+  Class? _oneByteString;
+  Class? _twoByteString;
+  Class? _smi;
+  Class? _double; // _Double, not double.
 
   VmTarget(this.flags);
 
@@ -116,7 +114,7 @@
     final Field little =
         coreTypes.index.getField('dart:typed_data', 'Endian', 'little');
     host.isConst = true;
-    host.initializer = new CloneVisitorNotMembers().clone(little.initializer)
+    host.initializer = new CloneVisitorNotMembers().clone(little.initializer!)
       ..parent = host;
   }
 
@@ -126,8 +124,8 @@
       CoreTypes coreTypes,
       List<Library> libraries,
       DiagnosticReporter diagnosticReporter,
-      {void Function(String msg) logger,
-      ChangedStructureNotifier changedStructureNotifier}) {
+      {void Function(String msg)? logger,
+      ChangedStructureNotifier? changedStructureNotifier}) {
     super.performPreConstantEvaluationTransformations(
         component, coreTypes, libraries, diagnosticReporter,
         logger: logger, changedStructureNotifier: changedStructureNotifier);
@@ -152,11 +150,11 @@
       CoreTypes coreTypes,
       ClassHierarchy hierarchy,
       List<Library> libraries,
-      Map<String, String> environmentDefines,
+      Map<String, String>? environmentDefines,
       DiagnosticReporter diagnosticReporter,
-      ReferenceFromIndex referenceFromIndex,
-      {void Function(String msg) logger,
-      ChangedStructureNotifier changedStructureNotifier}) {
+      ReferenceFromIndex? referenceFromIndex,
+      {void Function(String msg)? logger,
+      ChangedStructureNotifier? changedStructureNotifier}) {
     transformMixins.transformLibraries(
         this, coreTypes, hierarchy, libraries, referenceFromIndex);
     logger?.call("Transformed mixin applications");
@@ -184,7 +182,7 @@
     }
 
     // TODO(kmillikin): Make this run on a per-method basis.
-    bool productMode = environmentDefines["dart.vm.product"] == "true";
+    bool productMode = environmentDefines!["dart.vm.product"] == "true";
     transformAsync.transformLibraries(
         new TypeEnvironment(coreTypes, hierarchy), libraries,
         productMode: productMode);
@@ -204,9 +202,9 @@
       CoreTypes coreTypes,
       ClassHierarchy hierarchy,
       Procedure procedure,
-      Map<String, String> environmentDefines,
-      {void Function(String msg) logger}) {
-    bool productMode = environmentDefines["dart.vm.product"] == "true";
+      Map<String, String>? environmentDefines,
+      {void Function(String msg)? logger}) {
+    bool productMode = environmentDefines!["dart.vm.product"] == "true";
     transformAsync.transformProcedure(
         new TypeEnvironment(coreTypes, hierarchy), procedure,
         productMode: productMode);
@@ -451,7 +449,7 @@
   }
 
   @override
-  Class concreteIntLiteralClass(CoreTypes coreTypes, int value) {
+  Class? concreteIntLiteralClass(CoreTypes coreTypes, int value) {
     const int bitsPerInt32 = 32;
     const int smiBits32 = bitsPerInt32 - 2;
     const int smiMin32 = -(1 << smiBits32);
@@ -490,7 +488,6 @@
   Map<String, String> updateEnvironmentDefines(Map<String, String> map) {
     // TODO(alexmarkov): Call this from the front-end in order to have
     //  the same defines when compiling platform.
-    assert(map != null);
     map['dart.isVM'] = 'true';
     // TODO(dartbug.com/36460): Derive dart.library.* definitions from platform.
     for (String library in extraRequiredLibraries) {
diff --git a/pkg/vm/lib/transformations/type_flow/analysis.dart b/pkg/vm/lib/transformations/type_flow/analysis.dart
index 83c9a50..75eff47 100644
--- a/pkg/vm/lib/transformations/type_flow/analysis.dart
+++ b/pkg/vm/lib/transformations/type_flow/analysis.dart
@@ -2,10 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Global type flow analysis.
-library kernel.transformations.analysis;
 
 import 'dart:collection';
 import 'dart:core' hide Type;
@@ -51,24 +48,28 @@
 
 /// Maintains set of dependent invocations.
 class _DependencyTracker {
-  Set<_Invocation> _dependentInvocations;
+  Set<_Invocation>? _dependentInvocations;
 
   void addDependentInvocation(_Invocation invocation) {
     if (!identical(invocation, this)) {
-      _dependentInvocations ??= new Set<_Invocation>();
-      _dependentInvocations.add(invocation);
+      var dependentInvocations = _dependentInvocations;
+      if (dependentInvocations == null) {
+        _dependentInvocations = dependentInvocations = Set<_Invocation>();
+      }
+      dependentInvocations.add(invocation);
     }
   }
 
   void invalidateDependentInvocations(_WorkList workList) {
-    if (_dependentInvocations != null) {
+    final dependentInvocations = _dependentInvocations;
+    if (dependentInvocations != null) {
       if (kPrintTrace) {
         tracePrint('   - CHANGED: $this');
-        for (var di in _dependentInvocations) {
+        for (var di in dependentInvocations) {
           tracePrint('     - invalidating $di');
         }
       }
-      _dependentInvocations.forEach(workList.invalidateInvocation);
+      dependentInvocations.forEach(workList.invalidateInvocation);
     }
   }
 }
@@ -83,12 +84,12 @@
   final Selector selector;
   final Args<Type> args;
 
-  Type result;
+  Type? result;
 
   /// Result of the invocation calculated before invocation was invalidated.
   /// Used to check if the re-analysis of the invocation yields the same
   /// result or not (to avoid invalidation of callers if result hasn't changed).
-  Type invalidatedResult;
+  Type? invalidatedResult;
 
   /// Number of times result of this invocation was invalidated.
   int invalidationCounter = 0;
@@ -108,7 +109,7 @@
   /// Returns result of this invocation if its available without
   /// further analysis, or `null` if it's not available.
   /// Used for recursive calls while this invocation is being processed.
-  Type get resultForRecursiveInvocation => result;
+  Type? get resultForRecursiveInvocation => result;
 
   /// Use [type] as a current computed result of this invocation.
   /// If this invocation was invalidated, and the invalidated result is
@@ -116,7 +117,6 @@
   /// Result type may be saturated if this invocation was invalidated
   /// too many times.
   void setResult(TypeFlowAnalysis typeFlowAnalysis, Type type) {
-    assert(type != null);
     result = type;
 
     if (invalidatedResult != null) {
@@ -132,8 +132,8 @@
         // the analysis, result is saturated after invocation is invalidated
         // at least [_Invocation.invalidationLimit] times.
         if (invalidationCounter > _Invocation.invalidationLimit) {
-          result =
-              result.union(invalidatedResult, typeFlowAnalysis.hierarchyCache);
+          result = result!
+              .union(invalidatedResult!, typeFlowAnalysis.hierarchyCache);
         }
       }
       invalidatedResult = null;
@@ -192,11 +192,12 @@
     // they could fail bounds checks.
     //
     // TODO(sjindel): Use [TypeCheck] to avoid bounds checks.
-    if (selector.member.function != null) {
-      typeChecksNeeded = selector.member.function.typeParameters
-          .any((t) => t.isGenericCovariantImpl);
+    final function = selector.member.function;
+    if (function != null) {
+      typeChecksNeeded =
+          function.typeParameters.any((t) => t.isGenericCovariantImpl);
     } else {
-      Field field = selector.member;
+      Field field = selector.member as Field;
       if (selector.callKind == CallKind.PropertySet) {
         // TODO(dartbug.com/40615): Use TFA results to improve this criterion.
         typeChecksNeeded = field.isGenericCovariantImpl;
@@ -277,13 +278,10 @@
         fieldValue.isInitialized = true;
         return const EmptyType();
     }
-
-    // Make dartanalyzer happy.
-    throw 'Unexpected call kind ${selector.callKind}';
   }
 
   Type _processFunction(TypeFlowAnalysis typeFlowAnalysis) {
-    final Member member = selector.member;
+    final Member member = selector.member!;
     if (selector.memberAgreesToCallKind(member)) {
       if (_argumentsValid()) {
         final summary = typeFlowAnalysis.getSummary(member);
@@ -326,13 +324,12 @@
   }
 
   bool _argumentsValid() {
-    final function = selector.member.function;
-    assert(function != null);
-
+    final member = selector.member!;
+    final function = member.function!;
     final int positionalArguments = args.positionalCount;
 
-    final int firstParamIndex = numTypeParams(selector.member) +
-        (hasReceiverArg(selector.member) ? 1 : 0);
+    final int firstParamIndex =
+        numTypeParams(member) + (hasReceiverArg(member) ? 1 : 0);
     final int requiredParameters =
         firstParamIndex + function.requiredParameterCount;
     if (positionalArguments < requiredParameters) {
@@ -361,9 +358,9 @@
 
 class _DispatchableInvocation extends _Invocation {
   bool _isPolymorphic = false;
-  Set<Call> _callSites; // Populated only if not polymorphic.
-  Member _monomorphicTarget;
-  _DirectInvocation _monomorphicDirectInvocation;
+  Set<Call>? _callSites; // Populated only if not polymorphic.
+  Member? _monomorphicTarget;
+  _DirectInvocation? _monomorphicDirectInvocation;
 
   @override
   set typeChecksNeeded(bool value) {
@@ -434,7 +431,8 @@
 
           if (!_isPolymorphic) {
             assert(target == _monomorphicTarget);
-            _monomorphicDirectInvocation = directInvocation;
+            _monomorphicDirectInvocation =
+                directInvocation as _DirectInvocation;
           }
 
           type = typeFlowAnalysis.workList.processInvocation(directInvocation);
@@ -486,13 +484,13 @@
 
     final bool isNullableReceiver = receiver is NullableType;
     if (isNullableReceiver) {
-      receiver = (receiver as NullableType).baseType;
+      receiver = receiver.baseType;
       assert(receiver is! NullableType);
     }
 
     if (selector is InterfaceSelector) {
       final staticReceiverType = new ConeType(typeFlowAnalysis.hierarchyCache
-          .getTFClass(selector.member.enclosingClass));
+          .getTFClass(selector.member!.enclosingClass!));
       receiver = receiver.intersection(
           staticReceiverType, typeFlowAnalysis.hierarchyCache);
       assert(receiver is! NullableType);
@@ -507,7 +505,7 @@
       // invocation to the receiver class. A new allocated class discovered
       // in the receiver cone will invalidate this invocation.
       receiver = typeFlowAnalysis.hierarchyCache
-          .specializeTypeCone((receiver as ConeType).cls, allowWideCone: false);
+          .specializeTypeCone(receiver.cls, allowWideCone: false);
     }
 
     assert(targets.isEmpty);
@@ -535,7 +533,7 @@
     Class nullClass =
         typeFlowAnalysis.environment.coreTypes.deprecatedNullClass;
 
-    Member target = typeFlowAnalysis.hierarchyCache.hierarchy
+    Member? target = typeFlowAnalysis.hierarchyCache.hierarchy
         .getDispatchTarget(nullClass, selector.name, setter: selector.isSetter);
 
     if (target != null) {
@@ -552,7 +550,7 @@
       TypeFlowAnalysis typeFlowAnalysis) {
     final TFClass cls = receiver.cls;
 
-    Member target =
+    Member? target =
         (cls as _TFClassImpl).getDispatchTarget(selector, typeFlowAnalysis);
 
     if (target != null) {
@@ -647,8 +645,9 @@
     if (_isPolymorphic) {
       callSite.setPolymorphic();
     } else {
-      if (_monomorphicTarget != null) {
-        callSite.addTarget(_monomorphicTarget);
+      final monomorphicTarget = _monomorphicTarget;
+      if (monomorphicTarget != null) {
+        callSite.addTarget(monomorphicTarget);
       }
     }
 
@@ -660,18 +659,20 @@
   /// Notify call sites monitoring this invocation about changes in
   /// polymorphism of this invocation.
   void _notifyCallSites() {
-    if (_callSites != null) {
-      _callSites.forEach(_notifyCallSite);
+    final callSites = _callSites;
+    if (callSites != null) {
+      callSites.forEach(_notifyCallSite);
     }
   }
 
   @override
-  Type get resultForRecursiveInvocation {
+  Type? get resultForRecursiveInvocation {
     if (result != null) {
       return result;
     }
-    if (_monomorphicDirectInvocation != null) {
-      return _monomorphicDirectInvocation.resultForRecursiveInvocation;
+    final monomorphicDirectInvocation = _monomorphicDirectInvocation;
+    if (monomorphicDirectInvocation != null) {
+      return monomorphicDirectInvocation.resultForRecursiveInvocation;
     }
     return null;
   }
@@ -683,30 +684,30 @@
 /// 1) Add 1..N concrete types ordered by classId OR add 1 arbitrary type.
 /// 2) Make type nullable.
 class _ReceiverTypeBuilder {
-  Type _type;
-  List<ConcreteType> _list;
+  Type? _type;
+  List<ConcreteType>? _list;
   bool _nullable = false;
 
   /// Appends a ConcreteType. May be called multiple times.
   /// Should not be used in conjunction with [addType].
   void addConcreteType(ConcreteType type) {
-    if (_list == null) {
-      if (_type == null) {
+    final list = _list;
+    if (list == null) {
+      final Type? t = _type;
+      if (t == null) {
         _type = type;
         return;
       }
+      final ct = t as ConcreteType;
 
-      assert(_type is ConcreteType);
-      assert(_type != type);
-
-      _list = <ConcreteType>[];
-      _list.add(_type);
-
+      assert(ct != type);
+      assert(ct.cls.id < type.cls.id);
+      _list = <ConcreteType>[ct, type];
       _type = null;
+    } else {
+      assert(list.last.cls.id < type.cls.id);
+      list.add(type);
     }
-
-    assert(_list.last.cls.id < type.cls.id);
-    _list.add(type);
   }
 
   /// Appends an arbitrary Type. May be called only once.
@@ -723,12 +724,13 @@
 
   /// Returns union of added types.
   Type toType() {
-    Type t = _type;
+    Type? t = _type;
     if (t == null) {
-      if (_list == null) {
+      final list = _list;
+      if (list == null) {
         t = const EmptyType();
       } else {
-        t = new SetType(_list);
+        t = SetType(list);
       }
     } else {
       assert(_list == null);
@@ -753,7 +755,7 @@
   static const int maxInvocationsPerSelector = 5000;
 
   int count = 0;
-  _Invocation approximation;
+  _Invocation? approximation;
 }
 
 /// Maintains ([Selector], [Args]) => [_Invocation] cache.
@@ -771,7 +773,7 @@
     _Invocation invocation = (selector is DirectSelector)
         ? new _DirectInvocation(selector, args)
         : new _DispatchableInvocation(selector, args);
-    _Invocation result = _invocations.lookup(invocation);
+    _Invocation? result = _invocations.lookup(invocation);
     if (result != null) {
       return result;
     }
@@ -784,14 +786,16 @@
       final sa = (_approximations[selector] ??= new _SelectorApproximation());
 
       if (sa.count >= _SelectorApproximation.maxInvocationsPerSelector) {
-        if (sa.approximation == null) {
+        _Invocation? approximation = sa.approximation;
+        if (approximation == null) {
           final rawArgs =
               _typeFlowAnalysis.summaryCollector.rawArguments(selector);
-          sa.approximation = new _DispatchableInvocation(selector, rawArgs);
+          sa.approximation =
+              approximation = _DispatchableInvocation(selector, rawArgs);
           Statistics.approximateInvocationsCreated++;
         }
         Statistics.approximateInvocationsUsed++;
-        return sa.approximation;
+        return approximation;
       }
 
       ++sa.count;
@@ -809,8 +813,8 @@
 class _FieldValue extends _DependencyTracker {
   final Field field;
   final Type staticType;
-  final Summary typeGuardSummary;
-  Type value;
+  final Summary? typeGuardSummary;
+  Type value = const EmptyType();
 
   /// Flag indicating if field initializer was executed.
   bool isInitialized = false;
@@ -825,8 +829,6 @@
       : staticType = typesBuilder.fromStaticType(field.type, true) {
     if (field.initializer == null && _isDefaultValueOfFieldObservable()) {
       value = new Type.nullable(const EmptyType());
-    } else {
-      value = const EmptyType();
     }
   }
 
@@ -839,8 +841,7 @@
       return true;
     }
 
-    final enclosingClass = field.enclosingClass;
-    assert(enclosingClass != null);
+    final enclosingClass = field.enclosingClass!;
 
     // Default value is not observable if every generative constructor
     // is redirecting or initializes the field.
@@ -856,10 +857,11 @@
     });
   }
 
-  void ensureInitialized(TypeFlowAnalysis typeFlowAnalysis, Type receiverType) {
+  void ensureInitialized(
+      TypeFlowAnalysis typeFlowAnalysis, Type? receiverType) {
     if (field.initializer != null) {
       assert(field.isStatic == (receiverType == null));
-      final args = !field.isStatic ? <Type>[receiverType] : const <Type>[];
+      final args = !field.isStatic ? <Type>[receiverType!] : const <Type>[];
       final initializerInvocation = typeFlowAnalysis._invocationsCache
           .getInvocation(
               new DirectSelector(field, callKind: CallKind.FieldInitializer),
@@ -870,17 +872,18 @@
     }
   }
 
-  Type getValue(TypeFlowAnalysis typeFlowAnalysis, Type receiverType) {
+  Type getValue(TypeFlowAnalysis typeFlowAnalysis, Type? receiverType) {
     ensureInitialized(typeFlowAnalysis, receiverType);
     addDependentInvocation(typeFlowAnalysis.currentInvocation);
+    final typeGuardSummary = this.typeGuardSummary;
     return (typeGuardSummary != null)
-        ? typeGuardSummary.apply(Args([receiverType, value]),
+        ? typeGuardSummary.apply(Args([receiverType!, value]),
             typeFlowAnalysis.hierarchyCache, typeFlowAnalysis)
         : value;
   }
 
   void setValue(
-      Type newValue, TypeFlowAnalysis typeFlowAnalysis, Type receiverType) {
+      Type newValue, TypeFlowAnalysis typeFlowAnalysis, Type? receiverType) {
     // Make sure type cones are specialized before putting them into field
     // value, in order to ensure that dependency is established between
     // cone's base type and corresponding field setter.
@@ -907,10 +910,11 @@
     //
     final hierarchy = typeFlowAnalysis.hierarchyCache;
     // TODO(sjindel/tfa): Perform narrowing inside 'TypeCheck'.
+    final typeGuardSummary = this.typeGuardSummary;
     final narrowedNewValue = typeGuardSummary != null
         ? typeGuardSummary
-            .apply(
-                new Args([receiverType, newValue]), hierarchy, typeFlowAnalysis)
+            .apply(new Args([receiverType!, newValue]), hierarchy,
+                typeFlowAnalysis)
             .intersection(staticType, hierarchy)
         : newValue.specialize(hierarchy).intersection(staticType, hierarchy);
     Type newType =
@@ -952,28 +956,26 @@
   /// Flag indicating if this class has a noSuchMethod() method not inherited
   /// from Object.
   /// Lazy initialized by ClassHierarchyCache.hasNonTrivialNoSuchMethod().
-  bool hasNonTrivialNoSuchMethod;
+  bool? hasNonTrivialNoSuchMethod;
 
   _TFClassImpl(int id, Class classNode, this.supertypes)
       : super(id, classNode) {
     supertypes.add(this);
   }
 
-  ConcreteType _concreteType;
-  ConcreteType get concreteType =>
-      _concreteType ??= new ConcreteType(this, null);
+  late final ConcreteType concreteType = ConcreteType(this, null);
 
-  Type _specializedConeType;
+  Type? _specializedConeType;
   Type get specializedConeType =>
       _specializedConeType ??= _calculateConeTypeSpecialization();
 
   bool get hasWideCone =>
       _allocatedSubtypes.length > maxAllocatedTypesInSetSpecializations;
 
-  WideConeType _wideConeType;
+  late final WideConeType _wideConeType = WideConeType(this);
   WideConeType get wideConeType {
     assert(hasWideCone);
-    return _wideConeType ??= new WideConeType(this);
+    return _wideConeType;
   }
 
   Type _calculateConeTypeSpecialization() {
@@ -999,14 +1001,16 @@
     _specializedConeType = null; // Reset cached specialization.
   }
 
-  Member getDispatchTarget(
+  Member? getDispatchTarget(
       Selector selector, TypeFlowAnalysis typeFlowAnalysis) {
-    Member target = _dispatchTargets[selector];
+    Member? target = _dispatchTargets[selector];
     if (target == null) {
       target = typeFlowAnalysis.hierarchyCache.hierarchy.getDispatchTarget(
           classNode, selector.name,
           setter: selector.isSetter);
-      _dispatchTargets[selector] = target;
+      if (target != null) {
+        _dispatchTargets[selector] = target;
+      }
     }
     return target;
   }
@@ -1021,10 +1025,11 @@
   final cachedFlattenedTypeArgs = <Class, List<DartType>>{};
   final cachedFlattenedTypeArgsForNonGeneric = <Class, List<Type>>{};
 
-  RuntimeTypeTranslatorImpl closedTypeTranslator;
+  late final RuntimeTypeTranslatorImpl closedTypeTranslator;
 
-  GenericInterfacesInfoImpl(this.hierarchy) {
-    closedTypeTranslator = RuntimeTypeTranslatorImpl.forClosedTypes(this);
+  GenericInterfacesInfoImpl(CoreTypes coreTypes, this.hierarchy) {
+    closedTypeTranslator =
+        RuntimeTypeTranslatorImpl.forClosedTypes(coreTypes, this);
   }
 
   List<DartType> flattenedTypeArgumentsFor(Class klass, {bool useCache: true}) {
@@ -1049,7 +1054,7 @@
     if (klass == iface) return 0;
 
     final pair = new SubtypePair(klass, iface);
-    int offset = supertypeOffsetsCache[pair];
+    int? offset = supertypeOffsetsCache[pair];
 
     if (offset != null) return offset;
 
@@ -1064,16 +1069,16 @@
   }
 
   List<Type> flattenedTypeArgumentsForNonGeneric(Class klass) {
-    List<Type> result = cachedFlattenedTypeArgsForNonGeneric[klass];
+    List<Type>? result = cachedFlattenedTypeArgsForNonGeneric[klass];
     if (result != null) return result;
 
     List<DartType> flattenedTypeArgs =
         flattenedTypeArgumentsFor(klass, useCache: false);
-    result = new List<Type>.filled(flattenedTypeArgs.length, null);
-    for (int i = 0; i < flattenedTypeArgs.length; ++i) {
-      final translated = closedTypeTranslator.translate(flattenedTypeArgs[i]);
+    result = <Type>[];
+    for (DartType arg in flattenedTypeArgs) {
+      final translated = closedTypeTranslator.translate(arg);
       assert(translated is RuntimeType || translated is UnknownType);
-      result[i] = translated;
+      result.add(translated as Type);
     }
     cachedFlattenedTypeArgsForNonGeneric[klass] = result;
     return result;
@@ -1108,10 +1113,8 @@
   _ClassHierarchyCache(this._typeFlowAnalysis, this.hierarchy,
       this.genericInterfacesInfo, this.environment, bool nullSafety)
       : objectNoSuchMethod = hierarchy.getDispatchTarget(
-            environment.coreTypes.objectClass, noSuchMethodName),
-        super(environment.coreTypes, nullSafety) {
-    assert(objectNoSuchMethod != null);
-  }
+            environment.coreTypes.objectClass, noSuchMethodName)!,
+        super(environment.coreTypes, nullSafety);
 
   @override
   _TFClassImpl getTFClass(Class c) {
@@ -1198,10 +1201,13 @@
 
   bool hasNonTrivialNoSuchMethod(TFClass c) {
     final classImpl = c as _TFClassImpl;
-    classImpl.hasNonTrivialNoSuchMethod ??=
-        (hierarchy.getDispatchTarget(c.classNode, noSuchMethodName) !=
-            objectNoSuchMethod);
-    return classImpl.hasNonTrivialNoSuchMethod;
+    bool? value = classImpl.hasNonTrivialNoSuchMethod;
+    if (value == null) {
+      classImpl.hasNonTrivialNoSuchMethod = value =
+          (hierarchy.getDispatchTarget(c.classNode, noSuchMethodName) !=
+              objectNoSuchMethod);
+    }
+    return value;
   }
 
   _DynamicTargetSet getDynamicTargetSet(DynamicSelector selector) {
@@ -1294,10 +1300,11 @@
   }
 
   bool invalidateProtobufFields() {
-    if (_typeFlowAnalysis.protobufHandler == null) {
+    final protobufHandler = _typeFlowAnalysis.protobufHandler;
+    if (protobufHandler == null) {
       return false;
     }
-    final fields = _typeFlowAnalysis.protobufHandler.getInvalidatedFields();
+    final fields = protobufHandler.getInvalidatedFields();
     if (fields.isEmpty) {
       return false;
     }
@@ -1305,7 +1312,7 @@
     for (var field in fields) {
       assert(field.isStatic);
       // Reset summary in order to rebuild it.
-      _typeFlowAnalysis._summaries[field] = null;
+      _typeFlowAnalysis._summaries.remove(field);
       // Invalidate (and enqueue) field initializer invocation.
       final initializerInvocation = _typeFlowAnalysis._invocationsCache
           .getInvocation(
@@ -1328,10 +1335,11 @@
   }
 
   Type processInvocation(_Invocation invocation) {
-    if (invocation.result != null) {
+    Type? result = invocation.result;
+    if (result != null) {
       // Already processed.
       Statistics.usedCachedResultsOfInvocations++;
-      return invocation.result;
+      return result;
     }
 
     // Test if tracing is enabled to avoid expensive message formatting.
@@ -1374,18 +1382,18 @@
               -1);
         }
         processing.remove(invocation);
-        return invocation.invalidatedResult;
+        return invocation.invalidatedResult!;
       }
 
       callStack.add(invocation);
       pending.remove(invocation);
 
-      Type result = invocation.process(_typeFlowAnalysis);
+      result = invocation.process(_typeFlowAnalysis);
 
       invocation.setResult(_typeFlowAnalysis, result);
 
       // setResult may saturate result to ensure convergence.
-      result = invocation.result;
+      result = invocation.result!;
 
       // Invocation is still pending - it was invalidated while being processed.
       // Move result to invalidatedResult.
@@ -1434,12 +1442,12 @@
   final TypeEnvironment environment;
   final LibraryIndex libraryIndex;
   final PragmaAnnotationParser annotationMatcher;
-  final ProtobufHandler protobufHandler;
-  NativeCodeOracle nativeCodeOracle;
-  _ClassHierarchyCache hierarchyCache;
-  SummaryCollector summaryCollector;
-  _InvocationsCache _invocationsCache;
-  _WorkList workList;
+  final ProtobufHandler? protobufHandler;
+  late NativeCodeOracle nativeCodeOracle;
+  late _ClassHierarchyCache hierarchyCache;
+  late SummaryCollector summaryCollector;
+  late _InvocationsCache _invocationsCache;
+  late _WorkList workList;
   GenericInterfacesInfo _genericInterfacesInfo;
 
   final Map<Member, Summary> _summaries = <Member, Summary>{};
@@ -1459,7 +1467,7 @@
       this.environment,
       this.libraryIndex,
       this.protobufHandler,
-      PragmaAnnotationParser matcher)
+      PragmaAnnotationParser? matcher)
       : annotationMatcher =
             matcher ?? new ConstantPragmaAnnotationParser(coreTypes) {
     nativeCodeOracle = new NativeCodeOracle(libraryIndex, annotationMatcher);
@@ -1488,9 +1496,9 @@
   }
 
   _FieldValue getFieldValue(Field field) {
-    _FieldValue fieldValue = _fieldValues[field];
+    _FieldValue? fieldValue = _fieldValues[field];
     if (fieldValue == null) {
-      Summary typeGuardSummary = null;
+      Summary? typeGuardSummary = null;
       if (field.isGenericCovariantImpl) {
         typeGuardSummary = summaryCollector.createSummary(field,
             fieldSummaryType: FieldSummaryType.kFieldGuard);
@@ -1548,24 +1556,24 @@
 
   bool isClassAllocated(Class c) => hierarchyCache.allocatedClasses.contains(c);
 
-  Call callSite(TreeNode node) => summaryCollector.callSites[node];
+  Call? callSite(TreeNode node) => summaryCollector.callSites[node];
 
-  TypeCheck explicitCast(AsExpression cast) =>
+  TypeCheck? explicitCast(AsExpression cast) =>
       summaryCollector.explicitCasts[cast];
 
-  TypeCheck isTest(IsExpression node) => summaryCollector.isTests[node];
+  TypeCheck? isTest(IsExpression node) => summaryCollector.isTests[node];
 
-  NarrowNotNull nullTest(TreeNode node) => summaryCollector.nullTests[node];
+  NarrowNotNull? nullTest(TreeNode node) => summaryCollector.nullTests[node];
 
-  Type fieldType(Field field) => _fieldValues[field]?.value;
+  Type? fieldType(Field field) => _fieldValues[field]?.value;
 
-  Args<Type> argumentTypes(Member member) => _summaries[member]?.argumentTypes;
+  Args<Type>? argumentTypes(Member member) => _summaries[member]?.argumentTypes;
 
-  Type argumentType(Member member, VariableDeclaration memberParam) {
+  Type? argumentType(Member member, VariableDeclaration memberParam) {
     return _summaries[member]?.argumentType(member, memberParam);
   }
 
-  List<VariableDeclaration> uncheckedParameters(Member member) =>
+  List<VariableDeclaration>? uncheckedParameters(Member member) =>
       _summaries[member]?.uncheckedParameters;
 
   bool isTearOffTaken(Member member) => _tearOffTaken.contains(member);
@@ -1599,7 +1607,7 @@
   /// ---- Implementation of [CallHandler] interface. ----
 
   @override
-  Type applyCall(Call callSite, Selector selector, Args<Type> args,
+  Type applyCall(Call? callSite, Selector selector, Args<Type> args,
       {bool isResultUsed: true, bool processImmediately: true}) {
     _Invocation invocation = _invocationsCache.getInvocation(selector, args);
 
@@ -1629,7 +1637,7 @@
         workList.enqueueInvocation(invocation);
       }
 
-      return null;
+      return const EmptyType();
     }
   }
 
@@ -1680,7 +1688,7 @@
   }
 
   @override
-  void recordTearOff(Procedure target) {
+  void recordTearOff(Member target) {
     _tearOffTaken.add(target);
   }
 }
diff --git a/pkg/vm/lib/transformations/type_flow/calls.dart b/pkg/vm/lib/transformations/type_flow/calls.dart
index 060500a..dd16279d 100644
--- a/pkg/vm/lib/transformations/type_flow/calls.dart
+++ b/pkg/vm/lib/transformations/type_flow/calls.dart
@@ -2,10 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Declares classes which describe a call: selectors and arguments.
-library vm.transformations.type_flow.calls;
 
 import 'dart:core' hide Type;
 
@@ -30,10 +27,10 @@
   Selector(this.callKind);
 
   /// Interface or concrete target, may be null.
-  Member get member;
+  Member? get member;
 
   /// Selector name.
-  Name get name => member.name;
+  Name get name => member!.name;
 
   bool get isSetter => (callKind == CallKind.PropertySet);
 
@@ -46,6 +43,7 @@
 
   /// Static approximation of Dart return type.
   DartType get staticReturnType {
+    final member = this.member;
     if (member == null) {
       return const DynamicType();
     }
@@ -61,7 +59,6 @@
       case CallKind.SetFieldInConstructor:
         return const NeverType.nonNullable();
     }
-    return null;
   }
 
   bool memberAgreesToCallKind(Member member) {
@@ -79,7 +76,6 @@
       case CallKind.SetFieldInConstructor:
         return member is Field;
     }
-    return false;
   }
 
   String get _callKindPrefix {
@@ -94,7 +90,6 @@
       case CallKind.FieldInitializer:
         return 'init ';
     }
-    return '';
   }
 }
 
@@ -169,7 +164,7 @@
   DynamicSelector(CallKind callKind, this.name) : super(callKind);
 
   @override
-  Member get member => null;
+  Member? get member => null;
 
   @override
   int get hashCode => (super.hashCode ^ name.hashCode + 37) & kHashMask;
@@ -189,7 +184,8 @@
   final List<T> values;
   final List<String> names;
 
-  int _hashCode;
+  @override
+  late final int hashCode = _computeHashCode();
 
   Args(this.values, {this.names = const <String>[]}) {
     assert(isSorted(names));
@@ -206,9 +202,6 @@
 
   T get receiver => values[0];
 
-  @override
-  int get hashCode => _hashCode ??= _computeHashCode();
-
   int _computeHashCode() {
     int hash = 1231;
     for (var v in values) {
diff --git a/pkg/vm/lib/transformations/type_flow/native_code.dart b/pkg/vm/lib/transformations/type_flow/native_code.dart
index 7a5baf9..0611379 100644
--- a/pkg/vm/lib/transformations/type_flow/native_code.dart
+++ b/pkg/vm/lib/transformations/type_flow/native_code.dart
@@ -2,10 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Handling of native code and entry points.
-library vm.transformations.type_flow.native_code;
 
 import 'dart:core' hide Type;
 
@@ -35,24 +32,21 @@
   /// Record the fact that given member is called from this.
   void recordMemberCalledViaThis(Member target);
 
-  /// Record the fact that given method is torn off.
-  void recordTearOff(Procedure target) {}
+  /// Record the fact that given member is torn off.
+  void recordTearOff(Member target) {}
 }
 
 class PragmaEntryPointsVisitor extends RecursiveVisitor {
   final EntryPointsListener entryPoints;
   final NativeCodeOracle nativeCodeOracle;
   final PragmaAnnotationParser matcher;
-  Class currentClass = null;
 
   PragmaEntryPointsVisitor(
-      this.entryPoints, this.nativeCodeOracle, this.matcher) {
-    assert(matcher != null);
-  }
+      this.entryPoints, this.nativeCodeOracle, this.matcher);
 
-  PragmaEntryPointType _annotationsDefineRoot(List<Expression> annotations) {
+  PragmaEntryPointType? _annotationsDefineRoot(List<Expression> annotations) {
     for (var annotation in annotations) {
-      ParsedPragma pragma = matcher.parsePragma(annotation);
+      ParsedPragma? pragma = matcher.parsePragma(annotation);
       if (pragma == null) continue;
       if (pragma is ParsedEntryPointPragma) return pragma.type;
     }
@@ -72,7 +66,6 @@
       }
       nativeCodeOracle.addClassReferencedFromNativeCode(klass);
     }
-    currentClass = klass;
     klass.visitChildren(this);
   }
 
@@ -88,8 +81,7 @@
       }
       Member target = proc;
       while (target is Procedure && target.isRedirectingFactory) {
-        target = getRedirectingFactoryBody(target).target;
-        assert(target != null);
+        target = getRedirectingFactoryBody(target)!.target!;
         assert(
             (target is Procedure && target.isFactory) || target is Constructor);
       }
@@ -152,7 +144,7 @@
       }
       entryPoints
           .addRawCall(new DirectSelector(ctor, callKind: CallKind.Method));
-      entryPoints.addAllocatedClass(currentClass);
+      entryPoints.addAllocatedClass(ctor.enclosingClass);
       nativeCodeOracle.setMemberReferencedFromNativeCode(ctor);
     }
   }
@@ -201,9 +193,7 @@
   final Set<Class> _classesReferencedFromNativeCode = new Set<Class>();
   final PragmaAnnotationParser _matcher;
 
-  NativeCodeOracle(this._libraryIndex, this._matcher) {
-    assert(_matcher != null);
-  }
+  NativeCodeOracle(this._libraryIndex, this._matcher);
 
   void addClassReferencedFromNativeCode(Class klass) {
     _classesReferencedFromNativeCode.add(klass);
@@ -219,9 +209,9 @@
   bool isMemberReferencedFromNativeCode(Member member) =>
       _membersReferencedFromNativeCode.contains(member);
 
-  PragmaRecognizedType recognizedType(Member member) {
+  PragmaRecognizedType? recognizedType(Member member) {
     for (var annotation in member.annotations) {
-      ParsedPragma pragma = _matcher.parsePragma(annotation);
+      ParsedPragma? pragma = _matcher.parsePragma(annotation);
       if (pragma is ParsedRecognized) {
         return pragma.type;
       }
@@ -229,15 +219,16 @@
     return null;
   }
 
-  bool isRecognized(Member member, [List<PragmaRecognizedType> expectedTypes]) {
-    PragmaRecognizedType type = recognizedType(member);
+  bool isRecognized(Member member,
+      [List<PragmaRecognizedType>? expectedTypes]) {
+    PragmaRecognizedType? type = recognizedType(member);
     return type != null &&
         (expectedTypes == null || expectedTypes.contains(type));
   }
 
   bool hasDisableUnboxedParameters(Member member) {
     for (var annotation in member.annotations) {
-      ParsedPragma pragma = _matcher.parsePragma(annotation);
+      ParsedPragma? pragma = _matcher.parsePragma(annotation);
       if (pragma is ParsedDisableUnboxedParameters) {
         if (member.enclosingLibrary.importUri.scheme != "dart") {
           throw "ERROR: Cannot use @pragma(vm:disable-unboxed-parameters) outside core libraries.";
@@ -255,11 +246,11 @@
       EntryPointsListener entryPointsListener,
       TypesBuilder typesBuilder,
       RuntimeTypeTranslator translator) {
-    TypeExpr returnType = null;
-    bool nullable = null;
+    TypeExpr? returnType = null;
+    bool? nullable = null;
 
     for (var annotation in member.annotations) {
-      ParsedPragma pragma = _matcher.parsePragma(annotation);
+      ParsedPragma? pragma = _matcher.parsePragma(annotation);
       if (pragma == null) continue;
       if (pragma is ParsedResultTypeByTypePragma ||
           pragma is ParsedResultTypeByPathPragma ||
@@ -278,8 +269,8 @@
           returnType = entryPointsListener.addAllocatedClass(type.classNode);
           if (pragma.resultTypeUsesPassedTypeArguments) {
             returnType = translator.instantiateConcreteType(
-                returnType,
-                member.function.typeParameters
+                returnType as ConcreteType,
+                member.function!.typeParameters
                     .map((t) => TypeParameterType(
                         t, TypeParameterType.computeNullabilityFromBound(t)))
                     .toList());
@@ -314,7 +305,7 @@
       return returnType;
     } else {
       return typesBuilder.fromStaticType(
-          member.function.returnType, nullable ?? true);
+          member.function!.returnType, nullable ?? true);
     }
   }
 }
diff --git a/pkg/vm/lib/transformations/type_flow/protobuf_handler.dart b/pkg/vm/lib/transformations/type_flow/protobuf_handler.dart
index a4b0bbc..c0175a4 100644
--- a/pkg/vm/lib/transformations/type_flow/protobuf_handler.dart
+++ b/pkg/vm/lib/transformations/type_flow/protobuf_handler.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/ast.dart';
 import 'package:kernel/clone.dart' show CloneVisitorNotMembers;
 import 'package:kernel/core_types.dart' show CoreTypes;
@@ -47,14 +45,14 @@
   final Procedure _builderInfoAddMethod;
 
   // Type of BuilderInfo.add<Null>().
-  FunctionType _typeOfBuilderInfoAddOfNull;
+  late FunctionType _typeOfBuilderInfoAddOfNull;
 
   final _messageClasses = <Class, _MessageClass>{};
   final _invalidatedClasses = <_MessageClass>{};
 
   /// Creates [ProtobufHandler] instance for [component].
   /// Returns null if protobuf library is not used.
-  static ProtobufHandler forComponent(
+  static ProtobufHandler? forComponent(
       Component component, CoreTypes coreTypes) {
     final libraryIndex = LibraryIndex(component, [protobufLibraryUri]);
     if (!libraryIndex.containsLibrary(protobufLibraryUri)) {
@@ -68,12 +66,12 @@
             libraryIndex.getClass(protobufLibraryUri, 'GeneratedMessage'),
         _tagNumberClass =
             libraryIndex.getClass(protobufLibraryUri, 'TagNumber'),
-        _tagNumberField = libraryIndex.getMember(
-            protobufLibraryUri, 'TagNumber', 'tagNumber'),
+        _tagNumberField =
+            libraryIndex.getField(protobufLibraryUri, 'TagNumber', 'tagNumber'),
         _builderInfoClass =
             libraryIndex.getClass(protobufLibraryUri, 'BuilderInfo'),
-        _builderInfoAddMethod =
-            libraryIndex.getMember(protobufLibraryUri, 'BuilderInfo', 'add') {
+        _builderInfoAddMethod = libraryIndex.getProcedure(
+            protobufLibraryUri, 'BuilderInfo', 'add') {
     final functionType = _builderInfoAddMethod.getterType as FunctionType;
     _typeOfBuilderInfoAddOfNull = Substitution.fromPairs(
             functionType.typeParameters, const <DartType>[NullType()])
@@ -130,8 +128,9 @@
   List<Field> getInvalidatedFields() {
     final fields = <Field>[];
     for (var cls in _invalidatedClasses) {
-      if (cls._metadataField != null) {
-        fields.add(cls._metadataField);
+      final field = cls._metadataField;
+      if (field != null) {
+        fields.add(field);
       }
     }
     _invalidatedClasses.clear();
@@ -143,14 +142,15 @@
     ++Statistics.protobufMetadataInitializersUpdated;
     Statistics.protobufMetadataFieldsPruned -= cls.numberOfFieldsPruned;
 
-    final field = cls._metadataField;
-    if (cls._originalInitializer == null) {
-      cls._originalInitializer = field.initializer;
+    final field = cls._metadataField!;
+    Expression? originalInitializer = cls._originalInitializer;
+    if (originalInitializer == null) {
+      cls._originalInitializer = originalInitializer = field.initializer!;
     }
     final cloner = CloneVisitorNotMembers();
-    field.initializer = cloner.clone(cls._originalInitializer)..parent = field;
+    field.initializer = cloner.clone(originalInitializer)..parent = field;
     final transformer = _MetadataTransformer(this, cls);
-    field.initializer.accept(transformer);
+    field.initializer!.accept(transformer);
     _invalidatedClasses.remove(cls);
 
     cls.numberOfFieldsPruned = transformer.numberOfFieldsPruned;
@@ -168,8 +168,8 @@
 }
 
 class _MessageClass {
-  Field _metadataField;
-  Expression _originalInitializer;
+  Field? _metadataField;
+  Expression? _originalInitializer;
   final _usedTags = <int>{};
   int numberOfFieldsPruned = 0;
 }
diff --git a/pkg/vm/lib/transformations/type_flow/signature_shaking.dart b/pkg/vm/lib/transformations/type_flow/signature_shaking.dart
index a61e222..5ae2e16 100644
--- a/pkg/vm/lib/transformations/type_flow/signature_shaking.dart
+++ b/pkg/vm/lib/transformations/type_flow/signature_shaking.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/ast.dart';
 import 'package:kernel/external_name.dart';
 import 'package:kernel/type_environment.dart';
@@ -57,7 +55,7 @@
 
   SignatureShaker(this.typeFlowAnalysis, this.tableSelectorAssigner);
 
-  _ProcedureInfo _infoForMember(Member member) {
+  _ProcedureInfo? _infoForMember(Member member) {
     if (!(member is Procedure &&
             (member.kind == ProcedureKind.Method ||
                 member.kind == ProcedureKind.Factory) ||
@@ -89,7 +87,7 @@
     }
     while (worklist.isNotEmpty) {
       _ParameterInfo param = worklist.removeLast();
-      for (_ParameterInfo dependencyParam in param.useDependencies) {
+      for (_ParameterInfo dependencyParam in param.useDependencies!) {
         if (!dependencyParam.isRead) {
           dependencyParam.isRead = true;
           if (dependencyParam.useDependencies != null) {
@@ -141,7 +139,7 @@
     return positional.any((param) =>
             param.canBeEliminated ||
             (param.isAlwaysPassed &&
-                param.index >= function.requiredParameterCount)) ||
+                param.index! >= function.requiredParameterCount)) ||
         named.values
             .any((param) => param.canBeEliminated || param.isAlwaysPassed);
   }
@@ -149,7 +147,7 @@
 
 class _ParameterInfo {
   final _ProcedureInfo info;
-  final int index;
+  final int? index;
 
   int passCount = 0;
   bool isRead = false;
@@ -160,7 +158,7 @@
   /// List of parameter variables which were passed as arguments via this
   /// parameter. When this parameter is considered used, all [useDependencies]
   /// parameters should be transitively marked as read.
-  List<_ParameterInfo> useDependencies = null;
+  List<_ParameterInfo>? useDependencies = null;
 
   _ParameterInfo(this.info, this.index);
 
@@ -177,7 +175,7 @@
 
   void observeParameter(
       Member member, VariableDeclaration param, SignatureShaker shaker) {
-    final Type type = shaker.typeFlowAnalysis.argumentType(member, param);
+    final Type? type = shaker.typeFlowAnalysis.argumentType(member, param);
 
     // A parameter is considered constant if the TFA has inferred it to have a
     // constant value in every implementation. The constant value inferred does
@@ -214,19 +212,19 @@
   _Collect(this.shaker);
 
   void enterFunction(Member member) {
-    final _ProcedureInfo info = shaker._infoForMember(member);
+    final _ProcedureInfo? info = shaker._infoForMember(member);
     if (info == null) return;
 
     localParameters.clear();
     useDependencies.clear();
-    final FunctionNode fun = member.function;
+    final FunctionNode fun = member.function!;
     for (int i = 0; i < fun.positionalParameters.length; i++) {
       final VariableDeclaration param = fun.positionalParameters[i];
       localParameters[param] = info.ensurePositional(i)
         ..observeParameter(member, param, shaker);
     }
     for (VariableDeclaration param in fun.namedParameters) {
-      localParameters[param] = info.ensureNamed(param.name)
+      localParameters[param] = info.ensureNamed(param.name!)
         ..observeParameter(member, param, shaker);
     }
 
@@ -270,19 +268,22 @@
 
   void addUseDependency(Expression arg, _ParameterInfo param) {
     if (arg is VariableGet) {
-      _ParameterInfo localParam = localParameters[arg.variable];
+      _ParameterInfo? localParam = localParameters[arg.variable];
       if (localParam != null && !localParam.isUsed) {
         // This is a parameter passed as an argument. Mark it as a use
         // dependency.
-        param.useDependencies ??= [];
-        param.useDependencies.add(localParam);
+        var paramUseDependencies = param.useDependencies;
+        if (paramUseDependencies == null) {
+          param.useDependencies = paramUseDependencies = [];
+        }
+        paramUseDependencies.add(localParam);
         useDependencies.add(arg);
       }
     }
   }
 
   void collectCall(Member member, Arguments args) {
-    final _ProcedureInfo info = shaker._infoForMember(member);
+    final _ProcedureInfo? info = shaker._infoForMember(member);
     if (info == null) return;
 
     for (int i = 0; i < args.positional.length; i++) {
@@ -306,7 +307,10 @@
 
   @override
   void visitSuperMethodInvocation(SuperMethodInvocation node) {
-    collectCall(node.interfaceTarget, node.arguments);
+    final interfaceTarget = node.interfaceTarget;
+    if (interfaceTarget != null) {
+      collectCall(interfaceTarget, node.arguments);
+    }
     super.visitSuperMethodInvocation(node);
   }
 
@@ -338,7 +342,7 @@
 class _Transform extends RecursiveVisitor {
   final SignatureShaker shaker;
 
-  StaticTypeContext typeContext;
+  late StaticTypeContext typeContext;
   final Map<VariableDeclaration, Constant> eliminatedParams = {};
   final Set<VariableDeclaration> unusedParams = {};
   final List<LocalInitializer> addedInitializers = [];
@@ -349,16 +353,15 @@
       Member member, _ParameterInfo param, VariableDeclaration variable) {
     Constant value;
     if (param.isConstant) {
-      Type type = shaker.typeFlowAnalysis.argumentType(member, variable);
+      Type type = shaker.typeFlowAnalysis.argumentType(member, variable)!;
       if (type is ConcreteType) {
-        assert(type.constant != null);
-        value = type.constant;
+        value = type.constant!;
       } else {
         assert(type is NullableType && type.baseType is EmptyType);
         value = NullConstant();
       }
     } else {
-      value = (variable.initializer as ConstantExpression)?.constant ??
+      value = (variable.initializer as ConstantExpression?)?.constant ??
           NullConstant();
     }
     eliminatedParams[variable] = value;
@@ -370,10 +373,10 @@
     eliminatedParams.clear();
     unusedParams.clear();
 
-    final _ProcedureInfo info = shaker._infoForMember(member);
+    final _ProcedureInfo? info = shaker._infoForMember(member);
     if (info == null || !info.eligible || info.callCount == 0) return;
 
-    final FunctionNode function = member.function;
+    final FunctionNode function = member.function!;
 
     if (!info.transformNeeded(function)) return;
 
@@ -404,9 +407,9 @@
     //    as required positional parameters, alphabetically by name.
     final List<VariableDeclaration> sortedNamed = function.namedParameters
         .toList()
-      ..sort((var1, var2) => var1.name.compareTo(var2.name));
+      ..sort((var1, var2) => var1.name!.compareTo(var2.name!));
     for (VariableDeclaration variable in sortedNamed) {
-      final _ParameterInfo param = info.named[variable.name];
+      final _ParameterInfo param = info.named[variable.name!]!;
       if (param.isAlwaysPassed) {
         if (param.isUsed) {
           if (param.canBeEliminated) {
@@ -451,7 +454,7 @@
     // 4. All named parameters that are not always passed and can't be
     //    eliminated, as named parameters in alphabetical order.
     for (VariableDeclaration variable in sortedNamed) {
-      final _ParameterInfo param = info.named[variable.name];
+      final _ParameterInfo param = info.named[variable.name!]!;
       if (!param.isAlwaysPassed) {
         if (param.isUsed) {
           if (param.canBeEliminated) {
@@ -475,7 +478,7 @@
 
   @override
   void visitVariableGet(VariableGet node) {
-    Constant constantValue = eliminatedParams[node.variable];
+    Constant? constantValue = eliminatedParams[node.variable];
     if (constantValue != null) {
       node.replaceWith(ConstantExpression(constantValue));
     }
@@ -511,7 +514,7 @@
       void Function(Expression, _ParameterInfo) fun) {
     for (int i = args.named.length - 1; i >= 0; i--) {
       final NamedExpression namedExp = args.named[i];
-      fun(namedExp.value, info.named[namedExp.name]);
+      fun(namedExp.value, info.named[namedExp.name]!);
     }
     for (int i = args.positional.length - 1; i >= 0; i--) {
       fun(args.positional[i], info.positional[i]);
@@ -519,8 +522,8 @@
   }
 
   void transformCall(
-      Member target, TreeNode call, Expression receiver, Arguments args) {
-    final _ProcedureInfo info = shaker._infoForMember(target);
+      Member target, TreeNode call, Expression? receiver, Arguments args) {
+    final _ProcedureInfo? info = shaker._infoForMember(target);
     if (info == null || !info.eligible) return;
 
     bool transformNeeded = false;
@@ -544,7 +547,7 @@
     Map<Expression, VariableDeclaration> hoisted = {};
     if (hoistingNeeded) {
       if (call is Initializer) {
-        final Constructor constructor = call.parent;
+        final Constructor constructor = call.parent as Constructor;
         forEachArgumentRev(args, info, (Expression arg, _ParameterInfo param) {
           if (mayHaveOrSeeSideEffects(arg) && !isUnusedParam(arg)) {
             VariableDeclaration argVar = VariableDeclaration(null,
@@ -557,8 +560,8 @@
           }
         });
       } else {
-        final TreeNode parent = call.parent;
-        Expression current = call;
+        final TreeNode parent = call.parent!;
+        Expression current = call as Expression;
         forEachArgumentRev(args, info, (Expression arg, _ParameterInfo param) {
           if (mayHaveOrSeeSideEffects(arg) && !isUnusedParam(arg)) {
             VariableDeclaration argVar = VariableDeclaration(null,
@@ -606,7 +609,7 @@
     final List<NamedExpression> sortedNamed = args.named.toList()
       ..sort((var1, var2) => var1.name.compareTo(var2.name));
     for (NamedExpression arg in sortedNamed) {
-      final _ParameterInfo param = info.named[arg.name];
+      final _ParameterInfo param = info.named[arg.name]!;
       if (param.isAlwaysPassed && !param.canBeEliminated) {
         positional.add(getMaybeHoistedArg(arg.value));
       }
@@ -625,7 +628,7 @@
     //    eliminated, as named parameters in alphabetical order.
     //    (Arguments are kept in original order.)
     for (NamedExpression arg in args.named) {
-      final _ParameterInfo param = info.named[arg.name];
+      final _ParameterInfo param = info.named[arg.name]!;
       if (!param.isAlwaysPassed && !param.canBeEliminated) {
         arg.value = getMaybeHoistedArg(arg.value)..parent = arg;
         named.add(arg);
@@ -644,7 +647,10 @@
   @override
   void visitSuperMethodInvocation(SuperMethodInvocation node) {
     super.visitSuperMethodInvocation(node);
-    transformCall(node.interfaceTarget, node, null, node.arguments);
+    final interfaceTarget = node.interfaceTarget;
+    if (interfaceTarget != null) {
+      transformCall(interfaceTarget, node, null, node.arguments);
+    }
   }
 
   @override
diff --git a/pkg/vm/lib/transformations/type_flow/summary.dart b/pkg/vm/lib/transformations/type_flow/summary.dart
index dcae2df..fb18cec 100644
--- a/pkg/vm/lib/transformations/type_flow/summary.dart
+++ b/pkg/vm/lib/transformations/type_flow/summary.dart
@@ -2,10 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Type flow summary of a member, function or initializer.
-library vm.transformations.type_flow.summary;
 
 import 'dart:core' hide Type;
 
@@ -18,7 +15,7 @@
 
 abstract class CallHandler {
   Type applyCall(Call callSite, Selector selector, Args<Type> args,
-      {bool isResultUsed});
+      {required bool isResultUsed});
   void typeCheckTriggered();
   void addAllocatedClass(Class c);
 }
@@ -27,14 +24,10 @@
 abstract class Statement extends TypeExpr {
   /// Index of this statement in the [Summary].
   int index = -1;
-  Summary summary;
+  late Summary summary;
 
   @override
-  Type getComputedType(List<Type> types) {
-    final type = types[index];
-    assert(type != null);
-    return type;
-  }
+  Type getComputedType(List<Type?> types) => types[index]!;
 
   String get label => "t$index";
 
@@ -48,7 +41,7 @@
   void accept(StatementVisitor visitor);
 
   /// Execute this statement and compute its resulting type.
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
       CallHandler callHandler);
 }
 
@@ -74,9 +67,9 @@
   // [staticType] is null if no narrowing should be performed. This happens for
   // type parameters and for parameters whose type is narrowed by a [TypeCheck]
   // statement.
-  final Type staticTypeForNarrowing;
+  final Type? staticTypeForNarrowing;
 
-  Type defaultValue;
+  Type? defaultValue;
   Type _argumentType = const EmptyType();
 
   Parameter(this.name, this.staticTypeForNarrowing);
@@ -97,7 +90,7 @@
   }
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
           CallHandler callHandler) =>
       throw 'Unable to apply _Parameter';
 
@@ -110,7 +103,7 @@
   }
 
   Type _observeNotPassed(TypeHierarchy typeHierarchy) {
-    final Type argType = defaultValue.specialize(typeHierarchy);
+    final Type argType = defaultValue!.specialize(typeHierarchy);
     _observeArgumentType(argType, typeHierarchy);
     return argType;
   }
@@ -130,7 +123,7 @@
   String dump() => "$label = _Narrow ($arg to $type)";
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
           CallHandler callHandler) =>
       arg.getComputedType(computedTypes).intersection(type, typeHierarchy);
 }
@@ -147,11 +140,11 @@
 
   // Shared NarrowNotNull instances which are used when the outcome is
   // known at summary creation time.
-  static final NarrowNotNull alwaysNotNull = NarrowNotNull(null)
+  static final NarrowNotNull alwaysNotNull = NarrowNotNull(const EmptyType())
     .._flags = canBeNotNullFlag;
-  static final NarrowNotNull alwaysNull = NarrowNotNull(null)
+  static final NarrowNotNull alwaysNull = NarrowNotNull(const EmptyType())
     .._flags = canBeNullFlag;
-  static final NarrowNotNull unknown = NarrowNotNull(null)
+  static final NarrowNotNull unknown = NarrowNotNull(const EmptyType())
     .._flags = canBeNullFlag | canBeNotNullFlag;
 
   bool get isAlwaysNull => (_flags & canBeNotNullFlag) == 0;
@@ -173,14 +166,14 @@
   }
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
           CallHandler callHandler) =>
       handleArgument(arg.getComputedType(computedTypes));
 }
 
 /// Joins values from multiple sources. Its type is a union of [values].
 class Join extends Statement {
-  final String _name;
+  final String? _name;
   final DartType staticType;
   final List<TypeExpr> values = <TypeExpr>[]; // TODO(alexmarkov): Set
 
@@ -197,15 +190,14 @@
       " (${values.join(", ")})";
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
       CallHandler callHandler) {
-    Type type = null;
-    assert(values.isNotEmpty);
+    Type? type = null;
     for (var value in values) {
       final valueType = value.getComputedType(computedTypes);
       type = type != null ? type.union(valueType, typeHierarchy) : valueType;
     }
-    return type;
+    return type!;
   }
 }
 
@@ -222,7 +214,7 @@
   String dump() => "$label = _Use ($arg)";
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
           CallHandler callHandler) =>
       throw 'Use statements should be removed during summary normalization';
 }
@@ -231,7 +223,7 @@
 class Call extends Statement {
   final Selector selector;
   final Args<TypeExpr> args;
-  final Type staticResultType;
+  final Type? staticResultType;
 
   Call(this.selector, this.args, this.staticResultType,
       bool isInstanceCreation) {
@@ -252,9 +244,10 @@
   String dump() => "$label${isResultUsed ? '*' : ''} = _Call $selector $args";
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
       CallHandler callHandler) {
-    final List<Type> argTypes = new List<Type>.filled(args.values.length, null);
+    final List<Type> argTypes =
+        new List<Type>.filled(args.values.length, const EmptyType());
     for (int i = 0; i < args.values.length; i++) {
       final Type type = args.values[i].getComputedType(computedTypes);
       if (type == const EmptyType()) {
@@ -271,14 +264,15 @@
       callHandler
           .addAllocatedClass((argTypes[0] as ConcreteType).cls.classNode);
     }
-    final Stopwatch timer = kPrintTimings ? (new Stopwatch()..start()) : null;
+    final Stopwatch? timer = kPrintTimings ? (new Stopwatch()..start()) : null;
     Type result = callHandler.applyCall(
         this, selector, new Args<Type>(argTypes, names: args.names),
         isResultUsed: isResultUsed);
-    summary.calleeTime += kPrintTimings ? timer.elapsedMicroseconds : 0;
+    summary.calleeTime += kPrintTimings ? timer!.elapsedMicroseconds : 0;
     if (isInstanceCreation) {
       result = argTypes[0];
     } else if (isResultUsed) {
+      final staticResultType = this.staticResultType;
       if (staticResultType != null) {
         result = result.intersection(staticResultType, typeHierarchy);
       }
@@ -302,9 +296,9 @@
   static const int kReceiverMayBeInt = (1 << 6);
   static const int kInstanceCreation = (1 << 7);
 
-  Member _monomorphicTarget;
+  Member? _monomorphicTarget;
 
-  Member get monomorphicTarget => _monomorphicTarget;
+  Member? get monomorphicTarget => _monomorphicTarget;
 
   bool get isMonomorphic => (_flags & kMonomorphic) != 0;
 
@@ -396,18 +390,19 @@
       "/$paramIndex]${nullability.suffix})";
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
       CallHandler callHandler) {
     Type argType = arg.getComputedType(computedTypes);
-    Type extractedType;
+    Type? extractedType;
 
     void extractType(ConcreteType c) {
-      if (c.typeArgs == null) {
+      final typeArgs = c.typeArgs;
+      if (typeArgs == null) {
         extractedType = const UnknownType();
       } else {
         final interfaceOffset = typeHierarchy.genericInterfaceOffsetFor(
             c.cls.classNode, referenceClass);
-        final typeArg = c.typeArgs[interfaceOffset + paramIndex];
+        final typeArg = typeArgs[interfaceOffset + paramIndex];
         Type extracted = typeArg;
         if (typeArg is RuntimeType) {
           final argNullability = typeArg.nullability;
@@ -472,16 +467,15 @@
   }
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
       CallHandler callHandler) {
     bool hasRuntimeType = false;
-    final types = new List<Type>.filled(flattenedTypeArgs.length, null);
-    for (int i = 0; i < types.length; ++i) {
+    final types = List<Type>.generate(flattenedTypeArgs.length, (int i) {
       final computed = flattenedTypeArgs[i].getComputedType(computedTypes);
       assert(computed is RuntimeType || computed is UnknownType);
       if (computed is RuntimeType) hasRuntimeType = true;
-      types[i] = computed;
-    }
+      return computed;
+    });
     return new ConcreteType(cls, hasRuntimeType ? types : null);
   }
 }
@@ -505,14 +499,13 @@
       "${nullability.suffix})";
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
       CallHandler callHandler) {
-    final types = new List<RuntimeType>.filled(flattenedTypeArgs.length, null);
-    for (int i = 0; i < types.length; ++i) {
-      final computed = flattenedTypeArgs[i].getComputedType(computedTypes);
-      assert(computed is RuntimeType || computed is UnknownType);
+    final types = <RuntimeType>[];
+    for (TypeExpr arg in flattenedTypeArgs) {
+      final computed = arg.getComputedType(computedTypes);
       if (computed is UnknownType) return const UnknownType();
-      types[i] = computed;
+      types.add(computed as RuntimeType);
     }
     DartType dartType;
     if (klass == typeHierarchy.coreTypes.deprecatedFutureOrClass) {
@@ -545,17 +538,15 @@
   // "unchecked" entrypoint.
   bool isTestedOnlyOnCheckedEntryPoint;
 
-  VariableDeclaration get parameter =>
-      node is VariableDeclaration ? node : null;
+  bool get isParameterCheck => node is VariableDeclaration;
+  VariableDeclaration get parameterVariable => node as VariableDeclaration;
 
   bool alwaysPass = true;
   bool alwaysFail = true;
 
-  TypeCheck(this.arg, this.type, this.node, this.staticType, this.kind) {
-    assert(node != null);
-    isTestedOnlyOnCheckedEntryPoint =
-        parameter != null && !parameter.isCovariant;
-  }
+  TypeCheck(this.arg, this.type, this.node, this.staticType, this.kind)
+      : isTestedOnlyOnCheckedEntryPoint =
+            node is VariableDeclaration && !node.isCovariant;
 
   @override
   void accept(StatementVisitor visitor) => visitor.visitTypeCheck(this);
@@ -568,7 +559,7 @@
   }
 
   @override
-  Type apply(List<Type> computedTypes, TypeHierarchy typeHierarchy,
+  Type apply(List<Type?> computedTypes, TypeHierarchy typeHierarchy,
       CallHandler callHandler) {
     Type argType = arg.getComputedType(computedTypes);
     Type checkType = type.getComputedType(computedTypes);
@@ -624,11 +615,11 @@
   int requiredParameterCount;
 
   List<Statement> _statements = <Statement>[];
-  TypeExpr result = null;
-  Type resultType = EmptyType();
+  TypeExpr result = const EmptyType();
+  Type resultType = const EmptyType();
 
   // Analysis time of callees. Populated only if kPrintTimings.
-  int calleeTime;
+  int calleeTime = 0;
 
   Summary(this.name,
       {this.parameterCount: 0,
@@ -658,7 +649,7 @@
   /// Apply this summary to the given arguments and return the resulting type.
   Type apply(Args<Type> arguments, TypeHierarchy typeHierarchy,
       CallHandler callHandler) {
-    final Stopwatch timer = kPrintTimings ? (new Stopwatch()..start()) : null;
+    final Stopwatch? timer = kPrintTimings ? (new Stopwatch()..start()) : null;
     final int oldCalleeTime = calleeTime;
     calleeTime = 0;
     final args = arguments.values;
@@ -677,7 +668,7 @@
     //
     // The first `parameterCount` statements are Parameters.
 
-    List<Type> types = new List<Type>.filled(_statements.length, null);
+    List<Type?> types = new List<Type?>.filled(_statements.length, null);
 
     for (int i = 0; i < positionalArgCount; i++) {
       final Parameter param = _statements[i] as Parameter;
@@ -687,9 +678,9 @@
       }
       final argType = args[i].specialize(typeHierarchy);
       param._observeArgumentType(argType, typeHierarchy);
-      if (param.staticTypeForNarrowing != null) {
-        types[i] =
-            argType.intersection(param.staticTypeForNarrowing, typeHierarchy);
+      final staticTypeForNarrowing = param.staticTypeForNarrowing;
+      if (staticTypeForNarrowing != null) {
+        types[i] = argType.intersection(staticTypeForNarrowing, typeHierarchy);
       } else {
         // TODO(sjindel/tfa): Narrowing is performed inside a [TypeCheck] later.
         types[i] = args[i];
@@ -710,9 +701,10 @@
             args[positionalArgCount + argIndex].specialize(typeHierarchy);
         argIndex++;
         param._observeArgumentType(argType, typeHierarchy);
-        if (param.staticTypeForNarrowing != null) {
+        final staticTypeForNarrowing = param.staticTypeForNarrowing;
+        if (staticTypeForNarrowing != null) {
           types[i] =
-              argType.intersection(param.staticTypeForNarrowing, typeHierarchy);
+              argType.intersection(staticTypeForNarrowing, typeHierarchy);
         } else {
           types[i] = argType;
         }
@@ -741,7 +733,7 @@
     resultType = resultType.union(computedType, typeHierarchy);
 
     if (kPrintTimings) {
-      final dirtyTime = timer.elapsedMicroseconds;
+      final dirtyTime = timer!.elapsedMicroseconds;
       final pureTime = dirtyTime < calleeTime ? 0 : (dirtyTime - calleeTime);
       Statistics.numSummaryApplications.add(name);
       Statistics.dirtySummaryAnalysisTime.add(name, dirtyTime);
@@ -753,9 +745,9 @@
   }
 
   Args<Type> get argumentTypes {
-    final argTypes = new List<Type>.filled(parameterCount, null);
-    final argNames = new List<String>.filled(
-        parameterCount - positionalParameterCount, null);
+    final argTypes = new List<Type>.filled(parameterCount, const EmptyType());
+    final argNames =
+        new List<String>.filled(parameterCount - positionalParameterCount, '');
     for (int i = 0; i < parameterCount; i++) {
       Parameter param = _statements[i] as Parameter;
       argTypes[i] = param.argumentType;
@@ -769,7 +761,7 @@
   Type argumentType(Member member, VariableDeclaration memberParam) {
     final int firstParamIndex =
         numTypeParams(member) + (hasReceiverArg(member) ? 1 : 0);
-    final positional = member.function.positionalParameters;
+    final positional = member.function!.positionalParameters;
     for (int i = 0; i < positional.length; i++) {
       if (positional[i] == memberParam) {
         final Parameter param = _statements[firstParamIndex + i] as Parameter;
@@ -791,8 +783,8 @@
     for (Statement statement in _statements) {
       if (statement is TypeCheck &&
           statement.alwaysPass &&
-          statement.parameter != null) {
-        params.add(statement.parameter);
+          statement.isParameterCheck) {
+        params.add(statement.parameterVariable);
       }
     }
     return params;
@@ -808,17 +800,17 @@
         (hasReceiverArg(member) ? 1 : 0) + numTypeParams(member);
     final Map<String, Parameter> paramsByName = {};
     for (int i = implicit; i < parameterCount; i++) {
-      final Parameter param = statements[i];
+      final Parameter param = statements[i] as Parameter;
       paramsByName[param.name] = param;
     }
-    FunctionNode function = member.function;
+    FunctionNode function = member.function!;
     statements.length = implicit;
     for (VariableDeclaration param in function.positionalParameters) {
-      statements.add(paramsByName[param.name]);
+      statements.add(paramsByName[param.name]!);
     }
     positionalParameterCount = statements.length;
     for (VariableDeclaration param in function.namedParameters) {
-      statements.add(paramsByName[param.name]);
+      statements.add(paramsByName[param.name]!);
     }
     parameterCount = statements.length;
     requiredParameterCount = implicit + function.requiredParameterCount;
diff --git a/pkg/vm/lib/transformations/type_flow/summary_collector.dart b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
index cd78792..d2157f7 100644
--- a/pkg/vm/lib/transformations/type_flow/summary_collector.dart
+++ b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
@@ -2,10 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Creation of type flow summaries out of kernel AST.
-library vm.transformations.type_flow.summary_collector;
 
 import 'dart:core' hide Type;
 
@@ -14,6 +11,7 @@
 import 'package:kernel/ast.dart' as ast show Statement, StatementVisitor;
 import 'package:kernel/class_hierarchy.dart'
     show ClassHierarchy, ClosedWorldClassHierarchy;
+import 'package:kernel/core_types.dart' show CoreTypes;
 import 'package:kernel/type_environment.dart'
     show StaticTypeContext, SubtypeCheckMode, TypeEnvironment;
 import 'package:kernel/type_algebra.dart' show Substitution;
@@ -239,7 +237,7 @@
   // function and checks if control can fall through them or not.
 
   bool controlCanFallThrough(FunctionNode function) {
-    return function.body.accept(this);
+    return function.body!.accept(this);
   }
 
   @override
@@ -285,11 +283,11 @@
   bool visitContinueSwitchStatement(ContinueSwitchStatement node) => false;
 
   @override
-  bool visitIfStatement(IfStatement node) =>
-      node.then == null ||
-      node.otherwise == null ||
-      node.then.accept(this) ||
-      node.otherwise.accept(this);
+  bool visitIfStatement(IfStatement node) {
+    final otherwise = node.otherwise;
+    if (otherwise == null) return true;
+    return node.then.accept(this) || otherwise.accept(this);
+  }
 
   @override
   bool visitReturnStatement(ReturnStatement node) => false;
@@ -323,7 +321,7 @@
   final List<VariableDeclaration> varDeclarations = <VariableDeclaration>[];
 
   /// Set of captured variables.
-  Set<VariableDeclaration> captured;
+  Set<VariableDeclaration>? captured;
 
   /// Set of variables which were modified for each loop, switch statement
   /// and try block statement. Doesn't include captured variables and
@@ -334,10 +332,10 @@
   int numVariablesAtFunctionEntry = 0;
 
   /// Active loops, switch statements and try blocks.
-  List<ast.Statement> activeStatements;
+  List<ast.Statement>? activeStatements;
 
   /// Number of variables at entry of active statements.
-  List<int> numVariablesAtActiveStatements;
+  List<int>? numVariablesAtActiveStatements;
 
   _VariablesInfoCollector(Member member) {
     member.accept(this);
@@ -345,8 +343,10 @@
 
   int get numVariables => varDeclarations.length;
 
-  bool isCaptured(VariableDeclaration variable) =>
-      captured != null && captured.contains(variable);
+  bool isCaptured(VariableDeclaration variable) {
+    final captured = this.captured;
+    return captured != null && captured.contains(variable);
+  }
 
   Set<int> getModifiedVariables(ast.Statement st) {
     return modifiedSets[st] ?? const <int>{};
@@ -387,14 +387,15 @@
   }
 
   void _useVariable(VariableDeclaration variable, bool isVarAssignment) {
-    final index = varIndex[variable];
+    final index = varIndex[variable]!;
     if (_isDeclaredBefore(index, numVariablesAtFunctionEntry)) {
       _captureVariable(variable);
       return;
     }
+    final activeStatements = this.activeStatements;
     if (isVarAssignment && activeStatements != null) {
       for (int i = activeStatements.length - 1; i >= 0; --i) {
-        if (_isDeclaredBefore(index, numVariablesAtActiveStatements[i])) {
+        if (_isDeclaredBefore(index, numVariablesAtActiveStatements![i])) {
           final st = activeStatements[i];
           (modifiedSets[st] ??= <int>{}).add(index);
         } else {
@@ -410,8 +411,8 @@
   }
 
   void _endCollectingModifiedVariables() {
-    activeStatements.removeLast();
-    numVariablesAtActiveStatements.removeLast();
+    activeStatements!.removeLast();
+    numVariablesAtActiveStatements!.removeLast();
   }
 
   @override
@@ -457,7 +458,7 @@
   @override
   visitTryCatch(TryCatch node) {
     _startCollectingModifiedVariables(node);
-    node.body?.accept(this);
+    node.body.accept(this);
     _endCollectingModifiedVariables();
     visitList(node.catches, this);
   }
@@ -465,9 +466,9 @@
   @override
   visitTryFinally(TryFinally node) {
     _startCollectingModifiedVariables(node);
-    node.body?.accept(this);
+    node.body.accept(this);
     _endCollectingModifiedVariables();
-    node.finalizer?.accept(this);
+    node.finalizer.accept(this);
   }
 
   @override
@@ -489,7 +490,7 @@
     visitList(node.variables, this);
     _startCollectingModifiedVariables(node);
     node.condition?.accept(this);
-    node.body?.accept(this);
+    node.body.accept(this);
     visitList(node.updates, this);
     _endCollectingModifiedVariables();
   }
@@ -521,7 +522,7 @@
 enum FieldSummaryType { kFieldGuard, kInitializer }
 
 /// Create a type flow summary for a member from the kernel AST.
-class SummaryCollector extends RecursiveResultVisitor<TypeExpr> {
+class SummaryCollector extends RecursiveResultVisitor<TypeExpr?> {
   final Target target;
   final TypeEnvironment _environment;
   final ClosedWorldClassHierarchy _hierarchy;
@@ -529,7 +530,7 @@
   final TypesBuilder _typesBuilder;
   final NativeCodeOracle _nativeCodeOracle;
   final GenericInterfacesInfo _genericInterfacesInfo;
-  final ProtobufHandler _protobufHandler;
+  final ProtobufHandler? _protobufHandler;
 
   final Map<TreeNode, Call> callSites = <TreeNode, Call>{};
   final Map<AsExpression, TypeCheck> explicitCasts =
@@ -540,13 +541,13 @@
   final Set<Name> _nullMethodsAndGetters = <Name>{};
   final Set<Name> _nullSetters = <Name>{};
 
-  Summary _summary;
-  _VariablesInfoCollector _variablesInfo;
+  Summary _summary = Summary('<unused>');
+  late _VariablesInfoCollector _variablesInfo;
 
   // Current value of each variable. May contain null if variable is not
   // declared yet, or EmptyType if current location is unreachable
   // (e.g. after return or throw).
-  List<TypeExpr> _variableValues;
+  List<TypeExpr?> _variableValues = const <TypeExpr?>[];
 
   // Contains Joins which accumulate all values of certain variables.
   // Used only when all variable values should be merged regardless of control
@@ -558,30 +559,30 @@
   // If _variableCells[i] != null, then all values are accumulated in the
   // _variableCells[i]. _variableValues[i] does not change and remains equal
   // to _variableCells[i].
-  List<Join> _variableCells;
+  List<Join?> _variableCells = const <Join?>[];
 
   // Counts number of Joins inserted for each variable. Only used to set
   // readable names for such joins (foo_0, foo_1 etc.)
-  List<int> _variableVersions;
+  List<int> _variableVersions = const <int>[];
 
   // State of variables after corresponding LabeledStatement.
   // Used to collect states from BreakStatements.
-  Map<LabeledStatement, List<TypeExpr>> _variableValuesAfterLabeledStatements;
+  Map<LabeledStatement, List<TypeExpr?>>? _variableValuesAfterLabeledStatements;
 
   // Joins corresponding to variables on entry to switch cases.
   // Used to propagate state from ContinueSwitchStatement to a target case.
-  Map<SwitchCase, List<Join>> _joinsAtSwitchCases;
+  Map<SwitchCase, List<Join?>>? _joinsAtSwitchCases;
 
   // Join which accumulates all return values.
-  Join _returnValue;
+  Join? _returnValue;
 
-  Parameter _receiver;
-  ConstantAllocationCollector constantAllocationCollector;
-  RuntimeTypeTranslatorImpl _translator;
-  StaticTypeContext _staticTypeContext;
+  Parameter? _receiver;
+  late ConstantAllocationCollector constantAllocationCollector;
+  late RuntimeTypeTranslatorImpl _translator;
+  StaticTypeContext? _staticTypeContext;
 
   // Currently only used for factory constructors.
-  Map<TypeParameter, TypeExpr> _fnTypeVariables;
+  Map<TypeParameter, TypeExpr>? _fnTypeVariables;
 
   SummaryCollector(
       this.target,
@@ -592,7 +593,6 @@
       this._nativeCodeOracle,
       this._genericInterfacesInfo,
       this._protobufHandler) {
-    assert(_genericInterfacesInfo != null);
     constantAllocationCollector = new ConstantAllocationCollector(this);
     _nullMethodsAndGetters.addAll(getSelectors(
         _hierarchy, _environment.coreTypes.deprecatedNullClass,
@@ -615,8 +615,8 @@
     _staticTypeContext = new StaticTypeContext(member, _environment);
     _variablesInfo = new _VariablesInfoCollector(member);
     _variableValues =
-        new List<TypeExpr>.filled(_variablesInfo.numVariables, null);
-    _variableCells = new List<Join>.filled(_variablesInfo.numVariables, null);
+        new List<TypeExpr?>.filled(_variablesInfo.numVariables, null);
+    _variableCells = new List<Join?>.filled(_variablesInfo.numVariables, null);
     _variableVersions = new List<int>.filled(_variablesInfo.numVariables, 0);
     _variableValuesAfterLabeledStatements = null;
     _joinsAtSwitchCases = null;
@@ -633,25 +633,24 @@
             parameterCount: numArgs, positionalParameterCount: numArgs);
         // TODO(alexmarkov): subclass cone
         _receiver = _declareParameter("this",
-            _environment.coreTypes.legacyRawType(member.enclosingClass), null,
+            _environment.coreTypes.legacyRawType(member.enclosingClass!), null,
             isReceiver: true);
       } else {
         _summary = new Summary(summaryName);
       }
 
-      _translator = new RuntimeTypeTranslatorImpl(
-          this, _summary, _receiver, null, _genericInterfacesInfo);
+      _translator = new RuntimeTypeTranslatorImpl(_environment.coreTypes,
+          _summary, _receiver, null, _genericInterfacesInfo);
 
       if (fieldSummaryType == FieldSummaryType.kInitializer) {
-        assert(member.initializer != null);
-        _summary.result = _visit(member.initializer);
+        _summary.result = _visit(member.initializer!);
       } else {
         final Parameter valueParam =
             _declareParameter("value", member.type, null);
         _summary.result = _typeCheck(valueParam, member.type, member);
       }
     } else {
-      FunctionNode function = member.function;
+      final FunctionNode function = member.function!;
 
       final numTypeParameters = numTypeParams(member);
       final firstParamIndex = (hasReceiver ? 1 : 0) + numTypeParameters;
@@ -666,43 +665,42 @@
               firstParamIndex + function.requiredParameterCount);
 
       if (numTypeParameters > 0) {
-        _fnTypeVariables = <TypeParameter, TypeExpr>{};
-        for (int i = 0; i < numTypeParameters; ++i) {
-          _fnTypeVariables[function.typeParameters[i]] =
-              _declareParameter(function.typeParameters[i].name, null, null);
-        }
+        _fnTypeVariables = <TypeParameter, TypeExpr>{
+          for (TypeParameter tp in function.typeParameters)
+            tp: _declareParameter(tp.name!, null, null)
+        };
       }
 
       if (hasReceiver) {
         // TODO(alexmarkov): subclass cone
         _receiver = _declareParameter("this",
-            _environment.coreTypes.legacyRawType(member.enclosingClass), null,
+            _environment.coreTypes.legacyRawType(member.enclosingClass!), null,
             isReceiver: true);
       }
 
-      _translator = new RuntimeTypeTranslatorImpl(
-          this, _summary, _receiver, _fnTypeVariables, _genericInterfacesInfo);
+      _translator = new RuntimeTypeTranslatorImpl(_environment.coreTypes,
+          _summary, _receiver, _fnTypeVariables, _genericInterfacesInfo);
 
       // Handle forwarding stubs. We need to check types against the types of
       // the forwarding stub's target, [member.concreteForwardingStubTarget].
-      FunctionNode useTypesFrom = member.function;
-      if (member is Procedure &&
-          member.isForwardingStub &&
-          member.concreteForwardingStubTarget != null) {
+      FunctionNode useTypesFrom = function;
+      if (member is Procedure && member.isForwardingStub) {
         final target = member.concreteForwardingStubTarget;
-        if (target is Field) {
-          useTypesFrom = FunctionNode(null, positionalParameters: [
-            VariableDeclaration("value", type: target.type)
-          ]);
-        } else {
-          useTypesFrom = member.concreteForwardingStubTarget.function;
+        if (target != null) {
+          if (target is Field) {
+            useTypesFrom = FunctionNode(null, positionalParameters: [
+              VariableDeclaration("value", type: target.type)
+            ]);
+          } else {
+            useTypesFrom = target.function!;
+          }
         }
       }
 
       for (int i = 0; i < function.positionalParameters.length; ++i) {
         final decl = function.positionalParameters[i];
         _declareParameter(
-            decl.name,
+            decl.name!,
             _useTypeCheckForParameter(decl)
                 ? null
                 : useTypesFrom.positionalParameters[i].type,
@@ -711,7 +709,7 @@
       for (int i = 0; i < function.namedParameters.length; ++i) {
         final decl = function.namedParameters[i];
         _declareParameter(
-            decl.name,
+            decl.name!,
             _useTypeCheckForParameter(decl)
                 ? null
                 : useTypesFrom.namedParameters[i].type,
@@ -740,7 +738,7 @@
       assert(count == _summary.parameterCount);
 
       _returnValue = new Join("%result", function.returnType);
-      _summary.add(_returnValue);
+      _summary.add(_returnValue!);
 
       if (member is Constructor) {
         // Make sure instance field initializers are visited.
@@ -750,7 +748,7 @@
                 new DirectSelector(f, callKind: CallKind.FieldInitializer));
           }
         }
-        member.initializers.forEach(_visit);
+        member.initializers.forEach(_visitWithoutResult);
       }
 
       if (function.body == null) {
@@ -760,15 +758,15 @@
           // Runtime type could be more precise than static type, so
           // calculate intersection.
           final typeCheck = _typeCheck(type, function.returnType, function);
-          _returnValue.values.add(typeCheck);
+          _returnValue!.values.add(typeCheck);
         } else {
-          _returnValue.values.add(type);
+          _returnValue!.values.add(type);
         }
       } else {
-        _visit(function.body);
+        _visitWithoutResult(function.body!);
 
         if (_fallthroughDetector.controlCanFallThrough(function)) {
-          _returnValue.values.add(_nullType);
+          _returnValue!.values.add(_nullType);
         }
       }
 
@@ -776,15 +774,15 @@
         // In addition to what is returned from the function body,
         // operator == performs implicit comparison with null
         // and returns bool.
-        _returnValue.values.add(_boolType);
+        _returnValue!.values.add(_boolType);
       }
 
-      _summary.result = _returnValue;
+      _summary.result = _returnValue!;
     }
 
     member.annotations.forEach(_visit);
-    member.enclosingClass?.annotations?.forEach(_visit);
-    member.enclosingLibrary?.annotations?.forEach(_visit);
+    member.enclosingClass?.annotations.forEach(_visit);
+    member.enclosingLibrary.annotations.forEach(_visit);
 
     _staticTypeContext = null;
 
@@ -808,9 +806,7 @@
   }
 
   Args<Type> rawArguments(Selector selector) {
-    final member = selector.member;
-    assert(member != null);
-
+    final member = selector.member!;
     final List<Type> args = <Type>[];
     final List<String> names = <String>[];
 
@@ -822,15 +818,14 @@
     if (hasReceiverArg(member)) {
       assert(member.enclosingClass != null);
       final receiver =
-          new ConeType(_typesBuilder.getTFClass(member.enclosingClass));
+          new ConeType(_typesBuilder.getTFClass(member.enclosingClass!));
       args.add(receiver);
     }
 
     switch (selector.callKind) {
       case CallKind.Method:
         if (member is! Field) {
-          final function = member.function;
-          assert(function != null);
+          final function = member.function!;
 
           final int paramCount = function.positionalParameters.length +
               function.namedParameters.length;
@@ -840,7 +835,7 @@
 
           if (function.namedParameters.isNotEmpty) {
             for (var param in function.namedParameters) {
-              names.add(param.name);
+              names.add(param.name!);
             }
             // TODO(dartbug.com/32292): make sure parameters are sorted in
             // kernel AST and remove this sorting.
@@ -864,11 +859,15 @@
     return new Args<Type>(args, names: names);
   }
 
-  TypeExpr _visit(TreeNode node) => node.accept(this);
+  TypeExpr _visit(Expression node) => node.accept(this)!;
 
-  Args<TypeExpr> _visitArguments(TypeExpr receiver, Arguments arguments,
+  void _visitWithoutResult(TreeNode node) {
+    node.accept(this);
+  }
+
+  Args<TypeExpr> _visitArguments(TypeExpr? receiver, Arguments arguments,
       {bool passTypeArguments: false}) {
-    final args = <TypeExpr>[];
+    final List<TypeExpr> args = <TypeExpr>[];
     if (passTypeArguments) {
       for (var type in arguments.types) {
         args.add(_translator.translate(type));
@@ -890,7 +889,7 @@
       }
       names.sort();
       for (var name in names) {
-        args.add(map[name]);
+        args.add(map[name]!);
       }
       return new Args<TypeExpr>(args, names: names);
     } else {
@@ -899,9 +898,9 @@
   }
 
   Parameter _declareParameter(
-      String name, DartType type, Expression initializer,
+      String name, DartType? type, Expression? initializer,
       {bool isReceiver: false}) {
-    Type staticType;
+    Type? staticType;
     if (type != null) {
       staticType = _typesBuilder.fromStaticType(type, !isReceiver);
     }
@@ -916,7 +915,7 @@
         } else if (initializer is BasicLiteral ||
             initializer is SymbolLiteral ||
             initializer is TypeLiteral) {
-          param.defaultValue = _visit(initializer);
+          param.defaultValue = _visit(initializer) as Type;
         } else {
           throw 'Unexpected parameter $name default value ${initializer.runtimeType} $initializer';
         }
@@ -930,8 +929,7 @@
   }
 
   void _declareVariable(VariableDeclaration decl, TypeExpr initialValue) {
-    final int varIndex = _variablesInfo.varIndex[decl];
-    assert(varIndex != null);
+    final int varIndex = _variablesInfo.varIndex[decl]!;
     assert(_variablesInfo.varDeclarations[varIndex] == decl);
     assert(_variableValues[varIndex] == null);
     if (_variablesInfo.isCaptured(decl)) {
@@ -944,8 +942,8 @@
   }
 
   void _writeVariable(VariableDeclaration variable, TypeExpr value) {
-    final int varIndex = _variablesInfo.varIndex[variable];
-    final Join join = _variableCells[varIndex];
+    final int varIndex = _variablesInfo.varIndex[variable]!;
+    final Join? join = _variableCells[varIndex];
     if (join != null) {
       join.values.add(value);
     } else {
@@ -953,11 +951,12 @@
     }
   }
 
-  List<TypeExpr> _cloneVariableValues(List<TypeExpr> values) =>
-      new List<TypeExpr>.from(values);
+  List<TypeExpr?> _cloneVariableValues(List<TypeExpr?> values) =>
+      new List<TypeExpr?>.from(values);
 
-  List<TypeExpr> _makeEmptyVariableValues() {
-    final values = new List<TypeExpr>.filled(_variablesInfo.numVariables, null);
+  List<TypeExpr?> _makeEmptyVariableValues() {
+    final values =
+        new List<TypeExpr?>.filled(_variablesInfo.numVariables, null);
     for (int i = 0; i < values.length; ++i) {
       if (_variableCells[i] != null) {
         values[i] = _variableValues[i];
@@ -978,11 +977,11 @@
     return join;
   }
 
-  void _mergeVariableValues(List<TypeExpr> dst, List<TypeExpr> src) {
+  void _mergeVariableValues(List<TypeExpr?> dst, List<TypeExpr?> src) {
     assert(dst.length == src.length);
     for (int i = 0; i < dst.length; ++i) {
-      final TypeExpr dstValue = dst[i];
-      final TypeExpr srcValue = src[i];
+      final TypeExpr? dstValue = dst[i];
+      final TypeExpr? srcValue = src[i];
       if (identical(dstValue, srcValue)) {
         continue;
       }
@@ -997,21 +996,21 @@
       } else if (srcValue is Join && srcValue.values.contains(dstValue)) {
         dst[i] = srcValue;
       } else {
-        final Join join = _makeJoin(i, dst[i]);
-        join.values.add(src[i]);
+        final Join join = _makeJoin(i, dstValue);
+        join.values.add(srcValue);
         dst[i] = join;
       }
     }
   }
 
-  void _copyVariableValues(List<TypeExpr> dst, List<TypeExpr> src) {
+  void _copyVariableValues(List<TypeExpr?> dst, List<TypeExpr?> src) {
     assert(dst.length == src.length);
     for (int i = 0; i < dst.length; ++i) {
       dst[i] = src[i];
     }
   }
 
-  bool _isIdenticalState(List<TypeExpr> state1, List<TypeExpr> state2) {
+  bool _isIdenticalState(List<TypeExpr?> state1, List<TypeExpr?> state2) {
     assert(state1.length == state2.length);
     for (int i = 0; i < state1.length; ++i) {
       if (!identical(state1[i], state2[i])) {
@@ -1021,14 +1020,14 @@
     return true;
   }
 
-  List<Join> _insertJoinsForModifiedVariables(TreeNode node, bool isTry) {
-    final List<Join> joins =
-        new List<Join>.filled(_variablesInfo.numVariables, null);
+  List<Join?> _insertJoinsForModifiedVariables(ast.Statement node, bool isTry) {
+    final List<Join?> joins =
+        new List<Join?>.filled(_variablesInfo.numVariables, null);
     for (var i in _variablesInfo.getModifiedVariables(node)) {
       if (_variableCells[i] != null) {
         assert(_variableCells[i] == _variableValues[i]);
       } else {
-        final join = _makeJoin(i, _variableValues[i]);
+        final join = _makeJoin(i, _variableValues[i]!);
         joins[i] = join;
         _variableValues[i] = join;
         if (isTry) {
@@ -1044,7 +1043,7 @@
 
   /// Stops accumulating values in [joins] by removing them from
   /// _variableCells.
-  void _restoreVariableCellsAfterTry(List<Join> joins) {
+  void _restoreVariableCellsAfterTry(List<Join?> joins) {
     for (int i = 0; i < joins.length; ++i) {
       if (joins[i] != null) {
         assert(_variableCells[i] == joins[i]);
@@ -1053,14 +1052,14 @@
     }
   }
 
-  void _mergeVariableValuesToJoins(List<TypeExpr> values, List<Join> joins) {
+  void _mergeVariableValuesToJoins(List<TypeExpr?> values, List<Join?> joins) {
     for (int i = 0; i < joins.length; ++i) {
       final join = joins[i];
       final value = values[i];
       if (join != null &&
           !identical(join, value) &&
           !identical(join.values.first, value)) {
-        join.values.add(value);
+        join.values.add(value!);
       }
     }
   }
@@ -1079,16 +1078,17 @@
 
   // TODO(alexmarkov): Avoid declaring variables with static types.
   void _declareVariableWithStaticType(VariableDeclaration decl) {
-    if (decl.initializer != null) {
-      _visit(decl.initializer);
+    final initializer = decl.initializer;
+    if (initializer != null) {
+      _visit(initializer);
     }
     _declareVariable(decl, _typesBuilder.fromStaticType(decl.type, true));
   }
 
   Call _makeCall(TreeNode node, Selector selector, Args<TypeExpr> args,
       {bool isInstanceCreation = false}) {
-    Type staticResultType = null;
-    Member target;
+    Type? staticResultType = null;
+    Member? target;
     if (selector is DirectSelector) {
       target = selector.member;
     } else if (selector is InterfaceSelector) {
@@ -1101,9 +1101,7 @@
     }
     Call call = new Call(selector, args, staticResultType, isInstanceCreation);
     _summary.add(call);
-    if (node != null) {
-      callSites[node] = call;
-    }
+    callSites[node] = call;
     return call;
   }
 
@@ -1189,53 +1187,43 @@
   }
 
   DartType _staticDartType(Expression node) =>
-      node.getStaticType(_staticTypeContext);
+      node.getStaticType(_staticTypeContext!);
 
   Type _staticType(Expression node) =>
       _typesBuilder.fromStaticType(_staticDartType(node), true);
 
-  ConcreteType _cachedBoolType;
-  ConcreteType get _boolType => _cachedBoolType ??=
+  late final ConcreteType _boolType =
       _entryPointsListener.addAllocatedClass(_environment.coreTypes.boolClass);
 
-  ConcreteType _cachedBoolTrue;
-  ConcreteType get _boolTrue => _cachedBoolTrue ??=
-      new ConcreteType(_boolType.cls, null, BoolConstant(true));
+  late final ConcreteType _boolTrue =
+      ConcreteType(_boolType.cls, null, BoolConstant(true));
 
-  ConcreteType _cachedBoolFalse;
-  ConcreteType get _boolFalse => _cachedBoolFalse ??=
-      new ConcreteType(_boolType.cls, null, BoolConstant(false));
+  late final ConcreteType _boolFalse =
+      ConcreteType(_boolType.cls, null, BoolConstant(false));
 
-  Type _cachedDoubleType;
-  Type get _doubleType => _cachedDoubleType ??= new ConeType(
-      _typesBuilder.getTFClass(_environment.coreTypes.doubleClass));
+  late final Type _doubleType =
+      ConeType(_typesBuilder.getTFClass(_environment.coreTypes.doubleClass));
 
-  Type _cachedIntType;
-  Type get _intType => _cachedIntType ??=
-      new ConeType(_typesBuilder.getTFClass(_environment.coreTypes.intClass));
+  late final Type _intType =
+      ConeType(_typesBuilder.getTFClass(_environment.coreTypes.intClass));
 
-  Type _cachedStringType;
-  Type get _stringType => _cachedStringType ??= new ConeType(
-      _typesBuilder.getTFClass(_environment.coreTypes.stringClass));
+  late final Type _stringType =
+      ConeType(_typesBuilder.getTFClass(_environment.coreTypes.stringClass));
 
-  Type _cachedSymbolType;
-  Type get _symbolType => _cachedSymbolType ??= new ConeType(
-      _typesBuilder.getTFClass(_environment.coreTypes.symbolClass));
+  late final Type _symbolType =
+      ConeType(_typesBuilder.getTFClass(_environment.coreTypes.symbolClass));
 
-  Type _cachedTypeType;
-  Type get _typeType => _cachedTypeType ??=
-      new ConeType(_typesBuilder.getTFClass(_environment.coreTypes.typeClass));
+  late final Type _typeType =
+      ConeType(_typesBuilder.getTFClass(_environment.coreTypes.typeClass));
 
-  Type _cachedNullType;
-  Type get _nullType =>
-      _cachedNullType ??= new Type.nullable(const EmptyType());
+  late final Type _nullType = Type.nullable(const EmptyType());
 
-  Class get _superclass => _staticTypeContext.thisType.classNode.superclass;
+  Class get _superclass => _staticTypeContext!.thisType!.classNode.superclass!;
 
   Type _boolLiteralType(bool value) => value ? _boolTrue : _boolFalse;
 
-  Type _intLiteralType(int value, Constant constant) {
-    final Class concreteClass =
+  Type _intLiteralType(int value, Constant? constant) {
+    final Class? concreteClass =
         target.concreteIntLiteralClass(_environment.coreTypes, value);
     if (concreteClass != null) {
       constant ??= IntConstant(value);
@@ -1247,8 +1235,8 @@
     return _intType;
   }
 
-  Type _doubleLiteralType(double value, Constant constant) {
-    final Class concreteClass =
+  Type _doubleLiteralType(double value, Constant? constant) {
+    final Class? concreteClass =
         target.concreteDoubleLiteralClass(_environment.coreTypes, value);
     if (concreteClass != null) {
       constant ??= DoubleConstant(value);
@@ -1260,8 +1248,8 @@
     return _doubleType;
   }
 
-  Type _stringLiteralType(String value, Constant constant) {
-    final Class concreteClass =
+  Type _stringLiteralType(String value, Constant? constant) {
+    final Class? concreteClass =
         target.concreteStringLiteralClass(_environment.coreTypes, value);
     if (concreteClass != null) {
       constant ??= StringConstant(value);
@@ -1284,7 +1272,7 @@
     node.positionalParameters.forEach(_declareVariableWithStaticType);
     node.namedParameters.forEach(_declareVariableWithStaticType);
 
-    _visit(node.body);
+    _visitWithoutResult(node.body!);
 
     _variableValues = savedVariableValues;
     _returnValue = savedReturn;
@@ -1307,8 +1295,7 @@
       for (Class c
           in _hierarchy.computeSubtypesInformation().getSubtypesOf(cls)) {
         if (!c.isAbstract) {
-          final candidate = _hierarchy.getDispatchTarget(c, _equalsName);
-          assert(candidate != null);
+          final candidate = _hierarchy.getDispatchTarget(c, _equalsName)!;
           assert(!candidate.isAbstract);
           if (candidate != _environment.coreTypes.objectEquals) {
             _cachedHasOverriddenEquals[cls] = true;
@@ -1328,12 +1315,12 @@
   // On exit _variableValues is null, so caller should explicitly pick
   // either trueState or falseState.
   void _visitCondition(
-      Expression node, List<TypeExpr> trueState, List<TypeExpr> falseState) {
+      Expression node, List<TypeExpr?> trueState, List<TypeExpr?> falseState) {
     assert(_isIdenticalState(_variableValues, trueState));
     assert(_isIdenticalState(_variableValues, falseState));
     if (node is Not) {
       _visitCondition(node.operand, falseState, trueState);
-      _variableValues = null;
+      _variableValues = const <TypeExpr?>[]; // Should not be used.
       return;
     } else if (node is LogicalExpression) {
       final isOR = (node.operatorEnum == LogicalExpressionOperator.OR);
@@ -1351,7 +1338,7 @@
         _visitCondition(node.right, trueState, falseStateAfterRHS);
         _mergeVariableValues(falseState, falseStateAfterRHS);
       }
-      _variableValues = null;
+      _variableValues = const <TypeExpr?>[]; // Should not be used.
       return;
     } else if (node is VariableGet ||
         (node is AsExpression && node.operand is VariableGet)) {
@@ -1359,12 +1346,12 @@
       _addUse(_visit(node));
       final variableGet =
           (node is AsExpression ? node.operand : node) as VariableGet;
-      final int varIndex = _variablesInfo.varIndex[variableGet.variable];
+      final int varIndex = _variablesInfo.varIndex[variableGet.variable]!;
       if (_variableCells[varIndex] == null) {
         trueState[varIndex] = _boolTrue;
         falseState[varIndex] = _boolFalse;
       }
-      _variableValues = null;
+      _variableValues = const <TypeExpr?>[]; // Should not be used.
       return;
     } else if (node is EqualsCall && node.left is VariableGet) {
       final lhs = node.left as VariableGet;
@@ -1379,11 +1366,11 @@
               !_hasOverriddenEquals(lhs.variable.type))) {
         // 'x == c', where x is a variable and c is a constant.
         _addUse(_visit(node));
-        final int varIndex = _variablesInfo.varIndex[lhs.variable];
+        final int varIndex = _variablesInfo.varIndex[lhs.variable]!;
         if (_variableCells[varIndex] == null) {
           trueState[varIndex] = _visit(rhs);
         }
-        _variableValues = null;
+        _variableValues = const <TypeExpr?>[]; // Should not be used.
         return;
       }
     } else if (node is EqualsNull && node.expression is VariableGet) {
@@ -1393,12 +1380,12 @@
       _makeCall(node, DirectSelector(_environment.coreTypes.objectEquals),
           Args<TypeExpr>([expr, _nullType]));
       final narrowedNotNull = _makeNarrowNotNull(node, expr);
-      final int varIndex = _variablesInfo.varIndex[lhs.variable];
+      final int varIndex = _variablesInfo.varIndex[lhs.variable]!;
       if (_variableCells[varIndex] == null) {
         trueState[varIndex] = _nullType;
         falseState[varIndex] = narrowedNotNull;
       }
-      _variableValues = null;
+      _variableValues = const <TypeExpr?>[]; // Should not be used.
       return;
     } else if (node is IsExpression && node.operand is VariableGet) {
       // Handle 'x is T', where x is a variable.
@@ -1406,17 +1393,17 @@
       final TypeCheck typeCheck =
           _typeCheck(_visit(operand), node.type, node, SubtypeTestKind.IsTest);
       isTests[node] = typeCheck;
-      final int varIndex = _variablesInfo.varIndex[operand.variable];
+      final int varIndex = _variablesInfo.varIndex[operand.variable]!;
       if (_variableCells[varIndex] == null) {
         trueState[varIndex] = typeCheck;
       }
-      _variableValues = null;
+      _variableValues = const <TypeExpr?>[]; // Should not be used.
       return;
     }
     _addUse(_visit(node));
     _copyVariableValues(trueState, _variableValues);
     _copyVariableValues(falseState, _variableValues);
-    _variableValues = null;
+    _variableValues = const <TypeExpr?>[]; // Should not be used.
   }
 
   void _updateReceiverAfterCall(
@@ -1425,7 +1412,7 @@
     if (receiverNode is VariableGet) {
       final nullSelectors = isSetter ? _nullSetters : _nullMethodsAndGetters;
       if (!nullSelectors.contains(selector)) {
-        final int varIndex = _variablesInfo.varIndex[receiverNode.variable];
+        final int varIndex = _variablesInfo.varIndex[receiverNode.variable]!;
         if (_variableCells[varIndex] == null) {
           _variableValues[varIndex] =
               _makeNarrow(receiverValue, const AnyType());
@@ -1434,9 +1421,8 @@
     }
   }
 
-  Procedure _cachedUnsafeCast;
-  Procedure get unsafeCast => _cachedUnsafeCast ??= _environment.coreTypes.index
-      .getTopLevelMember('dart:_internal', 'unsafeCast');
+  late final Procedure unsafeCast = _environment.coreTypes.index
+      .getTopLevelProcedure('dart:_internal', 'unsafeCast');
 
   @override
   defaultTreeNode(TreeNode node) =>
@@ -1446,10 +1432,10 @@
   TypeExpr visitAsExpression(AsExpression node) {
     final operandNode = node.operand;
     final TypeExpr operand = _visit(operandNode);
-    final TypeExpr result = _typeCheck(operand, node.type, node);
+    final TypeCheck result = _typeCheck(operand, node.type, node);
     explicitCasts[node] = result;
     if (operandNode is VariableGet) {
-      final int varIndex = _variablesInfo.varIndex[operandNode.variable];
+      final int varIndex = _variablesInfo.varIndex[operandNode.variable]!;
       if (_variableCells[varIndex] == null) {
         _variableValues[varIndex] = result;
       }
@@ -1462,7 +1448,7 @@
     final operandNode = node.operand;
     final TypeExpr result = _makeNarrowNotNull(node, _visit(operandNode));
     if (operandNode is VariableGet) {
-      final int varIndex = _variablesInfo.varIndex[operandNode.variable];
+      final int varIndex = _variablesInfo.varIndex[operandNode.variable]!;
       if (_variableCells[varIndex] == null) {
         _variableValues[varIndex] = result;
       }
@@ -1549,20 +1535,20 @@
 
   @override
   TypeExpr visitLet(Let node) {
-    _declareVariable(node.variable, _visit(node.variable.initializer));
+    _declareVariable(node.variable, _visit(node.variable.initializer!));
     return _visit(node.body);
   }
 
   @override
   TypeExpr visitBlockExpression(BlockExpression node) {
-    _visit(node.body);
+    _visitWithoutResult(node.body);
     return _visit(node.value);
   }
 
   @override
   TypeExpr visitListLiteral(ListLiteral node) {
     node.expressions.forEach(_visit);
-    Class concreteClass =
+    Class? concreteClass =
         target.concreteListLiteralClass(_environment.coreTypes);
     if (concreteClass != null) {
       return _translator.instantiateConcreteType(
@@ -1588,7 +1574,7 @@
       _visit(entry.key);
       _visit(entry.value);
     }
-    Class concreteClass =
+    Class? concreteClass =
         target.concreteMapLiteralClass(_environment.coreTypes);
     if (concreteClass != null) {
       return _translator.instantiateConcreteType(
@@ -1690,7 +1676,7 @@
   }
 
   TypeExpr _handlePropertyGet(
-      TreeNode node, Expression receiverNode, Member target, Name selector) {
+      TreeNode node, Expression receiverNode, Member? target, Name selector) {
     var receiver = _visit(receiverNode);
     var args = new Args<TypeExpr>([receiver]);
     TypeExpr result;
@@ -1779,8 +1765,7 @@
   @override
   TypeExpr visitSuperPropertyGet(SuperPropertyGet node) {
     assert(kPartialMixinResolution);
-    assert(_receiver != null, "Should have receiver. Node: $node");
-    final args = new Args<TypeExpr>([_receiver]);
+    final args = new Args<TypeExpr>([_receiver!]);
     // Re-resolve target due to partial mixin resolution.
     final target = _hierarchy.getDispatchTarget(_superclass, node.name);
     if (target == null) {
@@ -1794,9 +1779,8 @@
   @override
   TypeExpr visitSuperPropertySet(SuperPropertySet node) {
     assert(kPartialMixinResolution);
-    assert(_receiver != null, "Should have receiver. Node: $node");
     final value = _visit(node.value);
-    final args = new Args<TypeExpr>([_receiver, value]);
+    final args = new Args<TypeExpr>([_receiver!, value]);
     // Re-resolve target due to partial mixin resolution.
     final target =
         _hierarchy.getDispatchTarget(_superclass, node.name, setter: true);
@@ -1882,8 +1866,7 @@
 
   @override
   TypeExpr visitThisExpression(ThisExpression node) {
-    assert(_receiver != null, "Should have receiver. Node: $node");
-    return _receiver;
+    return _receiver!;
   }
 
   @override
@@ -1900,7 +1883,7 @@
 
   @override
   TypeExpr visitVariableGet(VariableGet node) {
-    final v = _variableValues[_variablesInfo.varIndex[node.variable]];
+    final v = _variableValues[_variablesInfo.varIndex[node.variable]!];
     if (v == null) {
       throw 'Unable to find variable ${node.variable} at ${node.location}';
     }
@@ -1925,56 +1908,60 @@
   }
 
   @override
-  TypeExpr visitAssertStatement(AssertStatement node) {
+  TypeExpr? visitAssertStatement(AssertStatement node) {
     if (!kRemoveAsserts) {
       _addUse(_visit(node.condition));
-      if (node.message != null) {
-        _visit(node.message);
+      final message = node.message;
+      if (message != null) {
+        _visit(message);
       }
     }
     return null;
   }
 
   @override
-  TypeExpr visitBlock(Block node) {
-    node.statements.forEach(_visit);
+  TypeExpr? visitBlock(Block node) {
+    node.statements.forEach(_visitWithoutResult);
     return null;
   }
 
   @override
-  TypeExpr visitAssertBlock(AssertBlock node) {
+  TypeExpr? visitAssertBlock(AssertBlock node) {
     if (!kRemoveAsserts) {
-      node.statements.forEach(_visit);
+      node.statements.forEach(_visitWithoutResult);
     }
     return null;
   }
 
   @override
-  TypeExpr visitBreakStatement(BreakStatement node) {
-    _variableValuesAfterLabeledStatements ??=
-        <LabeledStatement, List<TypeExpr>>{};
-    final state = _variableValuesAfterLabeledStatements[node.target];
+  TypeExpr? visitBreakStatement(BreakStatement node) {
+    var afterLabels = _variableValuesAfterLabeledStatements;
+    if (afterLabels == null) {
+      _variableValuesAfterLabeledStatements =
+          afterLabels = <LabeledStatement, List<TypeExpr?>>{};
+    }
+    final state = afterLabels[node.target];
     if (state != null) {
       _mergeVariableValues(state, _variableValues);
     } else {
-      _variableValuesAfterLabeledStatements[node.target] = _variableValues;
+      afterLabels[node.target] = _variableValues;
     }
     _variableValues = _makeEmptyVariableValues();
     return null;
   }
 
   @override
-  TypeExpr visitContinueSwitchStatement(ContinueSwitchStatement node) {
+  TypeExpr? visitContinueSwitchStatement(ContinueSwitchStatement node) {
     _mergeVariableValuesToJoins(
-        _variableValues, _joinsAtSwitchCases[node.target]);
+        _variableValues, _joinsAtSwitchCases![node.target]!);
     _variableValues = _makeEmptyVariableValues();
     return null;
   }
 
   @override
-  TypeExpr visitDoStatement(DoStatement node) {
-    final List<Join> joins = _insertJoinsForModifiedVariables(node, false);
-    _visit(node.body);
+  TypeExpr? visitDoStatement(DoStatement node) {
+    final List<Join?> joins = _insertJoinsForModifiedVariables(node, false);
+    _visitWithoutResult(node.body);
     final trueState = _cloneVariableValues(_variableValues);
     final falseState = _cloneVariableValues(_variableValues);
     _visitCondition(node.condition, trueState, falseState);
@@ -1988,39 +1975,39 @@
   }
 
   @override
-  TypeExpr visitEmptyStatement(EmptyStatement node) => null;
+  TypeExpr? visitEmptyStatement(EmptyStatement node) => null;
 
   @override
-  TypeExpr visitExpressionStatement(ExpressionStatement node) {
+  TypeExpr? visitExpressionStatement(ExpressionStatement node) {
     _visit(node.expression);
     return null;
   }
 
   @override
-  TypeExpr visitForInStatement(ForInStatement node) {
+  TypeExpr? visitForInStatement(ForInStatement node) {
     _visit(node.iterable);
     // TODO(alexmarkov): try to infer more precise type from 'iterable'
     _declareVariableWithStaticType(node.variable);
 
-    final List<Join> joins = _insertJoinsForModifiedVariables(node, false);
+    final List<Join?> joins = _insertJoinsForModifiedVariables(node, false);
     final stateAfterLoop = _cloneVariableValues(_variableValues);
-    _visit(node.body);
+    _visitWithoutResult(node.body);
     _mergeVariableValuesToJoins(_variableValues, joins);
     _variableValues = stateAfterLoop;
     return null;
   }
 
   @override
-  TypeExpr visitForStatement(ForStatement node) {
+  TypeExpr? visitForStatement(ForStatement node) {
     node.variables.forEach(visitVariableDeclaration);
-    final List<Join> joins = _insertJoinsForModifiedVariables(node, false);
+    final List<Join?> joins = _insertJoinsForModifiedVariables(node, false);
     final trueState = _cloneVariableValues(_variableValues);
     final falseState = _cloneVariableValues(_variableValues);
     if (node.condition != null) {
-      _visitCondition(node.condition, trueState, falseState);
+      _visitCondition(node.condition!, trueState, falseState);
     }
     _variableValues = trueState;
-    _visit(node.body);
+    _visitWithoutResult(node.body);
     node.updates.forEach(_visit);
     _mergeVariableValuesToJoins(_variableValues, joins);
     // Kernel represents 'break;' as a BreakStatement referring to a
@@ -2032,7 +2019,7 @@
   }
 
   @override
-  TypeExpr visitFunctionDeclaration(FunctionDeclaration node) {
+  TypeExpr? visitFunctionDeclaration(FunctionDeclaration node) {
     // TODO(alexmarkov): support function types.
     node.variable.annotations.forEach(_visit);
     _declareVariableWithStaticType(node.variable);
@@ -2041,18 +2028,18 @@
   }
 
   @override
-  TypeExpr visitIfStatement(IfStatement node) {
+  TypeExpr? visitIfStatement(IfStatement node) {
     final trueState = _cloneVariableValues(_variableValues);
     final falseState = _cloneVariableValues(_variableValues);
     _visitCondition(node.condition, trueState, falseState);
 
     _variableValues = trueState;
-    _visit(node.then);
+    _visitWithoutResult(node.then);
     final stateAfter = _variableValues;
 
     _variableValues = falseState;
     if (node.otherwise != null) {
-      _visit(node.otherwise);
+      _visitWithoutResult(node.otherwise!);
     }
 
     _mergeVariableValues(stateAfter, _variableValues);
@@ -2061,8 +2048,8 @@
   }
 
   @override
-  TypeExpr visitLabeledStatement(LabeledStatement node) {
-    _visit(node.body);
+  TypeExpr? visitLabeledStatement(LabeledStatement node) {
+    _visitWithoutResult(node.body);
     final state = _variableValuesAfterLabeledStatements?.remove(node);
     if (state != null) {
       _mergeVariableValues(_variableValues, state);
@@ -2071,34 +2058,35 @@
   }
 
   @override
-  TypeExpr visitReturnStatement(ReturnStatement node) {
-    TypeExpr ret =
-        (node.expression != null) ? _visit(node.expression) : _nullType;
-    if (_returnValue != null) {
-      _returnValue.values.add(ret);
-    }
+  TypeExpr? visitReturnStatement(ReturnStatement node) {
+    final expression = node.expression;
+    TypeExpr ret = (expression != null) ? _visit(expression) : _nullType;
+    _returnValue?.values.add(ret);
     _variableValues = _makeEmptyVariableValues();
     return null;
   }
 
   @override
-  TypeExpr visitSwitchStatement(SwitchStatement node) {
+  TypeExpr? visitSwitchStatement(SwitchStatement node) {
     _visit(node.expression);
     // Insert joins at each case in case there are 'continue' statements.
     final stateOnEntry = _variableValues;
-    final variableValuesAtCaseEntry = <SwitchCase, List<TypeExpr>>{};
-    _joinsAtSwitchCases ??= <SwitchCase, List<Join>>{};
+    final variableValuesAtCaseEntry = <SwitchCase, List<TypeExpr?>>{};
+    Map<SwitchCase, List<Join?>>? joinsAtSwitchCases = _joinsAtSwitchCases;
+    if (joinsAtSwitchCases == null) {
+      _joinsAtSwitchCases = joinsAtSwitchCases = <SwitchCase, List<Join?>>{};
+    }
     for (var switchCase in node.cases) {
       _variableValues = _cloneVariableValues(stateOnEntry);
-      _joinsAtSwitchCases[switchCase] =
+      joinsAtSwitchCases[switchCase] =
           _insertJoinsForModifiedVariables(node, false);
       variableValuesAtCaseEntry[switchCase] = _variableValues;
     }
     bool hasDefault = false;
     for (var switchCase in node.cases) {
-      _variableValues = variableValuesAtCaseEntry[switchCase];
+      _variableValues = variableValuesAtCaseEntry[switchCase]!;
       switchCase.expressions.forEach(_visit);
-      _visit(switchCase.body);
+      _visitWithoutResult(switchCase.body);
       hasDefault = hasDefault || switchCase.isDefault;
     }
     if (!hasDefault) {
@@ -2108,21 +2096,21 @@
   }
 
   @override
-  TypeExpr visitTryCatch(TryCatch node) {
+  TypeExpr? visitTryCatch(TryCatch node) {
     final joins = _insertJoinsForModifiedVariables(node, true);
     final stateAfterTry = _cloneVariableValues(_variableValues);
-    _visit(node.body);
+    _visitWithoutResult(node.body);
     _restoreVariableCellsAfterTry(joins);
-    List<TypeExpr> stateAfterCatch;
+    List<TypeExpr?>? stateAfterCatch;
     for (var catchClause in node.catches) {
       _variableValues = _cloneVariableValues(stateAfterTry);
       if (catchClause.exception != null) {
-        _declareVariableWithStaticType(catchClause.exception);
+        _declareVariableWithStaticType(catchClause.exception!);
       }
       if (catchClause.stackTrace != null) {
-        _declareVariableWithStaticType(catchClause.stackTrace);
+        _declareVariableWithStaticType(catchClause.stackTrace!);
       }
-      _visit(catchClause.body);
+      _visitWithoutResult(catchClause.body);
       if (stateAfterCatch == null) {
         stateAfterCatch = _variableValues;
       } else {
@@ -2130,38 +2118,39 @@
       }
     }
     _variableValues = stateAfterTry;
-    _mergeVariableValues(_variableValues, stateAfterCatch);
+    _mergeVariableValues(_variableValues, stateAfterCatch!);
     return null;
   }
 
   @override
-  TypeExpr visitTryFinally(TryFinally node) {
+  TypeExpr? visitTryFinally(TryFinally node) {
     final joins = _insertJoinsForModifiedVariables(node, true);
     final stateAfterTry = _cloneVariableValues(_variableValues);
-    _visit(node.body);
+    _visitWithoutResult(node.body);
     _restoreVariableCellsAfterTry(joins);
     _variableValues = stateAfterTry;
-    _visit(node.finalizer);
+    _visitWithoutResult(node.finalizer);
     return null;
   }
 
   @override
-  TypeExpr visitVariableDeclaration(VariableDeclaration node) {
+  TypeExpr? visitVariableDeclaration(VariableDeclaration node) {
     node.annotations.forEach(_visit);
+    final initializer = node.initializer;
     final TypeExpr initialValue =
-        node.initializer == null ? _nullType : _visit(node.initializer);
+        initializer == null ? _nullType : _visit(initializer);
     _declareVariable(node, initialValue);
     return null;
   }
 
   @override
-  TypeExpr visitWhileStatement(WhileStatement node) {
-    final List<Join> joins = _insertJoinsForModifiedVariables(node, false);
+  TypeExpr? visitWhileStatement(WhileStatement node) {
+    final List<Join?> joins = _insertJoinsForModifiedVariables(node, false);
     final trueState = _cloneVariableValues(_variableValues);
     final falseState = _cloneVariableValues(_variableValues);
     _visitCondition(node.condition, trueState, falseState);
     _variableValues = trueState;
-    _visit(node.body);
+    _visitWithoutResult(node.body);
     _mergeVariableValuesToJoins(_variableValues, joins);
     // Kernel represents 'break;' as a BreakStatement referring to a
     // LabeledStatement. We are therefore guaranteed to always have the
@@ -2172,15 +2161,15 @@
   }
 
   @override
-  TypeExpr visitYieldStatement(YieldStatement node) {
+  TypeExpr? visitYieldStatement(YieldStatement node) {
     _visit(node.expression);
     return null;
   }
 
   @override
-  TypeExpr visitFieldInitializer(FieldInitializer node) {
+  TypeExpr? visitFieldInitializer(FieldInitializer node) {
     final value = _visit(node.value);
-    final args = new Args<TypeExpr>([_receiver, value]);
+    final args = new Args<TypeExpr>([_receiver!, value]);
     _makeCall(
         node,
         new DirectSelector(node.field,
@@ -2190,17 +2179,17 @@
   }
 
   @override
-  TypeExpr visitRedirectingInitializer(RedirectingInitializer node) {
+  TypeExpr? visitRedirectingInitializer(RedirectingInitializer node) {
     final args = _visitArguments(_receiver, node.arguments);
     _makeCall(node, new DirectSelector(node.target), args);
     return null;
   }
 
   @override
-  TypeExpr visitSuperInitializer(SuperInitializer node) {
+  TypeExpr? visitSuperInitializer(SuperInitializer node) {
     final args = _visitArguments(_receiver, node.arguments);
 
-    Constructor target = null;
+    Constructor? target = null;
     if (kPartialMixinResolution) {
       // Re-resolve target due to partial mixin resolution.
       for (var replacement in _superclass.constructors) {
@@ -2212,27 +2201,26 @@
     } else {
       target = node.target;
     }
-    assert(target != null);
-    _makeCall(node, new DirectSelector(target), args);
+    _makeCall(node, new DirectSelector(target!), args);
     return null;
   }
 
   @override
-  TypeExpr visitLocalInitializer(LocalInitializer node) {
+  TypeExpr? visitLocalInitializer(LocalInitializer node) {
     visitVariableDeclaration(node.variable);
     return null;
   }
 
   @override
-  TypeExpr visitAssertInitializer(AssertInitializer node) {
+  TypeExpr? visitAssertInitializer(AssertInitializer node) {
     if (!kRemoveAsserts) {
-      _visit(node.statement);
+      _visitWithoutResult(node.statement);
     }
     return null;
   }
 
   @override
-  TypeExpr visitInvalidInitializer(InvalidInitializer node) {
+  TypeExpr? visitInvalidInitializer(InvalidInitializer node) {
     return null;
   }
 
@@ -2244,21 +2232,21 @@
 
 class RuntimeTypeTranslatorImpl extends DartTypeVisitor<TypeExpr>
     implements RuntimeTypeTranslator {
-  final Summary summary;
-  final Map<TypeParameter, TypeExpr> functionTypeVariables;
+  final CoreTypes coreTypes;
+  final Summary? summary;
+  final Map<TypeParameter, TypeExpr>? functionTypeVariables;
   final Map<DartType, TypeExpr> typesCache = <DartType, TypeExpr>{};
-  final TypeExpr receiver;
+  final TypeExpr? receiver;
   final GenericInterfacesInfo genericInterfacesInfo;
-  final SummaryCollector summaryCollector;
 
-  RuntimeTypeTranslatorImpl(this.summaryCollector, this.summary, this.receiver,
+  RuntimeTypeTranslatorImpl(this.coreTypes, this.summary, this.receiver,
       this.functionTypeVariables, this.genericInterfacesInfo) {}
 
   // Create a type translator which can be used only for types with no free type
   // variables.
-  RuntimeTypeTranslatorImpl.forClosedTypes(this.genericInterfacesInfo)
-      : summaryCollector = null,
-        summary = null,
+  RuntimeTypeTranslatorImpl.forClosedTypes(
+      this.coreTypes, this.genericInterfacesInfo)
+      : summary = null,
         functionTypeVariables = null,
         receiver = null {}
 
@@ -2271,8 +2259,7 @@
     final substitution = Substitution.fromPairs(klass.typeParameters, typeArgs);
     final flattenedTypeArgs =
         genericInterfacesInfo.flattenedTypeArgumentsFor(klass);
-    final flattenedTypeExprs =
-        new List<TypeExpr>.filled(flattenedTypeArgs.length, null);
+    final flattenedTypeExprs = <TypeExpr>[];
 
     bool createConcreteType = true;
     bool allUnknown = true;
@@ -2281,7 +2268,7 @@
           translate(substitution.substituteType(flattenedTypeArgs[i]));
       if (typeExpr is! UnknownType) allUnknown = false;
       if (typeExpr is Statement) createConcreteType = false;
-      flattenedTypeExprs[i] = typeExpr;
+      flattenedTypeExprs.add(typeExpr);
     }
 
     if (allUnknown) return type;
@@ -2291,7 +2278,7 @@
           type.cls, new List<Type>.from(flattenedTypeExprs));
     } else {
       final instantiate = new CreateConcreteType(type.cls, flattenedTypeExprs);
-      summary.add(instantiate);
+      summary!.add(instantiate);
       return instantiate;
     }
   }
@@ -2341,8 +2328,7 @@
         type.classNode.typeParameters, type.typeArguments);
     final flattenedTypeArgs =
         genericInterfacesInfo.flattenedTypeArgumentsFor(type.classNode);
-    final flattenedTypeExprs =
-        new List<TypeExpr>.filled(flattenedTypeArgs.length, null);
+    final flattenedTypeExprs = <TypeExpr>[];
 
     bool createRuntimeType = true;
     for (var i = 0; i < flattenedTypeArgs.length; ++i) {
@@ -2350,7 +2336,7 @@
           translate(substitution.substituteType(flattenedTypeArgs[i]));
       if (typeExpr == const UnknownType()) return const UnknownType();
       if (typeExpr is! RuntimeType) createRuntimeType = false;
-      flattenedTypeExprs[i] = typeExpr;
+      flattenedTypeExprs.add(typeExpr);
     }
 
     if (createRuntimeType) {
@@ -2360,7 +2346,7 @@
     } else {
       final instantiate = new CreateRuntimeType(
           type.classNode, type.nullability, flattenedTypeExprs);
-      summary.add(instantiate);
+      summary!.add(instantiate);
       return instantiate;
     }
   }
@@ -2375,32 +2361,32 @@
           <RuntimeType>[typeArg]);
     } else {
       final instantiate = new CreateRuntimeType(
-          summaryCollector._environment.coreTypes.deprecatedFutureOrClass,
+          coreTypes.deprecatedFutureOrClass,
           type.nullability,
           <TypeExpr>[typeArg]);
-      summary.add(instantiate);
+      summary!.add(instantiate);
       return instantiate;
     }
   }
 
   @override
   visitTypeParameterType(TypeParameterType type) {
+    final functionTypeVariables = this.functionTypeVariables;
     if (functionTypeVariables != null) {
       final result = functionTypeVariables[type.parameter];
       if (result != null) return result;
     }
     if (type.parameter.parent is! Class) return const UnknownType();
     final interfaceClass = type.parameter.parent as Class;
-    assert(receiver != null);
     // Undetermined nullability is equivalent to nonNullable when
     // instantiating type parameter, so convert it right away.
     Nullability nullability = type.nullability;
     if (nullability == Nullability.undetermined) {
       nullability = Nullability.nonNullable;
     }
-    final extract = new Extract(receiver, interfaceClass,
+    final extract = new Extract(receiver!, interfaceClass,
         interfaceClass.typeParameters.indexOf(type.parameter), nullability);
-    summary.add(extract);
+    summary!.add(extract);
     return extract;
   }
 }
@@ -2420,7 +2406,7 @@
 
   Type _getStaticType(Constant constant) =>
       summaryCollector._typesBuilder.fromStaticType(
-          constant.getType(summaryCollector._staticTypeContext), false);
+          constant.getType(summaryCollector._staticTypeContext!), false);
 
   @override
   defaultConstant(Constant constant) {
@@ -2467,7 +2453,7 @@
     for (final Constant entry in constant.entries) {
       typeFor(entry);
     }
-    final Class concreteClass = summaryCollector.target
+    final Class? concreteClass = summaryCollector.target
         .concreteConstListLiteralClass(summaryCollector._environment.coreTypes);
     if (concreteClass != null) {
       return new ConcreteType(
diff --git a/pkg/vm/lib/transformations/type_flow/table_selector_assigner.dart b/pkg/vm/lib/transformations/type_flow/table_selector_assigner.dart
index f1901e7..0080748 100644
--- a/pkg/vm/lib/transformations/type_flow/table_selector_assigner.dart
+++ b/pkg/vm/lib/transformations/type_flow/table_selector_assigner.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/ast.dart';
 
 import 'utils.dart' show UnionFind;
@@ -18,7 +16,7 @@
   final Map<Class, Map<Name, int>> _methodOrSetterMemberIds = {};
 
   final UnionFind _unionFind = UnionFind();
-  List<int> _selectorIdForMemberId;
+  late List<int?> _selectorIdForMemberId;
 
   TableSelectorAssigner(Component component) {
     for (Library library in component.libraries) {
@@ -44,20 +42,21 @@
     }
   }
 
-  Map<Name, int> _memberIdsForClass(Class cls, {bool getter}) {
+  Map<Name, int> _memberIdsForClass(Class? cls, {required bool getter}) {
     if (cls == null) return {};
 
     final cache = getter ? _getterMemberIds : _methodOrSetterMemberIds;
 
     // Already computed for this class?
-    Map<Name, int> memberIds = cache[cls];
-    if (memberIds != null) return memberIds;
+    final cachedMemberIds = cache[cls];
+    if (cachedMemberIds != null) return cachedMemberIds;
 
     // Merge maps from supertypes.
-    memberIds = Map.from(_memberIdsForClass(cls.superclass, getter: getter));
+    final memberIds =
+        Map<Name, int>.from(_memberIdsForClass(cls.superclass, getter: getter));
     for (Supertype impl in cls.implementedTypes) {
       _memberIdsForClass(impl.classNode, getter: getter).forEach((name, id) {
-        final int firstId = memberIds[name];
+        final int? firstId = memberIds[name];
         if (firstId == null) {
           memberIds[name] = id;
         } else if (firstId != id) {
@@ -99,9 +98,9 @@
     return cache[cls] = memberIds;
   }
 
-  int _selectorIdForMember(Member member, {bool getter}) {
+  int _selectorIdForMember(Member member, {required bool getter}) {
     final map = getter ? _getterMemberIds : _methodOrSetterMemberIds;
-    int memberId = map[member.enclosingClass][member.name];
+    int? memberId = map[member.enclosingClass!]![member.name];
     if (memberId == null) {
       assert(member is Procedure &&
               ((identical(map, _getterMemberIds) &&
@@ -115,7 +114,7 @@
       return ProcedureAttributesMetadata.kInvalidSelectorId;
     }
     memberId = _unionFind.find(memberId);
-    int selectorId = _selectorIdForMemberId[memberId];
+    int? selectorId = _selectorIdForMemberId[memberId];
     if (selectorId == null) {
       _selectorIdForMemberId[memberId] = selectorId = metadata.addSelector();
     }
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index feb185d..82bebec 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -2,10 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Transformations based on type flow analysis.
-library vm.transformations.type_flow.transformer;
 
 import 'dart:core' hide Type;
 
@@ -14,7 +11,8 @@
 import 'package:kernel/ast.dart' as ast show Statement;
 import 'package:kernel/clone.dart' show CloneVisitorNotMembers;
 import 'package:kernel/core_types.dart' show CoreTypes;
-import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
+import 'package:kernel/class_hierarchy.dart'
+    show ClassHierarchy, ClosedWorldClassHierarchy;
 import 'package:kernel/library_index.dart' show LibraryIndex;
 import 'package:kernel/type_environment.dart';
 
@@ -43,16 +41,18 @@
 /// Assumes strong mode and closed world.
 Component transformComponent(
     Target target, CoreTypes coreTypes, Component component,
-    {PragmaAnnotationParser matcher,
+    {PragmaAnnotationParser? matcher,
     bool treeShakeSignatures: true,
     bool treeShakeWriteOnlyFields: true,
     bool treeShakeProtobufs: false}) {
   void ignoreAmbiguousSupertypes(Class cls, Supertype a, Supertype b) {}
   final hierarchy = new ClassHierarchy(component, coreTypes,
-      onAmbiguousSupertypes: ignoreAmbiguousSupertypes);
+          onAmbiguousSupertypes: ignoreAmbiguousSupertypes)
+      as ClosedWorldClassHierarchy;
   final types = new TypeEnvironment(coreTypes, hierarchy);
   final libraryIndex = new LibraryIndex.all(component);
-  final genericInterfacesInfo = new GenericInterfacesInfoImpl(hierarchy);
+  final genericInterfacesInfo =
+      new GenericInterfacesInfoImpl(coreTypes, hierarchy);
   final protobufHandler = treeShakeProtobufs
       ? ProtobufHandler.forComponent(component, coreTypes)
       : null;
@@ -73,7 +73,7 @@
       protobufHandler,
       matcher);
 
-  Procedure main = component.mainMethod;
+  Procedure? main = component.mainMethod;
 
   // `main` can be null, roots can also come from @pragma("vm:entry-point").
   if (main != null) {
@@ -149,7 +149,7 @@
         if (!f.isStatic &&
             !f.isLate &&
             f.initializer != null &&
-            mayHaveSideEffects(f.initializer))
+            mayHaveSideEffects(f.initializer!))
           f
     ];
     if (fields.isEmpty) return;
@@ -173,7 +173,7 @@
       };
       final List<Initializer> newInitializers = [];
       for (Field f in fields) {
-        Expression initExpr = f.initializer;
+        Expression initExpr = f.initializer!;
         if (!isFirst) {
           initExpr = CloneVisitorNotMembers().clone(initExpr);
         }
@@ -204,7 +204,7 @@
 class CleanupAnnotations extends RecursiveVisitor {
   final Class externalNameClass;
   final Class pragmaClass;
-  final ProtobufHandler protobufHandler;
+  final ProtobufHandler? protobufHandler;
 
   CleanupAnnotations(
       CoreTypes coreTypes, LibraryIndex index, this.protobufHandler)
@@ -238,7 +238,7 @@
         return (cls == externalNameClass) ||
             (cls == pragmaClass) ||
             (protobufHandler != null &&
-                protobufHandler.usesAnnotationClass(cls));
+                protobufHandler!.usesAnnotationClass(cls));
       }
     }
     return false;
@@ -255,11 +255,11 @@
       : super(_typeFlowAnalysis.environment.coreTypes, component, hierarchy);
 
   @override
-  DirectCallMetadata getDirectCall(TreeNode node, Member interfaceTarget,
+  DirectCallMetadata? getDirectCall(TreeNode node, Member? interfaceTarget,
       {bool setter = false}) {
     final callSite = _typeFlowAnalysis.callSite(node);
     if (callSite != null) {
-      final Member singleTarget = fieldMorpher
+      final Member? singleTarget = fieldMorpher
           .getMorphedMember(callSite.monomorphicTarget, isSetter: setter);
       if (singleTarget != null) {
         return new DirectCallMetadata(
@@ -283,12 +283,13 @@
   final UnboxingInfoMetadataRepository _unboxingInfoMetadata;
   final UnboxingInfoManager _unboxingInfo;
   final Class _intClass;
-  Constant _nullConstant;
+  late final Constant _nullConstant = NullConstant();
 
   AnnotateKernel(Component component, this._typeFlowAnalysis, this.fieldMorpher,
       this._tableSelectorAssigner, this._unboxingInfo)
       : _directCallMetadataRepository =
-            component.metadata[DirectCallMetadataRepository.repositoryTag],
+            component.metadata[DirectCallMetadataRepository.repositoryTag]
+                as DirectCallMetadataRepository,
         _inferredTypeMetadata = new InferredTypeMetadataRepository(),
         _unreachableNodeMetadata = new UnreachableNodeMetadataRepository(),
         _procedureAttributesMetadata =
@@ -308,12 +309,10 @@
     return _directCallMetadataRepository.mapping.containsKey(node);
   }
 
-  InferredType _convertType(Type type,
+  InferredType? _convertType(Type type,
       {bool skipCheck: false, bool receiverNotInt: false}) {
-    assert(type != null);
-
-    Class concreteClass;
-    Constant constantValue;
+    Class? concreteClass;
+    Constant? constantValue;
     bool isInt = false;
 
     final nullable = type is NullableType;
@@ -324,7 +323,7 @@
     if (nullable && type == const EmptyType()) {
       concreteClass =
           _typeFlowAnalysis.environment.coreTypes.deprecatedNullClass;
-      constantValue = _nullConstant ??= new NullConstant();
+      constantValue = _nullConstant;
     } else {
       concreteClass = type.getConcreteClass(_typeFlowAnalysis.hierarchyCache);
 
@@ -337,9 +336,9 @@
       }
     }
 
-    List<DartType> typeArgs;
+    List<DartType?>? typeArgs;
     if (type is ConcreteType && type.typeArgs != null) {
-      typeArgs = type.typeArgs
+      typeArgs = type.typeArgs!
           .take(type.numImmediateTypeArgs)
           .map((t) =>
               t is UnknownType ? null : (t as RuntimeType).representedType)
@@ -374,7 +373,7 @@
     _unreachableNodeMetadata.mapping[node] = const UnreachableNode();
   }
 
-  void _annotateCallSite(TreeNode node, Member interfaceTarget) {
+  void _annotateCallSite(TreeNode node, Member? interfaceTarget) {
     final callSite = _typeFlowAnalysis.callSite(node);
     if (callSite == null) return;
     if (!callSite.isReachable) {
@@ -405,7 +404,7 @@
         if (interfaceTarget == null ||
             _typeFlowAnalysis.hierarchyCache.hierarchy.isSubtypeOf(
                 _typeFlowAnalysis.hierarchyCache.coreTypes.intClass,
-                interfaceTarget.enclosingClass)) {
+                interfaceTarget.enclosingClass!)) {
           markReceiverNotInt = true;
         }
       }
@@ -446,35 +445,33 @@
   void _annotateMember(Member member) {
     if (_typeFlowAnalysis.isMemberUsed(member)) {
       if (member is Field) {
-        _setInferredType(member, _typeFlowAnalysis.fieldType(member));
+        _setInferredType(member, _typeFlowAnalysis.fieldType(member)!);
       } else {
-        Args<Type> argTypes = _typeFlowAnalysis.argumentTypes(member);
+        Args<Type> argTypes = _typeFlowAnalysis.argumentTypes(member)!;
         final uncheckedParameters =
             _typeFlowAnalysis.uncheckedParameters(member);
-        assert(argTypes != null);
 
         final int firstParamIndex =
             numTypeParams(member) + (hasReceiverArg(member) ? 1 : 0);
 
-        final positionalParams = member.function.positionalParameters;
+        final positionalParams = member.function!.positionalParameters;
         assert(argTypes.positionalCount ==
             firstParamIndex + positionalParams.length);
 
         for (int i = 0; i < positionalParams.length; i++) {
           _setInferredType(
               positionalParams[i], argTypes.values[firstParamIndex + i],
-              skipCheck: uncheckedParameters.contains(positionalParams[i]));
+              skipCheck: uncheckedParameters!.contains(positionalParams[i]));
         }
 
         // TODO(dartbug.com/32292): make sure parameters are sorted in kernel
         // AST and iterate parameters in parallel, without lookup.
         final names = argTypes.names;
         for (int i = 0; i < names.length; i++) {
-          final param = findNamedParameter(member.function, names[i]);
-          assert(param != null);
+          final param = findNamedParameter(member.function!, names[i])!;
           _setInferredType(param,
               argTypes.values[firstParamIndex + positionalParams.length + i],
-              skipCheck: uncheckedParameters.contains(param));
+              skipCheck: uncheckedParameters!.contains(param));
         }
 
         // TODO(alexmarkov): figure out how to pass receiver type.
@@ -521,7 +518,7 @@
     // interface target, and table dispatch calls need selector IDs for all
     // interface targets.
     if (member.isInstanceMember) {
-      final original = fieldMorpher.getOriginalMember(member);
+      final original = fieldMorpher.getOriginalMember(member)!;
       final attrs = new ProcedureAttributesMetadata(
           methodOrSetterCalledDynamically:
               _typeFlowAnalysis.isCalledDynamically(original),
@@ -689,11 +686,11 @@
   final Set<Member> _usedMembers = new Set<Member>();
   final Set<Extension> _usedExtensions = new Set<Extension>();
   final Set<Typedef> _usedTypedefs = new Set<Typedef>();
-  FieldMorpher fieldMorpher;
-  _TreeShakerTypeVisitor typeVisitor;
-  _TreeShakerConstantVisitor constantVisitor;
-  _TreeShakerPass1 _pass1;
-  _TreeShakerPass2 _pass2;
+  late final FieldMorpher fieldMorpher;
+  late final _TreeShakerTypeVisitor typeVisitor;
+  late final _TreeShakerConstantVisitor constantVisitor;
+  late final _TreeShakerPass1 _pass1;
+  late final _TreeShakerPass2 _pass2;
 
   TreeShaker(Component component, this.typeFlowAnalysis,
       {this.treeShakeWriteOnlyFields: true}) {
@@ -734,7 +731,7 @@
               (!f.isStatic &&
                   f.initializer != null &&
                   isFieldInitializerReachable(f) &&
-                  mayHaveSideEffects(f.initializer)) ||
+                  mayHaveSideEffects(f.initializer!)) ||
               (f.isLate && f.isFinal)) ||
       isMemberReferencedFromNativeCode(f) ||
       _isInstanceFieldOfAllocatedEnum(f);
@@ -745,8 +742,8 @@
   bool _isInstanceFieldOfAllocatedEnum(Field node) =>
       !node.isStatic &&
       node.enclosingClass != null &&
-      node.enclosingClass.isEnum &&
-      isClassAllocated(node.enclosingClass);
+      node.enclosingClass!.isEnum &&
+      isClassAllocated(node.enclosingClass!);
 
   void addClassUsedInType(Class c) {
     if (_classesUsedInType.add(c)) {
@@ -777,7 +774,7 @@
         _usedClasses.add(enclosingClass);
       }
 
-      FunctionNode func = null;
+      FunctionNode? func = null;
       if (m is Field) {
         m.type.accept(typeVisitor);
       } else if (m is Procedure) {
@@ -786,19 +783,19 @@
           m.stubTarget = fieldMorpher.adjustInstanceCallTarget(
               m.concreteForwardingStubTarget,
               isSetter: m.isSetter);
-          addUsedMember(m.concreteForwardingStubTarget);
+          addUsedMember(m.concreteForwardingStubTarget!);
         }
         if (m.abstractForwardingStubTarget != null) {
           m.stubTarget = fieldMorpher.adjustInstanceCallTarget(
               m.abstractForwardingStubTarget,
               isSetter: m.isSetter);
-          addUsedMember(m.abstractForwardingStubTarget);
+          addUsedMember(m.abstractForwardingStubTarget!);
         }
         if (m.memberSignatureOrigin != null) {
           m.stubTarget = fieldMorpher.adjustInstanceCallTarget(
               m.memberSignatureOrigin,
               isSetter: m.isSetter);
-          addUsedMember(m.memberSignatureOrigin);
+          addUsedMember(m.memberSignatureOrigin!);
         }
       } else if (m is Constructor) {
         func = m.function;
@@ -821,8 +818,7 @@
         final extension = m.enclosingLibrary.extensions.firstWhere((extension) {
           return extension.members
               .any((descriptor) => descriptor.member.asMember == m);
-        }, orElse: () => null);
-        assert(extension != null);
+        });
 
         // Ensure we retain the [Extension] itself (though members might be
         // shaken)
@@ -844,7 +840,7 @@
     if (_usedExtensions.add(node)) {
       node.annotations = const <Expression>[];
       _pass1.transformTypeParameterList(node.typeParameters, node);
-      node.onType?.accept(typeVisitor);
+      node.onType.accept(typeVisitor);
     }
   }
 
@@ -898,7 +894,7 @@
           isAbstract: true, fileUri: field.fileUri);
     }
     accessor.fileOffset = field.fileOffset;
-    field.enclosingClass.addProcedure(accessor);
+    field.enclosingClass!.addProcedure(accessor);
     _removedFields[accessor] = field;
     shaker.addUsedMember(accessor);
     return accessor;
@@ -908,7 +904,7 @@
   /// If necessary, creates a getter or setter as a replacement if target is a
   /// field which is going to be removed by the tree shaker.
   /// This method is used during tree shaker pass 1.
-  Member adjustInstanceCallTarget(Member target, {bool isSetter = false}) {
+  Member? adjustInstanceCallTarget(Member? target, {bool isSetter = false}) {
     if (target is Field && !shaker.retainField(target)) {
       final targets =
           isSetter ? _settersForRemovedFields : _gettersForRemovedFields;
@@ -923,9 +919,9 @@
 
   /// Return a member which replaced [target] in instance calls.
   /// This method can be used after tree shaking to discover replacement.
-  Member getMorphedMember(Member target, {bool isSetter = false}) {
-    if (target == null) {
-      return null;
+  Member? getMorphedMember(Member? target, {bool isSetter = false}) {
+    if (target is! Field) {
+      return target;
     }
     final targets =
         isSetter ? _settersForRemovedFields : _gettersForRemovedFields;
@@ -934,7 +930,7 @@
 
   /// Return original member which was replaced by [target] in instance calls.
   /// This method can be used after tree shaking.
-  Member getOriginalMember(Member target) {
+  Member? getOriginalMember(Member? target) {
     if (target == null) {
       return null;
     }
@@ -994,16 +990,15 @@
   final TreeShaker shaker;
   final FieldMorpher fieldMorpher;
   final TypeEnvironment environment;
-  Procedure _unsafeCast;
 
-  StaticTypeContext _staticTypeContext;
-  Member _currentMember;
+  StaticTypeContext? _staticTypeContext;
+  Member? _currentMember;
 
   StaticTypeContext get staticTypeContext =>
       _staticTypeContext ??= StaticTypeContext(currentMember, environment);
 
-  Member get currentMember => _currentMember;
-  set currentMember(Member m) {
+  Member get currentMember => _currentMember!;
+  set currentMember(Member? m) {
     _currentMember = m;
     _staticTypeContext = null;
   }
@@ -1022,7 +1017,7 @@
   }
 
   List<Expression> _flattenArguments(Arguments arguments,
-      {Expression receiver}) {
+      {Expression? receiver}) {
     final args = <Expression>[];
     if (receiver != null) {
       args.add(receiver);
@@ -1035,9 +1030,9 @@
   bool _isThrowExpression(Expression expr) {
     for (;;) {
       if (expr is Let) {
-        expr = (expr as Let).body;
+        expr = expr.body;
       } else if (expr is BlockExpression) {
-        expr = (expr as BlockExpression).value;
+        expr = expr.value;
       } else {
         break;
       }
@@ -1068,7 +1063,7 @@
     return BlockExpression(Block(statements), value);
   }
 
-  TreeNode _makeUnreachableCall(List<Expression> args) {
+  Expression _makeUnreachableCall(List<Expression> args) {
     Expression node;
     final int last = args.indexWhere(_isThrowExpression);
     if (last >= 0) {
@@ -1090,12 +1085,12 @@
         new VariableDeclaration(null, initializer: _makeUnreachableCall(args)));
   }
 
-  NarrowNotNull _getNullTest(TreeNode node) =>
+  NarrowNotNull? _getNullTest(TreeNode node) =>
       shaker.typeFlowAnalysis.nullTest(node);
 
-  TreeNode _visitAssertNode(TreeNode node, TreeNode removalSentinel) {
+  TreeNode _visitAssertNode(TreeNode node, TreeNode? removalSentinel) {
     if (kRemoveAsserts) {
-      return removalSentinel;
+      return removalSentinel!;
     } else {
       node.transformOrRemoveChildren(this);
       return node;
@@ -1103,31 +1098,31 @@
   }
 
   @override
-  DartType visitDartType(DartType node, DartType removalSentinel) {
+  DartType visitDartType(DartType node, DartType? removalSentinel) {
     node.accept(shaker.typeVisitor);
     return node;
   }
 
   @override
-  Supertype visitSupertype(Supertype node, Supertype removalSentinel) {
+  Supertype visitSupertype(Supertype node, Supertype? removalSentinel) {
     node.accept(shaker.typeVisitor);
     return node;
   }
 
   @override
-  TreeNode visitTypedef(Typedef node, TreeNode removalSentinel) {
+  TreeNode visitTypedef(Typedef node, TreeNode? removalSentinel) {
     return node; // Do not go deeper.
   }
 
   @override
-  Extension visitExtension(Extension node, TreeNode removalSentinel) {
+  TreeNode visitExtension(Extension node, TreeNode? removalSentinel) {
     // The extension can be considered a weak node, we'll only retain it if
     // normal code references any of it's members.
     return node;
   }
 
   @override
-  TreeNode visitClass(Class node, TreeNode removalSentinel) {
+  TreeNode visitClass(Class node, TreeNode? removalSentinel) {
     if (shaker.isClassAllocated(node) ||
         shaker.isClassReferencedFromNativeCode(node)) {
       shaker.addClassUsedInType(node);
@@ -1140,7 +1135,7 @@
   }
 
   @override
-  TreeNode defaultMember(Member node, TreeNode removalSentinel) {
+  TreeNode defaultMember(Member node, TreeNode? removalSentinel) {
     currentMember = node;
     if (shaker.isMemberBodyReachable(node)) {
       if (kPrintTrace) {
@@ -1160,7 +1155,7 @@
   }
 
   @override
-  TreeNode visitField(Field node, TreeNode removalSentinel) {
+  TreeNode visitField(Field node, TreeNode? removalSentinel) {
     currentMember = node;
     if (shaker.retainField(node)) {
       if (kPrintTrace) {
@@ -1185,21 +1180,21 @@
 
   @override
   TreeNode visitInstanceInvocation(
-      InstanceInvocation node, TreeNode removalSentinel) {
+      InstanceInvocation node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall(
           _flattenArguments(node.arguments, receiver: node.receiver));
     }
-    node.interfaceTarget =
-        fieldMorpher.adjustInstanceCallTarget(node.interfaceTarget);
+    node.interfaceTarget = fieldMorpher
+        .adjustInstanceCallTarget(node.interfaceTarget) as Procedure;
     shaker.addUsedMember(node.interfaceTarget);
     return node;
   }
 
   @override
   TreeNode visitDynamicInvocation(
-      DynamicInvocation node, TreeNode removalSentinel) {
+      DynamicInvocation node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall(
@@ -1210,7 +1205,7 @@
 
   @override
   TreeNode visitLocalFunctionInvocation(
-      LocalFunctionInvocation node, TreeNode removalSentinel) {
+      LocalFunctionInvocation node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall(_flattenArguments(node.arguments));
@@ -1220,7 +1215,7 @@
 
   @override
   TreeNode visitFunctionInvocation(
-      FunctionInvocation node, TreeNode removalSentinel) {
+      FunctionInvocation node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall(
@@ -1230,24 +1225,24 @@
   }
 
   @override
-  TreeNode visitEqualsCall(EqualsCall node, TreeNode removalSentinel) {
+  TreeNode visitEqualsCall(EqualsCall node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.left, node.right]);
     }
-    node.interfaceTarget =
-        fieldMorpher.adjustInstanceCallTarget(node.interfaceTarget);
+    node.interfaceTarget = fieldMorpher
+        .adjustInstanceCallTarget(node.interfaceTarget) as Procedure;
     shaker.addUsedMember(node.interfaceTarget);
     return node;
   }
 
   @override
-  TreeNode visitEqualsNull(EqualsNull node, TreeNode removalSentinel) {
+  TreeNode visitEqualsNull(EqualsNull node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.expression]);
     }
-    final nullTest = _getNullTest(node);
+    final nullTest = _getNullTest(node)!;
     if (nullTest.isAlwaysNull || nullTest.isAlwaysNotNull) {
       return _evaluateArguments([node.expression],
           BoolLiteral(nullTest.isAlwaysNull)..fileOffset = node.fileOffset);
@@ -1256,13 +1251,13 @@
   }
 
   @override
-  TreeNode visitInstanceGet(InstanceGet node, TreeNode removalSentinel) {
+  TreeNode visitInstanceGet(InstanceGet node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.receiver]);
     } else {
       node.interfaceTarget =
-          fieldMorpher.adjustInstanceCallTarget(node.interfaceTarget);
+          fieldMorpher.adjustInstanceCallTarget(node.interfaceTarget)!;
       shaker.addUsedMember(node.interfaceTarget);
       return node;
     }
@@ -1270,20 +1265,20 @@
 
   @override
   TreeNode visitInstanceTearOff(
-      InstanceTearOff node, TreeNode removalSentinel) {
+      InstanceTearOff node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.receiver]);
     } else {
-      node.interfaceTarget =
-          fieldMorpher.adjustInstanceCallTarget(node.interfaceTarget);
+      node.interfaceTarget = fieldMorpher
+          .adjustInstanceCallTarget(node.interfaceTarget) as Procedure;
       shaker.addUsedMember(node.interfaceTarget);
       return node;
     }
   }
 
   @override
-  TreeNode visitDynamicGet(DynamicGet node, TreeNode removalSentinel) {
+  TreeNode visitDynamicGet(DynamicGet node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.receiver]);
@@ -1294,7 +1289,7 @@
 
   @override
   TreeNode visitFunctionTearOff(
-      FunctionTearOff node, TreeNode removalSentinel) {
+      FunctionTearOff node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.receiver]);
@@ -1304,20 +1299,20 @@
   }
 
   @override
-  TreeNode visitInstanceSet(InstanceSet node, TreeNode removalSentinel) {
+  TreeNode visitInstanceSet(InstanceSet node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.receiver, node.value]);
     } else {
       node.interfaceTarget = fieldMorpher
-          .adjustInstanceCallTarget(node.interfaceTarget, isSetter: true);
+          .adjustInstanceCallTarget(node.interfaceTarget, isSetter: true)!;
       shaker.addUsedMember(node.interfaceTarget);
       return node;
     }
   }
 
   @override
-  TreeNode visitDynamicSet(DynamicSet node, TreeNode removalSentinel) {
+  TreeNode visitDynamicSet(DynamicSet node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.receiver, node.value]);
@@ -1328,15 +1323,15 @@
 
   @override
   TreeNode visitSuperMethodInvocation(
-      SuperMethodInvocation node, TreeNode removalSentinel) {
+      SuperMethodInvocation node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall(_flattenArguments(node.arguments));
     } else {
-      node.interfaceTarget =
-          fieldMorpher.adjustInstanceCallTarget(node.interfaceTarget);
+      node.interfaceTarget = fieldMorpher
+          .adjustInstanceCallTarget(node.interfaceTarget) as Procedure?;
       if (node.interfaceTarget != null) {
-        shaker.addUsedMember(node.interfaceTarget);
+        shaker.addUsedMember(node.interfaceTarget!);
       }
       return node;
     }
@@ -1344,7 +1339,7 @@
 
   @override
   TreeNode visitSuperPropertyGet(
-      SuperPropertyGet node, TreeNode removalSentinel) {
+      SuperPropertyGet node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([]);
@@ -1352,7 +1347,7 @@
       node.interfaceTarget =
           fieldMorpher.adjustInstanceCallTarget(node.interfaceTarget);
       if (node.interfaceTarget != null) {
-        shaker.addUsedMember(node.interfaceTarget);
+        shaker.addUsedMember(node.interfaceTarget!);
       }
       return node;
     }
@@ -1360,7 +1355,7 @@
 
   @override
   TreeNode visitSuperPropertySet(
-      SuperPropertySet node, TreeNode removalSentinel) {
+      SuperPropertySet node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.value]);
@@ -1368,7 +1363,7 @@
       node.interfaceTarget = fieldMorpher
           .adjustInstanceCallTarget(node.interfaceTarget, isSetter: true);
       if (node.interfaceTarget != null) {
-        shaker.addUsedMember(node.interfaceTarget);
+        shaker.addUsedMember(node.interfaceTarget!);
       }
       return node;
     }
@@ -1376,7 +1371,7 @@
 
   @override
   TreeNode visitStaticInvocation(
-      StaticInvocation node, TreeNode removalSentinel) {
+      StaticInvocation node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall(_flattenArguments(node.arguments));
@@ -1390,7 +1385,7 @@
   }
 
   @override
-  TreeNode visitStaticGet(StaticGet node, TreeNode removalSentinel) {
+  TreeNode visitStaticGet(StaticGet node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([]);
@@ -1405,13 +1400,13 @@
   }
 
   @override
-  Constant visitConstant(Constant node, Constant removalSentinel) {
+  Constant visitConstant(Constant node, Constant? removalSentinel) {
     shaker.constantVisitor.analyzeConstant(node);
     return node;
   }
 
   @override
-  TreeNode visitStaticSet(StaticSet node, TreeNode removalSentinel) {
+  TreeNode visitStaticSet(StaticSet node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall([node.value]);
@@ -1428,7 +1423,7 @@
 
   @override
   TreeNode visitConstructorInvocation(
-      ConstructorInvocation node, TreeNode removalSentinel) {
+      ConstructorInvocation node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableCall(_flattenArguments(node.arguments));
@@ -1444,7 +1439,7 @@
 
   @override
   TreeNode visitRedirectingInitializer(
-      RedirectingInitializer node, TreeNode removalSentinel) {
+      RedirectingInitializer node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableInitializer(_flattenArguments(node.arguments));
@@ -1457,7 +1452,7 @@
 
   @override
   TreeNode visitSuperInitializer(
-      SuperInitializer node, TreeNode removalSentinel) {
+      SuperInitializer node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableInitializer(_flattenArguments(node.arguments));
@@ -1469,7 +1464,7 @@
 
   @override
   TreeNode visitFieldInitializer(
-      FieldInitializer node, TreeNode removalSentinel) {
+      FieldInitializer node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     if (_isUnreachable(node)) {
       return _makeUnreachableInitializer([node.value]);
@@ -1482,7 +1477,7 @@
           return LocalInitializer(
               VariableDeclaration(null, initializer: node.value));
         } else {
-          return removalSentinel;
+          return removalSentinel!;
         }
       }
       return node;
@@ -1491,18 +1486,18 @@
 
   @override
   TreeNode visitAssertStatement(
-      AssertStatement node, TreeNode removalSentinel) {
+      AssertStatement node, TreeNode? removalSentinel) {
     return _visitAssertNode(node, removalSentinel);
   }
 
   @override
-  TreeNode visitAssertBlock(AssertBlock node, TreeNode removalSentinel) {
+  TreeNode visitAssertBlock(AssertBlock node, TreeNode? removalSentinel) {
     return _visitAssertNode(node, removalSentinel);
   }
 
   @override
   TreeNode visitAssertInitializer(
-      AssertInitializer node, TreeNode removalSentinel) {
+      AssertInitializer node, TreeNode? removalSentinel) {
     return _visitAssertNode(node, removalSentinel);
   }
 
@@ -1520,21 +1515,21 @@
 
   // Returns Block corresponding to the given extended bool literal,
   // or null if the expression is a simple bool literal.
-  Block _getExtendedBoolLiteralBlock(Expression expr) =>
+  Block? _getExtendedBoolLiteralBlock(Expression expr) =>
       (expr is BoolLiteral) ? null : (expr as BlockExpression).body;
 
   @override
-  TreeNode visitIfStatement(IfStatement node, TreeNode removalSentinel) {
+  TreeNode visitIfStatement(IfStatement node, TreeNode? removalSentinel) {
     final condition = transform(node.condition);
     if (_isExtendedBoolLiteral(condition)) {
       final bool conditionValue = _getExtendedBoolLiteralValue(condition);
-      final Block conditionBlock = _getExtendedBoolLiteralBlock(condition);
-      ast.Statement body;
+      final Block? conditionBlock = _getExtendedBoolLiteralBlock(condition);
+      ast.Statement? body;
       if (conditionValue) {
         body = transform(node.then);
       } else {
         if (node.otherwise != null) {
-          body = transformOrRemoveStatement(node.otherwise);
+          body = transformOrRemoveStatement(node.otherwise!);
         }
       }
       if (conditionBlock != null) {
@@ -1549,7 +1544,7 @@
     node.condition = condition..parent = node;
     node.then = transform(node.then)..parent = node;
     if (node.otherwise != null) {
-      node.otherwise = transformOrRemoveStatement(node.otherwise);
+      node.otherwise = transformOrRemoveStatement(node.otherwise!);
       node.otherwise?.parent = node;
     }
     return node;
@@ -1557,7 +1552,7 @@
 
   @override
   visitConditionalExpression(
-      ConditionalExpression node, TreeNode removalSentinel) {
+      ConditionalExpression node, TreeNode? removalSentinel) {
     final condition = transform(node.condition);
     if (_isExtendedBoolLiteral(condition)) {
       final bool value = _getExtendedBoolLiteralValue(condition);
@@ -1578,7 +1573,7 @@
   }
 
   @override
-  TreeNode visitNot(Not node, TreeNode removalSentinel) {
+  TreeNode visitNot(Not node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     final operand = node.operand;
     if (_isExtendedBoolLiteral(operand)) {
@@ -1595,7 +1590,7 @@
 
   @override
   TreeNode visitLogicalExpression(
-      LogicalExpression node, TreeNode removalSentinel) {
+      LogicalExpression node, TreeNode? removalSentinel) {
     final left = transform(node.left);
     final operatorEnum = node.operatorEnum;
     if (_isExtendedBoolLiteral(left)) {
@@ -1621,8 +1616,8 @@
   }
 
   @override
-  TreeNode visitIsExpression(IsExpression node, TreeNode removalSentinel) {
-    TypeCheck check = shaker.typeFlowAnalysis.isTest(node);
+  TreeNode visitIsExpression(IsExpression node, TreeNode? removalSentinel) {
+    TypeCheck? check = shaker.typeFlowAnalysis.isTest(node);
     if (check != null && (check.alwaysFail || check.alwaysPass)) {
       final operand = transform(node.operand);
       final result = BoolLiteral(!check.alwaysFail)
@@ -1634,9 +1629,9 @@
   }
 
   @override
-  TreeNode visitAsExpression(AsExpression node, TreeNode removalSentinel) {
+  TreeNode visitAsExpression(AsExpression node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
-    TypeCheck check = shaker.typeFlowAnalysis.explicitCast(node);
+    TypeCheck? check = shaker.typeFlowAnalysis.explicitCast(node);
     if (check != null && check.alwaysPass) {
       return StaticInvocation(
           unsafeCast, Arguments([node.operand], types: [node.type]))
@@ -1646,9 +1641,9 @@
   }
 
   @override
-  TreeNode visitNullCheck(NullCheck node, TreeNode removalSentinel) {
+  TreeNode visitNullCheck(NullCheck node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
-    final nullTest = _getNullTest(node);
+    final nullTest = _getNullTest(node)!;
     if (nullTest.isAlwaysNotNull) {
       return StaticInvocation(
           unsafeCast,
@@ -1659,12 +1654,9 @@
     return node;
   }
 
-  Procedure get unsafeCast {
-    _unsafeCast ??= shaker.typeFlowAnalysis.environment.coreTypes.index
-        .getTopLevelMember('dart:_internal', 'unsafeCast');
-    assert(_unsafeCast != null);
-    return _unsafeCast;
-  }
+  late final Procedure unsafeCast = shaker
+      .typeFlowAnalysis.environment.coreTypes.index
+      .getTopLevelProcedure('dart:_internal', 'unsafeCast');
 }
 
 /// The second pass of [TreeShaker]. It is called after set of used
@@ -1680,7 +1672,7 @@
   void transformComponent(Component component) {
     component.transformOrRemoveChildren(this);
     for (Source source in component.uriToSource.values) {
-      source?.constantCoverageConstructors?.removeWhere((Reference reference) {
+      source.constantCoverageConstructors?.removeWhere((Reference reference) {
         Member node = reference.asMember;
         return !shaker.isMemberUsed(node);
       });
@@ -1688,7 +1680,7 @@
   }
 
   @override
-  TreeNode visitLibrary(Library node, TreeNode removalSentinel) {
+  TreeNode visitLibrary(Library node, TreeNode? removalSentinel) {
     node.transformOrRemoveChildren(this);
     // The transformer API does not iterate over `Library.additionalExports`,
     // so we manually delete the references to shaken nodes.
@@ -1708,12 +1700,12 @@
   }
 
   @override
-  Typedef visitTypedef(Typedef node, TreeNode removalSentinel) {
-    return shaker.isTypedefUsed(node) ? node : removalSentinel;
+  TreeNode visitTypedef(Typedef node, TreeNode? removalSentinel) {
+    return shaker.isTypedefUsed(node) ? node : removalSentinel!;
   }
 
   @override
-  Class visitClass(Class node, TreeNode removalSentinel) {
+  TreeNode visitClass(Class node, TreeNode? removalSentinel) {
     if (!shaker.isClassUsed(node)) {
       debugPrint('Dropped class ${node.name}');
       // Ensure that kernel file writer will not be able to
@@ -1724,7 +1716,7 @@
           "been repurposed for ${node.reference.node}.");
       node.reference.canonicalName?.unbind();
       Statistics.classesDropped++;
-      return removalSentinel; // Remove the class.
+      return removalSentinel!; // Remove the class.
     }
 
     if (!shaker.isClassUsedInType(node)) {
@@ -1755,7 +1747,7 @@
   }
 
   @override
-  Member defaultMember(Member node, TreeNode removalSentinel) {
+  TreeNode defaultMember(Member node, TreeNode? removalSentinel) {
     if (!shaker.isMemberUsed(node)) {
       // Ensure that kernel file writer will not be able to
       // write a dangling reference to the deleted member.
@@ -1767,10 +1759,10 @@
         node.getterReference.canonicalName?.unbind();
         if (node.hasSetter) {
           assert(
-              node.setterReference.node == node,
+              node.setterReference!.node == node,
               "Trying to remove canonical name from reference on $node which "
-              "has been repurposed for ${node.setterReference.node}.");
-          node.setterReference.canonicalName?.unbind();
+              "has been repurposed for ${node.setterReference!.node}.");
+          node.setterReference!.canonicalName?.unbind();
         }
       } else {
         assert(
@@ -1780,13 +1772,13 @@
         node.reference.canonicalName?.unbind();
       }
       Statistics.membersDropped++;
-      return removalSentinel;
+      return removalSentinel!;
     }
 
     if (!shaker.isMemberBodyReachable(node)) {
       if (node is Procedure) {
         // Remove body of unused member.
-        if (!node.isStatic && node.enclosingClass.isAbstract) {
+        if (!node.isStatic && node.enclosingClass!.isAbstract) {
           node.isAbstract = true;
           node.function.body = null;
         } else {
@@ -1829,7 +1821,7 @@
   }
 
   @override
-  Extension visitExtension(Extension node, TreeNode removalSentinel) {
+  TreeNode visitExtension(Extension node, TreeNode? removalSentinel) {
     if (shaker.isExtensionUsed(node)) {
       int writeIndex = 0;
       for (int i = 0; i < node.members.length; ++i) {
@@ -1840,7 +1832,7 @@
         // member was already removed or it will be removed later.
         final Reference memberReference = descriptor.member;
         final bool isBound = memberReference.node != null;
-        if (isBound && shaker.isMemberUsed(memberReference.node)) {
+        if (isBound && shaker.isMemberUsed(memberReference.asMember)) {
           node.members[writeIndex++] = descriptor;
         }
       }
@@ -1850,7 +1842,7 @@
       assert(node.members.length > 0);
       return node;
     }
-    return removalSentinel;
+    return removalSentinel!;
   }
 
   void _makeUnreachableBody(FunctionNode function) {
@@ -1871,7 +1863,7 @@
   }
 
   @override
-  TreeNode defaultTreeNode(TreeNode node, TreeNode removalSentinel) {
+  TreeNode defaultTreeNode(TreeNode node, TreeNode? removalSentinel) {
     return node; // Do not traverse into other nodes.
   }
 }
diff --git a/pkg/vm/lib/transformations/type_flow/types.dart b/pkg/vm/lib/transformations/type_flow/types.dart
index 588512c..3ed7b9b 100644
--- a/pkg/vm/lib/transformations/type_flow/types.dart
+++ b/pkg/vm/lib/transformations/type_flow/types.dart
@@ -2,10 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Declares the type system used by global type flow analysis.
-library vm.transformations.type_flow.types;
 
 import 'dart:core' hide Type;
 
@@ -138,10 +135,7 @@
   /// values can flow through the program.
   Type specializeTypeCone(TFClass base, {bool allowWideCone = false});
 
-  Type _cachedIntType;
-  Type get intType {
-    return _cachedIntType ??= fromStaticType(coreTypes.intLegacyRawType, true);
-  }
+  late final Type intType = fromStaticType(coreTypes.intLegacyRawType, true);
 }
 
 /// Base class for type expressions.
@@ -151,7 +145,7 @@
 
   /// Returns computed type of this type expression.
   /// [types] is the list of types computed for the statements in the summary.
-  Type getComputedType(List<Type> types);
+  Type getComputedType(List<Type?> types);
 }
 
 /// Kind of a subtype test: subtype/cast/'as' test or instance check/'is' test.
@@ -174,7 +168,7 @@
   /// Create a type representing arbitrary nullable object (`dynamic`).
   factory Type.nullableAny() => new NullableType(const AnyType());
 
-  Class getConcreteClass(TypeHierarchy typeHierarchy) => null;
+  Class? getConcreteClass(TypeHierarchy typeHierarchy) => null;
 
   bool isSubtypeOf(TypeHierarchy typeHierarchy, Class cls) => false;
 
@@ -185,7 +179,7 @@
       RuntimeType runtimeType, SubtypeTestKind kind);
 
   @override
-  Type getComputedType(List<Type> types) => this;
+  Type getComputedType(List<Type?> types) => this;
 
   /// Order of precedence for evaluation of union/intersection.
   int get order;
@@ -260,7 +254,6 @@
   final Type baseType;
 
   NullableType(this.baseType) {
-    assert(baseType != null);
     assert(baseType is! NullableType);
   }
 
@@ -387,7 +380,9 @@
 class SetType extends Type {
   /// List of concrete types, sorted by classId.
   final List<ConcreteType> types;
-  int _hashCode;
+
+  @override
+  late final int hashCode = _computeHashCode();
 
   /// Creates a new SetType using list of concrete types sorted by classId.
   SetType(this.types) {
@@ -395,9 +390,6 @@
     assert(isSorted(types));
   }
 
-  @override
-  int get hashCode => _hashCode ??= _computeHashCode();
-
   int _computeHashCode() {
     int hash = 1237;
     for (var t in types) {
@@ -470,8 +462,8 @@
     return types;
   }
 
-  static List<ConcreteType> _intersectLists(
-      List<ConcreteType> types1, List<ConcreteType> types2) {
+  static List<ConcreteType> _intersectLists(List<ConcreteType> types1,
+      List<ConcreteType> types2, TypeHierarchy typeHierarchy) {
     int i1 = 0;
     int i2 = 0;
     List<ConcreteType> types = <ConcreteType>[];
@@ -491,9 +483,9 @@
             t2.constant == null) {
           types.add(t1);
         } else {
-          final intersect = t1.intersection(t2, null);
+          final intersect = t1.intersection(t2, typeHierarchy);
           if (intersect is! EmptyType) {
-            types.add(intersect);
+            types.add(intersect as ConcreteType);
           }
         }
         ++i1;
@@ -558,7 +550,8 @@
       return other.intersection(this, typeHierarchy);
     }
     if (other is SetType) {
-      List<ConcreteType> list = _intersectLists(types, other.types);
+      List<ConcreteType> list =
+          _intersectLists(types, other.types, typeHierarchy);
       final size = list.length;
       if (size == 0) {
         return const EmptyType();
@@ -594,7 +587,7 @@
   ConeType(this.cls);
 
   @override
-  Class getConcreteClass(TypeHierarchy typeHierarchy) => typeHierarchy
+  Class? getConcreteClass(TypeHierarchy typeHierarchy) => typeHierarchy
       .specializeTypeCone(cls, allowWideCone: true)
       .getConcreteClass(typeHierarchy);
 
@@ -696,7 +689,7 @@
   WideConeType(TFClass cls) : super(cls);
 
   @override
-  Class getConcreteClass(TypeHierarchy typeHierarchy) => null;
+  Class? getConcreteClass(TypeHierarchy typeHierarchy) => null;
 
   @override
   int get hashCode => (cls.id + 41) & kHashMask;
@@ -783,7 +776,9 @@
 /// or `null` object).
 class ConcreteType extends Type implements Comparable<ConcreteType> {
   final TFClass cls;
-  int _hashCode;
+
+  @override
+  late final int hashCode = _computeHashCode();
 
   // May be null if there are no type arguments constraints. The type arguments
   // should represent type sets, i.e. `UnknownType` or `RuntimeType`. The type
@@ -796,19 +791,19 @@
   // 'numImmediateTypeArgs' is the length of the prefix of 'typeArgs' which
   // holds the type arguments to the class itself.
   final int numImmediateTypeArgs;
-  final List<Type> typeArgs;
+  final List<Type>? typeArgs;
 
   // May be null if constant value is not inferred.
-  final Constant constant;
+  final Constant? constant;
 
-  ConcreteType(this.cls, [List<Type> typeArgs_, this.constant])
+  ConcreteType(this.cls, [List<Type>? typeArgs_, this.constant])
       : typeArgs = typeArgs_,
         numImmediateTypeArgs =
             typeArgs_ != null ? cls.classNode.typeParameters.length : 0 {
     // TODO(alexmarkov): support closures
     assert(!cls.classNode.isAbstract);
     assert(typeArgs == null || cls.classNode.typeParameters.isNotEmpty);
-    assert(typeArgs == null || typeArgs.any((t) => t is RuntimeType));
+    assert(typeArgs == null || typeArgs!.any((t) => t is RuntimeType));
   }
 
   ConcreteType get raw => cls.concreteType;
@@ -839,7 +834,7 @@
 
       if (rhs.typeArguments.isEmpty) return true;
 
-      List<Type> usableTypeArgs = typeArgs;
+      List<Type>? usableTypeArgs = typeArgs;
       if (usableTypeArgs == null) {
         if (cls.classNode.typeParameters.isEmpty) {
           usableTypeArgs =
@@ -862,7 +857,7 @@
         }
         assert(ta is RuntimeType);
         if (!ta.isSubtypeOfRuntimeType(
-            typeHierarchy, runtimeType.typeArgs[i], SubtypeTestKind.Subtype)) {
+            typeHierarchy, runtimeType.typeArgs![i], SubtypeTestKind.Subtype)) {
           return false;
         }
       }
@@ -877,29 +872,26 @@
         } else {
           final interfaceOffset = typeHierarchy.genericInterfaceOffsetFor(
               cls.classNode, typeHierarchy.coreTypes.futureClass);
-          typeArg = typeArgs[interfaceOffset];
+          typeArg = typeArgs![interfaceOffset];
         }
         final RuntimeType lhs =
             typeArg is RuntimeType ? typeArg : RuntimeType(DynamicType(), null);
         return lhs.isSubtypeOfRuntimeType(
-            typeHierarchy, runtimeType.typeArgs[0], SubtypeTestKind.Subtype);
+            typeHierarchy, runtimeType.typeArgs![0], SubtypeTestKind.Subtype);
       } else {
         return isSubtypeOfRuntimeType(
-            typeHierarchy, runtimeType.typeArgs[0], SubtypeTestKind.Subtype);
+            typeHierarchy, runtimeType.typeArgs![0], SubtypeTestKind.Subtype);
       }
     }
     return false;
   }
 
-  @override
-  int get hashCode => _hashCode ??= _computeHashCode();
-
   int _computeHashCode() {
     int hash = cls.hashCode ^ 0x1234 & kHashMask;
     // We only need to hash the first type arguments vector, since the type
     // arguments of the implemented interfaces are implied by it.
     for (int i = 0; i < numImmediateTypeArgs; ++i) {
-      hash = (((hash * 31) & kHashMask) + typeArgs[i].hashCode) & kHashMask;
+      hash = (((hash * 31) & kHashMask) + typeArgs![i].hashCode) & kHashMask;
     }
     hash = ((hash * 31) & kHashMask) + constant.hashCode;
     return hash;
@@ -915,7 +907,7 @@
       }
       if (this.typeArgs != null) {
         for (int i = 0; i < numImmediateTypeArgs; ++i) {
-          if (this.typeArgs[i] != other.typeArgs[i]) {
+          if (this.typeArgs![i] != other.typeArgs![i]) {
             return false;
           }
         }
@@ -942,10 +934,10 @@
     final StringBuffer buf = new StringBuffer();
     buf.write("_T (${cls}");
     if (typeArgs != null) {
-      buf.write("<${typeArgs.take(numImmediateTypeArgs).join(', ')}>");
+      buf.write("<${typeArgs!.take(numImmediateTypeArgs).join(', ')}>");
     }
     if (constant != null) {
-      buf.write(", ${nodeToText(constant)}");
+      buf.write(", ${nodeToText(constant!)}");
     }
     buf.write(")");
     return buf.toString();
@@ -997,17 +989,21 @@
         return this;
       }
 
-      List<Type> mergedTypeArgs;
-      if (typeArgs == null) {
-        mergedTypeArgs = other.typeArgs;
-      } else if (other.typeArgs == null) {
-        mergedTypeArgs = typeArgs;
+      List<Type>? mergedTypeArgs;
+      final thisTypeArgs = this.typeArgs;
+      final otherTypeArgs = other.typeArgs;
+      if (thisTypeArgs == null) {
+        mergedTypeArgs = otherTypeArgs;
+      } else if (otherTypeArgs == null) {
+        mergedTypeArgs = thisTypeArgs;
       } else {
-        mergedTypeArgs = new List<Type>.filled(typeArgs.length, null);
+        assert(thisTypeArgs.length == otherTypeArgs.length);
+        mergedTypeArgs =
+            new List<Type>.filled(thisTypeArgs.length, const EmptyType());
         bool hasRuntimeType = false;
-        for (int i = 0; i < typeArgs.length; ++i) {
+        for (int i = 0; i < thisTypeArgs.length; ++i) {
           final merged =
-              typeArgs[i].intersection(other.typeArgs[i], typeHierarchy);
+              thisTypeArgs[i].intersection(otherTypeArgs[i], typeHierarchy);
           if (merged is EmptyType) {
             return const EmptyType();
           } else if (merged is RuntimeType) {
@@ -1020,7 +1016,7 @@
         }
       }
 
-      Constant mergedConstant;
+      Constant? mergedConstant;
       if (constant == null) {
         mergedConstant = other.constant;
       } else if (other.constant == null || constant == other.constant) {
@@ -1062,7 +1058,7 @@
   final DartType _type; // Doesn't contain type args.
 
   final int numImmediateTypeArgs;
-  final List<RuntimeType> typeArgs;
+  final List<RuntimeType>? typeArgs;
 
   RuntimeType(DartType type, this.typeArgs)
       : _type = type,
@@ -1070,14 +1066,12 @@
             ? type.classNode.typeParameters.length
             : (type is FutureOrType ? 1 : 0) {
     if (_type is InterfaceType && numImmediateTypeArgs > 0) {
-      assert(typeArgs != null);
-      assert(typeArgs.length >= numImmediateTypeArgs);
+      assert(typeArgs!.length >= numImmediateTypeArgs);
       assert((_type as InterfaceType)
           .typeArguments
           .every((t) => t == const DynamicType()));
     } else if (_type is FutureOrType) {
-      assert(typeArgs != null);
-      assert(typeArgs.length >= numImmediateTypeArgs);
+      assert(typeArgs!.length >= numImmediateTypeArgs);
       DartType typeArgument = (_type as FutureOrType).typeArgument;
       assert(typeArgument == const DynamicType());
     } else {
@@ -1098,25 +1092,27 @@
     final type = _type;
     if (type is InterfaceType && typeArgs != null) {
       final klass = type.classNode;
-      final typeArguments = typeArgs
+      final typeArguments = typeArgs!
           .take(klass.typeParameters.length)
           .map((pt) => pt.representedType)
           .toList();
       return new InterfaceType(klass, type.nullability, typeArguments);
     } else if (type is FutureOrType) {
-      return new FutureOrType(typeArgs[0].representedType, type.nullability);
+      return new FutureOrType(typeArgs![0].representedType, type.nullability);
     } else {
       return type;
     }
   }
 
   @override
-  int get hashCode {
+  late final int hashCode = _computeHashCode();
+
+  int _computeHashCode() {
     int hash = _type.hashCode ^ 0x1234 & kHashMask;
     // Only hash by the type arguments of the class. The type arguments of
     // supertypes are are implied by them.
     for (int i = 0; i < numImmediateTypeArgs; ++i) {
-      hash = (((hash * 31) & kHashMask) + typeArgs[i].hashCode) & kHashMask;
+      hash = (((hash * 31) & kHashMask) + typeArgs![i].hashCode) & kHashMask;
     }
     return hash;
   }
@@ -1127,7 +1123,7 @@
     if (other is RuntimeType) {
       if (other._type != _type) return false;
       assert(numImmediateTypeArgs == other.numImmediateTypeArgs);
-      return typeArgs == null || listEquals(typeArgs, other.typeArgs);
+      return typeArgs == null || listEquals(typeArgs!, other.typeArgs!);
     }
     return false;
   }
@@ -1139,7 +1135,7 @@
         : "${nodeToText(_type)}";
     final typeArgsStrs = (numImmediateTypeArgs == 0)
         ? ""
-        : "<${typeArgs.take(numImmediateTypeArgs).map((t) => "$t").join(", ")}>";
+        : "<${typeArgs!.take(numImmediateTypeArgs).map((t) => "$t").join(", ")}>";
     final nullability = _type.nullability.suffix;
     return "$head$typeArgsStrs$nullability";
   }
@@ -1200,15 +1196,15 @@
       if (_type is InterfaceType) {
         Class thisClass = (_type as InterfaceType).classNode;
         if (thisClass == typeHierarchy.coreTypes.futureClass) {
-          return typeArgs[0].isSubtypeOfRuntimeType(
-              typeHierarchy, runtimeType.typeArgs[0], SubtypeTestKind.Subtype);
+          return typeArgs![0].isSubtypeOfRuntimeType(
+              typeHierarchy, runtimeType.typeArgs![0], SubtypeTestKind.Subtype);
         } else {
           return isSubtypeOfRuntimeType(
-              typeHierarchy, runtimeType.typeArgs[0], SubtypeTestKind.Subtype);
+              typeHierarchy, runtimeType.typeArgs![0], SubtypeTestKind.Subtype);
         }
       } else if (_type is FutureOrType) {
-        return typeArgs[0].isSubtypeOfRuntimeType(
-            typeHierarchy, runtimeType.typeArgs[0], SubtypeTestKind.Subtype);
+        return typeArgs![0].isSubtypeOfRuntimeType(
+            typeHierarchy, runtimeType.typeArgs![0], SubtypeTestKind.Subtype);
       }
     }
 
@@ -1236,7 +1232,7 @@
       return true;
     }
 
-    List<Type> usableTypeArgs = typeArgs;
+    List<Type>? usableTypeArgs = typeArgs;
     if (usableTypeArgs == null) {
       assert(thisClass.typeParameters.isEmpty);
       usableTypeArgs =
@@ -1248,7 +1244,7 @@
         runtimeType.numImmediateTypeArgs);
     for (int i = 0; i < runtimeType.numImmediateTypeArgs; ++i) {
       if (!usableTypeArgs[interfaceOffset + i].isSubtypeOfRuntimeType(
-          typeHierarchy, runtimeType.typeArgs[i], SubtypeTestKind.Subtype)) {
+          typeHierarchy, runtimeType.typeArgs![i], SubtypeTestKind.Subtype)) {
         return false;
       }
     }
diff --git a/pkg/vm/lib/transformations/type_flow/unboxing_info.dart b/pkg/vm/lib/transformations/type_flow/unboxing_info.dart
index 723e673..682cf58 100644
--- a/pkg/vm/lib/transformations/type_flow/unboxing_info.dart
+++ b/pkg/vm/lib/transformations/type_flow/unboxing_info.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'package:kernel/ast.dart';
 import 'package:kernel/core_types.dart';
 import 'package:kernel/external_name.dart' show getExternalName;
@@ -30,12 +28,12 @@
         _coreTypes = typeFlowAnalysis.environment.coreTypes,
         _nativeCodeOracle = typeFlowAnalysis.nativeCodeOracle;
 
-  UnboxingInfoMetadata getUnboxingInfoOfMember(Member member) {
-    final UnboxingInfoMetadata info = _memberInfo[member];
+  UnboxingInfoMetadata? getUnboxingInfoOfMember(Member member) {
+    final UnboxingInfoMetadata? info = _memberInfo[member];
     if (member is Procedure && member.isGetter) {
       // Remove placeholder parameter info slot for setters that the getter is
       // grouped with.
-      return UnboxingInfoMetadata(0)..returnInfo = info.returnInfo;
+      return UnboxingInfoMetadata(0)..returnInfo = info!.returnInfo;
     }
     return info;
   }
@@ -81,8 +79,8 @@
           ? (member.hasSetter ? 1 : 0)
           : member is Procedure && member.isGetter
               ? 1
-              : member.function.requiredParameterCount;
-      UnboxingInfoMetadata info;
+              : member.function!.requiredParameterCount;
+      UnboxingInfoMetadata? info;
       if (member.isInstanceMember) {
         int selectorId =
             member is Field || member is Procedure && member.isGetter
@@ -121,20 +119,18 @@
   void _updateUnboxingInfoOfMember(
       Member member, TypeFlowAnalysis typeFlowAnalysis) {
     if (typeFlowAnalysis.isMemberUsed(member)) {
-      final UnboxingInfoMetadata unboxingInfo = _memberInfo[member];
+      final UnboxingInfoMetadata unboxingInfo = _memberInfo[member]!;
       if (_cannotUnbox(member)) {
         unboxingInfo.unboxedArgsInfo.length = 0;
         unboxingInfo.returnInfo = UnboxingInfoMetadata.kBoxed;
         return;
       }
       if (member is Procedure || member is Constructor) {
-        final Args<Type> argTypes = typeFlowAnalysis.argumentTypes(member);
-        assert(argTypes != null);
-
+        final Args<Type> argTypes = typeFlowAnalysis.argumentTypes(member)!;
         final int firstParamIndex =
             numTypeParams(member) + (hasReceiverArg(member) ? 1 : 0);
 
-        final positionalParams = member.function.positionalParameters;
+        final positionalParams = member.function!.positionalParameters;
         assert(argTypes.positionalCount ==
             firstParamIndex + positionalParams.length);
 
diff --git a/pkg/vm/lib/transformations/type_flow/utils.dart b/pkg/vm/lib/transformations/type_flow/utils.dart
index b04e69e..c85dfc7 100644
--- a/pkg/vm/lib/transformations/type_flow/utils.dart
+++ b/pkg/vm/lib/transformations/type_flow/utils.dart
@@ -2,12 +2,11 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 /// Declares miscellaneous utility functions and constants for type flow
 /// analysis.
 library vm.transformations.type_flow.utils;
 
+import 'package:collection/collection.dart' show IterableExtension;
 import 'package:kernel/ast.dart';
 import 'package:kernel/src/printer.dart';
 
@@ -123,9 +122,8 @@
   return true;
 }
 
-VariableDeclaration findNamedParameter(FunctionNode function, String name) {
-  return function.namedParameters
-      .firstWhere((p) => p.name == name, orElse: () => null);
+VariableDeclaration? findNamedParameter(FunctionNode function, String name) {
+  return function.namedParameters.firstWhereOrNull((p) => p.name == name);
 }
 
 class Histogram<K> {
@@ -143,7 +141,7 @@
     print(
         '-------------------------------------------------------------------');
     List<K> keys = values.keys.toList();
-    keys.sort((k1, k2) => values[k1].compareTo(values[k2]));
+    keys.sort((k1, k2) => values[k1]!.compareTo(values[k2]!));
     final cut = keys.length < n ? 0 : keys.length - n;
     for (int i = keys.length - 1; i >= cut; --i) {
       final k = keys[i];
@@ -376,7 +374,7 @@
 };
 
 extension NullabilitySuffix on Nullability {
-  String get suffix => nullabilitySuffix[this];
+  String get suffix => nullabilitySuffix[this]!;
 }
 
 bool mayHaveSideEffects(Expression node) {
diff --git a/pkg/vm/pubspec.yaml b/pkg/vm/pubspec.yaml
index f57cf389..0e78a09 100644
--- a/pkg/vm/pubspec.yaml
+++ b/pkg/vm/pubspec.yaml
@@ -18,6 +18,7 @@
   meta:
     path: ../meta
   package_config: any
+  collection: ^1.15.0
 
 dev_dependencies:
   expect:
diff --git a/pkg/vm/test/common_test_utils.dart b/pkg/vm/test/common_test_utils.dart
index 3f8bf9c..1ff586a 100644
--- a/pkg/vm/test/common_test_utils.dart
+++ b/pkg/vm/test/common_test_utils.dart
@@ -2,8 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.9
-
 import 'dart:async';
 import 'dart:io';
 
@@ -37,11 +35,11 @@
 }
 
 Future<Component> compileTestCaseToKernelProgram(Uri sourceUri,
-    {Target target,
+    {Target? target,
     bool enableSuperMixins = false,
-    List<String> experimentalFlags,
-    Map<String, String> environmentDefines,
-    Uri packagesFileUri}) async {
+    List<String>? experimentalFlags,
+    Map<String, String>? environmentDefines,
+    Uri? packagesFileUri}) async {
   final platformKernel =
       computePlatformBinariesLocation().resolve('vm_platform_strong.dill');
   target ??= new TestingVmTarget(new TargetFlags())
@@ -62,11 +60,11 @@
     };
 
   final Component component =
-      (await kernelForProgram(sourceUri, options)).component;
+      (await kernelForProgram(sourceUri, options))!.component!;
 
   // Make sure the library name is the same and does not depend on the order
   // of test cases.
-  component.mainMethod.enclosingLibrary.name = '#lib';
+  component.mainMethod!.enclosingLibrary.name = '#lib';
 
   return component;
 }
@@ -75,19 +73,19 @@
   final StringBuffer buffer = new StringBuffer();
   final printer = new Printer(buffer, showMetadata: true);
   printer.writeLibraryFile(library);
-  printer.writeConstantTable(library.enclosingComponent);
+  printer.writeConstantTable(library.enclosingComponent!);
   return buffer
       .toString()
-      .replaceAll(library.importUri.toString(), library.name);
+      .replaceAll(library.importUri.toString(), library.name!);
 }
 
 String kernelComponentToString(Component component) {
   final StringBuffer buffer = new StringBuffer();
   new Printer(buffer, showMetadata: true).writeComponentFile(component);
-  final mainLibrary = component.mainMethod.enclosingLibrary;
+  final mainLibrary = component.mainMethod!.enclosingLibrary;
   return buffer
       .toString()
-      .replaceAll(mainLibrary.importUri.toString(), mainLibrary.name);
+      .replaceAll(mainLibrary.importUri.toString(), mainLibrary.name!);
 }
 
 class DevNullSink<T> extends Sink<T> {
diff --git a/pkg/vm/test/transformations/type_flow/summary_collector_test.dart b/pkg/vm/test/transformations/type_flow/summary_collector_test.dart
index f9ea8d7..2e25344 100644
--- a/pkg/vm/test/transformations/type_flow/summary_collector_test.dart
+++ b/pkg/vm/test/transformations/type_flow/summary_collector_test.dart
@@ -60,7 +60,7 @@
   void recordMemberCalledViaThis(Member target) {}
 
   @override
-  void recordTearOff(Procedure target) {}
+  void recordTearOff(Member target) {}
 }
 
 class PrintSummaries extends RecursiveVisitor {
@@ -78,7 +78,7 @@
         typesBuilder,
         new NativeCodeOracle(
             null, new ConstantPragmaAnnotationParser(coreTypes)),
-        new GenericInterfacesInfoImpl(hierarchy),
+        new GenericInterfacesInfoImpl(coreTypes, hierarchy),
         /*_protobufHandler=*/ null);
   }
 
diff --git a/runtime/tests/vm/dart/isolates/dart_api_create_lightweight_isolate_test.dart b/runtime/tests/vm/dart/isolates/dart_api_create_lightweight_isolate_test.dart
index 0087928..2fa4962 100644
--- a/runtime/tests/vm/dart/isolates/dart_api_create_lightweight_isolate_test.dart
+++ b/runtime/tests/vm/dart/isolates/dart_api_create_lightweight_isolate_test.dart
@@ -14,6 +14,7 @@
 import 'package:expect/expect.dart';
 import 'package:ffi/ffi.dart';
 
+import 'test_utils.dart' show isArtificialReloadMode;
 import '../../../../../tests/ffi/dylib_utils.dart';
 
 final bool isolateGroupsEnabled =
@@ -240,5 +241,10 @@
     await testNotSupported();
     return;
   }
+
+  // This test should not run in hot-reload because of the way it is written
+  // (embedder related code written in Dart instead of C)
+  if (isArtificialReloadMode) return;
+
   await testJitOrAot();
 }
diff --git a/runtime/tests/vm/dart_2/isolates/dart_api_create_lightweight_isolate_test.dart b/runtime/tests/vm/dart_2/isolates/dart_api_create_lightweight_isolate_test.dart
index 5ce5984..8b92de1 100644
--- a/runtime/tests/vm/dart_2/isolates/dart_api_create_lightweight_isolate_test.dart
+++ b/runtime/tests/vm/dart_2/isolates/dart_api_create_lightweight_isolate_test.dart
@@ -14,6 +14,7 @@
 import 'package:expect/expect.dart';
 import 'package:ffi/ffi.dart';
 
+import 'test_utils.dart' show isArtificialReloadMode;
 import '../../../../../tests/ffi/dylib_utils.dart';
 
 final bool isolateGroupsEnabled =
@@ -240,5 +241,10 @@
     await testNotSupported();
     return;
   }
+
+  // This test should not run in hot-reload because of the way it is written
+  // (embedder related code written in Dart instead of C)
+  if (isArtificialReloadMode) return;
+
   await testJitOrAot();
 }
diff --git a/tools/VERSION b/tools/VERSION
index 8235dad..3b8e28a 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 357
+PRERELEASE 358
 PRERELEASE_PATCH 0
\ No newline at end of file