diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart b/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart
index 7a92c54..2649c47 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_collection_builders.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
-
 part of 'constant_evaluator.dart';
 
 abstract class _ListOrSetConstantBuilder<L extends Expression> {
@@ -23,7 +21,7 @@
   ///
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant add(Expression element) {
+  AbortConstant? add(Expression element) {
     Constant constant = evaluator._evaluateSubexpression(element);
     if (constant is AbortConstant) return constant;
     if (evaluator.shouldBeUnevaluated) {
@@ -37,7 +35,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant addSpread(Expression spreadExpression) {
+  AbortConstant? addSpread(Expression spreadExpression) {
     Constant constant = evaluator._evaluateSubexpression(spreadExpression);
     if (constant is AbortConstant) return constant;
     Constant spread = evaluator.unlower(constant);
@@ -73,7 +71,7 @@
             spreadExpression, messageConstEvalNotListOrSetInSpread);
       }
       for (Constant entry in entries) {
-        AbortConstant error = addConstant(entry, spreadExpression);
+        AbortConstant? error = addConstant(entry, spreadExpression);
         if (error != null) return error;
       }
     }
@@ -82,7 +80,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant addConstant(Constant constant, TreeNode context);
+  AbortConstant? addConstant(Constant constant, TreeNode context);
 
   Constant build();
 }
@@ -104,10 +102,10 @@
       new ListLiteral(elements, isConst: true);
 
   @override
-  AbortConstant addConstant(Constant constant, TreeNode context) {
+  AbortConstant? addConstant(Constant constant, TreeNode context) {
     List<Constant> lastPart;
     if (parts.last is List<Constant>) {
-      lastPart = parts.last;
+      lastPart = parts.last as List<Constant>;
     } else {
       // Probably unreachable.
       parts.add(lastPart = <Constant>[]);
@@ -122,11 +120,12 @@
   Constant build() {
     if (parts.length == 1) {
       // Fully evaluated
+      List<Constant> entries = parts.single as List<Constant>;
       if (isMutable) {
-        return new MutableListConstant(elementType, parts.single);
+        return new MutableListConstant(elementType, entries);
       }
       return evaluator
-          .lowerListConstant(new ListConstant(elementType, parts.single));
+          .lowerListConstant(new ListConstant(elementType, entries));
     }
     // TODO(kallentu): Handle partially evaluated [isMutable] lists.
     List<Expression> lists = <Expression>[];
@@ -158,7 +157,7 @@
       new SetLiteral(elements, isConst: true);
 
   @override
-  AbortConstant addConstant(Constant constant, TreeNode context) {
+  AbortConstant? addConstant(Constant constant, TreeNode context) {
     if (!evaluator.hasPrimitiveEqual(constant)) {
       return evaluator.createErrorConstant(
           context,
@@ -184,7 +183,7 @@
 
     List<Constant> lastPart;
     if (parts.last is List<Constant>) {
-      lastPart = parts.last;
+      lastPart = parts.last as List<Constant>;
     } else {
       // Probably unreachable.
       parts.add(lastPart = <Constant>[]);
@@ -199,7 +198,7 @@
   Constant build() {
     if (parts.length == 1) {
       // Fully evaluated
-      List<Constant> entries = parts.single;
+      List<Constant> entries = parts.single as List<Constant>;
       SetConstant result = new SetConstant(elementType, entries);
       return evaluator.lowerSetConstant(result);
     }
@@ -239,7 +238,7 @@
   ///
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant add(MapLiteralEntry element) {
+  AbortConstant? add(MapLiteralEntry element) {
     Constant key = evaluator._evaluateSubexpression(element.key);
     if (key is AbortConstant) return key;
     Constant value = evaluator._evaluateSubexpression(element.value);
@@ -259,7 +258,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant addSpread(Expression spreadExpression) {
+  AbortConstant? addSpread(Expression spreadExpression) {
     Constant constant = evaluator._evaluateSubexpression(spreadExpression);
     if (constant is AbortConstant) return constant;
     Constant spread = evaluator.unlower(constant);
@@ -274,12 +273,12 @@
       // Fully evaluated spread
       if (spread is MapConstant) {
         for (ConstantMapEntry entry in spread.entries) {
-          AbortConstant error = addConstant(
+          AbortConstant? error = addConstant(
               entry.key, entry.value, spreadExpression, spreadExpression);
           if (error != null) return error;
         }
       } else if (evaluator.backend.isLoweredMapConstant(spread)) {
-        AbortConstant error;
+        AbortConstant? error;
         evaluator.backend.forEachLoweredMapConstantEntry(spread,
             (Constant key, Constant value) {
           error ??= addConstant(key, value, spreadExpression, spreadExpression);
@@ -296,11 +295,11 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant addConstant(Constant key, Constant value, TreeNode keyContext,
+  AbortConstant? addConstant(Constant key, Constant value, TreeNode keyContext,
       TreeNode valueContext) {
     List<ConstantMapEntry> lastPart;
     if (parts.last is List<ConstantMapEntry>) {
-      lastPart = parts.last;
+      lastPart = parts.last as List<ConstantMapEntry>;
     } else {
       // Probably unreachable.
       parts.add(lastPart = <ConstantMapEntry>[]);
@@ -337,8 +336,9 @@
   Constant build() {
     if (parts.length == 1) {
       // Fully evaluated
+      List<ConstantMapEntry> entries = parts.single as List<ConstantMapEntry>;
       return evaluator
-          .lowerMapConstant(new MapConstant(keyType, valueType, parts.single));
+          .lowerMapConstant(new MapConstant(keyType, valueType, entries));
     }
     List<Expression> maps = <Expression>[];
     for (Object part in parts) {
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index df03f0b..2956b23 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.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
-
 /// This library implements a kernel2kernel constant evaluation transformation.
 ///
 /// Even though it is expected that the frontend does not emit kernel AST which
@@ -84,17 +82,22 @@
     Map<String, String> environmentDefines,
     ErrorReporter errorReporter,
     EvaluationMode evaluationMode,
-    {bool evaluateAnnotations,
-    bool desugarSets,
-    bool enableTripleShift,
-    bool enableConstFunctions,
-    bool errorOnUnevaluatedConstant,
-    CoreTypes coreTypes,
-    ClassHierarchy hierarchy}) {
+    {required bool evaluateAnnotations,
+    required bool desugarSets,
+    required bool enableTripleShift,
+    required bool enableConstFunctions,
+    required bool errorOnUnevaluatedConstant,
+    CoreTypes? coreTypes,
+    ClassHierarchy? hierarchy}) {
+  // ignore: unnecessary_null_comparison
   assert(evaluateAnnotations != null);
+  // ignore: unnecessary_null_comparison
   assert(desugarSets != null);
+  // ignore: unnecessary_null_comparison
   assert(enableTripleShift != null);
+  // ignore: unnecessary_null_comparison
   assert(enableConstFunctions != null);
+  // ignore: unnecessary_null_comparison
   assert(errorOnUnevaluatedConstant != null);
   coreTypes ??= new CoreTypes(component);
   hierarchy ??= new ClassHierarchy(component, coreTypes);
@@ -118,13 +121,17 @@
     TypeEnvironment typeEnvironment,
     ErrorReporter errorReporter,
     EvaluationMode evaluationMode,
-    {bool evaluateAnnotations,
-    bool enableTripleShift,
-    bool enableConstFunctions,
-    bool errorOnUnevaluatedConstant}) {
+    {required bool evaluateAnnotations,
+    required bool enableTripleShift,
+    required bool enableConstFunctions,
+    required bool errorOnUnevaluatedConstant}) {
+  // ignore: unnecessary_null_comparison
   assert(evaluateAnnotations != null);
+  // ignore: unnecessary_null_comparison
   assert(enableTripleShift != null);
+  // ignore: unnecessary_null_comparison
   assert(enableConstFunctions != null);
+  // ignore: unnecessary_null_comparison
   assert(errorOnUnevaluatedConstant != null);
   final ConstantsTransformer constantsTransformer = new ConstantsTransformer(
       backend,
@@ -153,9 +160,13 @@
     bool enableTripleShift: false,
     bool enableConstFunctions: false,
     bool errorOnUnevaluatedConstant: false}) {
+  // ignore: unnecessary_null_comparison
   assert(evaluateAnnotations != null);
+  // ignore: unnecessary_null_comparison
   assert(enableTripleShift != null);
+  // ignore: unnecessary_null_comparison
   assert(enableConstFunctions != null);
+  // ignore: unnecessary_null_comparison
   assert(errorOnUnevaluatedConstant != null);
   final ConstantsTransformer constantsTransformer = new ConstantsTransformer(
       backend,
@@ -176,12 +187,12 @@
   strong,
 }
 
-class ConstantWeakener extends ComputeOnceConstantVisitor<Constant> {
+class ConstantWeakener extends ComputeOnceConstantVisitor<Constant?> {
   ConstantEvaluator _evaluator;
 
   ConstantWeakener(this._evaluator);
 
-  Constant processValue(Constant node, Constant value) {
+  Constant? processValue(Constant node, Constant? value) {
     if (value != null) {
       value = _evaluator.canonicalize(value);
     }
@@ -189,40 +200,40 @@
   }
 
   @override
-  Constant defaultConstant(Constant node) => throw new UnsupportedError(
+  Constant? defaultConstant(Constant node) => throw new UnsupportedError(
       "Unhandled constant ${node} (${node.runtimeType})");
 
   @override
-  Constant visitNullConstant(NullConstant node) => null;
+  Constant? visitNullConstant(NullConstant node) => null;
 
   @override
-  Constant visitBoolConstant(BoolConstant node) => null;
+  Constant? visitBoolConstant(BoolConstant node) => null;
 
   @override
-  Constant visitIntConstant(IntConstant node) => null;
+  Constant? visitIntConstant(IntConstant node) => null;
 
   @override
-  Constant visitDoubleConstant(DoubleConstant node) => null;
+  Constant? visitDoubleConstant(DoubleConstant node) => null;
 
   @override
-  Constant visitStringConstant(StringConstant node) => null;
+  Constant? visitStringConstant(StringConstant node) => null;
 
   @override
-  Constant visitSymbolConstant(SymbolConstant node) => null;
+  Constant? visitSymbolConstant(SymbolConstant node) => null;
 
   @override
-  Constant visitMapConstant(MapConstant node) {
-    DartType keyType = computeConstCanonicalType(
+  Constant? visitMapConstant(MapConstant node) {
+    DartType? keyType = computeConstCanonicalType(
         node.keyType, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
-    DartType valueType = computeConstCanonicalType(
+    DartType? valueType = computeConstCanonicalType(
         node.valueType, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
-    List<ConstantMapEntry> entries;
+    List<ConstantMapEntry>? entries;
     for (int index = 0; index < node.entries.length; index++) {
       ConstantMapEntry entry = node.entries[index];
-      Constant key = visitConstant(entry.key);
-      Constant value = visitConstant(entry.value);
+      Constant? key = visitConstant(entry.key);
+      Constant? value = visitConstant(entry.value);
       if (key != null || value != null) {
         entries ??= node.entries.toList(growable: false);
         entries[index] =
@@ -237,13 +248,13 @@
   }
 
   @override
-  Constant visitListConstant(ListConstant node) {
-    DartType typeArgument = computeConstCanonicalType(
+  Constant? visitListConstant(ListConstant node) {
+    DartType? typeArgument = computeConstCanonicalType(
         node.typeArgument, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
-    List<Constant> entries;
+    List<Constant>? entries;
     for (int index = 0; index < node.entries.length; index++) {
-      Constant entry = visitConstant(node.entries[index]);
+      Constant? entry = visitConstant(node.entries[index]);
       if (entry != null) {
         entries ??= node.entries.toList(growable: false);
         entries[index] = entry;
@@ -257,13 +268,13 @@
   }
 
   @override
-  Constant visitSetConstant(SetConstant node) {
-    DartType typeArgument = computeConstCanonicalType(
+  Constant? visitSetConstant(SetConstant node) {
+    DartType? typeArgument = computeConstCanonicalType(
         node.typeArgument, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
-    List<Constant> entries;
+    List<Constant>? entries;
     for (int index = 0; index < node.entries.length; index++) {
-      Constant entry = visitConstant(node.entries[index]);
+      Constant? entry = visitConstant(node.entries[index]);
       if (entry != null) {
         entries ??= node.entries.toList(growable: false);
         entries[index] = entry;
@@ -277,10 +288,10 @@
   }
 
   @override
-  Constant visitInstanceConstant(InstanceConstant node) {
-    List<DartType> typeArguments;
+  Constant? visitInstanceConstant(InstanceConstant node) {
+    List<DartType>? typeArguments;
     for (int index = 0; index < node.typeArguments.length; index++) {
-      DartType typeArgument = computeConstCanonicalType(
+      DartType? typeArgument = computeConstCanonicalType(
           node.typeArguments[index], _evaluator.coreTypes,
           isNonNullableByDefault: _evaluator.isNonNullableByDefault);
       if (typeArgument != null) {
@@ -288,9 +299,10 @@
         typeArguments[index] = typeArgument;
       }
     }
-    Map<Reference, Constant> fieldValues;
-    for (Reference reference in node.fieldValues.keys) {
-      Constant value = visitConstant(node.fieldValues[reference]);
+    Map<Reference, Constant>? fieldValues;
+    for (MapEntry<Reference, Constant> entry in node.fieldValues.entries) {
+      Reference reference = entry.key;
+      Constant? value = visitConstant(entry.value);
       if (value != null) {
         fieldValues ??= new Map<Reference, Constant>.from(node.fieldValues);
         fieldValues[reference] = value;
@@ -304,11 +316,11 @@
   }
 
   @override
-  Constant visitPartialInstantiationConstant(
+  Constant? visitPartialInstantiationConstant(
       PartialInstantiationConstant node) {
-    List<DartType> types;
+    List<DartType>? types;
     for (int index = 0; index < node.types.length; index++) {
-      DartType type = computeConstCanonicalType(
+      DartType? type = computeConstCanonicalType(
           node.types[index], _evaluator.coreTypes,
           isNonNullableByDefault: _evaluator.isNonNullableByDefault);
       if (type != null) {
@@ -323,11 +335,11 @@
   }
 
   @override
-  Constant visitTearOffConstant(TearOffConstant node) => null;
+  Constant? visitTearOffConstant(TearOffConstant node) => null;
 
   @override
-  Constant visitTypeLiteralConstant(TypeLiteralConstant node) {
-    DartType type = computeConstCanonicalType(node.type, _evaluator.coreTypes,
+  Constant? visitTypeLiteralConstant(TypeLiteralConstant node) {
+    DartType? type = computeConstCanonicalType(node.type, _evaluator.coreTypes,
         isNonNullableByDefault: _evaluator.isNonNullableByDefault);
     if (type != null) {
       return new TypeLiteralConstant(type);
@@ -336,14 +348,14 @@
   }
 
   @override
-  Constant visitUnevaluatedConstant(UnevaluatedConstant node) => null;
+  Constant? visitUnevaluatedConstant(UnevaluatedConstant node) => null;
 }
 
 class ConstantsTransformer extends RemovingTransformer {
   final ConstantsBackend backend;
   final ConstantEvaluator constantEvaluator;
   final TypeEnvironment typeEnvironment;
-  StaticTypeContext _staticTypeContext;
+  StaticTypeContext? _staticTypeContext;
 
   final bool evaluateAnnotations;
   final bool enableTripleShift;
@@ -401,7 +413,7 @@
   }
 
   @override
-  LibraryPart visitLibraryPart(LibraryPart node, TreeNode removalSentinel) {
+  LibraryPart visitLibraryPart(LibraryPart node, TreeNode? removalSentinel) {
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
     });
@@ -410,7 +422,7 @@
 
   @override
   LibraryDependency visitLibraryDependency(
-      LibraryDependency node, TreeNode removalSentinel) {
+      LibraryDependency node, TreeNode? removalSentinel) {
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
     });
@@ -418,8 +430,8 @@
   }
 
   @override
-  Class visitClass(Class node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  Class visitClass(Class node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext.forAnnotations(
         node.enclosingLibrary, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
@@ -436,8 +448,8 @@
   }
 
   @override
-  Extension visitExtension(Extension node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  Extension visitExtension(Extension node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext.forAnnotations(
         node.enclosingLibrary, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
@@ -449,8 +461,8 @@
   }
 
   @override
-  Procedure visitProcedure(Procedure node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  Procedure visitProcedure(Procedure node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
@@ -461,8 +473,8 @@
   }
 
   @override
-  Constructor visitConstructor(Constructor node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  Constructor visitConstructor(Constructor node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
@@ -474,7 +486,7 @@
   }
 
   @override
-  Typedef visitTypedef(Typedef node, TreeNode removalSentinel) {
+  Typedef visitTypedef(Typedef node, TreeNode? removalSentinel) {
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
       transformTypeParameterList(node.typeParameters, node);
@@ -487,10 +499,10 @@
 
   @override
   RedirectingFactoryConstructor visitRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor node, TreeNode removalSentinel) {
+      RedirectingFactoryConstructor node, TreeNode? removalSentinel) {
     // Currently unreachable as the compiler doesn't produce
     // RedirectingFactoryConstructor.
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
@@ -504,7 +516,7 @@
 
   @override
   TypeParameter visitTypeParameter(
-      TypeParameter node, TreeNode removalSentinel) {
+      TypeParameter node, TreeNode? removalSentinel) {
     transformAnnotations(node.annotations, node);
     return node;
   }
@@ -527,36 +539,39 @@
   // Handle definition of constants:
 
   @override
-  FunctionNode visitFunctionNode(FunctionNode node, TreeNode removalSentinel) {
+  FunctionNode visitFunctionNode(FunctionNode node, TreeNode? removalSentinel) {
     transformTypeParameterList(node.typeParameters, node);
     final int positionalParameterCount = node.positionalParameters.length;
     for (int i = 0; i < positionalParameterCount; ++i) {
       final VariableDeclaration variable = node.positionalParameters[i];
       transformAnnotations(variable.annotations, variable);
-      if (variable.initializer != null) {
+      Expression? initializer = variable.initializer;
+      if (initializer != null) {
         variable.initializer =
-            evaluateAndTransformWithContext(variable, variable.initializer)
+            evaluateAndTransformWithContext(variable, initializer)
               ..parent = variable;
       }
     }
     for (final VariableDeclaration variable in node.namedParameters) {
       transformAnnotations(variable.annotations, variable);
-      if (variable.initializer != null) {
+      Expression? initializer = variable.initializer;
+      if (initializer != null) {
         variable.initializer =
-            evaluateAndTransformWithContext(variable, variable.initializer)
+            evaluateAndTransformWithContext(variable, initializer)
               ..parent = variable;
       }
     }
     if (node.body != null) {
-      node.body = transform(node.body)..parent = node;
+      node.body = transform(node.body!)..parent = node;
     }
     return node;
   }
 
   @override
-  Statement visitFunctionDeclaration(
-      FunctionDeclaration node, TreeNode removalSentinel) {
+  TreeNode visitFunctionDeclaration(
+      FunctionDeclaration node, TreeNode? removalSentinel) {
     if (enableConstFunctions) {
+      // ignore: unnecessary_null_comparison
       if (node.function != null) {
         node.function = transform(node.function)..parent = node;
       }
@@ -569,19 +584,20 @@
   }
 
   @override
-  Statement visitVariableDeclaration(
-      VariableDeclaration node, TreeNode removalSentinel) {
+  TreeNode visitVariableDeclaration(
+      VariableDeclaration node, TreeNode? removalSentinel) {
     transformAnnotations(node.annotations, node);
 
-    if (node.initializer != null) {
+    Expression? initializer = node.initializer;
+    if (initializer != null) {
       if (node.isConst) {
-        final Constant constant = evaluateWithContext(node, node.initializer);
+        final Constant constant = evaluateWithContext(node, initializer);
         constantEvaluator.env.addVariableValue(node, constant);
-        node.initializer = makeConstantExpression(constant, node.initializer)
-          ..parent = node;
+        initializer = node.initializer =
+            makeConstantExpression(constant, initializer)..parent = node;
 
         // If this constant is inlined, remove it.
-        if (!keepLocals && shouldInline(node.initializer)) {
+        if (!keepLocals && shouldInline(initializer)) {
           if (constant is! UnevaluatedConstant) {
             // If the constant is unevaluated we need to keep the expression,
             // so that, in the case the constant contains error but the local
@@ -590,45 +606,45 @@
           }
         }
       } else {
-        node.initializer = transform(node.initializer)..parent = node;
+        node.initializer = transform(initializer)..parent = node;
       }
     }
     return node;
   }
 
   @override
-  Field visitField(Field node, TreeNode removalSentinel) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+  TreeNode visitField(Field node, TreeNode? removalSentinel) {
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
-    Field field = constantEvaluator.withNewEnvironment(() {
+    TreeNode result = constantEvaluator.withNewEnvironment(() {
+      Expression? initializer = node.initializer;
       if (node.isConst) {
         transformAnnotations(node.annotations, node);
-        node.initializer =
-            evaluateAndTransformWithContext(node, node.initializer)
-              ..parent = node;
+        initializer = node.initializer =
+            evaluateAndTransformWithContext(node, initializer!)..parent = node;
 
         // If this constant is inlined, remove it.
-        if (!keepFields && shouldInline(node.initializer)) {
-          return removalSentinel;
+        if (!keepFields && shouldInline(initializer)) {
+          return removalSentinel!;
         }
       } else {
         transformAnnotations(node.annotations, node);
-        if (node.initializer != null) {
-          node.initializer = transform(node.initializer)..parent = node;
+        if (initializer != null) {
+          node.initializer = transform(initializer)..parent = node;
         }
       }
       return node;
     });
     _staticTypeContext = oldStaticTypeContext;
-    return field;
+    return result;
   }
 
   // Handle use-sites of constants (and "inline" constant expressions):
 
   @override
-  Expression visitSymbolLiteral(SymbolLiteral node, TreeNode removalSentinel) {
+  TreeNode visitSymbolLiteral(SymbolLiteral node, TreeNode? removalSentinel) {
     return makeConstantExpression(
-        constantEvaluator.evaluate(_staticTypeContext, node), node);
+        constantEvaluator.evaluate(_staticTypeContext!, node), node);
   }
 
   bool _isNull(Expression node) {
@@ -637,7 +653,7 @@
   }
 
   @override
-  Expression visitEqualsCall(EqualsCall node, TreeNode removalSentinel) {
+  TreeNode visitEqualsCall(EqualsCall node, TreeNode? removalSentinel) {
     Expression left = transform(node.left);
     Expression right = transform(node.right);
     if (_isNull(left)) {
@@ -651,17 +667,17 @@
   }
 
   @override
-  Expression visitStaticGet(StaticGet node, TreeNode removalSentinel) {
+  TreeNode visitStaticGet(StaticGet node, TreeNode? removalSentinel) {
     final Member target = node.target;
     if (target is Field && target.isConst) {
       // Make sure the initializer is evaluated first.
-      StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+      StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
       _staticTypeContext = new StaticTypeContext(target, typeEnvironment);
       target.initializer =
-          evaluateAndTransformWithContext(target, target.initializer)
+          evaluateAndTransformWithContext(target, target.initializer!)
             ..parent = target;
       _staticTypeContext = oldStaticTypeContext;
-      if (shouldInline(target.initializer)) {
+      if (shouldInline(target.initializer!)) {
         return evaluateAndTransformWithContext(node, node);
       }
     } else if (target is Procedure && target.kind == ProcedureKind.Method) {
@@ -671,7 +687,7 @@
   }
 
   @override
-  Expression visitStaticTearOff(StaticTearOff node, TreeNode removalSentinel) {
+  TreeNode visitStaticTearOff(StaticTearOff node, TreeNode? removalSentinel) {
     final Member target = node.target;
     if (target is Procedure && target.kind == ProcedureKind.Method) {
       return evaluateAndTransformWithContext(node, node);
@@ -680,28 +696,28 @@
   }
 
   @override
-  SwitchCase visitSwitchCase(SwitchCase node, TreeNode removalSentinel) {
+  TreeNode visitSwitchCase(SwitchCase node, TreeNode? removalSentinel) {
     transformExpressions(node.expressions, node);
     return super.visitSwitchCase(node, removalSentinel);
   }
 
   @override
-  SwitchStatement visitSwitchStatement(
-      SwitchStatement node, TreeNode removalSentinel) {
-    SwitchStatement result = super.visitSwitchStatement(node, removalSentinel);
+  TreeNode visitSwitchStatement(
+      SwitchStatement node, TreeNode? removalSentinel) {
+    TreeNode result = super.visitSwitchStatement(node, removalSentinel);
     Library library = constantEvaluator.libraryOf(node);
+    // ignore: unnecessary_null_comparison
     if (library != null && library.isNonNullableByDefault) {
       for (SwitchCase switchCase in node.cases) {
         for (Expression caseExpression in switchCase.expressions) {
           if (caseExpression is ConstantExpression) {
             if (!constantEvaluator.hasPrimitiveEqual(caseExpression.constant)) {
-              Uri uri = constantEvaluator.getFileUri(caseExpression);
-              int offset = constantEvaluator.getFileOffset(uri, caseExpression);
               constantEvaluator.errorReporter.report(
-                  templateConstEvalCaseImplementsEqual
-                      .withArguments(caseExpression.constant,
-                          constantEvaluator.isNonNullableByDefault)
-                      .withLocation(uri, offset, noLength),
+                  constantEvaluator.createLocatedMessage(
+                      caseExpression,
+                      templateConstEvalCaseImplementsEqual.withArguments(
+                          caseExpression.constant,
+                          constantEvaluator.isNonNullableByDefault)),
                   null);
             }
           } else {
@@ -715,13 +731,13 @@
   }
 
   @override
-  Expression visitVariableGet(VariableGet node, TreeNode removalSentinel) {
+  TreeNode visitVariableGet(VariableGet node, TreeNode? removalSentinel) {
     final VariableDeclaration variable = node.variable;
     if (variable.isConst) {
       variable.initializer =
-          evaluateAndTransformWithContext(variable, variable.initializer)
+          evaluateAndTransformWithContext(variable, variable.initializer!)
             ..parent = variable;
-      if (shouldInline(variable.initializer)) {
+      if (shouldInline(variable.initializer!)) {
         return evaluateAndTransformWithContext(node, node);
       }
     }
@@ -729,7 +745,7 @@
   }
 
   @override
-  Expression visitListLiteral(ListLiteral node, TreeNode removalSentinel) {
+  TreeNode visitListLiteral(ListLiteral node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -737,13 +753,13 @@
   }
 
   @override
-  Expression visitListConcatenation(
-      ListConcatenation node, TreeNode removalSentinel) {
+  TreeNode visitListConcatenation(
+      ListConcatenation node, TreeNode? removalSentinel) {
     return evaluateAndTransformWithContext(node, node);
   }
 
   @override
-  Expression visitSetLiteral(SetLiteral node, TreeNode removalSentinel) {
+  TreeNode visitSetLiteral(SetLiteral node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -751,13 +767,13 @@
   }
 
   @override
-  Expression visitSetConcatenation(
-      SetConcatenation node, TreeNode removalSentinel) {
+  TreeNode visitSetConcatenation(
+      SetConcatenation node, TreeNode? removalSentinel) {
     return evaluateAndTransformWithContext(node, node);
   }
 
   @override
-  Expression visitMapLiteral(MapLiteral node, TreeNode removalSentinel) {
+  TreeNode visitMapLiteral(MapLiteral node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -765,7 +781,7 @@
   }
 
   @override
-  Expression visitTypeLiteral(TypeLiteral node, TreeNode removalSentinel) {
+  TreeNode visitTypeLiteral(TypeLiteral node, TreeNode? removalSentinel) {
     if (!containsFreeTypeVariables(node.type)) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -773,14 +789,14 @@
   }
 
   @override
-  Expression visitMapConcatenation(
-      MapConcatenation node, TreeNode removalSentinel) {
+  TreeNode visitMapConcatenation(
+      MapConcatenation node, TreeNode? removalSentinel) {
     return evaluateAndTransformWithContext(node, node);
   }
 
   @override
-  Expression visitConstructorInvocation(
-      ConstructorInvocation node, TreeNode removalSentinel) {
+  TreeNode visitConstructorInvocation(
+      ConstructorInvocation node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -788,8 +804,8 @@
   }
 
   @override
-  Expression visitStaticInvocation(
-      StaticInvocation node, TreeNode removalSentinel) {
+  TreeNode visitStaticInvocation(
+      StaticInvocation node, TreeNode? removalSentinel) {
     if (node.isConst) {
       return evaluateAndTransformWithContext(node, node);
     }
@@ -797,8 +813,8 @@
   }
 
   @override
-  Expression visitConstantExpression(
-      ConstantExpression node, TreeNode removalSentinel) {
+  TreeNode visitConstantExpression(
+      ConstantExpression node, TreeNode? removalSentinel) {
     Constant constant = node.constant;
     if (constant is UnevaluatedConstant) {
       Expression expression = constant.expression;
@@ -816,10 +832,10 @@
 
   Constant evaluateWithContext(TreeNode treeContext, Expression node) {
     if (treeContext == node) {
-      return constantEvaluator.evaluate(_staticTypeContext, node);
+      return constantEvaluator.evaluate(_staticTypeContext!, node);
     }
 
-    return constantEvaluator.evaluate(_staticTypeContext, node,
+    return constantEvaluator.evaluate(_staticTypeContext!, node,
         contextNode: treeContext);
   }
 
@@ -829,7 +845,7 @@
       return constant.expression;
     }
     return new ConstantExpression(
-        constant, node.getStaticType(_staticTypeContext))
+        constant, node.getStaticType(_staticTypeContext!))
       ..fileOffset = node.fileOffset;
   }
 
@@ -844,12 +860,12 @@
 class ConstantEvaluator implements ExpressionVisitor<Constant> {
   final ConstantsBackend backend;
   final NumberSemantics numberSemantics;
-  ConstantIntFolder intFolder;
-  Map<String, String> environmentDefines;
+  late ConstantIntFolder intFolder;
+  Map<String, String>? environmentDefines;
   final bool errorOnUnevaluatedConstant;
   final CoreTypes coreTypes;
   final TypeEnvironment typeEnvironment;
-  StaticTypeContext _staticTypeContext;
+  StaticTypeContext? _staticTypeContext;
   final ErrorReporter errorReporter;
   final EvaluationMode evaluationMode;
 
@@ -860,31 +876,31 @@
       new IsInstantiatedVisitor().isInstantiated;
 
   final Map<Constant, Constant> canonicalizationCache;
-  final Map<Node, Object> nodeCache;
+  final Map<Node, Constant?> nodeCache;
   final CloneVisitorNotMembers cloner = new CloneVisitorNotMembers();
 
-  Map<Class, bool> primitiveEqualCache;
+  late Map<Class, bool> primitiveEqualCache;
 
   final NullConstant nullConstant = new NullConstant();
   final BoolConstant trueConstant = new BoolConstant(true);
   final BoolConstant falseConstant = new BoolConstant(false);
 
-  InstanceBuilder instanceBuilder;
+  InstanceBuilder? instanceBuilder;
   EvaluationEnvironment env;
   Set<Expression> replacementNodes = new Set<Expression>.identity();
   Map<Constant, Constant> lowered = new Map<Constant, Constant>.identity();
 
-  bool seenUnevaluatedChild; // Any children that were left unevaluated?
-  int lazyDepth; // Current nesting depth of lazy regions.
+  bool seenUnevaluatedChild = false; // Any children that were left unevaluated?
+  int lazyDepth = -1; // Current nesting depth of lazy regions.
 
   bool get shouldBeUnevaluated => seenUnevaluatedChild || lazyDepth != 0;
 
   bool get targetingJavaScript => numberSemantics == NumberSemantics.js;
 
   bool get isNonNullableByDefault =>
-      _staticTypeContext.nonNullable == Nullability.nonNullable;
+      _staticTypeContext!.nonNullable == Nullability.nonNullable;
 
-  ConstantWeakener _weakener;
+  late ConstantWeakener _weakener;
 
   ConstantEvaluator(this.backend, this.environmentDefines, this.typeEnvironment,
       this.errorReporter,
@@ -925,11 +941,11 @@
       case EvaluationMode.agnostic:
         return norm(coreTypes, type);
       case EvaluationMode.weak:
-        return computeConstCanonicalType(norm(coreTypes, type), coreTypes,
-            isNonNullableByDefault: isNonNullableByDefault);
+        type = norm(coreTypes, type);
+        return computeConstCanonicalType(type, coreTypes,
+                isNonNullableByDefault: isNonNullableByDefault) ??
+            type;
     }
-    throw new UnsupportedError(
-        "Unexpected evaluation mode: ${evaluationMode}.");
   }
 
   List<DartType> convertTypes(List<DartType> types) {
@@ -938,24 +954,37 @@
       case EvaluationMode.agnostic:
         return types.map((DartType type) => norm(coreTypes, type)).toList();
       case EvaluationMode.weak:
-        return types
-            .map((DartType type) => computeConstCanonicalType(
-                norm(coreTypes, type), coreTypes,
-                isNonNullableByDefault: isNonNullableByDefault))
-            .toList();
+        return types.map((DartType type) {
+          type = norm(coreTypes, type);
+          return computeConstCanonicalType(type, coreTypes,
+                  isNonNullableByDefault: isNonNullableByDefault) ??
+              type;
+        }).toList();
     }
-    throw new UnsupportedError(
-        "Unexpected evaluation mode: ${evaluationMode}.");
   }
 
-  Uri getFileUri(TreeNode node) {
-    while (node != null && node is! FileUriNode) {
+  LocatedMessage createLocatedMessage(TreeNode? node, Message message) {
+    Uri? uri = getFileUri(node);
+    if (uri == null) {
+      // TODO(johnniwinther): Ensure that we always have a uri.
+      return message.withoutLocation();
+    }
+    int offset = getFileOffset(uri, node);
+    return message.withLocation(uri, offset, noLength);
+  }
+
+  // TODO(johnniwinther): Avoid this by adding a current file uri field.
+  Uri? getFileUri(TreeNode? node) {
+    while (node != null) {
+      if (node is FileUriNode) {
+        return node.fileUri;
+      }
       node = node.parent;
     }
-    return (node as FileUriNode)?.fileUri;
+    return null;
   }
 
-  int getFileOffset(Uri uri, TreeNode node) {
+  int getFileOffset(Uri? uri, TreeNode? node) {
     if (uri == null) return TreeNode.noOffset;
     while (node != null && node.fileOffset == TreeNode.noOffset) {
       node = node.parent;
@@ -968,34 +997,27 @@
   /// If the expression in the UnevaluatedConstant is an InvalidExpression,
   /// an error occurred during constant evaluation.
   Constant evaluate(StaticTypeContext context, Expression node,
-      {TreeNode contextNode}) {
+      {TreeNode? contextNode}) {
     _staticTypeContext = context;
     seenUnevaluatedChild = false;
     lazyDepth = 0;
     Constant result = _evaluateSubexpression(node);
     if (result is AbortConstant) {
       if (result is _AbortDueToErrorConstant) {
-        final Uri uri = getFileUri(result.node);
-        final int fileOffset = getFileOffset(uri, result.node);
         final LocatedMessage locatedMessageActualError =
-            result.message.withLocation(uri, fileOffset, noLength);
-
+            createLocatedMessage(result.node, result.message);
         final List<LocatedMessage> contextMessages = <LocatedMessage>[
           locatedMessageActualError
         ];
-        if (result.context != null) contextMessages.addAll(result.context);
+        if (result.context != null) contextMessages.addAll(result.context!);
         if (contextNode != null && contextNode != result.node) {
-          final Uri uri = getFileUri(contextNode);
-          final int fileOffset = getFileOffset(uri, contextNode);
-          contextMessages.add(
-              messageConstEvalContext.withLocation(uri, fileOffset, noLength));
+          contextMessages
+              .add(createLocatedMessage(contextNode, messageConstEvalContext));
         }
 
         {
-          final Uri uri = getFileUri(node);
-          final int fileOffset = getFileOffset(uri, node);
-          final LocatedMessage locatedMessage = messageConstEvalStartingPoint
-              .withLocation(uri, fileOffset, noLength);
+          final LocatedMessage locatedMessage =
+              createLocatedMessage(node, messageConstEvalStartingPoint);
           errorReporter.report(locatedMessage, contextMessages);
         }
         return new UnevaluatedConstant(
@@ -1008,7 +1030,7 @@
         return new UnevaluatedConstant(invalid);
       } else if (result is _AbortDueToThrowConstant) {
         final Object value = result.throwValue;
-        Message message;
+        Message? message;
         if (value is Constant) {
           message = templateConstEvalUnhandledException.withArguments(
               value, isNonNullableByDefault);
@@ -1018,18 +1040,14 @@
         }
         assert(message != null);
 
-        final Uri uri = getFileUri(result.node);
-        final int fileOffset = getFileOffset(uri, result.node);
         final LocatedMessage locatedMessageActualError =
-            message.withLocation(uri, fileOffset, noLength);
+            createLocatedMessage(result.node, message!);
         final List<LocatedMessage> contextMessages = <LocatedMessage>[
           locatedMessageActualError
         ];
         {
-          final Uri uri = getFileUri(node);
-          final int fileOffset = getFileOffset(uri, node);
-          final LocatedMessage locatedMessage = messageConstEvalStartingPoint
-              .withLocation(uri, fileOffset, noLength);
+          final LocatedMessage locatedMessage =
+              createLocatedMessage(node, messageConstEvalStartingPoint);
           errorReporter.report(locatedMessage, contextMessages);
         }
         return new UnevaluatedConstant(new InvalidExpression(message.message));
@@ -1052,11 +1070,12 @@
         new StatementConstantEvaluator(this);
     ExecutionStatus status = statement.accept(statementEvaluator);
     if (status is ReturnStatus) {
-      if (status.value == null) {
+      Constant? value = status.value;
+      if (value == null) {
         // Void return type from executing the function body.
         return new NullConstant();
       }
-      return status.value;
+      return value;
     } else if (status is AbortStatus) {
       return status.error;
     } else if (status is ProceedStatus) {
@@ -1069,8 +1088,8 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant executeConstructorBody(Constructor constructor) {
-    final Statement body = constructor.function.body;
+  AbortConstant? executeConstructorBody(Constructor constructor) {
+    final Statement body = constructor.function.body!;
     StatementConstantEvaluator statementEvaluator =
         new StatementConstantEvaluator(this);
     ExecutionStatus status = body.accept(statementEvaluator);
@@ -1091,7 +1110,7 @@
   /// Create an error-constant indicating that an error has been detected during
   /// constant evaluation.
   AbortConstant createErrorConstant(TreeNode node, Message message,
-      {List<LocatedMessage> context}) {
+      {List<LocatedMessage>? context}) {
     return new _AbortDueToErrorConstant(node, message, context: context);
   }
 
@@ -1106,7 +1125,7 @@
   Constant unevaluated(Expression original, Expression replacement) {
     replacement.fileOffset = original.fileOffset;
     return new UnevaluatedConstant(
-        new FileUriExpression(replacement, getFileUri(original))
+        new FileUriExpression(replacement, getFileUri(original)!)
           ..fileOffset = original.fileOffset);
   }
 
@@ -1175,7 +1194,7 @@
   }
 
   void _recordConstructorCoverage(Constructor constructor, TreeNode caller) {
-    Uri currentUri = getFileUri(caller);
+    Uri currentUri = getFileUri(caller)!;
     Set<Reference> uriCoverage = _constructorCoverage[currentUri] ??= {};
     uriCoverage.add(constructor.reference);
   }
@@ -1211,21 +1230,23 @@
       // value.
       bool isGetter = node is InstanceGet || node is PropertyGet;
       if (nodeCache.containsKey(node) && !(enableConstFunctions && isGetter)) {
-        result = nodeCache[node];
-        if (result == null) {
+        Constant? cachedResult = nodeCache[node];
+        if (cachedResult == null) {
           // [null] is a sentinel value only used when still evaluating the same
           // node.
           return createErrorConstant(node, messageConstEvalCircularity);
         }
+        result = cachedResult;
       } else {
         nodeCache[node] = null;
-        result = node.accept(this);
-        if (result is AbortConstant) {
+        Constant evaluatedResult = node.accept(this);
+        if (evaluatedResult is AbortConstant) {
           nodeCache.remove(node);
-          return result;
+          return evaluatedResult;
         } else {
-          nodeCache[node] = result;
+          nodeCache[node] = evaluatedResult;
         }
+        result = evaluatedResult;
       }
     } else {
       bool sentinelInserted = false;
@@ -1247,19 +1268,20 @@
         nodeCache[node] = null;
         sentinelInserted = true;
       }
-      result = node.accept(this);
+      Constant evaluatedResult = node.accept(this);
       if (sentinelInserted) {
         nodeCache.remove(node);
       }
-      if (result is AbortConstant) {
-        return result;
+      if (evaluatedResult is AbortConstant) {
+        return evaluatedResult;
       }
+      result = evaluatedResult;
     }
     seenUnevaluatedChild = wasUnevaluated || result is UnevaluatedConstant;
     return result;
   }
 
-  Constant _evaluateNullableSubexpression(Expression node) {
+  Constant _evaluateNullableSubexpression(Expression? node) {
     if (node == null) return nullConstant;
     return _evaluateSubexpression(node);
   }
@@ -1304,16 +1326,17 @@
 
   @override
   Constant visitTypeLiteral(TypeLiteral node) {
-    DartType type = _evaluateDartType(node, node.type);
+    DartType? type = _evaluateDartType(node, node.type);
     if (type != null) {
       type = convertType(type);
     }
-    if (type == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (type == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(type != null);
     return canonicalize(new TypeLiteralConstant(type));
   }
@@ -1353,7 +1376,7 @@
     bool wasOrBecameUnevaluated = seenUnevaluatedChild;
     for (Expression element in node.expressions) {
       seenUnevaluatedChild = false;
-      AbortConstant error = builder.add(element);
+      AbortConstant? error = builder.add(element);
       wasOrBecameUnevaluated |= seenUnevaluatedChild;
       if (error != null) return error;
     }
@@ -1366,7 +1389,7 @@
     final ListConstantBuilder builder =
         new ListConstantBuilder(node, convertType(node.typeArgument), this);
     for (Expression list in node.lists) {
-      AbortConstant error = builder.addSpread(list);
+      AbortConstant? error = builder.addSpread(list);
       if (error != null) return error;
     }
     return builder.build();
@@ -1386,7 +1409,7 @@
     bool wasOrBecameUnevaluated = seenUnevaluatedChild;
     for (Expression element in node.expressions) {
       seenUnevaluatedChild = false;
-      AbortConstant error = builder.add(element);
+      AbortConstant? error = builder.add(element);
       wasOrBecameUnevaluated |= seenUnevaluatedChild;
       if (error != null) return error;
     }
@@ -1399,7 +1422,7 @@
     final SetConstantBuilder builder =
         new SetConstantBuilder(node, convertType(node.typeArgument), this);
     for (Expression set_ in node.sets) {
-      AbortConstant error = builder.addSpread(set_);
+      AbortConstant? error = builder.addSpread(set_);
       if (error != null) return error;
     }
     return builder.build();
@@ -1419,7 +1442,7 @@
     bool wasOrBecameUnevaluated = seenUnevaluatedChild;
     for (MapLiteralEntry element in node.entries) {
       seenUnevaluatedChild = false;
-      AbortConstant error = builder.add(element);
+      AbortConstant? error = builder.add(element);
       wasOrBecameUnevaluated |= seenUnevaluatedChild;
       if (error != null) return error;
     }
@@ -1432,7 +1455,7 @@
     final MapConstantBuilder builder = new MapConstantBuilder(
         node, convertType(node.keyType), convertType(node.valueType), this);
     for (Expression map in node.maps) {
-      AbortConstant error = builder.addSpread(map);
+      AbortConstant? error = builder.addSpread(map);
       if (error != null) return error;
     }
     return builder.build();
@@ -1454,7 +1477,7 @@
     }
 
     final Constructor constructor = node.target;
-    AbortConstant error = checkConstructorConst(node, constructor);
+    AbortConstant? error = checkConstructorConst(node, constructor);
     if (error != null) return error;
 
     final Class klass = constructor.enclosingClass;
@@ -1464,23 +1487,26 @@
           node, 'Constructor "$node" belongs to abstract class "${klass}".');
     }
 
-    final List<Constant> positionals =
+    final List<Constant>? positionals =
         _evaluatePositionalArguments(node.arguments);
-    if (positionals == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (positionals == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(positionals != null);
 
-    final Map<String, Constant> named = _evaluateNamedArguments(node.arguments);
-    if (named == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    final Map<String, Constant>? named =
+        _evaluateNamedArguments(node.arguments);
+    if (named == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(named != null);
 
     bool isSymbol = klass == coreTypes.internalSymbolClass;
@@ -1506,13 +1532,14 @@
               nameValue, isNonNullableByDefault));
     }
 
-    List<DartType> types = _evaluateTypeArguments(node, node.arguments);
-    if (types == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    List<DartType>? types = _evaluateTypeArguments(node, node.arguments);
+    if (types == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(types != null);
 
     final List<DartType> typeArguments = convertTypes(types);
@@ -1529,25 +1556,25 @@
       // initialize the fields of the new instance.
       if (shouldBeUnevaluated) {
         enterLazy();
-        AbortConstant error = handleConstructorInvocation(
+        AbortConstant? error = handleConstructorInvocation(
             constructor, typeArguments, positionals, named, node);
         if (error != null) return error;
         leaveLazy();
-        return unevaluated(node, instanceBuilder.buildUnevaluatedInstance());
+        return unevaluated(node, instanceBuilder!.buildUnevaluatedInstance());
       }
-      AbortConstant error = handleConstructorInvocation(
+      AbortConstant? error = handleConstructorInvocation(
           constructor, typeArguments, positionals, named, node);
       if (error != null) return error;
       if (shouldBeUnevaluated) {
-        return unevaluated(node, instanceBuilder.buildUnevaluatedInstance());
+        return unevaluated(node, instanceBuilder!.buildUnevaluatedInstance());
       }
-      return canonicalize(instanceBuilder.buildInstance());
+      return canonicalize(instanceBuilder!.buildInstance());
     });
   }
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant checkConstructorConst(TreeNode node, Constructor constructor) {
+  AbortConstant? checkConstructorConst(TreeNode node, Constructor constructor) {
     if (!constructor.isConst) {
       return createInvalidExpressionConstant(
           node, 'Non-const constructor invocation.');
@@ -1569,19 +1596,20 @@
     return withNewInstanceBuilder(
         node.classNode, convertTypes(node.typeArguments), () {
       for (AssertStatement statement in node.asserts) {
-        AbortConstant error = checkAssert(statement);
+        AbortConstant? error = checkAssert(statement);
         if (error != null) return error;
       }
-      AbortConstant error;
-      node.fieldValues.forEach((Reference fieldRef, Expression value) {
-        if (error != null) return;
+      AbortConstant? error;
+      for (MapEntry<Reference, Expression> entry in node.fieldValues.entries) {
+        Reference fieldRef = entry.key;
+        Expression value = entry.value;
         Constant constant = _evaluateSubexpression(value);
         if (constant is AbortConstant) {
-          error ??= constant;
-          return;
+          error = constant;
+          break;
         }
-        instanceBuilder.setFieldValue(fieldRef.asField, constant);
-      });
+        instanceBuilder!.setFieldValue(fieldRef.asField, constant);
+      }
       if (error != null) return error;
       for (Expression value in node.unusedArguments) {
         if (error != null) return error;
@@ -1591,15 +1619,15 @@
           return error;
         }
         if (constant is UnevaluatedConstant) {
-          instanceBuilder.unusedArguments.add(extract(constant));
+          instanceBuilder!.unusedArguments.add(extract(constant));
         }
       }
       if (error != null) return error;
       if (shouldBeUnevaluated) {
-        return unevaluated(node, instanceBuilder.buildUnevaluatedInstance());
+        return unevaluated(node, instanceBuilder!.buildUnevaluatedInstance());
       }
       // We can get here when re-evaluating a previously unevaluated constant.
-      return canonicalize(instanceBuilder.buildInstance());
+      return canonicalize(instanceBuilder!.buildInstance());
     });
   }
 
@@ -1643,6 +1671,7 @@
       'unary-'
     };
 
+    // ignore: unnecessary_null_comparison
     if (name == null) return false;
     if (name == '') return true;
 
@@ -1730,7 +1759,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant handleConstructorInvocation(
+  AbortConstant? handleConstructorInvocation(
       Constructor constructor,
       List<DartType> typeArguments,
       List<Constant> positionalArguments,
@@ -1773,49 +1802,52 @@
         if (!field.isStatic) {
           Constant constant = _evaluateNullableSubexpression(field.initializer);
           if (constant is AbortConstant) return constant;
-          instanceBuilder.setFieldValue(field, constant);
+          instanceBuilder!.setFieldValue(field, constant);
         }
       }
       for (final Initializer init in constructor.initializers) {
         if (init is FieldInitializer) {
           Constant constant = _evaluateSubexpression(init.value);
           if (constant is AbortConstant) return constant;
-          instanceBuilder.setFieldValue(init.field, constant);
+          instanceBuilder!.setFieldValue(init.field, constant);
         } else if (init is LocalInitializer) {
           final VariableDeclaration variable = init.variable;
-          Constant constant = _evaluateSubexpression(variable.initializer);
+          Constant constant = _evaluateSubexpression(variable.initializer!);
           if (constant is AbortConstant) return constant;
           env.addVariableValue(variable, constant);
         } else if (init is SuperInitializer) {
-          AbortConstant error = checkConstructorConst(init, constructor);
+          AbortConstant? error = checkConstructorConst(init, constructor);
           if (error != null) return error;
-          List<DartType> types = _evaluateSuperTypeArguments(
-              init, constructor.enclosingClass.supertype);
-          if (types == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          List<DartType>? types = _evaluateSuperTypeArguments(
+              init, constructor.enclosingClass.supertype!);
+          if (types == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(types != null);
 
-          List<Constant> positionalArguments =
+          List<Constant>? positionalArguments =
               _evaluatePositionalArguments(init.arguments);
-          if (positionalArguments == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          if (positionalArguments == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(positionalArguments != null);
-          Map<String, Constant> namedArguments =
+          Map<String, Constant>? namedArguments =
               _evaluateNamedArguments(init.arguments);
-          if (namedArguments == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          if (namedArguments == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(namedArguments != null);
           error = handleConstructorInvocation(init.target, types,
               positionalArguments, namedArguments, constructor);
@@ -1823,33 +1855,35 @@
         } else if (init is RedirectingInitializer) {
           // Since a redirecting constructor targets a constructor of the same
           // class, we pass the same [typeArguments].
-          AbortConstant error = checkConstructorConst(init, constructor);
+          AbortConstant? error = checkConstructorConst(init, constructor);
           if (error != null) return error;
-          List<Constant> positionalArguments =
+          List<Constant>? positionalArguments =
               _evaluatePositionalArguments(init.arguments);
-          if (positionalArguments == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          if (positionalArguments == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(positionalArguments != null);
 
-          Map<String, Constant> namedArguments =
+          Map<String, Constant>? namedArguments =
               _evaluateNamedArguments(init.arguments);
-          if (namedArguments == null && _gotError != null) {
-            AbortConstant error = _gotError;
+          if (namedArguments == null) {
+            AbortConstant error = _gotError!;
             _gotError = null;
             return error;
           }
           assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
           assert(namedArguments != null);
 
           error = handleConstructorInvocation(init.target, typeArguments,
               positionalArguments, namedArguments, constructor);
           if (error != null) return error;
         } else if (init is AssertInitializer) {
-          AbortConstant error = checkAssert(init.statement);
+          AbortConstant? error = checkAssert(init.statement);
           if (error != null) return error;
         } else {
           // InvalidInitializer or new Initializers.
@@ -1866,11 +1900,12 @@
       }
 
       for (UnevaluatedConstant constant in env.unevaluatedUnreadConstants) {
-        instanceBuilder.unusedArguments.add(extract(constant));
+        instanceBuilder!.unusedArguments.add(extract(constant));
       }
 
+      // ignore: unnecessary_null_comparison
       if (enableConstFunctions && constructor.function != null) {
-        AbortConstant error = executeConstructorBody(constructor);
+        AbortConstant? error = executeConstructorBody(constructor);
         if (error != null) return error;
       }
 
@@ -1880,20 +1915,20 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant checkAssert(AssertStatement statement) {
+  AbortConstant? checkAssert(AssertStatement statement) {
     final Constant condition = _evaluateSubexpression(statement.condition);
     if (condition is AbortConstant) return condition;
 
     if (shouldBeUnevaluated) {
-      Expression message = null;
+      Expression? message = null;
       if (statement.message != null) {
         enterLazy();
-        Constant constant = _evaluateSubexpression(statement.message);
+        Constant constant = _evaluateSubexpression(statement.message!);
         if (constant is AbortConstant) return constant;
         message = extract(constant);
         leaveLazy();
       }
-      instanceBuilder.asserts.add(new AssertStatement(extract(condition),
+      instanceBuilder!.asserts.add(new AssertStatement(extract(condition),
           message: message,
           conditionStartOffset: statement.conditionStartOffset,
           conditionEndOffset: statement.conditionEndOffset));
@@ -1903,10 +1938,10 @@
           return createErrorConstant(
               statement.condition, messageConstEvalFailedAssertion);
         }
-        final Constant message = _evaluateSubexpression(statement.message);
+        final Constant message = _evaluateSubexpression(statement.message!);
         if (message is AbortConstant) return message;
         if (shouldBeUnevaluated) {
-          instanceBuilder.asserts.add(new AssertStatement(extract(condition),
+          instanceBuilder!.asserts.add(new AssertStatement(extract(condition),
               message: extract(message),
               conditionStartOffset: statement.conditionStartOffset,
               conditionEndOffset: statement.conditionEndOffset));
@@ -1917,11 +1952,11 @@
                   .withArguments(message.value));
         } else {
           return createErrorConstant(
-              statement.message,
+              statement.message!,
               templateConstEvalInvalidType.withArguments(
                   message,
                   typeEnvironment.coreTypes.stringLegacyRawType,
-                  message.getType(_staticTypeContext),
+                  message.getType(_staticTypeContext!),
                   isNonNullableByDefault));
         }
       }
@@ -1931,7 +1966,7 @@
           templateConstEvalInvalidType.withArguments(
               condition,
               typeEnvironment.coreTypes.boolLegacyRawType,
-              condition.getType(_staticTypeContext),
+              condition.getType(_staticTypeContext!),
               isNonNullableByDefault));
     }
 
@@ -1940,7 +1975,7 @@
 
   @override
   Constant visitInvalidExpression(InvalidExpression node) {
-    return createInvalidExpressionConstant(node, node.message);
+    return createInvalidExpressionConstant(node, node.message ?? '');
   }
 
   @override
@@ -1959,15 +1994,16 @@
 
     final Constant receiver = _evaluateSubexpression(node.receiver);
     if (receiver is AbortConstant) return receiver;
-    final List<Constant> arguments =
+    final List<Constant>? arguments =
         _evaluatePositionalArguments(node.arguments);
 
-    if (arguments == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (arguments == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(arguments != null);
 
     if (shouldBeUnevaluated) {
@@ -1997,15 +2033,16 @@
 
     final Constant receiver = _evaluateSubexpression(node.receiver);
     if (receiver is AbortConstant) return receiver;
-    final List<Constant> arguments =
+    final List<Constant>? arguments =
         _evaluatePositionalArguments(node.arguments);
 
-    if (arguments == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (arguments == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(arguments != null);
 
     if (shouldBeUnevaluated) {
@@ -2040,7 +2077,8 @@
       return createInvalidExpressionConstant(node, "local function invocation");
     }
 
-    final Constant receiver = env.lookupVariable(node.variable);
+    final Constant receiver = env.lookupVariable(node.variable)!;
+    // ignore: unnecessary_null_comparison
     assert(receiver != null);
     if (receiver is AbortConstant) return receiver;
 
@@ -2049,35 +2087,38 @@
 
   Constant _evaluateFunctionInvocation(
       TreeNode node, Constant receiver, Arguments argumentsNode) {
-    final List<Constant> arguments =
+    final List<Constant>? arguments =
         _evaluatePositionalArguments(argumentsNode);
 
-    if (arguments == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (arguments == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(arguments != null);
 
     // Evaluate type arguments of the function invoked.
-    List<DartType> types = _evaluateTypeArguments(node, argumentsNode);
-    if (types == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    List<DartType>? types = _evaluateTypeArguments(node, argumentsNode);
+    if (types == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(types != null);
 
     // Evaluate named arguments of the function invoked.
-    final Map<String, Constant> named = _evaluateNamedArguments(argumentsNode);
-    if (named == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    final Map<String, Constant>? named = _evaluateNamedArguments(argumentsNode);
+    if (named == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(named != null);
 
     if (receiver is FunctionValue) {
@@ -2136,25 +2177,13 @@
       return createErrorConstant(
           node,
           templateConstEvalInvalidEqualsOperandType.withArguments(
-              left, left.getType(_staticTypeContext), isNonNullableByDefault));
+              left, left.getType(_staticTypeContext!), isNonNullableByDefault));
     }
   }
 
-  /// Converts integer constant types to an int value.
-  ///
-  /// Returns [null] on unmatched [intFolder] and [value] type.
-  int _convertToInt(Constant value) {
-    if (intFolder is JsConstantIntFolder && value is DoubleConstant) {
-      return value.value.toInt();
-    } else if (intFolder is VmConstantIntFolder && value is IntConstant) {
-      return value.value;
-    }
-    return null;
-  }
-
   Constant _handleInvocation(
       Expression node, Name name, Constant receiver, List<Constant> arguments,
-      {List<DartType> typeArguments, Map<String, Constant> namedArguments}) {
+      {List<DartType>? typeArguments, Map<String, Constant>? namedArguments}) {
     final String op = name.text;
 
     // TODO(kallentu): Handle all constant toString methods.
@@ -2187,14 +2216,12 @@
                     '+',
                     receiver,
                     typeEnvironment.coreTypes.stringLegacyRawType,
-                    other.getType(_staticTypeContext),
+                    other.getType(_staticTypeContext!),
                     isNonNullableByDefault));
           case '[]':
             if (enableConstFunctions) {
-              if (intFolder.isInt(other)) {
-                int index = _convertToInt(other);
-                assert(index != null);
-
+              int? index = intFolder.asInt(other);
+              if (index != null) {
                 if (index < 0 || index >= receiver.value.length) {
                   return new _AbortDueToThrowConstant(
                       node, new RangeError.index(index, receiver.value));
@@ -2207,7 +2234,7 @@
                       '[]',
                       receiver,
                       typeEnvironment.coreTypes.intNonNullableRawType,
-                      other.getType(_staticTypeContext),
+                      other.getType(_staticTypeContext!),
                       isNonNullableByDefault));
             }
         }
@@ -2229,7 +2256,7 @@
                     op,
                     other,
                     typeEnvironment.coreTypes.intLegacyRawType,
-                    other.getType(_staticTypeContext),
+                    other.getType(_staticTypeContext!),
                     isNonNullableByDefault));
           }
           num receiverValue = (receiver as PrimitiveConstant<num>).value;
@@ -2242,7 +2269,7 @@
                 op,
                 receiver,
                 typeEnvironment.coreTypes.numLegacyRawType,
-                other.getType(_staticTypeContext),
+                other.getType(_staticTypeContext!),
                 isNonNullableByDefault));
       }
     } else if (receiver is DoubleConstant) {
@@ -2254,7 +2281,7 @@
                 op,
                 receiver,
                 typeEnvironment.coreTypes.intLegacyRawType,
-                receiver.getType(_staticTypeContext),
+                receiver.getType(_staticTypeContext!),
                 isNonNullableByDefault));
       }
       if (arguments.length == 0) {
@@ -2276,7 +2303,7 @@
                 op,
                 receiver,
                 typeEnvironment.coreTypes.numLegacyRawType,
-                other.getType(_staticTypeContext),
+                other.getType(_staticTypeContext!),
                 isNonNullableByDefault));
       }
     } else if (receiver is BoolConstant) {
@@ -2303,10 +2330,8 @@
         final Constant other = arguments[0];
         switch (op) {
           case '[]':
-            if (intFolder.isInt(other)) {
-              int index = _convertToInt(other);
-              assert(index != null);
-
+            int? index = intFolder.asInt(other);
+            if (index != null) {
               if (index < 0 || index >= receiver.entries.length) {
                 return new _AbortDueToThrowConstant(
                     node, new RangeError.index(index, receiver.entries));
@@ -2319,7 +2344,7 @@
                     '[]',
                     receiver,
                     typeEnvironment.coreTypes.intNonNullableRawType,
-                    other.getType(_staticTypeContext),
+                    other.getType(_staticTypeContext!),
                     isNonNullableByDefault));
           case 'add':
             if (receiver is MutableListConstant) {
@@ -2334,25 +2359,29 @@
         final Constant other = arguments[0];
         switch (op) {
           case '[]':
-            final ConstantMapEntry mapEntry = receiver.entries
-                .firstWhere((entry) => entry.key == other, orElse: () => null);
-            // Null value if key is not in the map.
-            return mapEntry?.value ?? new NullConstant();
+            for (ConstantMapEntry entry in receiver.entries) {
+              if (entry.key == other) {
+                return entry.value;
+              }
+            }
+            return new NullConstant();
         }
       }
     } else if (receiver is InstanceConstant && enableConstFunctions) {
       final Class instanceClass = receiver.classNode;
       assert(typeEnvironment.hierarchy is ClassHierarchy);
       final Member member = (typeEnvironment.hierarchy as ClassHierarchy)
-          .getDispatchTarget(instanceClass, name);
-      final FunctionNode function = member.function;
+          .getDispatchTarget(instanceClass, name)!;
+      final FunctionNode? function = member.function;
 
       // TODO(kallentu): Implement [Object] class methods which have backend
       // specific functions that cannot be run by the constant evaluator.
       final bool isObjectMember = member.enclosingClass != null &&
-          member.enclosingClass.name == "Object";
+          member.enclosingClass!.name == "Object";
       if (function != null && !isObjectMember) {
-        return withNewInstanceBuilder(instanceClass, typeArguments, () {
+        // TODO(johnniwinther): Make [typeArguments] and [namedArguments]
+        // required and non-nullable.
+        return withNewInstanceBuilder(instanceClass, typeArguments!, () {
           final EvaluationEnvironment newEnv = new EvaluationEnvironment();
           for (int i = 0; i < instanceClass.typeParameters.length; i++) {
             newEnv.addTypeParameterValue(
@@ -2361,9 +2390,9 @@
 
           // Ensure that fields are visible for instance access.
           receiver.fieldValues.forEach((Reference fieldRef, Constant value) =>
-              instanceBuilder.setFieldValue(fieldRef.asField, value));
+              instanceBuilder!.setFieldValue(fieldRef.asField, value));
           return _handleFunctionInvocation(
-              function, receiver.typeArguments, arguments, namedArguments,
+              function, receiver.typeArguments, arguments, namedArguments!,
               functionEnvironment: newEnv);
         });
       }
@@ -2399,37 +2428,40 @@
     final Constant receiver = _evaluateSubexpression(node.receiver);
     if (receiver is AbortConstant) return receiver;
 
-    final List<Constant> arguments =
+    final List<Constant>? arguments =
         _evaluatePositionalArguments(node.arguments);
 
-    if (arguments == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    if (arguments == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(arguments != null);
 
     if (enableConstFunctions) {
       // Evaluate type arguments of the method invoked.
-      List<DartType> types = _evaluateTypeArguments(node, node.arguments);
-      if (types == null && _gotError != null) {
-        AbortConstant error = _gotError;
+      List<DartType>? types = _evaluateTypeArguments(node, node.arguments);
+      if (types == null) {
+        AbortConstant error = _gotError!;
         _gotError = null;
         return error;
       }
       assert(_gotError == null);
+      // ignore: unnecessary_null_comparison
       assert(types != null);
 
       // Evaluate named arguments of the method invoked.
-      final Map<String, Constant> named =
+      final Map<String, Constant>? named =
           _evaluateNamedArguments(node.arguments);
-      if (named == null && _gotError != null) {
-        AbortConstant error = _gotError;
+      if (named == null) {
+        AbortConstant error = _gotError!;
         _gotError = null;
         return error;
       }
       assert(_gotError == null);
+      // ignore: unnecessary_null_comparison
       assert(named != null);
 
       if (receiver is FunctionValue) {
@@ -2488,7 +2520,7 @@
                   logicalExpressionOperatorToString(node.operatorEnum),
                   left,
                   typeEnvironment.coreTypes.boolLegacyRawType,
-                  right.getType(_staticTypeContext),
+                  right.getType(_staticTypeContext!),
                   isNonNullableByDefault));
         }
         return createErrorConstant(
@@ -2513,7 +2545,7 @@
                   logicalExpressionOperatorToString(node.operatorEnum),
                   left,
                   typeEnvironment.coreTypes.boolLegacyRawType,
-                  right.getType(_staticTypeContext),
+                  right.getType(_staticTypeContext!),
                   isNonNullableByDefault));
         }
         return createErrorConstant(
@@ -2558,7 +2590,7 @@
           templateConstEvalInvalidType.withArguments(
               condition,
               typeEnvironment.coreTypes.boolLegacyRawType,
-              condition.getType(_staticTypeContext),
+              condition.getType(_staticTypeContext!),
               isNonNullableByDefault));
     }
   }
@@ -2573,9 +2605,11 @@
         return createErrorConstant(node, messageNotAConstantExpression);
       }
 
-      for (final Field field in instanceBuilder.fields.keys) {
+      for (final MapEntry<Field, Constant> entry
+          in instanceBuilder!.fields.entries) {
+        final Field field = entry.key;
         if (field.name == node.name) {
-          return instanceBuilder.fields[field];
+          return entry.value;
         }
       }
 
@@ -2631,10 +2665,11 @@
           return receiver.entries.single;
       }
     } else if (receiver is InstanceConstant && enableConstFunctions) {
-      for (final Reference fieldRef in receiver.fieldValues.keys) {
-        final Field field = fieldRef.asField;
+      for (final MapEntry<Reference, Constant> entry
+          in receiver.fieldValues.entries) {
+        final Field field = entry.key.asField;
         if (field.name == node.name) {
-          return receiver.fieldValues[fieldRef];
+          return entry.value;
         }
       }
     }
@@ -2692,9 +2727,11 @@
         return createErrorConstant(node, messageNotAConstantExpression);
       }
 
-      for (final Field field in instanceBuilder.fields.keys) {
+      for (final MapEntry<Field, Constant> entry
+          in instanceBuilder!.fields.entries) {
+        final Field field = entry.key;
         if (field.name == node.name) {
-          return instanceBuilder.fields[field];
+          return entry.value;
         }
       }
 
@@ -2747,10 +2784,11 @@
           return receiver.entries.single;
       }
     } else if (receiver is InstanceConstant && enableConstFunctions) {
-      for (final Reference fieldRef in receiver.fieldValues.keys) {
-        final Field field = fieldRef.asField;
+      for (final MapEntry<Reference, Constant> entry
+          in receiver.fieldValues.entries) {
+        final Field field = entry.key.asField;
         if (field.name == node.name) {
-          return receiver.fieldValues[fieldRef];
+          return entry.value;
         }
       }
     }
@@ -2762,7 +2800,7 @@
 
   @override
   Constant visitLet(Let node) {
-    Constant value = _evaluateSubexpression(node.variable.initializer);
+    Constant value = _evaluateSubexpression(node.variable.initializer!);
     if (value is AbortConstant) return value;
     env.addVariableValue(node.variable, value);
     return _evaluateSubexpression(node.body);
@@ -2779,18 +2817,20 @@
     final VariableDeclaration variable = node.variable;
     if (enableConstFunctions) {
       return env.lookupVariable(variable) ??
-          createErrorConstant(node,
-              templateConstEvalGetterNotFound.withArguments(variable.name));
+          createErrorConstant(
+              node,
+              templateConstEvalGetterNotFound
+                  .withArguments(variable.name ?? ''));
     } else {
       if (variable.parent is Let || _isFormalParameter(variable)) {
         return env.lookupVariable(node.variable) ??
             createErrorConstant(
                 node,
                 templateConstEvalNonConstantVariableGet
-                    .withArguments(variable.name));
+                    .withArguments(variable.name ?? ''));
       }
       if (variable.isConst) {
-        return _evaluateSubexpression(variable.initializer);
+        return _evaluateSubexpression(variable.initializer!);
       }
     }
     return createInvalidExpressionConstant(
@@ -2816,11 +2856,11 @@
   /// the constant is defined in a library compiled with the agnostic evaluation
   /// mode.
   Constant _evaluateExpressionInContext(Member member, Expression expression) {
-    StaticTypeContext oldStaticTypeContext = _staticTypeContext;
+    StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(member, typeEnvironment);
     Constant constant = _evaluateSubexpression(expression);
     if (constant is! AbortConstant) {
-      if (_staticTypeContext.nonNullableByDefaultCompiledMode ==
+      if (_staticTypeContext!.nonNullableByDefaultCompiledMode ==
               NonNullableByDefaultCompiledMode.Agnostic &&
           evaluationMode == EvaluationMode.weak) {
         constant = _weakener.visitConstant(constant) ?? constant;
@@ -2836,7 +2876,7 @@
       final Member target = node.target;
       if (target is Field) {
         if (target.isConst) {
-          return _evaluateExpressionInContext(target, target.initializer);
+          return _evaluateExpressionInContext(target, target.initializer!);
         }
         return createErrorConstant(
             node,
@@ -2909,18 +2949,17 @@
     }
     if (concatenated.length > 1) {
       final List<Expression> expressions =
-          new List<Expression>.filled(concatenated.length, null);
-      for (int i = 0; i < concatenated.length; i++) {
+          new List<Expression>.generate(concatenated.length, (int i) {
         Object value = concatenated[i];
         if (value is StringBuffer) {
-          expressions[i] = new ConstantExpression(
+          return new ConstantExpression(
               canonicalize(new StringConstant(value.toString())));
         } else {
           // The value is either unevaluated constant or a non-primitive
           // constant in an unevaluated expression.
-          expressions[i] = extract(value);
+          return extract(value as Constant);
         }
-      }
+      }, growable: false);
       return unevaluated(node, new StringConcatenation(expressions));
     }
     return canonicalize(new StringConstant(concatenated.single.toString()));
@@ -2930,7 +2969,7 @@
     VariableDeclaration variable = target.function.namedParameters
         .singleWhere((v) => v.name == 'defaultValue');
     return variable.initializer != null
-        ? _evaluateExpressionInContext(target, variable.initializer)
+        ? _evaluateExpressionInContext(target, variable.initializer!)
         :
         // Not reachable unless a defaultValue in fromEnvironment in dart:core
         // becomes null.
@@ -2939,8 +2978,8 @@
 
   Constant _handleFromEnvironment(
       Procedure target, StringConstant name, Map<String, Constant> named) {
-    String value = environmentDefines[name.value];
-    Constant defaultValue = named["defaultValue"];
+    String? value = environmentDefines![name.value];
+    Constant? defaultValue = named["defaultValue"];
     if (target.enclosingClass == coreTypes.boolClass) {
       Constant boolConstant;
       if (value == "true") {
@@ -2961,10 +3000,10 @@
       }
       return boolConstant;
     } else if (target.enclosingClass == coreTypes.intClass) {
-      int intValue = value != null ? int.tryParse(value) : null;
+      int? intValue = value != null ? int.tryParse(value) : null;
       Constant intConstant;
       if (intValue != null) {
-        bool negated = value.startsWith('-');
+        bool negated = value!.startsWith('-');
         intConstant = intFolder.makeIntConstant(intValue, unsigned: !negated);
       } else if (defaultValue != null) {
         if (intFolder.isInt(defaultValue)) {
@@ -2998,7 +3037,7 @@
   }
 
   Constant _handleHasEnvironment(StringConstant name) {
-    return environmentDefines.containsKey(name.value)
+    return environmentDefines!.containsKey(name.value)
         ? trueConstant
         : falseConstant;
   }
@@ -3007,33 +3046,36 @@
   Constant visitStaticInvocation(StaticInvocation node) {
     final Procedure target = node.target;
     final Arguments arguments = node.arguments;
-    List<DartType> types = _evaluateTypeArguments(node, arguments);
-    if (types == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    List<DartType>? types = _evaluateTypeArguments(node, arguments);
+    if (types == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(types != null);
 
     final List<DartType> typeArguments = convertTypes(types);
 
-    final List<Constant> positionals = _evaluatePositionalArguments(arguments);
-    if (positionals == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    final List<Constant>? positionals = _evaluatePositionalArguments(arguments);
+    if (positionals == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(positionals != null);
 
-    final Map<String, Constant> named = _evaluateNamedArguments(arguments);
-    if (named == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    final Map<String, Constant>? named = _evaluateNamedArguments(arguments);
+    if (named == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(named != null);
 
     if (shouldBeUnevaluated) {
@@ -3072,7 +3114,7 @@
       }
     } else if (target.name.text == 'identical') {
       // Ensure the "identical()" function comes from dart:core.
-      final TreeNode parent = target.parent;
+      final TreeNode? parent = target.parent;
       if (parent is Library && parent == coreTypes.coreLibrary) {
         final Constant left = positionals[0];
         final Constant right = positionals[1];
@@ -3082,8 +3124,8 @@
           // identical here.
           Constant result = makeBoolConstant(identical(left, right));
           if (evaluationMode == EvaluationMode.agnostic) {
-            Constant weakLeft = _weakener.visitConstant(left);
-            Constant weakRight = _weakener.visitConstant(right);
+            Constant? weakLeft = _weakener.visitConstant(left);
+            Constant? weakRight = _weakener.visitConstant(right);
             if (weakLeft != null || weakRight != null) {
               Constant weakResult = makeBoolConstant(
                   identical(weakLeft ?? left, weakRight ?? right));
@@ -3112,9 +3154,9 @@
     String name = target.name.text;
     if (target is Procedure && target.isFactory) {
       if (name.isEmpty) {
-        name = target.enclosingClass.name;
+        name = target.enclosingClass!.name;
       } else {
-        name = '${target.enclosingClass.name}.${name}';
+        name = '${target.enclosingClass!.name}.${name}';
       }
 
       if (enableConstFunctions) {
@@ -3130,7 +3172,7 @@
       List<DartType> typeArguments,
       List<Constant> positionalArguments,
       Map<String, Constant> namedArguments,
-      {EvaluationEnvironment functionEnvironment}) {
+      {EvaluationEnvironment? functionEnvironment}) {
     Constant executeFunction() {
       // Map arguments from caller to callee.
       for (int i = 0; i < function.typeParameters.length; i++) {
@@ -3153,7 +3195,7 @@
         env.addVariableValue(parameter, value);
       }
 
-      final Constant result = executeBody(function.body);
+      final Constant result = executeBody(function.body!);
       if (result is NullConstant &&
           function.returnType.nullability == Nullability.nonNullable) {
         // Ensure that the evaluated constant returned is not null if the
@@ -3163,7 +3205,7 @@
             templateConstEvalInvalidType.withArguments(
                 result,
                 function.returnType,
-                result.getType(_staticTypeContext),
+                result.getType(_staticTypeContext!),
                 isNonNullableByDefault));
       }
       return result;
@@ -3184,15 +3226,16 @@
           node,
           new AsExpression(extract(constant), env.substituteType(node.type))
             ..isForNonNullableByDefault =
-                _staticTypeContext.isNonNullableByDefault);
+                _staticTypeContext!.isNonNullableByDefault);
     }
-    DartType type = _evaluateDartType(node, node.type);
-    if (type == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    DartType? type = _evaluateDartType(node, node.type);
+    if (type == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(type != null);
     return ensureIsSubtype(constant, type, node);
   }
@@ -3209,16 +3252,18 @@
             ..flags = node.flags);
     }
 
-    DartType type = _evaluateDartType(node, node.type);
-    if (type == null && _gotError != null) {
-      AbortConstant error = _gotError;
+    DartType? type = _evaluateDartType(node, node.type);
+    if (type == null) {
+      AbortConstant error = _gotError!;
       _gotError = null;
       return error;
     }
     assert(_gotError == null);
+    // ignore: unnecessary_null_comparison
     assert(type != null);
 
-    bool performIs(Constant constant, {bool strongMode}) {
+    bool performIs(Constant constant, {required bool strongMode}) {
+      // ignore: unnecessary_null_comparison
       assert(strongMode != null);
       if (strongMode) {
         return isSubtype(constant, type, SubtypeCheckMode.withNullabilities);
@@ -3263,7 +3308,6 @@
       case EvaluationMode.weak:
         return makeBoolConstant(performIs(constant, strongMode: false));
     }
-    throw new UnsupportedError("Unexpected evaluation mode $evaluationMode");
   }
 
   @override
@@ -3281,7 +3325,7 @@
         templateConstEvalInvalidType.withArguments(
             constant,
             typeEnvironment.coreTypes.boolLegacyRawType,
-            constant.getType(_staticTypeContext),
+            constant.getType(_staticTypeContext!),
             isNonNullableByDefault));
   }
 
@@ -3300,7 +3344,7 @@
 
   @override
   Constant visitSymbolLiteral(SymbolLiteral node) {
-    final Reference libraryReference =
+    final Reference? libraryReference =
         node.value.startsWith('_') ? libraryOf(node).reference : null;
     return canonicalize(new SymbolConstant(node.value, libraryReference));
   }
@@ -3328,13 +3372,14 @@
     if (constant is TearOffConstant) {
       if (node.typeArguments.length ==
           constant.procedure.function.typeParameters.length) {
-        List<DartType> types = _evaluateDartTypes(node, node.typeArguments);
-        if (types == null && _gotError != null) {
-          AbortConstant error = _gotError;
+        List<DartType>? types = _evaluateDartTypes(node, node.typeArguments);
+        if (types == null) {
+          AbortConstant error = _gotError!;
           _gotError = null;
           return error;
         }
         assert(_gotError == null);
+        // ignore: unnecessary_null_comparison
         assert(types != null);
 
         final List<DartType> typeArguments = convertTypes(types);
@@ -3356,8 +3401,8 @@
 
   @override
   Constant visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) {
-    return createErrorConstant(
-        node, templateConstEvalDeferredLibrary.withArguments(node.import.name));
+    return createErrorConstant(node,
+        templateConstEvalDeferredLibrary.withArguments(node.import.name!));
   }
 
   // Helper methods:
@@ -3365,7 +3410,7 @@
   /// If both constants are DoubleConstant whose values would give different
   /// results from == and [identical], return the result of ==. Otherwise
   /// return null.
-  Constant doubleSpecialCases(Constant a, Constant b) {
+  Constant? doubleSpecialCases(Constant a, Constant b) {
     if (a is DoubleConstant && b is DoubleConstant) {
       if (a.value.isNaN && b.value.isNaN) return falseConstant;
       if (a.value == 0.0 && b.value == 0.0) return trueConstant;
@@ -3383,12 +3428,12 @@
 
   bool hasPrimitiveEqual(Constant constant) {
     if (intFolder.isInt(constant)) return true;
-    DartType type = constant.getType(_staticTypeContext);
+    DartType type = constant.getType(_staticTypeContext!);
     return !(type is InterfaceType && !classHasPrimitiveEqual(type.classNode));
   }
 
   bool classHasPrimitiveEqual(Class klass) {
-    bool cached = primitiveEqualCache[klass];
+    bool? cached = primitiveEqualCache[klass];
     if (cached != null) return cached;
     for (Procedure procedure in klass.procedures) {
       if (procedure.kind == ProcedureKind.Operator &&
@@ -3400,14 +3445,14 @@
     }
     if (klass.supertype == null) return true; // To be on the safe side
     return primitiveEqualCache[klass] =
-        classHasPrimitiveEqual(klass.supertype.classNode);
+        classHasPrimitiveEqual(klass.supertype!.classNode);
   }
 
   BoolConstant makeBoolConstant(bool value) =>
       value ? trueConstant : falseConstant;
 
   bool isSubtype(Constant constant, DartType type, SubtypeCheckMode mode) {
-    DartType constantType = constant.getType(_staticTypeContext);
+    DartType constantType = constant.getType(_staticTypeContext!);
     if (mode == SubtypeCheckMode.ignoringNullabilities) {
       constantType = rawLegacyErasure(constantType) ?? constantType;
     }
@@ -3462,20 +3507,20 @@
       return createErrorConstant(
           node,
           templateConstEvalInvalidType.withArguments(constant, type,
-              constant.getType(_staticTypeContext), isNonNullableByDefault));
+              constant.getType(_staticTypeContext!), isNonNullableByDefault));
     }
     return constant;
   }
 
   /// Returns the types on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  List<DartType> _evaluateTypeArguments(TreeNode node, Arguments arguments) {
+  List<DartType>? _evaluateTypeArguments(TreeNode node, Arguments arguments) {
     return _evaluateDartTypes(node, arguments.types);
   }
 
   /// Returns the types on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  List<DartType> _evaluateSuperTypeArguments(TreeNode node, Supertype type) {
+  List<DartType>? _evaluateSuperTypeArguments(TreeNode node, Supertype type) {
     return _evaluateDartTypes(node, type.typeArguments);
   }
 
@@ -3483,22 +3528,23 @@
   /// "error"-constant is saved here. Normally this should be null.
   /// Once a caller calls such a procedure and it gives an error here,
   /// the caller should fetch it an null-out this variable.
-  AbortConstant _gotError;
+  AbortConstant? _gotError;
 
   /// Returns the types on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  List<DartType> _evaluateDartTypes(TreeNode node, List<DartType> types) {
+  List<DartType>? _evaluateDartTypes(TreeNode node, List<DartType> types) {
     // TODO: Once the frontend guarantees that there are no free type variables
     // left over after substitution, we can enable this shortcut again:
     // if (env.isEmpty) return types;
     List<DartType> result =
-        new List<DartType>.filled(types.length, null, growable: true);
+        new List<DartType>.filled(types.length, dummyDartType, growable: true);
     for (int i = 0; i < types.length; i++) {
-      DartType type = _evaluateDartType(node, types[i]);
-      if (type == null && _gotError != null) {
+      DartType? type = _evaluateDartType(node, types[i]);
+      if (type == null) {
         return null;
       }
       assert(_gotError == null);
+      // ignore: unnecessary_null_comparison
       assert(type != null);
       result[i] = type;
     }
@@ -3507,7 +3553,7 @@
 
   /// Returns the type on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  DartType _evaluateDartType(TreeNode node, DartType type) {
+  DartType? _evaluateDartType(TreeNode node, DartType type) {
     final DartType result = env.substituteType(type);
 
     if (!isInstantiated(result)) {
@@ -3523,9 +3569,9 @@
 
   /// Returns the types on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  List<Constant> _evaluatePositionalArguments(Arguments arguments) {
+  List<Constant>? _evaluatePositionalArguments(Arguments arguments) {
     List<Constant> result = new List<Constant>.filled(
-        arguments.positional.length, null,
+        arguments.positional.length, dummyConstant,
         growable: true);
     for (int i = 0; i < arguments.positional.length; i++) {
       Constant constant = _evaluateSubexpression(arguments.positional[i]);
@@ -3540,7 +3586,7 @@
 
   /// Returns the arguments on success and null on failure.
   /// Note that on failure an errorConstant is saved in [_gotError].
-  Map<String, Constant> _evaluateNamedArguments(Arguments arguments) {
+  Map<String, Constant>? _evaluateNamedArguments(Arguments arguments) {
     if (arguments.named.isEmpty) return const <String, Constant>{};
 
     final Map<String, Constant> named = {};
@@ -3560,9 +3606,9 @@
   Arguments unevaluatedArguments(List<Constant> positionalArgs,
       Map<String, Constant> namedArgs, List<DartType> types) {
     final List<Expression> positional =
-        new List<Expression>.filled(positionalArgs.length, null);
-    final List<NamedExpression> named =
-        new List<NamedExpression>.filled(namedArgs.length, null);
+        new List<Expression>.filled(positionalArgs.length, dummyExpression);
+    final List<NamedExpression> named = new List<NamedExpression>.filled(
+        namedArgs.length, dummyNamedExpression);
     for (int i = 0; i < positionalArgs.length; ++i) {
       positional[i] = extract(positionalArgs[i]);
     }
@@ -3581,7 +3627,7 @@
 
   T withNewInstanceBuilder<T>(
       Class klass, List<DartType> typeArguments, T fn()) {
-    InstanceBuilder old = instanceBuilder;
+    InstanceBuilder? old = instanceBuilder;
     instanceBuilder = new InstanceBuilder(this, klass, typeArguments);
     T result = fn();
     instanceBuilder = old;
@@ -3610,14 +3656,14 @@
 
   /// Binary operation between two operands, at least one of which is a double.
   Constant evaluateBinaryNumericOperation(
-      String op, num a, num b, TreeNode node) {
+      String op, num a, num b, Expression node) {
     switch (op) {
       case '+':
-        return new DoubleConstant(a + b);
+        return new DoubleConstant((a + b) as double);
       case '-':
-        return new DoubleConstant(a - b);
+        return new DoubleConstant((a - b) as double);
       case '*':
-        return new DoubleConstant(a * b);
+        return new DoubleConstant((a * b) as double);
       case '/':
         return new DoubleConstant(a / b);
       case '~/':
@@ -3627,7 +3673,7 @@
         }
         return intFolder.truncatingDivide(node, a, b);
       case '%':
-        return new DoubleConstant(a % b);
+        return new DoubleConstant((a % b) as double);
     }
 
     switch (op) {
@@ -3646,12 +3692,14 @@
         node, "Unexpected binary numeric operation '$op'.");
   }
 
-  Library libraryOf(TreeNode node) {
+  // TODO(johnniwinther): Remove the need for this by adding a current library
+  // field.
+  Library libraryOf(TreeNode? node) {
     // The tree structure of the kernel AST ensures we always have an enclosing
     // library.
     while (true) {
       if (node is Library) return node;
-      node = node.parent;
+      node = node!.parent;
     }
   }
 
@@ -3727,7 +3775,7 @@
 
   @override
   ExecutionStatus visitAssertStatement(AssertStatement node) {
-    AbortConstant error = exprEvaluator.checkAssert(node);
+    AbortConstant? error = exprEvaluator.checkAssert(node);
     if (error != null) return new AbortStatus(error);
     return const ProceedStatus();
   }
@@ -3790,7 +3838,7 @@
     if ((condition as BoolConstant).value) {
       return node.then.accept(this);
     } else if (node.otherwise != null) {
-      return node.otherwise.accept(this);
+      return node.otherwise!.accept(this);
     }
     return const ProceedStatus();
   }
@@ -3802,8 +3850,8 @@
       if (status is! ProceedStatus) return status;
     }
 
-    Constant condition =
-        node.condition != null ? evaluate(node.condition) : null;
+    Constant? condition =
+        node.condition != null ? evaluate(node.condition!) : null;
     while (node.condition == null || condition is BoolConstant) {
       if (condition is BoolConstant && !condition.value) break;
 
@@ -3818,7 +3866,7 @@
       }
 
       if (node.condition != null) {
-        condition = evaluate(node.condition);
+        condition = evaluate(node.condition!);
       }
     }
 
@@ -3845,9 +3893,9 @@
 
   @override
   ExecutionStatus visitReturnStatement(ReturnStatement node) {
-    Constant result;
+    Constant? result;
     if (node.expression != null) {
-      result = evaluate(node.expression);
+      result = evaluate(node.expression!);
       if (result is AbortConstant) return new AbortStatus(result);
     }
     return new ReturnStatus(result);
@@ -3878,9 +3926,9 @@
         final DartType defaultType =
             exprEvaluator.typeEnvironment.coreTypes.objectNonNullableRawType;
 
-        DartType throwType;
+        DartType? throwType;
         if (throwValue is Constant) {
-          throwType = throwValue.getType(exprEvaluator._staticTypeContext);
+          throwType = throwValue.getType(exprEvaluator._staticTypeContext!);
         } else if (throwValue is StateError) {
           final Class stateErrorClass = exprEvaluator
               .coreTypes.coreLibrary.classes
@@ -3897,7 +3945,7 @@
         assert(throwType != null);
 
         for (Catch catchClause in node.catches) {
-          if (exprEvaluator.typeEnvironment.isSubtypeOf(throwType,
+          if (exprEvaluator.typeEnvironment.isSubtypeOf(throwType!,
                   catchClause.guard, SubtypeCheckMode.withNullabilities) ||
               catchClause.guard == defaultType) {
             return exprEvaluator.withNewEnvironment(() {
@@ -3905,7 +3953,7 @@
                 // TODO(kallentu): Store non-constant exceptions.
                 if (throwValue is Constant) {
                   exprEvaluator.env
-                      .addVariableValue(catchClause.exception, throwValue);
+                      .addVariableValue(catchClause.exception!, throwValue);
                 }
               }
               // TODO(kallentu): Store appropriate stack trace in environment.
@@ -3930,7 +3978,7 @@
   ExecutionStatus visitVariableDeclaration(VariableDeclaration node) {
     Constant value;
     if (node.initializer != null) {
-      value = evaluate(node.initializer);
+      value = evaluate(node.initializer!);
       if (value is AbortConstant) return new AbortStatus(value);
     } else {
       value = new NullConstant();
@@ -4024,16 +4072,16 @@
   final Set<VariableDeclaration> _unreadUnevaluatedVariables =
       new Set<VariableDeclaration>();
 
-  EvaluationEnvironment _parent;
+  final EvaluationEnvironment? _parent;
 
-  EvaluationEnvironment();
+  EvaluationEnvironment() : _parent = null;
   EvaluationEnvironment.withParent(this._parent);
 
   /// Whether the current environment is empty.
   bool get isEmpty {
     // Since we look up variables in enclosing environment, the environment
     // is not empty if its parent is not empty.
-    if (_parent != null && !_parent.isEmpty) return false;
+    if (_parent != null && !_parent!.isEmpty) return false;
     return _typeVariables.isEmpty && _variables.isEmpty;
   }
 
@@ -4049,16 +4097,17 @@
     }
   }
 
-  Constant updateVariableValue(VariableDeclaration variable, Constant value) {
-    if (_variables.containsKey(variable)) {
-      _variables[variable].value = value;
+  Constant? updateVariableValue(VariableDeclaration variable, Constant value) {
+    EvaluationReference? reference = _variables[variable];
+    if (reference != null) {
+      reference.value = value;
       return value;
     }
     return _parent?.updateVariableValue(variable, value);
   }
 
-  Constant lookupVariable(VariableDeclaration variable) {
-    Constant value = _variables[variable]?.value;
+  Constant? lookupVariable(VariableDeclaration variable) {
+    Constant? value = _variables[variable]?.value;
     if (value is UnevaluatedConstant) {
       _unreadUnevaluatedVariables.remove(variable);
     } else if (value == null) {
@@ -4071,7 +4120,8 @@
   Iterable<UnevaluatedConstant> get unevaluatedUnreadConstants {
     if (_unreadUnevaluatedVariables.isEmpty) return const [];
     return _unreadUnevaluatedVariables.map<UnevaluatedConstant>(
-        (VariableDeclaration variable) => _variables[variable].value);
+        (VariableDeclaration variable) =>
+            _variables[variable]!.value as UnevaluatedConstant);
   }
 
   DartType substituteType(DartType type) {
@@ -4079,23 +4129,22 @@
     final DartType substitutedType = substitute(type, _typeVariables);
     if (identical(substitutedType, type) && _parent != null) {
       // No distinct type created, substitute type in parent.
-      return _parent.substituteType(type);
+      return _parent!.substituteType(type);
     }
     return substitutedType;
   }
 }
 
 class RedundantFileUriExpressionRemover extends Transformer {
-  Uri currentFileUri = null;
+  Uri? currentFileUri = null;
 
   TreeNode visitFileUriExpression(FileUriExpression node) {
     if (node.fileUri == currentFileUri) {
       return node.expression.accept(this);
     } else {
-      Uri oldFileUri = currentFileUri;
+      Uri? oldFileUri = currentFileUri;
       currentFileUri = node.fileUri;
-      node.expression = node.expression.accept(this) as Expression
-        ..parent = node;
+      node.expression = transform(node.expression)..parent = node;
       currentFileUri = oldFileUri;
       return node;
     }
@@ -4121,7 +4170,7 @@
 
 /// Status that the statement returned a valid [Constant] value.
 class ReturnStatus extends ExecutionStatus {
-  final Constant value;
+  final Constant? value;
   ReturnStatus(this.value);
 }
 
@@ -4150,7 +4199,7 @@
 /// respective environment within the [ConstantEvaluator].
 class FunctionValue implements Constant {
   final FunctionNode function;
-  final EvaluationEnvironment environment;
+  final EvaluationEnvironment? environment;
 
   FunctionValue(this.function, this.environment);
 
@@ -4210,7 +4259,7 @@
 class _AbortDueToErrorConstant extends AbortConstant {
   final TreeNode node;
   final Message message;
-  final List<LocatedMessage> context;
+  final List<LocatedMessage>? context;
 
   _AbortDueToErrorConstant(this.node, this.message, {this.context});
 
@@ -4382,7 +4431,7 @@
 abstract class ErrorReporter {
   const ErrorReporter();
 
-  void report(LocatedMessage message, List<LocatedMessage> context);
+  void report(LocatedMessage message, List<LocatedMessage>? context);
 
   void reportInvalidExpression(InvalidExpression node);
 }
@@ -4391,10 +4440,12 @@
   const SimpleErrorReporter();
 
   @override
-  void report(LocatedMessage message, List<LocatedMessage> context) {
+  void report(LocatedMessage message, List<LocatedMessage>? context) {
     _report(message);
-    for (LocatedMessage contextMessage in context) {
-      _report(contextMessage);
+    if (context != null) {
+      for (LocatedMessage contextMessage in context) {
+        _report(contextMessage);
+      }
     }
   }
 
@@ -4407,7 +4458,7 @@
     reportMessage(message.uri, message.charOffset, message.message);
   }
 
-  void reportMessage(Uri uri, int offset, String message) {
+  void reportMessage(Uri? uri, int offset, String message) {
     io.exitCode = 42;
     io.stderr.writeln('$uri:$offset Constant evaluation error: $message');
   }
@@ -4476,7 +4527,7 @@
 }
 
 bool _isFormalParameter(VariableDeclaration variable) {
-  final TreeNode parent = variable.parent;
+  final TreeNode? parent = variable.parent;
   if (parent is FunctionNode) {
     return parent.positionalParameters.contains(variable) ||
         parent.namedParameters.contains(variable);
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_int_folder.dart b/pkg/front_end/lib/src/fasta/kernel/constant_int_folder.dart
index fbbd0ca..8ffd6f5 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_int_folder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_int_folder.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/target/targets.dart';
 
@@ -29,8 +27,16 @@
     }
   }
 
+  /// Returns `true` of [constant] is an integer value.
   bool isInt(Constant constant);
 
+  /// Returns the value of [constant] as an [int], of `null` [constant] is
+  /// not an integer value.
+  ///
+  /// This method must return a non-null value iff `isInt(constant)` returns
+  /// `true`.
+  int? asInt(Constant constant);
+
   Constant makeIntConstant(int value, {bool unsigned: false});
 
   Constant foldUnaryOperator(
@@ -43,7 +49,7 @@
 
   /// Returns [null] on success and an error-"constant" on failure, as such the
   /// return value should be checked.
-  AbortConstant _checkOperands(
+  AbortConstant? _checkOperands(
       Expression node, String op, num left, num right) {
     if ((op == '<<' || op == '>>' || op == '>>>') && right < 0) {
       return evaluator.createErrorConstant(node,
@@ -64,6 +70,14 @@
   bool isInt(Constant constant) => constant is IntConstant;
 
   @override
+  int? asInt(Constant constant) {
+    if (constant is IntConstant) {
+      return constant.value;
+    }
+    return null;
+  }
+
+  @override
   IntConstant makeIntConstant(int value, {bool unsigned: false}) {
     return new IntConstant(value);
   }
@@ -87,7 +101,7 @@
       Expression node, String op, IntConstant left, IntConstant right) {
     int a = left.value;
     int b = right.value;
-    AbortConstant error = _checkOperands(node, op, a, b);
+    AbortConstant? error = _checkOperands(node, op, a, b);
     if (error != null) return error;
     switch (op) {
       case '+':
@@ -161,6 +175,14 @@
   }
 
   @override
+  int? asInt(Constant constant) {
+    if (constant is DoubleConstant && _valueIsInteger(constant.value)) {
+      return constant.value.toInt();
+    }
+    return null;
+  }
+
+  @override
   DoubleConstant makeIntConstant(int value, {bool unsigned: false}) {
     double doubleValue = value.toDouble();
     // Invalid assert: assert(doubleValue.toInt() == value);
@@ -192,7 +214,7 @@
       Expression node, String op, DoubleConstant left, DoubleConstant right) {
     double a = left.value;
     double b = right.value;
-    AbortConstant error = _checkOperands(node, op, a, b);
+    AbortConstant? error = _checkOperands(node, op, a, b);
     if (error != null) return error;
     switch (op) {
       case '+':
diff --git a/pkg/front_end/test/constant_evaluator_benchmark.dart b/pkg/front_end/test/constant_evaluator_benchmark.dart
index 77b6084..c1eb8fb 100644
--- a/pkg/front_end/test/constant_evaluator_benchmark.dart
+++ b/pkg/front_end/test/constant_evaluator_benchmark.dart
@@ -101,6 +101,8 @@
             evaluateAnnotations: true,
             enableTripleShift: target
                 .isExperimentEnabledGlobally(ExperimentalFlag.tripleShift),
+            enableConstFunctions: target
+                .isExperimentEnabledGlobally(ExperimentalFlag.constFunctions),
             errorOnUnevaluatedConstant:
                 incrementalCompiler.context.options.errorOnUnevaluatedConstant);
         print("Transformed constants with $environmentDefinesDescription"
diff --git a/pkg/kernel/lib/src/const_canonical_type.dart b/pkg/kernel/lib/src/const_canonical_type.dart
index b7edbd5..4c00536 100644
--- a/pkg/kernel/lib/src/const_canonical_type.dart
+++ b/pkg/kernel/lib/src/const_canonical_type.dart
@@ -12,7 +12,15 @@
 ///
 /// The algorithm is specified at
 /// https://github.com/dart-lang/language/blob/master/accepted/future-releases/nnbd/feature-specification.md#constant-instances
-DartType computeConstCanonicalType(DartType type, CoreTypes coreTypes,
+DartType? computeConstCanonicalType(DartType type, CoreTypes coreTypes,
+    {required bool isNonNullableByDefault}) {
+  // TODO(johnniwinther,dmitryas): Support returning `null` when the resulting
+  // type is the same as the input type.
+  return _computeConstCanonicalType(type, coreTypes,
+      isNonNullableByDefault: isNonNullableByDefault);
+}
+
+DartType _computeConstCanonicalType(DartType type, CoreTypes coreTypes,
     {required bool isNonNullableByDefault}) {
   // ignore: unnecessary_null_comparison
   assert(isNonNullableByDefault != null);
@@ -41,7 +49,7 @@
       isTypeWithoutNullabilityMarker(type,
           isNonNullableByDefault: isNonNullableByDefault)) {
     return new FutureOrType(
-        computeConstCanonicalType(type.typeArgument, coreTypes,
+        _computeConstCanonicalType(type.typeArgument, coreTypes,
             isNonNullableByDefault: isNonNullableByDefault),
         Nullability.legacy);
   }
@@ -51,7 +59,7 @@
   // if S is R* then R?
   // else S?
   if (isNullableTypeConstructorApplication(type)) {
-    return computeConstCanonicalType(
+    return _computeConstCanonicalType(
             computeTypeWithoutNullabilityMarker(type,
                 isNonNullableByDefault: isNonNullableByDefault),
             coreTypes,
@@ -62,7 +70,7 @@
   // CONST_CANONICAL_TYPE(T*) = CONST_CANONICAL_TYPE(T)
   if (isLegacyTypeConstructorApplication(type,
       isNonNullableByDefault: isNonNullableByDefault)) {
-    return computeConstCanonicalType(
+    return _computeConstCanonicalType(
         computeTypeWithoutNullabilityMarker(type,
             isNonNullableByDefault: isNonNullableByDefault),
         coreTypes,
@@ -93,7 +101,7 @@
       typeArguments =
           new List<DartType>.of(type.typeArguments, growable: false);
       for (int i = 0; i < typeArguments.length; ++i) {
-        typeArguments[i] = computeConstCanonicalType(
+        typeArguments[i] = _computeConstCanonicalType(
             typeArguments[i], coreTypes,
             isNonNullableByDefault: isNonNullableByDefault);
       }
@@ -121,7 +129,7 @@
       substitution = freshTypeParameters.substitution;
       canonicalizedTypeParameters = freshTypeParameters.freshTypeParameters;
       for (TypeParameter parameter in canonicalizedTypeParameters) {
-        parameter.bound = computeConstCanonicalType(parameter.bound, coreTypes,
+        parameter.bound = _computeConstCanonicalType(parameter.bound, coreTypes,
             isNonNullableByDefault: isNonNullableByDefault);
       }
       List<DartType> defaultTypes = calculateBoundsInternal(
@@ -139,7 +147,7 @@
       canonicalizedPositionalParameters =
           new List<DartType>.of(type.positionalParameters, growable: false);
       for (int i = 0; i < canonicalizedPositionalParameters.length; ++i) {
-        DartType canonicalized = computeConstCanonicalType(
+        DartType canonicalized = _computeConstCanonicalType(
             canonicalizedPositionalParameters[i], coreTypes,
             isNonNullableByDefault: isNonNullableByDefault);
         if (substitution != null) {
@@ -156,7 +164,7 @@
       canonicalizedNamedParameters =
           new List<NamedType>.of(type.namedParameters, growable: false);
       for (int i = 0; i < canonicalizedNamedParameters.length; ++i) {
-        DartType canonicalized = computeConstCanonicalType(
+        DartType canonicalized = _computeConstCanonicalType(
             canonicalizedNamedParameters[i].type, coreTypes,
             isNonNullableByDefault: isNonNullableByDefault);
         if (substitution != null) {
@@ -168,7 +176,7 @@
       }
     }
 
-    DartType canonicalizedReturnType = computeConstCanonicalType(
+    DartType canonicalizedReturnType = _computeConstCanonicalType(
         type.returnType, coreTypes,
         isNonNullableByDefault: isNonNullableByDefault);
     if (substitution != null) {
@@ -189,7 +197,7 @@
         canonicalizedTypeArguments =
             new List<DartType>.of(typedefType.typeArguments, growable: false);
         for (int i = 0; i < canonicalizedTypeArguments.length; ++i) {
-          canonicalizedTypeArguments[i] = computeConstCanonicalType(
+          canonicalizedTypeArguments[i] = _computeConstCanonicalType(
               canonicalizedTypeArguments[i], coreTypes,
               isNonNullableByDefault: isNonNullableByDefault);
         }