diff --git a/DEPS b/DEPS
index 02d36bb..5d510bd 100644
--- a/DEPS
+++ b/DEPS
@@ -44,7 +44,7 @@
   # co19 is a cipd package. Use update.sh in tests/co19[_2] to update these
   # hashes. It requires access to the dart-build-access group, which EngProd
   # has.
-  "co19_rev": "da33ec472443aa14d969bf54b9adc3af71cb6382",
+  "co19_rev": "58e95961ea492a749ca6eccf5586fdf8271f8266",
   "co19_2_rev": "e48b3090826cf40b8037648f19d211e8eab1b4b6",
 
   # The internal benchmarks to use. See go/dart-benchmarks-internal
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index 1f4fe07..e429f2b 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -85,7 +85,7 @@
 /// TODO(scheglov) Clean up the list of implicitly analyzed files.
 class AnalysisDriver implements AnalysisDriverGeneric {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 111;
+  static const int DATA_VERSION = 112;
 
   /// The length of the list returned by [_computeDeclaredVariablesSignature].
   static const int _declaredVariablesSignatureLength = 4;
diff --git a/pkg/analyzer/lib/src/dart/element/replacement_visitor.dart b/pkg/analyzer/lib/src/dart/element/replacement_visitor.dart
index d636bf2..c90174a 100644
--- a/pkg/analyzer/lib/src/dart/element/replacement_visitor.dart
+++ b/pkg/analyzer/lib/src/dart/element/replacement_visitor.dart
@@ -13,12 +13,17 @@
 import 'package:analyzer/src/dart/element/type_schema.dart';
 import 'package:analyzer/src/dart/element/type_visitor.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/summary2/function_type_builder.dart';
+import 'package:analyzer/src/summary2/named_type_builder.dart';
 import 'package:meta/meta.dart';
 
 /// Helper visitor that clones a type if a nested type is replaced, and
 /// otherwise returns `null`.
 class ReplacementVisitor
-    implements TypeVisitor<DartType>, InferenceTypeVisitor<DartType> {
+    implements
+        TypeVisitor<DartType>,
+        InferenceTypeVisitor<DartType>,
+        LinkingTypeVisitor<DartType> {
   const ReplacementVisitor();
 
   void changeVariance() {}
@@ -47,6 +52,27 @@
     );
   }
 
+  DartType createFunctionTypeBuilder({
+    @required FunctionTypeBuilder type,
+    @required List<TypeParameterElement> newTypeParameters,
+    @required List<ParameterElement> newParameters,
+    @required DartType newReturnType,
+    @required NullabilitySuffix newNullability,
+  }) {
+    if (newNullability == null &&
+        newReturnType == null &&
+        newParameters == null) {
+      return null;
+    }
+
+    return FunctionTypeBuilder(
+      newTypeParameters ?? type.typeFormals,
+      newParameters ?? type.parameters,
+      newReturnType ?? type.returnType,
+      newNullability ?? type.nullabilitySuffix,
+    );
+  }
+
   DartType createInterfaceType({
     @required InterfaceType type,
     @required List<DartType> newTypeArguments,
@@ -63,6 +89,23 @@
     );
   }
 
+  NamedTypeBuilder createNamedTypeBuilder({
+    @required NamedTypeBuilder type,
+    @required List<DartType> newTypeArguments,
+    @required NullabilitySuffix newNullability,
+  }) {
+    if (newTypeArguments == null && newNullability == null) {
+      return null;
+    }
+
+    return NamedTypeBuilder(
+      type.typeSystem,
+      type.element,
+      newTypeArguments ?? type.arguments,
+      newNullability ?? type.nullabilitySuffix,
+    );
+  }
+
   DartType createNeverType({
     @required NeverTypeImpl type,
     @required NullabilitySuffix newNullability,
@@ -207,17 +250,99 @@
   }
 
   @override
+  DartType visitFunctionTypeBuilder(FunctionTypeBuilder node) {
+    var newNullability = visitNullability(node);
+
+    List<TypeParameterElement> newTypeParameters;
+    for (var i = 0; i < node.typeFormals.length; i++) {
+      var typeParameter = node.typeFormals[i];
+      var bound = typeParameter.bound;
+      if (bound != null) {
+        var newBound = bound.accept(this);
+        if (newBound != null) {
+          newTypeParameters ??= node.typeFormals.toList(growable: false);
+          newTypeParameters[i] = TypeParameterElementImpl.synthetic(
+            typeParameter.name,
+          )..bound = newBound;
+        }
+      }
+    }
+
+    Substitution substitution;
+    if (newTypeParameters != null) {
+      var map = <TypeParameterElement, DartType>{};
+      for (var i = 0; i < newTypeParameters.length; ++i) {
+        var typeParameter = node.typeFormals[i];
+        var newTypeParameter = newTypeParameters[i];
+        map[typeParameter] = newTypeParameter.instantiate(
+          nullabilitySuffix: NullabilitySuffix.none,
+        );
+      }
+
+      substitution = Substitution.fromMap(map);
+
+      for (var i = 0; i < newTypeParameters.length; i++) {
+        var newTypeParameter = newTypeParameters[i];
+        var bound = newTypeParameter.bound;
+        if (bound != null) {
+          var newBound = substitution.substituteType(bound);
+          (newTypeParameter as TypeParameterElementImpl).bound = newBound;
+        }
+      }
+    }
+
+    DartType visitType(DartType type) {
+      if (type == null) return null;
+      var result = type.accept(this);
+      if (substitution != null) {
+        result = substitution.substituteType(result ?? type);
+      }
+      return result;
+    }
+
+    var newReturnType = visitType(node.returnType);
+
+    changeVariance();
+
+    List<ParameterElement> newParameters;
+    for (var i = 0; i < node.parameters.length; i++) {
+      var parameter = node.parameters[i];
+
+      var type = parameter.type;
+      var newType = visitType(type);
+
+      // ignore: deprecated_member_use_from_same_package
+      var kind = parameter.parameterKind;
+      var newKind = visitParameterKind(kind);
+
+      if (newType != null || newKind != null) {
+        newParameters ??= node.parameters.toList(growable: false);
+        newParameters[i] = parameter.copyWith(
+          type: newType,
+          kind: newKind,
+        );
+      }
+    }
+
+    changeVariance();
+
+    return createFunctionTypeBuilder(
+      type: node,
+      newTypeParameters: newTypeParameters,
+      newParameters: newParameters,
+      newReturnType: newReturnType,
+      newNullability: newNullability,
+    );
+  }
+
+  @override
   DartType visitInterfaceType(InterfaceType type) {
     var newNullability = visitNullability(type);
 
-    List<DartType> newTypeArguments;
-    for (var i = 0; i < type.typeArguments.length; i++) {
-      var substitution = type.typeArguments[i].accept(this);
-      if (substitution != null) {
-        newTypeArguments ??= type.typeArguments.toList(growable: false);
-        newTypeArguments[i] = substitution;
-      }
-    }
+    var newTypeArguments = _typeArguments(
+      type.element.typeParameters,
+      type.typeArguments,
+    );
 
     return createInterfaceType(
       type: type,
@@ -227,6 +352,26 @@
   }
 
   @override
+  DartType visitNamedTypeBuilder(NamedTypeBuilder type) {
+    var newNullability = visitNullability(type);
+
+    var parameters = const <TypeParameterElement>[];
+    var element = type.element;
+    if (element is ClassElement) {
+      parameters = element.typeParameters;
+    } else if (element is FunctionTypeAliasElement) {
+      parameters = element.typeParameters;
+    }
+
+    var newArguments = _typeArguments(parameters, type.arguments);
+    return createNamedTypeBuilder(
+      type: type,
+      newTypeArguments: newArguments,
+      newNullability: newNullability,
+    );
+  }
+
+  @override
   DartType visitNeverType(NeverType type) {
     var newNullability = visitNullability(type);
 
@@ -244,6 +389,11 @@
     return null;
   }
 
+  DartType visitTypeArgument(
+      TypeParameterElement parameter, DartType argument) {
+    return argument.accept(this);
+  }
+
   @override
   DartType visitTypeParameterType(TypeParameterType type) {
     var newNullability = visitNullability(type);
@@ -273,4 +423,28 @@
   DartType visitVoidType(VoidType type) {
     return null;
   }
+
+  List<DartType> _typeArguments(
+    List<TypeParameterElement> parameters,
+    List<DartType> arguments,
+  ) {
+    if (arguments == null) {
+      return null;
+    }
+
+    if (arguments.length != parameters.length) {
+      return null;
+    }
+
+    List<DartType> newArguments;
+    for (var i = 0; i < arguments.length; i++) {
+      var substitution = visitTypeArgument(parameters[i], arguments[i]);
+      if (substitution != null) {
+        newArguments ??= arguments.toList(growable: false);
+        newArguments[i] = substitution;
+      }
+    }
+
+    return newArguments;
+  }
 }
diff --git a/pkg/analyzer/lib/src/dart/micro/cider_byte_store.dart b/pkg/analyzer/lib/src/dart/micro/cider_byte_store.dart
index 5d97366..57531d9 100644
--- a/pkg/analyzer/lib/src/dart/micro/cider_byte_store.dart
+++ b/pkg/analyzer/lib/src/dart/micro/cider_byte_store.dart
@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/src/dart/analysis/cache.dart';
 import 'package:collection/collection.dart';
 
 /// Store of bytes associated with string keys and a hash.
@@ -23,19 +24,16 @@
   void put(String key, List<int> signature, List<int> bytes);
 }
 
-class CiderCacheEntry {
-  final List<int> signature;
-  final List<int> bytes;
+class CiderCachedByteStore implements CiderByteStore {
+  final Cache<String, CiderCacheEntry> _cache;
 
-  CiderCacheEntry(this.signature, this.bytes);
-}
-
-class CiderMemoryByteStore implements CiderByteStore {
-  final Map<String, CiderCacheEntry> _map = {};
+  CiderCachedByteStore(int maxCacheSize)
+      : _cache =
+            Cache<String, CiderCacheEntry>(maxCacheSize, (v) => v.bytes.length);
 
   @override
   List<int> get(String key, List<int> signature) {
-    var entry = _map[key];
+    var entry = _cache.get(key, () => null);
 
     if (entry != null &&
         const ListEquality<int>().equals(entry.signature, signature)) {
@@ -46,6 +44,13 @@
 
   @override
   void put(String key, List<int> signature, List<int> bytes) {
-    _map[key] = CiderCacheEntry(signature, bytes);
+    _cache.put(key, CiderCacheEntry(signature, bytes));
   }
 }
+
+class CiderCacheEntry {
+  final List<int> signature;
+  final List<int> bytes;
+
+  CiderCacheEntry(this.signature, this.bytes);
+}
diff --git a/pkg/analyzer/lib/src/dart/micro/resolve_file.dart b/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
index 206d69c..5216076 100644
--- a/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
+++ b/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
@@ -40,6 +40,9 @@
 import 'package:meta/meta.dart';
 import 'package:yaml/yaml.dart';
 
+const M = 1024 * 1024 /*1 MiB*/;
+const memoryCacheSize = 200 * M;
+
 class FileContext {
   final AnalysisOptionsImpl analysisOptions;
   final FileState file;
@@ -113,7 +116,7 @@
         getFileDigest = getFileDigest,
         prefetchFiles = prefetchFiles,
         workspace = workspace {
-    byteStore ??= CiderMemoryByteStore();
+    byteStore ??= CiderCachedByteStore(memoryCacheSize);
     this.byteStore = byteStore;
     _libraryContextReset = _LibraryContextReset(
       fileResolver: this,
diff --git a/pkg/analyzer/lib/src/summary2/default_types_builder.dart b/pkg/analyzer/lib/src/summary2/default_types_builder.dart
index ce0b852..d06952b 100644
--- a/pkg/analyzer/lib/src/summary2/default_types_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/default_types_builder.dart
@@ -6,13 +6,15 @@
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/replacement_visitor.dart';
 import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/dart/element/type_algebra.dart';
+import 'package:analyzer/src/dart/resolver/variance.dart';
 import 'package:analyzer/src/summary2/function_type_builder.dart';
 import 'package:analyzer/src/summary2/lazy_ast.dart';
 import 'package:analyzer/src/summary2/named_type_builder.dart';
 import 'package:analyzer/src/summary2/type_builder.dart';
 import 'package:analyzer/src/util/graph.dart';
+import 'package:meta/meta.dart';
 
 class DefaultTypesBuilder {
   void build(List<AstNode> nodes) {
@@ -152,12 +154,14 @@
     if (parameterList == null) return;
 
     var typeProvider = declarationElement.library.typeProvider;
-    var dynamicType = typeProvider.dynamicType;
-    var nullType = typeProvider.nullType;
+    var dynamicType = DynamicTypeImpl.instance;
+    var bottomType = declarationElement.library.isNonNullableByDefault
+        ? NeverTypeImpl.instance
+        : typeProvider.nullType;
 
     var nodes = parameterList.typeParameters;
     var length = nodes.length;
-    var elements = List<TypeParameterElement>(length);
+    var elements = List<TypeParameterElementImpl>(length);
     var bounds = List<DartType>(length);
     for (int i = 0; i < length; i++) {
       var node = nodes[i];
@@ -173,15 +177,17 @@
       for (var i in component) {
         var element = elements[i];
         dynamicSubstitution[element] = dynamicType;
-        nullSubstitution[element] = nullType;
+        nullSubstitution[element] = bottomType;
       }
 
-      var substitution = Substitution.fromUpperAndLowerBounds(
-        dynamicSubstitution,
-        nullSubstitution,
-      );
       for (var i in component) {
-        bounds[i] = substitution.substituteType(bounds[i]);
+        var variable = elements[i];
+        var visitor = _UpperLowerReplacementVisitor(
+          upper: dynamicSubstitution,
+          lower: nullSubstitution,
+          variance: variable.variance,
+        );
+        bounds[i] = visitor.run(bounds[i]);
       }
     }
 
@@ -190,14 +196,16 @@
       var nullSubstitution = <TypeParameterElement, DartType>{};
       var element = elements[i];
       thisSubstitution[element] = bounds[i];
-      nullSubstitution[element] = nullType;
+      nullSubstitution[element] = bottomType;
 
-      var substitution = Substitution.fromUpperAndLowerBounds(
-        thisSubstitution,
-        nullSubstitution,
-      );
       for (var j = 0; j < length; j++) {
-        bounds[j] = substitution.substituteType(bounds[j]);
+        var variable = elements[j];
+        var visitor = _UpperLowerReplacementVisitor(
+          upper: thisSubstitution,
+          lower: nullSubstitution,
+          variance: variable.variance,
+        );
+        bounds[j] = visitor.run(bounds[j]);
       }
     }
 
@@ -355,3 +363,55 @@
     }
   }
 }
+
+class _UpperLowerReplacementVisitor extends ReplacementVisitor {
+  final Map<TypeParameterElement, DartType> _upper;
+  final Map<TypeParameterElement, DartType> _lower;
+  Variance _variance;
+
+  _UpperLowerReplacementVisitor({
+    @required Map<TypeParameterElement, DartType> upper,
+    @required Map<TypeParameterElement, DartType> lower,
+    @required Variance variance,
+  })  : _upper = upper,
+        _lower = lower,
+        _variance = variance;
+
+  @override
+  void changeVariance() {
+    if (_variance == Variance.covariant) {
+      _variance = Variance.contravariant;
+    } else if (_variance == Variance.contravariant) {
+      _variance = Variance.covariant;
+    }
+  }
+
+  DartType run(DartType type) {
+    return type.accept(this) ?? type;
+  }
+
+  @override
+  DartType visitTypeArgument(
+    TypeParameterElement parameter,
+    DartType argument,
+  ) {
+    var savedVariance = _variance;
+    try {
+      _variance = _variance.combine(
+        (parameter as TypeParameterElementImpl).variance,
+      );
+      return super.visitTypeArgument(parameter, argument);
+    } finally {
+      _variance = savedVariance;
+    }
+  }
+
+  @override
+  DartType visitTypeParameterType(TypeParameterType type) {
+    if (_variance == Variance.contravariant) {
+      return _lower[type.element];
+    } else {
+      return _upper[type.element];
+    }
+  }
+}
diff --git a/pkg/analyzer/test/src/dart/micro/file_resolution.dart b/pkg/analyzer/test/src/dart/micro/file_resolution.dart
index 3e90ad5..250b588 100644
--- a/pkg/analyzer/test/src/dart/micro/file_resolution.dart
+++ b/pkg/analyzer/test/src/dart/micro/file_resolution.dart
@@ -22,7 +22,8 @@
 class FileResolutionTest with ResourceProviderMixin, ResolutionTest {
   static final String _testFile = '/workspace/dart/test/lib/test.dart';
 
-  final CiderByteStore byteStore = CiderMemoryByteStore();
+  final CiderByteStore byteStore =
+      CiderCachedByteStore(20 * 1024 * 1024 /* 20 MB */);
 
   final StringBuffer logBuffer = StringBuffer();
   PerformanceLog logger;
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 77e7e0e..863692f 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -1766,6 +1766,135 @@
         withTypeParameterVariance: true);
   }
 
+  test_class_typeParameters_defaultType_functionTypeAlias_contravariant_legacy() async {
+    var library = await checkLibrary(r'''
+typedef F<X> = void Function(X);
+
+class A<X extends F<X>> {}
+''');
+    checkElementText(
+        library,
+        r'''
+typedef F<contravariant X> = void Function(X );
+notSimplyBounded class A<covariant X extends void Function(X) = void Function(Null)> {
+}
+''',
+        withTypeParameterVariance: true);
+  }
+
+  test_class_typeParameters_defaultType_functionTypeAlias_contravariant_nullSafe() async {
+    featureSet = enableNnbd;
+    var library = await checkLibrary(r'''
+typedef F<X> = void Function(X);
+
+class A<X extends F<X>> {}
+''');
+    checkElementText(
+        library,
+        r'''
+typedef F<contravariant X> = void Function(X );
+notSimplyBounded class A<covariant X extends void Function(X) = void Function(Never)> {
+}
+''',
+        withTypeParameterVariance: true);
+  }
+
+  test_class_typeParameters_defaultType_functionTypeAlias_invariant_legacy() async {
+    var library = await checkLibrary(r'''
+typedef F<X> = X Function(X);
+
+class A<X extends F<X>> {}
+''');
+    checkElementText(
+        library,
+        r'''
+typedef F<invariant X> = X Function(X );
+notSimplyBounded class A<covariant X extends X Function(X) = dynamic Function(dynamic)> {
+}
+''',
+        withTypeParameterVariance: true);
+  }
+
+  test_class_typeParameters_defaultType_functionTypeAlias_invariant_nullSafe() async {
+    featureSet = enableNnbd;
+    var library = await checkLibrary(r'''
+typedef F<X> = X Function(X);
+
+class A<X extends F<X>> {}
+''');
+    checkElementText(
+        library,
+        r'''
+typedef F<invariant X> = X Function(X );
+notSimplyBounded class A<covariant X extends X Function(X) = dynamic Function(dynamic)> {
+}
+''',
+        withTypeParameterVariance: true);
+  }
+
+  test_class_typeParameters_defaultType_genericFunctionType_both_legacy() async {
+    var library = await checkLibrary(r'''
+class A<X extends X Function(X)> {}
+''');
+    checkElementText(library, r'''
+notSimplyBounded class A<X extends X Function(X) = dynamic Function(Null)> {
+}
+''');
+  }
+
+  test_class_typeParameters_defaultType_genericFunctionType_both_nullSafe() async {
+    featureSet = enableNnbd;
+    var library = await checkLibrary(r'''
+class A<X extends X Function(X)> {}
+''');
+    checkElementText(library, r'''
+notSimplyBounded class A<X extends X Function(X) = dynamic Function(Never)> {
+}
+''');
+  }
+
+  test_class_typeParameters_defaultType_genericFunctionType_contravariant_legacy() async {
+    var library = await checkLibrary(r'''
+class A<X extends void Function(X)> {}
+''');
+    checkElementText(library, r'''
+notSimplyBounded class A<X extends void Function(X) = void Function(Null)> {
+}
+''');
+  }
+
+  test_class_typeParameters_defaultType_genericFunctionType_contravariant_nullSafe() async {
+    featureSet = enableNnbd;
+    var library = await checkLibrary(r'''
+class A<X extends void Function(X)> {}
+''');
+    checkElementText(library, r'''
+notSimplyBounded class A<X extends void Function(X) = void Function(Never)> {
+}
+''');
+  }
+
+  test_class_typeParameters_defaultType_genericFunctionType_covariant_legacy() async {
+    var library = await checkLibrary(r'''
+class A<X extends X Function()> {}
+''');
+    checkElementText(library, r'''
+notSimplyBounded class A<X extends X Function() = dynamic Function()> {
+}
+''');
+  }
+
+  test_class_typeParameters_defaultType_genericFunctionType_covariant_nullSafe() async {
+    featureSet = enableNnbd;
+    var library = await checkLibrary(r'''
+class A<X extends X Function()> {}
+''');
+    checkElementText(library, r'''
+notSimplyBounded class A<X extends X Function() = dynamic Function()> {
+}
+''');
+  }
+
   test_classes() async {
     var library = await checkLibrary('class C {} class D {}');
     checkElementText(library, r'''
@@ -11463,14 +11592,14 @@
   test_typedef_type_parameters_f_bound_complex() async {
     var library = await checkLibrary('typedef U F<T extends List<U>, U>(T t);');
     checkElementText(library, r'''
-notSimplyBounded typedef F<T extends List<U> = List<dynamic>, U> = U Function(T t);
+notSimplyBounded typedef F<T extends List<U> = List<Null>, U> = U Function(T t);
 ''');
   }
 
   test_typedef_type_parameters_f_bound_simple() async {
     var library = await checkLibrary('typedef U F<T extends U, U>(T t);');
     checkElementText(library, r'''
-notSimplyBounded typedef F<T extends U, U> = U Function(T t);
+notSimplyBounded typedef F<T extends U = Null, U> = U Function(T t);
 ''');
   }
 
@@ -11478,7 +11607,7 @@
     var library =
         await checkLibrary('typedef F<T extends U, U> = U Function(T t);');
     checkElementText(library, r'''
-notSimplyBounded typedef F<T extends U, U> = U Function(T t);
+notSimplyBounded typedef F<T extends U = Null, U> = U Function(T t);
 ''');
   }
 
diff --git a/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart b/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart
index 61305c7..4b00e14 100644
--- a/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart
+++ b/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.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.
 
-import 'dart:async';
-
 import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/analysis/session.dart';
diff --git a/tests/language/nnbd/definite_assignment/read_error_test.dart b/tests/language/nnbd/definite_assignment/read_error_test.dart
index 2f08ad1..0894e58 100644
--- a/tests/language/nnbd/definite_assignment/read_error_test.dart
+++ b/tests/language/nnbd/definite_assignment/read_error_test.dart
@@ -1066,8 +1066,10 @@
     final dynamic x;
     x = 3;
     3 ?? x;
-    //   ^
-    // [analyzer] STATIC_WARNING.DEAD_NULL_AWARE_EXPRESSION
+//  ^
+// [cfe] Operand of null-aware operation '??' has type 'int' which excludes null.
+//       ^
+// [analyzer] STATIC_WARNING.DEAD_NULL_AWARE_EXPRESSION
   }
 }
 
diff --git a/tools/VERSION b/tools/VERSION
index 1fad799..300b947 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 11
 PATCH 0
-PRERELEASE 175
+PRERELEASE 176
 PRERELEASE_PATCH 0
\ No newline at end of file