diff --git a/pkg/analyzer/lib/error/error.dart b/pkg/analyzer/lib/error/error.dart
index e65f60b..67b4f36 100644
--- a/pkg/analyzer/lib/error/error.dart
+++ b/pkg/analyzer/lib/error/error.dart
@@ -142,7 +142,6 @@
   CompileTimeErrorCode.CONTINUE_LABEL_ON_SWITCH,
   CompileTimeErrorCode.COULD_NOT_INFER,
   CompileTimeErrorCode.DEFAULT_LIST_CONSTRUCTOR,
-  CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER,
   CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR,
   CompileTimeErrorCode.DEFAULT_VALUE_ON_REQUIRED_PARAMETER,
   CompileTimeErrorCode.DEFERRED_IMPORT_OF_EXTENSION,
diff --git a/pkg/analyzer/lib/src/dart/element/member.dart b/pkg/analyzer/lib/src/dart/element/member.dart
index 5c08ec5..db5240f 100644
--- a/pkg/analyzer/lib/src/dart/element/member.dart
+++ b/pkg/analyzer/lib/src/dart/element/member.dart
@@ -7,10 +7,12 @@
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/dart/element/type_provider.dart';
 import 'package:analyzer/src/dart/element/display_string_builder.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/nullability_eliminator.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
+import 'package:analyzer/src/dart/element/type_provider.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ -25,10 +27,11 @@
   /// Initialize a newly created element to represent a constructor, based on
   /// the [declaration], and applied [substitution].
   ConstructorMember(
+    TypeProviderImpl typeProvider,
     ConstructorElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
-  ) : super(declaration, substitution, isLegacy,
+  ) : super(typeProvider, declaration, substitution, isLegacy,
             const <TypeParameterElement>[]);
 
   @deprecated
@@ -79,7 +82,7 @@
       substitution = _substitution;
     }
 
-    return ConstructorMember(declaration, substitution, false);
+    return ConstructorMember(_typeProvider, declaration, substitution, false);
   }
 
   @override
@@ -118,6 +121,7 @@
     }
 
     return ConstructorMember(
+      constructor.library.typeProvider,
       constructor,
       Substitution.fromInterfaceType(definingType),
       isLegacy,
@@ -141,11 +145,12 @@
   /// their bounds.  The [substitution] includes replacing [declaration] type
   /// parameters with the provided fresh [typeParameters].
   ExecutableMember(
+    TypeProviderImpl typeProvider,
     ExecutableElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
     this.typeParameters,
-  ) : super(declaration, substitution, isLegacy);
+  ) : super(typeProvider, declaration, substitution, isLegacy);
 
   @deprecated
   @override
@@ -185,9 +190,10 @@
   List<ParameterElement> get parameters {
     return declaration.parameters.map<ParameterElement>((p) {
       if (p is FieldFormalParameterElement) {
-        return FieldFormalParameterMember(p, _substitution, isLegacy);
+        return FieldFormalParameterMember(
+            _typeProvider, p, _substitution, isLegacy);
       }
-      return ParameterMember(p, _substitution, isLegacy);
+      return ParameterMember(_typeProvider, p, _substitution, isLegacy);
     }).toList();
   }
 
@@ -222,11 +228,13 @@
       return null;
     }
 
+    TypeProvider typeProvider;
     var isLegacy = false;
     var combined = substitution;
     if (element is ExecutableMember) {
       ExecutableMember member = element;
       element = member.declaration;
+      typeProvider = member._typeProvider;
 
       isLegacy = member.isLegacy;
 
@@ -236,6 +244,8 @@
       }
       map.addAll(substitution.map);
       combined = Substitution.fromMap(map);
+    } else {
+      typeProvider = element.library.typeProvider;
     }
 
     if (!isLegacy && combined.map.isEmpty) {
@@ -243,11 +253,11 @@
     }
 
     if (element is ConstructorElement) {
-      return ConstructorMember(element, combined, isLegacy);
+      return ConstructorMember(typeProvider, element, combined, isLegacy);
     } else if (element is MethodElement) {
-      return MethodMember(element, combined, isLegacy);
+      return MethodMember(typeProvider, element, combined, isLegacy);
     } else if (element is PropertyAccessorElement) {
-      return PropertyAccessorMember(element, combined, isLegacy);
+      return PropertyAccessorMember(typeProvider, element, combined, isLegacy);
     } else {
       throw UnimplementedError('(${element.runtimeType}) $element');
     }
@@ -259,6 +269,7 @@
 class FieldFormalParameterMember extends ParameterMember
     implements FieldFormalParameterElement {
   factory FieldFormalParameterMember(
+    TypeProviderImpl typeProvider,
     FieldFormalParameterElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
@@ -268,6 +279,7 @@
       substitution,
     );
     return FieldFormalParameterMember._(
+      typeProvider,
       declaration,
       freshTypeParameters.substitution,
       isLegacy,
@@ -276,11 +288,18 @@
   }
 
   FieldFormalParameterMember._(
+    TypeProviderImpl typeProvider,
     FieldFormalParameterElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
     List<TypeParameterElement> typeParameters,
-  ) : super._(declaration, substitution, isLegacy, typeParameters);
+  ) : super._(
+          typeProvider,
+          declaration,
+          substitution,
+          isLegacy,
+          typeParameters,
+        );
 
   @override
   FieldElement get field {
@@ -289,7 +308,7 @@
       return null;
     }
 
-    return FieldMember(field, _substitution, isLegacy);
+    return FieldMember(_typeProvider, field, _substitution, isLegacy);
   }
 
   @override
@@ -309,10 +328,11 @@
   /// Initialize a newly created element to represent a field, based on the
   /// [declaration], with applied [substitution].
   FieldMember(
+    TypeProviderImpl typeProvider,
     FieldElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
-  ) : super(declaration, substitution, isLegacy);
+  ) : super(typeProvider, declaration, substitution, isLegacy);
 
   @deprecated
   @override
@@ -330,7 +350,8 @@
     if (baseGetter == null) {
       return null;
     }
-    return PropertyAccessorMember(baseGetter, _substitution, isLegacy);
+    return PropertyAccessorMember(
+        _typeProvider, baseGetter, _substitution, isLegacy);
   }
 
   @override
@@ -354,7 +375,8 @@
     if (baseSetter == null) {
       return null;
     }
-    return PropertyAccessorMember(baseSetter, _substitution, isLegacy);
+    return PropertyAccessorMember(
+        _typeProvider, baseSetter, _substitution, isLegacy);
   }
 
   @override
@@ -370,6 +392,7 @@
       return field;
     }
     return FieldMember(
+      field.library.typeProvider,
       field,
       Substitution.fromInterfaceType(definingType),
       false,
@@ -383,13 +406,16 @@
     if (substitution.map.isEmpty) {
       return element;
     }
-    return FieldMember(element, substitution, false);
+    var typeProvider = element.library.typeProvider;
+    return FieldMember(typeProvider, element, substitution, false);
   }
 }
 
 class FunctionMember extends ExecutableMember implements FunctionElement {
-  FunctionMember(FunctionElement declaration, bool isLegacy)
+  FunctionMember(
+      TypeProviderImpl typeProvider, FunctionElement declaration, bool isLegacy)
       : super(
+          typeProvider,
           declaration,
           Substitution.empty,
           isLegacy,
@@ -411,6 +437,9 @@
 /// An element defined in a parameterized type where the values of the type
 /// parameters are known.
 abstract class Member implements Element {
+  /// A type provider (might be legacy, might be null-safe).
+  final TypeProviderImpl _typeProvider;
+
   /// The element on which the parameterized element was created.
   final Element _declaration;
 
@@ -422,7 +451,8 @@
 
   /// Initialize a newly created element to represent a member, based on the
   /// [declaration], and applied [_substitution].
-  Member(this._declaration, this._substitution, this.isLegacy) {
+  Member(this._typeProvider, this._declaration, this._substitution,
+      this.isLegacy) {
     if (_declaration is Member) {
       throw StateError('Members must be created from a declarations.');
     }
@@ -599,8 +629,7 @@
   /// Otherwise, return the type unchanged.
   DartType _toLegacyType(DartType type) {
     if (isLegacy) {
-      var typeProvider = declaration.library.typeProvider;
-      return NullabilityEliminator.perform(typeProvider, type);
+      return NullabilityEliminator.perform(_typeProvider, type);
     } else {
       return type;
     }
@@ -617,18 +646,24 @@
       } else if (element is Member) {
         var member = element as Member;
         return ConstructorMember(
+          member._typeProvider,
           member._declaration,
           member._substitution,
           true,
         );
       } else {
-        return ConstructorMember(element, Substitution.empty, true);
+        var typeProvider = element.library.typeProvider;
+        return ConstructorMember(
+            typeProvider, element, Substitution.empty, true);
       }
     } else if (element is FunctionElement) {
       if (!element.library.isNonNullableByDefault) {
         return element;
       } else {
-        return FunctionMember(element.declaration, true);
+        var typeProvider = element is Member
+            ? (element as Member)._typeProvider
+            : element.library.typeProvider;
+        return FunctionMember(typeProvider, element.declaration, true);
       }
     } else if (element is MethodElement) {
       if (!element.library.isNonNullableByDefault) {
@@ -636,12 +671,14 @@
       } else if (element is Member) {
         var member = element as Member;
         return MethodMember(
+          member._typeProvider,
           member._declaration,
           member._substitution,
           true,
         );
       } else {
-        return MethodMember(element, Substitution.empty, true);
+        var typeProvider = element.library.typeProvider;
+        return MethodMember(typeProvider, element, Substitution.empty, true);
       }
     } else if (element is PropertyAccessorElement) {
       if (!element.library.isNonNullableByDefault) {
@@ -649,12 +686,15 @@
       } else if (element is Member) {
         var member = element as Member;
         return PropertyAccessorMember(
+          member._typeProvider,
           member._declaration,
           member._substitution,
           true,
         );
       } else {
-        return PropertyAccessorMember(element, Substitution.empty, true);
+        var typeProvider = element.library.typeProvider;
+        return PropertyAccessorMember(
+            typeProvider, element, Substitution.empty, true);
       }
     } else {
       return element;
@@ -666,6 +706,7 @@
 /// type parameters are known.
 class MethodMember extends ExecutableMember implements MethodElement {
   factory MethodMember(
+    TypeProviderImpl typeProvider,
     MethodElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
@@ -675,6 +716,7 @@
       substitution,
     );
     return MethodMember._(
+      typeProvider,
       declaration,
       freshTypeParameters.substitution,
       isLegacy,
@@ -683,11 +725,12 @@
   }
 
   MethodMember._(
+    TypeProviderImpl typeProvider,
     MethodElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
     List<TypeParameterElement> typeParameters,
-  ) : super(declaration, substitution, isLegacy, typeParameters);
+  ) : super(typeProvider, declaration, substitution, isLegacy, typeParameters);
 
   @deprecated
   @override
@@ -712,7 +755,9 @@
       return method;
     }
 
+    var typeProvider = method.library.typeProvider;
     return MethodMember(
+      typeProvider,
       method,
       Substitution.fromInterfaceType(definingType),
       false,
@@ -726,7 +771,8 @@
     if (substitution.map.isEmpty) {
       return element;
     }
-    return MethodMember(element, substitution, false);
+    var typeProvider = element.library.typeProvider;
+    return MethodMember(typeProvider, element, substitution, false);
   }
 }
 
@@ -739,6 +785,7 @@
   final List<TypeParameterElement> typeParameters;
 
   factory ParameterMember(
+    TypeProviderImpl typeProvider,
     ParameterElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
@@ -748,6 +795,7 @@
       substitution,
     );
     return ParameterMember._(
+      typeProvider,
       declaration,
       freshTypeParameters.substitution,
       isLegacy,
@@ -758,11 +806,12 @@
   /// Initialize a newly created element to represent a parameter, based on the
   /// [declaration], with applied [substitution].
   ParameterMember._(
+    TypeProviderImpl typeProvider,
     ParameterElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
     this.typeParameters,
-  ) : super(declaration, substitution, isLegacy);
+  ) : super(typeProvider, declaration, substitution, isLegacy);
 
   @deprecated
   @override
@@ -828,6 +877,7 @@
 class PropertyAccessorMember extends ExecutableMember
     implements PropertyAccessorElement {
   factory PropertyAccessorMember(
+    TypeProviderImpl typeProvider,
     PropertyAccessorElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
@@ -837,6 +887,7 @@
       substitution,
     );
     return PropertyAccessorMember._(
+      typeProvider,
       declaration,
       freshTypeParameters.substitution,
       isLegacy,
@@ -845,11 +896,12 @@
   }
 
   PropertyAccessorMember._(
+    TypeProviderImpl typeProvider,
     PropertyAccessorElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
     List<TypeParameterElement> typeParameters,
-  ) : super(declaration, substitution, isLegacy, typeParameters);
+  ) : super(typeProvider, declaration, substitution, isLegacy, typeParameters);
 
   @deprecated
   @override
@@ -861,7 +913,8 @@
     if (baseGetter == null) {
       return null;
     }
-    return PropertyAccessorMember(baseGetter, _substitution, isLegacy);
+    return PropertyAccessorMember(
+        _typeProvider, baseGetter, _substitution, isLegacy);
   }
 
   @override
@@ -870,7 +923,8 @@
     if (baseSetter == null) {
       return null;
     }
-    return PropertyAccessorMember(baseSetter, _substitution, isLegacy);
+    return PropertyAccessorMember(
+        _typeProvider, baseSetter, _substitution, isLegacy);
   }
 
   @override
@@ -891,9 +945,10 @@
     // TODO
     PropertyInducingElement variable = declaration.variable;
     if (variable is FieldElement) {
-      return FieldMember(variable, _substitution, isLegacy);
+      return FieldMember(_typeProvider, variable, _substitution, isLegacy);
     } else if (variable is TopLevelVariableElement) {
-      return TopLevelVariableMember(variable, _substitution, isLegacy);
+      return TopLevelVariableMember(
+          _typeProvider, variable, _substitution, isLegacy);
     }
     return variable;
   }
@@ -921,7 +976,9 @@
       return accessor;
     }
 
+    var typeProvider = accessor.library.typeProvider;
     return PropertyAccessorMember(
+      typeProvider,
       accessor,
       Substitution.fromInterfaceType(definingType),
       false,
@@ -932,10 +989,11 @@
 class TopLevelVariableMember extends VariableMember
     implements TopLevelVariableElement {
   TopLevelVariableMember(
+    TypeProviderImpl typeProvider,
     VariableElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
-  ) : super(declaration, substitution, isLegacy);
+  ) : super(typeProvider, declaration, substitution, isLegacy);
 
   @override
   TopLevelVariableElement get declaration => _declaration;
@@ -946,7 +1004,8 @@
     if (baseGetter == null) {
       return null;
     }
-    return PropertyAccessorMember(baseGetter, _substitution, isLegacy);
+    return PropertyAccessorMember(
+        _typeProvider, baseGetter, _substitution, isLegacy);
   }
 
   @override
@@ -961,7 +1020,8 @@
     if (baseSetter == null) {
       return null;
     }
-    return PropertyAccessorMember(baseSetter, _substitution, isLegacy);
+    return PropertyAccessorMember(
+        _typeProvider, baseSetter, _substitution, isLegacy);
   }
 
   @override
@@ -978,10 +1038,11 @@
   /// Initialize a newly created element to represent a variable, based on the
   /// [declaration], with applied [substitution].
   VariableMember(
+    TypeProviderImpl typeProvider,
     VariableElement declaration,
     MapSubstitution substitution,
     bool isLegacy,
-  ) : super(declaration, substitution, isLegacy);
+  ) : super(typeProvider, declaration, substitution, isLegacy);
 
   @deprecated
   @override
diff --git a/pkg/analyzer/lib/src/dart/error/hint_codes.dart b/pkg/analyzer/lib/src/dart/error/hint_codes.dart
index fb65bd2..1e0761f 100644
--- a/pkg/analyzer/lib/src/dart/error/hint_codes.dart
+++ b/pkg/analyzer/lib/src/dart/error/hint_codes.dart
@@ -2575,9 +2575,14 @@
    */
   // #### Description
   //
-  // The analyzer produces this diagnostic when a private class, enum, mixin,
-  // typedef, top level variable, top level function, or method is declared but
-  // never referenced.
+  // The analyzer produces this diagnostic when a private declaration isn't
+  // referenced in the library that contains the declaration. The following
+  // kinds of declarations are analyzed:
+  // - Private top-level declarations, such as classes, enums, mixins, typedefs,
+  //   top-level variables, and top-level functions
+  // - Private static and instance methods
+  // - Optional parameters of private functions for which a value is never
+  //   passed, even when the parameter doesn't have a private name
   //
   // #### Examples
   //
@@ -2588,11 +2593,30 @@
   // class [!_C!] {}
   // ```
   //
+  // Assuming that no code in the library passes a value for `y` in any
+  // invocation of `_m`, the following code produces this diagnostic:
+  //
+  // ```dart
+  // class C {
+  //   void _m(int x, [int [!y!]]) {}
+  //
+  //   void n() => _m(0);
+  // }
+  // ```
+  //
   // #### Common fixes
   //
-  // If the declaration isn't needed, then remove it.
+  // If the declaration isn't needed, then remove it:
   //
-  // If the declaration was intended to be used, then add the missing code.
+  // ```dart
+  // class C {
+  //   void _m(int x) {}
+  //
+  //   void n() => _m(0);
+  // }
+  // ```
+  //
+  // If the declaration is intended to be used, then add the code to use it.
   static const HintCode UNUSED_ELEMENT = HintCode(
       'UNUSED_ELEMENT', "The declaration '{0}' isn't referenced.",
       correction: "Try removing the declaration of '{0}'.",
diff --git a/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart b/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
index b701c7d..ba5d73a 100644
--- a/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
+++ b/pkg/analyzer/lib/src/dart/error/syntactic_errors.dart
@@ -131,9 +131,37 @@
           "Top-level declarations can't be declared to be covariant.",
           correction: "Try removing the keyword 'covariant'.");
 
+  /**
+   * No parameters.
+   */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a function type associated with
+  // a parameter includes optional parameters that have a default value. This
+  // isn't allowed because the default values of parameters aren't part of the
+  // function's type, and therefore including them doesn't provide any value.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the parameter `p` has a
+  // default value even though it's part of the type of the parameter `g`:
+  //
+  // ```dart
+  // void f(void Function([int p [!=!] 0]) g) {
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // Remove the default value from the function-type's parameter:
+  //
+  // ```dart
+  // void f(void Function([int p]) g) {
+  // }
+  // ```
   static const ParserErrorCode DEFAULT_VALUE_IN_FUNCTION_TYPE = ParserErrorCode(
       'DEFAULT_VALUE_IN_FUNCTION_TYPE',
-      "Parameters in a function type cannot have default values",
+      "Parameters in a function type can't have default values.",
       correction: "Try removing the default value.");
 
   static const ParserErrorCode DEFERRED_AFTER_PREFIX = _DEFERRED_AFTER_PREFIX;
diff --git a/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
index 489aa70..e16e7da 100644
--- a/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
@@ -18,7 +18,6 @@
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/type_promotion_manager.dart';
-import 'package:analyzer/src/task/strong/checker.dart';
 import 'package:meta/meta.dart';
 
 /// Helper for resolving [BinaryExpression]s.
@@ -107,26 +106,12 @@
     );
   }
 
-  /// Gets the definite type of expression, which can be used in cases where
-  /// the most precise type is desired, for example computing the least upper
-  /// bound.
-  ///
-  /// See [getExpressionType] for more information. Without strong mode, this is
-  /// equivalent to [_getStaticType].
-  ///
-  /// TODO(scheglov) this is duplicate
-  DartType _getExpressionType(Expression expr, {bool read = false}) =>
-      getExpressionType(expr, _typeSystem, _typeProvider, read: read);
-
   /// Return the static type of the given [expression] that is to be used for
   /// type analysis.
   ///
   /// TODO(scheglov) this is duplicate
-  DartType _getStaticType(Expression expression, {bool read = false}) {
-    if (expression is NullLiteral) {
-      return _typeProvider.nullType;
-    }
-    DartType type = read ? getReadType(expression) : expression.staticType;
+  DartType _getStaticType(Expression expression) {
+    DartType type = expression.staticType;
     return _resolveTypeParameter(type);
   }
 
@@ -170,7 +155,7 @@
 
     left.accept(_resolver);
     left = node.leftOperand;
-    var leftType = _getExpressionType(left, read: false);
+    var leftType = left.staticType;
 
     var rightContextType = InferenceContext.getContext(node);
     if (rightContextType == null || rightContextType.isDynamic) {
@@ -183,9 +168,7 @@
     right = node.rightOperand;
     flow?.ifNullExpression_end();
 
-    // TODO(scheglov) This (and above) is absolutely wrong, and convoluted.
-    // This is just the status quo, until we can make types straight.
-    var rightType = _getExpressionType(right, read: false);
+    var rightType = right.staticType;
     if (_isNonNullableByDefault) {
       var promotedLeftType = _typeSystem.promoteToNonNull(leftType);
       _analyzeLeastUpperBoundTypes(node, promotedLeftType, rightType);
diff --git a/pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart
index 75d46e2..30df9bf 100644
--- a/pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/postfix_expression_resolver.dart
@@ -17,7 +17,6 @@
 import 'package:analyzer/src/dart/resolver/type_property_resolver.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/resolver.dart';
-import 'package:analyzer/src/task/strong/checker.dart';
 import 'package:meta/meta.dart';
 
 /// Helper for resolving [PostfixExpression]s.
@@ -228,7 +227,7 @@
     operand.accept(_resolver);
     operand = node.operand;
 
-    var operandType = getReadType(operand);
+    var operandType = operand.staticType;
 
     var type = _typeSystem.promoteToNonNull(operandType);
     _inferenceHelper.recordStaticType(node, type);
diff --git a/pkg/analyzer/lib/src/error/codes.dart b/pkg/analyzer/lib/src/error/codes.dart
index 3fa6b6d..cf508c2 100644
--- a/pkg/analyzer/lib/src/error/codes.dart
+++ b/pkg/analyzer/lib/src/error/codes.dart
@@ -697,14 +697,52 @@
               "or removing the 'await' before the for loop.");
 
   /**
-   * nnbd/feature-specification.md
-   *
-   * It is an error for the initializer expression of a `late` local variable
-   * to use a prefix `await` expression.
+   * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a local variable that has the
+  // 'late' modifier uses an 'await' expression in the initializer.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because an 'await' expression
+  // is used in the initializer for 'v', a local variable that is marked 'late':
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // Future<int> f() async {
+  //   late v = [!await!] 42;
+  //   return v;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the initializer can be rewritten to not use 'await', then rewrite it:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // Future<int> f() async {
+  //   late v = 42;
+  //   return v;
+  // }
+  // ```
+  //
+  // If the initializer can't be rewritten, then remove the 'late' modifier:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // Future<int> f() async {
+  //   var v = await 42;
+  //   return v;
+  // }
+  // ```
   static const CompileTimeErrorCode AWAIT_IN_LATE_LOCAL_VARIABLE_INITIALIZER =
-      CompileTimeErrorCode('AWAIT_IN_LATE_LOCAL_VARIABLE_INITIALIZER',
-          "The await expression can't be used in a 'late' local variable.",
+      CompileTimeErrorCode(
+          'AWAIT_IN_LATE_LOCAL_VARIABLE_INITIALIZER',
+          "The 'await' expression can't be used in a 'late' local variable's "
+              "initializer.",
           correction:
               "Try removing the 'late' modifier, or rewriting the initializer "
               "without using the 'await' expression.");
@@ -1372,19 +1410,53 @@
               "removing the keyword 'const'.");
 
   /**
-   * 10.6.3 Constant Constructors: It is a compile-time error if a constant
-   * constructor is declared by a class C if any instance variable declared in C
-   * is initialized with an expression that is not a constant expression.
-   *
    * Parameters:
    * 0: the name of the field
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a constructor has the keyword
+  // `const`, but a field in the class is initialized to a non-constant value.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the field `s` is
+  // initialized to a non-constant value:
+  //
+  // ```dart
+  // class C {
+  //   final String s = 3.toString();
+  //   [!const!] C();
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the field can be initialized to a constant value, then change the
+  // initializer to a constant expression:
+  //
+  // ```dart
+  // class C {
+  //   final String s = '3';
+  //   const C();
+  // }
+  // ```
+  //
+  // If the field can't be initialized to a constant value, then remove the
+  // keyword `const` from the constructor:
+  //
+  // ```dart
+  // class C {
+  //   final String s = 3.toString();
+  //   C();
+  // }
+  // ```
   static const CompileTimeErrorCode
       CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST =
       CompileTimeErrorCode(
           'CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST',
-          "Can't define the const constructor because the field '{0}' "
-              "is initialized with a non-constant value.",
+          "Can't define the 'const' constructor because the field '{0}' is "
+              "initialized with a non-constant value.",
           correction: "Try initializing the field to a constant value, or "
               "removing the keyword 'const' from the constructor.");
 
@@ -1927,15 +1999,6 @@
           hasPublishedDocs: true);
 
   /**
-   * 16.12.2 Const: It is a compile-time error if <i>T</i> is not a class
-   * accessible in the current scope, optionally followed by type arguments.
-   *
-   * 16.12.2 Const: If <i>e</i> is of the form <i>const T.id(a<sub>1</sub>,
-   * &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>, &hellip;
-   * x<sub>n+k</sub>: a<sub>n+k</sub>)</i> it is a compile-time error if
-   * <i>T</i> is not a class accessible in the current scope, optionally
-   * followed by type arguments.
-   *
    * Parameters:
    * 0: the name of the non-type element
    */
@@ -2037,17 +2100,6 @@
           hasPublishedDocs: true);
 
   /**
-   * 6.2.1 Required Formals: By means of a function signature that names the
-   * parameter and describes its type as a function type. It is a compile-time
-   * error if any default values are specified in the signature of such a
-   * function type.
-   */
-  static const CompileTimeErrorCode DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER =
-      CompileTimeErrorCode('DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER',
-          "Default values aren't allowed in function typed parameters.",
-          correction: "Try removing the default value.");
-
-  /**
    * 7.6.2 Factories: It is a compile-time error if <i>k</i> explicitly
    * specifies a default value for an optional parameter.
    */
@@ -2601,6 +2653,58 @@
    * Parameters:
    * 0: The name of the disallowed type
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when one of the restricted classes is
+  // used in either an `extends`, `implements`, `with`, or `on` clause. The
+  // classes `bool`, `double`, `FutureOr`, `int`, `Null`, `num`, and `String`
+  // are all restricted in this way, to allow for more efficient
+  // implementations.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because `String` is used in an
+  // `extends` clause:
+  //
+  // ```dart
+  // class A extends [!String!] {}
+  // ```
+  //
+  // The following code produces this diagnostic because `String` is used in an
+  // `implements` clause:
+  //
+  // ```dart
+  // class B implements [!String!] {}
+  // ```
+  //
+  // The following code produces this diagnostic because `String` is used in a
+  // `with` clause:
+  //
+  // ```dart
+  // class C with [!String!] {}
+  // ```
+  //
+  // The following code produces this diagnostic because `String` is used in an
+  // `on` clause:
+  //
+  // ```dart
+  // mixin M on [!String!] {}
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If a different type should be specified, then replace the type:
+  //
+  // ```dart
+  // class A extends Object {}
+  // ```
+  //
+  // If there isn't a different type that would be appropriate, then remove the
+  // type, and possibly the whole clause:
+  //
+  // ```dart
+  // class B {}
+  // ```
   static const CompileTimeErrorCode EXTENDS_DISALLOWED_CLASS =
       // TODO(scheglov) We might want to restore specific code with FrontEnd.
       //  https://github.com/dart-lang/sdk/issues/31821
@@ -3578,19 +3682,59 @@
           correction: "Try changing the types so that they are compatible.");
 
   /**
-   * nnbd/feature-specification.md
-   *
-   * It is an error if a class has a setter and a getter with the same basename
-   * where the return type of the getter is not a subtype of the argument type
-   * of the setter. Note that this error specifically requires subtyping and
-   * not assignability and hence makes no exception for `dynamic`.
-   *
    * Parameters:
    * 0: the name of the getter
    * 1: the type of the getter
    * 2: the type of the setter
    * 3: the name of the setter
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the return type of a getter
+  // isn't a subtype of the type of the parameter of a setter with the same
+  // name.
+  //
+  // The subtype relationship is a requirement whether the getter and setter are
+  // in the same class or whether one of them is in a superclass of the other.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the return type of the
+  // getter `x` is `num`, the parameter type of the setter `x` is `int`, and
+  // `num` isn't a subtype of `int`:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // class C {
+  //   num get [!x!] => 0;
+  //
+  //   set x(int y) {}
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the type of the getter is correct, then change the type of the setter:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // class C {
+  //   num get x => 0;
+  //
+  //   set x(num y) {}
+  // }
+  // ```
+  //
+  // If the type of the setter is correct, then change the type of the getter:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // class C {
+  //   int get x => 0;
+  //
+  //   set x(int y) {}
+  // }
+  // ```
   static const CompileTimeErrorCode GETTER_NOT_SUBTYPE_SETTER_TYPES =
       CompileTimeErrorCode(
           'GETTER_NOT_SUBTYPE_SETTER_TYPES',
@@ -4371,11 +4515,74 @@
               "-9,223,372,036,854,775,808.");
 
   /**
-   * 15 Metadata: Metadata consists of a series of annotations, each of which
-   * begin with the character @, followed by a constant expression that must be
-   * either a reference to a compile-time constant variable, or a call to a
-   * constant constructor.
+   * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when an annotation is found that is
+  // using something that is neither a variable marked as `const` or the
+  // invocation of a `const` constructor.
+  //
+  // Getters can't be used as annotations.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the variable `v` isn't
+  // a `const` variable:
+  //
+  // ```dart
+  // var v = 0;
+  //
+  // [!@v!]
+  // void f() {
+  // }
+  // ```
+  //
+  // The following code produces this diagnostic because `f` isn't a variable:
+  //
+  // ```dart
+  // [!@f!]
+  // void f() {
+  // }
+  // ```
+  //
+  // The following code produces this diagnostic because `f` isn't a
+  // constructor:
+  //
+  // ```dart
+  // [!@f()!]
+  // void f() {
+  // }
+  // ```
+  //
+  // The following code produces this diagnostic because `g` is a getter:
+  //
+  // ```dart
+  // [!@g!]
+  // int get g => 0;
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the annotation is referencing a variable that isn't a `const`
+  // constructor, add the keyword `const` to the variable's declaration:
+  //
+  // ```dart
+  // const v = 0;
+  //
+  // @v
+  // void f() {
+  // }
+  // ```
+  //
+  // If the annotation isn't referencing a variable, then remove it:
+  //
+  // ```dart
+  // int v = 0;
+  //
+  // void f() {
+  // }
+  // ```
   static const CompileTimeErrorCode INVALID_ANNOTATION = CompileTimeErrorCode(
       'INVALID_ANNOTATION',
       "Annotation must be either a const variable reference or const "
@@ -5099,11 +5306,51 @@
           "correcting the name to match an existing label.");
 
   /**
-   * nnbd/feature-specification.md
-   *
-   * It is an error for a class with a `const` constructor to have a
-   * `late final` field.
+   * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a class that has at least one
+  // `const` constructor also has a field marked both `late` and `final`.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the class `A` has a
+  // `const` constructor and the `final` field `f` is marked as `late`:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // class A {
+  //   [!late!] final int f;
+  //
+  //   const A();
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the field doesn't need to be marked `late`, then remove the `late`
+  // modifier from the field:
+  //
+  // ```dart
+  // class A {
+  //   final int f = 0;
+  //
+  //   const A();
+  // }
+  // ```
+  //
+  // If the field must be marked `late`, then remove the `const` modifier from
+  // the constructors:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // class A {
+  //   late final int f;
+  //
+  //   A();
+  // }
+  // ```
   static const CompileTimeErrorCode LATE_FINAL_FIELD_WITH_CONST_CONSTRUCTOR =
       CompileTimeErrorCode('LATE_FINAL_FIELD_WITH_CONST_CONSTRUCTOR',
           "Can't have a late final field in a class with a const constructor.",
@@ -5111,14 +5358,61 @@
               "'const' constructors.");
 
   /**
-   * nnbd/feature-specification.md
-   *
-   * It is a compile time error to assign a value to a local variable marked
-   * `late` and `final` when the variable is definitely assigned.
+   * No parameters.
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when the analyzer can prove that a
+  // local variable marked as both `late` and `final` was already assigned a
+  // value at the point where another assignment occurs.
+  //
+  // Because `final` variables can only be assigned once, subsequent assignments
+  // are guaranteed to fail, so they're flagged.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the `final` variable
+  // `v` is assigned a value in two places:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // int f() {
+  //   late final int v;
+  //   v = 0;
+  //   [!v!] += 1;
+  //   return v;
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If you need to be able to reassign the variable, then remove the `final`
+  // keyword:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // int f() {
+  //   late int v;
+  //   v = 0;
+  //   v += 1;
+  //   return v;
+  // }
+  // ```
+  //
+  // If you don't need to reassign the variable, then remove all except the
+  // first of the assignments:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // int f() {
+  //   late final int v;
+  //   v = 0;
+  //   return v;
+  // }
+  // ```
   static const CompileTimeErrorCode LATE_FINAL_LOCAL_ALREADY_ASSIGNED =
       CompileTimeErrorCode('LATE_FINAL_LOCAL_ALREADY_ASSIGNED',
-          "The late final local variable is already definitely assigned.",
+          "The late final local variable is already assigned.",
           correction: "Try removing the 'final' modifier, or don't reassign "
               "the value.");
 
@@ -5617,7 +5911,7 @@
       CompileTimeErrorCodeWithUniqueName(
           'SUBTYPE_OF_DISALLOWED_TYPE',
           'MIXIN_SUPER_CLASS_CONSTRAINT_DISALLOWED_CLASS',
-          "'{0}' can't be used as a super-class constraint.",
+          "''{0}' can't be used as a superclass constraint.",
           correction: "Try specifying a different super-class constraint, or "
               "remove the 'on' clause.");
 
@@ -5692,12 +5986,50 @@
           correction: "Try removing all but one of the 'super' initializers.");
 
   /**
-   * 12.11.1 New: It is a static warning if <i>T</i> is not a class accessible
-   * in the current scope, optionally followed by type arguments.
-   *
    * Parameters:
    * 0: the name of the non-type element
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when an instance creation using
+  // either `new` or `const` specifies a name that isn't defined as a class.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because `f` is a function
+  // rather than a class:
+  //
+  // ```dart
+  // int f() => 0;
+  //
+  // void g() {
+  //   new [!f!]();
+  // }
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If a class should be created, then replace the invalid name with the name
+  // of a valid class:
+  //
+  // ```dart
+  // int f() => 0;
+  //
+  // void g() {
+  //   new Object();
+  // }
+  // ```
+  //
+  // If the name is the name of a function and you want that function to be
+  // invoked, then remove the `new` or `const` keyword:
+  //
+  // ```dart
+  // int f() => 0;
+  //
+  // void g() {
+  //   f();
+  // }
+  // ```
   static const CompileTimeErrorCode NEW_WITH_NON_TYPE =
       CompileTimeErrorCodeWithUniqueName('CREATION_WITH_NON_TYPE',
           'NEW_WITH_NON_TYPE', "The name '{0}' isn't a class.",
@@ -5820,22 +6152,64 @@
           hasPublishedDocs: true);
 
   /**
-   * A method `m` of a class `C` is subject to override inference if it is
-   * missing one or more component types of its signature, and one or more of
-   * the direct superinterfaces of `C` has a member named `m` (*that is, `C.m`
-   * overrides one or more declarations*).  Each missing type is filled in with
-   * the corresponding type from the combined member signature `s` of `m` in
-   * the direct superinterfaces of `C`.
-   *
-   * A compile-time error occurs if `s` does not exist.
-   *
    * Parameters:
    * 0: the name of the class where override error was detected
    * 1: the list of candidate signatures which cannot be combined
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when there is a method declaration
+  // for which one or more types needs to be inferred, and those types can't be
+  // inferred because none of the overridden methods has a function type that is
+  // a supertype of all the other overridden methods, as specified by
+  // [override inference][].
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the method `m` declared
+  // in the class `C` is missing both the return type and the type of the
+  // parameter `a`, and neither of the missing types can be inferred for it:
+  //
+  // ```dart
+  // abstract class A {
+  //   A m(String a);
+  // }
+  //
+  // abstract class B {
+  //   B m(int a);
+  // }
+  //
+  // abstract class C implements A, B {
+  //   [!m!](a);
+  // }
+  // ```
+  //
+  // In this example, override inference can't be performed because the
+  // overridden methods are incompatible in these ways:
+  // - Neither parameter type (`String` and `int`) is a supertype of the other.
+  // - Neither return type is a subtype of the other.
+  //
+  // #### Common fixes
+  //
+  // If possible, add types to the method in the subclass that are consistent
+  // with the types from all the overridden methods:
+  //
+  // ```dart
+  // abstract class A {
+  //   A m(String a);
+  // }
+  //
+  // abstract class B {
+  //   B m(int a);
+  // }
+  //
+  // abstract class C implements A, B {
+  //   C m(Object a);
+  // }
+  // ```
   static const CompileTimeErrorCode NO_COMBINED_SUPER_SIGNATURE =
       CompileTimeErrorCode('NO_COMBINED_SUPER_SIGNATURE',
-          "No valid combined signature in superinterfaces of '{0}': {1}.",
+          "Can't infer missing types in '{0}' from overridden methods: {1}.",
           correction: "Try providing explicit types for this method's "
               "parameters and return type.");
 
@@ -7485,9 +7859,44 @@
               "different part.");
 
   /**
-   * 14.1 Imports: It is a compile-time error if the current library declares a
-   * top-level member named <i>p</i>.
+   * Parameters:
+   * 0: The name of the prefix
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a name is used as both an import
+  // prefix and the name of a top-level declaration in the same library.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because `f` is used as both an
+  // import prefix and the name of a function:
+  //
+  // ```dart
+  // import 'dart:math' as f;
+  //
+  // int [!f!]() => f.min(0, 1);
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If you want to use the name for the import prefix, then rename the
+  // top-level declaration:
+  //
+  // ```dart
+  // import 'dart:math' as f;
+  //
+  // int g() => f.min(0, 1);
+  // ```
+  //
+  // If you want to use the name for the top-level declaration, then rename the
+  // import prefix:
+  //
+  // ```dart
+  // import 'dart:math' as math;
+  //
+  // int f() => math.min(0, 1);
+  // ```
   static const CompileTimeErrorCode PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER =
       CompileTimeErrorCode(
           'PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER',
@@ -9679,9 +10088,9 @@
    */
   // #### Description
   //
-  // The analyzer produces this diagnostic when an inherited member is
-  // referenced using `super`, but there’s no member with that name in the
-  // superclass chain.
+  // The analyzer produces this diagnostic when an inherited member (method,
+  // getter, setter, or operator) is referenced using `super`, but there’s no
+  // member with that name in the superclass chain.
   //
   // #### Examples
   //
@@ -9715,8 +10124,8 @@
   // If the member you intend to invoke is defined in the same class, then
   // remove the `super.`.
   //
-  // If not, then either add the member to one of the superclasses or remove the
-  // invocation.
+  // If the member isn’t defined, then either add the member to one of the
+  // superclasses or remove the invocation.
   static const CompileTimeErrorCode UNDEFINED_SUPER_METHOD =
       CompileTimeErrorCodeWithUniqueName(
           'UNDEFINED_SUPER_MEMBER',
@@ -10213,19 +10622,59 @@
           correction: "Try adjusting the number of type arguments.");
 
   /**
-   * It will be a static type warning if <i>m</i> is not a generic method with
-   * exactly <i>n</i> type parameters.
-   *
    * Parameters:
    * 0: the name of the method being referenced (<i>G</i>)
    * 1: the number of type parameters that were declared
    * 2: the number of type arguments provided
    */
+  // #### Description
+  //
+  // The analyzer produces this diagnostic when a method or function is invoked
+  // with a different number of type arguments than the number of type
+  // parameters specified in its declaration. There must either be no type
+  // arguments or the number of arguments must match the number of parameters.
+  //
+  // #### Example
+  //
+  // The following code produces this diagnostic because the invocation of the
+  // method `m` has two type arguments, but the declaration of `m` only has one
+  // type parameter:
+  //
+  // ```dart
+  // class C {
+  //   int m<A>(A a) => 0;
+  // }
+  //
+  // int f(C c) => c.m[!<int, int>!](2);
+  // ```
+  //
+  // #### Common fixes
+  //
+  // If the type arguments are necessary, then make them match the number of
+  // type parameters by either adding or removing type arguments:
+  //
+  // ```dart
+  // class C {
+  //   int m<A>(A a) => 0;
+  // }
+  //
+  // int f(C c) => c.m<int>(2);
+  // ```
+  //
+  // If the type arguments aren't necessary, then remove them:
+  //
+  // ```dart
+  // class C {
+  //   int m<A>(A a) => 0;
+  // }
+  //
+  // int f(C c) => c.m(2);
+  // ```
   static const CompileTimeErrorCode WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD =
       CompileTimeErrorCode(
           'WRONG_NUMBER_OF_TYPE_ARGUMENTS_METHOD',
-          "The method '{0}' is declared with {1} type parameters, "
-              "but {2} type arguments were given.",
+          "The method '{0}' is declared with {1} type parameters, but {2} type "
+              "arguments are given.",
           correction: "Try adjusting the number of type arguments.");
 
   /**
@@ -10538,7 +10987,7 @@
   // #### Description
   //
   // The analyzer produces this diagnostic when a null-aware operator (`?.`,
-  // `?..`, `?[`, `?..[`, or `...?`) is used on a receiver that's known to be
+  // `?..`, `?[`, `?..[`, or `...?`) is used on a target that's known to be
   // non-nullable.
   //
   // #### Example
@@ -10560,6 +11009,26 @@
   // var b = [[!...?!]a];
   // ```
   //
+  // The following code produces this diagnostic because `s?.length` can't
+  // return `null`:
+  //
+  // ```dart
+  // %experiments=non-nullable
+  // void f(String? s) {
+  //   s?.length[!?.!]isEven;
+  // }
+  // ```
+  //
+  // The reason `s?.length` can't return `null` is because the null-aware
+  // operator following `s` short-circuits the evaluation of both `length` and
+  // `isEven` if `s` is `null`. In other words, if `s` is `null`, then neither
+  // `length` nor `isEven` will be invoked, and if `s` is non-`null`, then
+  // `length` can't return a `null` value. Either way, `isEven` can't be invoked
+  // on a `null` value, so the null-aware operator is neither necessary nor
+  // allowed. See
+  // [Understanding null safety](https://dart.dev/null-safety/understanding-null-safety#smarter-null-aware-methods)
+  // for more details.
+  //
   // #### Common fixes
   //
   // Replace the null-aware operator with a non-null-aware equivalent; for
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
index 4a49b97..9955b67 100644
--- a/pkg/analyzer/lib/src/generated/error_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -40,7 +40,6 @@
 import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk, SdkLibrary;
 import 'package:analyzer/src/generated/this_access_tracker.dart';
-import 'package:analyzer/src/task/strong/checker.dart';
 import 'package:meta/meta.dart';
 
 class EnclosingExecutableContext {
@@ -319,8 +318,7 @@
       _checkForArgumentTypeNotAssignableForArgument(rhs);
     }
     if (operatorType == TokenType.QUESTION_QUESTION_EQ) {
-      _checkForDeadNullCoalesce(
-          getReadType(node.leftHandSide), node.rightHandSide);
+      _checkForDeadNullCoalesce(node.readType, node.rightHandSide);
     }
     _checkForAssignmentToFinal(lhs);
     super.visitAssignmentExpression(node);
@@ -355,8 +353,7 @@
     }
 
     if (type == TokenType.QUESTION_QUESTION) {
-      _checkForDeadNullCoalesce(
-          getReadType(node.leftOperand), node.rightOperand);
+      _checkForDeadNullCoalesce(node.leftOperand.staticType, node.rightOperand);
     }
 
     _checkForUseOfVoidResult(node.leftOperand);
@@ -533,7 +530,6 @@
   @override
   void visitDefaultFormalParameter(DefaultFormalParameter node) {
     _checkForInvalidAssignment(node.identifier, node.defaultValue);
-    _checkForDefaultValueInFunctionTypedParameter(node);
     super.visitDefaultFormalParameter(node);
   }
 
@@ -2218,26 +2214,6 @@
     }
   }
 
-  /// Verify that the given default formal [parameter] is not part of a function
-  /// typed parameter.
-  ///
-  /// See [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER].
-  void _checkForDefaultValueInFunctionTypedParameter(
-      DefaultFormalParameter parameter) {
-    // OK, not in a function typed parameter.
-    if (!_isInFunctionTypedFormalParameter) {
-      return;
-    }
-    // OK, no default value.
-    if (parameter.defaultValue == null) {
-      return;
-    }
-
-    _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER,
-        parameter);
-  }
-
   /// Report a diagnostic if there are any extensions in the imported library
   /// that are not hidden.
   void _checkForDeferredImportOfExtensions(
diff --git a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
index ecee766..a06752f 100644
--- a/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
+++ b/pkg/analyzer/lib/src/generated/static_type_analyzer.dart
@@ -16,8 +16,6 @@
 import 'package:analyzer/src/dart/resolver/flow_analysis_visitor.dart';
 import 'package:analyzer/src/generated/migration.dart';
 import 'package:analyzer/src/generated/resolver.dart';
-import 'package:analyzer/src/task/strong/checker.dart'
-    show getExpressionType, getReadType;
 
 /// Instances of the class `StaticTypeAnalyzer` perform two type-related tasks. First, they
 /// compute the static type of every expression. Second, they look for any static type errors or
@@ -344,10 +342,9 @@
   /// Set the static type of [node] to be the least upper bound of the static
   /// types of subexpressions [expr1] and [expr2].
   void _analyzeLeastUpperBound(
-      Expression node, Expression expr1, Expression expr2,
-      {bool read = false}) {
-    DartType staticType1 = _getExpressionType(expr1, read: read);
-    DartType staticType2 = _getExpressionType(expr2, read: read);
+      Expression node, Expression expr1, Expression expr2) {
+    DartType staticType1 = expr1.staticType;
+    DartType staticType2 = expr2.staticType;
 
     _analyzeLeastUpperBoundTypes(node, staticType1, staticType2);
   }
@@ -371,20 +368,11 @@
     recordStaticType(node, staticType);
   }
 
-  /// Gets the definite type of expression, which can be used in cases where
-  /// the most precise type is desired, for example computing the least upper
-  /// bound.
-  ///
-  /// See [getExpressionType] for more information. Without strong mode, this is
-  /// equivalent to [_getStaticType].
-  DartType _getExpressionType(Expression expr, {bool read = false}) =>
-      getExpressionType(expr, _typeSystem, _typeProvider, read: read);
-
   /// Return the static type of the given [expression].
   DartType _getStaticType(Expression expression, {bool read = false}) {
     DartType type;
     if (read) {
-      type = getReadType(expression);
+      type = expression.staticType;
     } else {
       if (expression is SimpleIdentifier && expression.inSetterContext()) {
         var element = expression.staticElement;
diff --git a/pkg/analyzer/lib/src/task/strong/checker.dart b/pkg/analyzer/lib/src/task/strong/checker.dart
index 4e67d44..e3049ad 100644
--- a/pkg/analyzer/lib/src/task/strong/checker.dart
+++ b/pkg/analyzer/lib/src/task/strong/checker.dart
@@ -20,22 +20,9 @@
 import 'package:analyzer/src/error/codes.dart'
     show CompileTimeErrorCode, StrongModeCode;
 import 'package:analyzer/src/summary/idl.dart';
+import 'package:meta/meta.dart';
 
-/// Given an [expression] and a corresponding [typeSystem] and [typeProvider],
-/// gets the known static type of the expression.
-DartType getExpressionType(
-    Expression expression, TypeSystemImpl typeSystem, TypeProvider typeProvider,
-    {bool read = false}) {
-  DartType type;
-  if (read) {
-    type = getReadType(expression);
-  } else {
-    type = expression.staticType;
-  }
-  type ??= DynamicTypeImpl.instance;
-  return type;
-}
-
+@Deprecated('Use CompoundAssignmentExpression.readType')
 DartType getReadType(Expression expression) {
   if (expression is IndexExpression) {
     var aux = expression.auxiliaryElements;
@@ -148,8 +135,8 @@
     }
   }
 
-  void checkAssignment(Expression expr, DartType type) {
-    checkForCast(expr, type);
+  void checkAssignment(Expression expr, DartType to) {
+    checkForCast(expr, from: expr.staticType, to: to);
   }
 
   /// Analyzer checks boolean conversions, but we need to check too, because
@@ -176,20 +163,26 @@
 
       var exprType = element.expression.staticType;
       var asIterableType = exprType.asInstanceOf(typeProvider.iterableElement);
-      var elementType =
-          asIterableType == null ? null : asIterableType.typeArguments[0];
-      // Items in the spread will then potentially be downcast to the expected
-      // type.
-      _checkImplicitCast(element.expression, expectedType,
-          from: elementType, forSpread: true);
+
+      if (asIterableType != null) {
+        var elementType = asIterableType.typeArguments[0];
+        // Items in the spread will then potentially be downcast to the expected
+        // type.
+        _checkImplicitCast(element.expression,
+            to: expectedType, from: elementType, forSpread: true);
+      }
     }
   }
 
-  void checkForCast(Expression expr, DartType type) {
+  void checkForCast(
+    Expression expr, {
+    @required DartType from,
+    @required DartType to,
+  }) {
     if (expr is ParenthesizedExpression) {
-      checkForCast(expr.expression, type);
+      checkForCast(expr.expression, from: from, to: to);
     } else {
-      _checkImplicitCast(expr, type);
+      _checkImplicitCast(expr, from: from, to: to);
     }
   }
 
@@ -214,16 +207,18 @@
       var exprType = element.expression.staticType;
       var asMapType = exprType.asInstanceOf(typeProvider.mapElement);
 
-      var elementKeyType =
-          asMapType == null ? null : asMapType.typeArguments[0];
-      var elementValueType =
-          asMapType == null ? null : asMapType.typeArguments[1];
-      // Keys and values in the spread will then potentially be downcast to
-      // the expected types.
-      _checkImplicitCast(element.expression, expectedKeyType,
-          from: elementKeyType, forSpreadKey: true);
-      _checkImplicitCast(element.expression, expectedValueType,
-          from: elementValueType, forSpreadValue: true);
+      if (asMapType != null) {
+        var elementKeyType = asMapType.typeArguments[0];
+        var elementValueType = asMapType.typeArguments[1];
+        // Keys and values in the spread will then potentially be downcast to
+        // the expected types.
+        _checkImplicitCast(element.expression,
+            to: expectedKeyType, from: elementKeyType, forSpreadKey: true);
+        _checkImplicitCast(element.expression,
+            to: expectedValueType,
+            from: elementValueType,
+            forSpreadValue: true);
+      }
     }
   }
 
@@ -241,16 +236,17 @@
 
   @override
   void visitAssignmentExpression(AssignmentExpression node) {
+    var left = node.leftHandSide;
+    var right = node.rightHandSide;
     Token operator = node.operator;
     TokenType operatorType = operator.type;
     if (operatorType == TokenType.EQ ||
         operatorType == TokenType.QUESTION_QUESTION_EQ) {
-      DartType staticType = _getExpressionType(node.leftHandSide);
-      checkAssignment(node.rightHandSide, staticType);
+      checkForCast(right, from: right.staticType, to: node.writeType);
     } else if (operatorType == TokenType.AMPERSAND_AMPERSAND_EQ ||
         operatorType == TokenType.BAR_BAR_EQ) {
-      checkAssignment(node.leftHandSide, typeProvider.boolType);
-      checkAssignment(node.rightHandSide, typeProvider.boolType);
+      checkBoolean(left);
+      checkBoolean(right);
     } else {
       _checkCompoundAssignment(node);
     }
@@ -457,7 +453,8 @@
 
   @override
   void visitPostfixExpression(PostfixExpression node) {
-    _checkUnary(node.operand, node.operator, node.staticElement);
+    _checkUnary(node.operand, node.operator, node.staticElement,
+        readType: node.readType, writeType: node.writeType);
     node.visitChildren(this);
   }
 
@@ -466,7 +463,8 @@
     if (node.operator.type == TokenType.BANG) {
       checkBoolean(node.operand);
     } else {
-      _checkUnary(node.operand, node.operator, node.staticElement);
+      _checkUnary(node.operand, node.operator, node.staticElement,
+          readType: node.readType, writeType: node.writeType);
     }
     node.visitChildren(this);
   }
@@ -588,7 +586,8 @@
       for (VariableDeclaration variable in node.variables) {
         var initializer = variable.initializer;
         if (initializer != null) {
-          checkForCast(initializer, type.type);
+          checkForCast(initializer,
+              from: initializer.staticType, to: type.type);
         }
       }
     }
@@ -622,10 +621,9 @@
       assert(functionType.optionalParameterTypes.isEmpty);
 
       // Refine the return type.
-      var rhsType = _getExpressionType(expr.rightHandSide);
-      var lhsType = _getExpressionType(expr.leftHandSide);
+      var rhsType = expr.rightHandSide.staticType;
       var returnType = rules.refineBinaryExpressionType(
-        lhsType,
+        expr.readType,
         op,
         rhsType,
         functionType.returnType,
@@ -633,7 +631,7 @@
       );
 
       // Check the argument for an implicit cast.
-      _checkImplicitCast(expr.rightHandSide, paramTypes[0], from: rhsType);
+      _checkImplicitCast(expr.rightHandSide, to: paramTypes[0], from: rhsType);
 
       // Check the return type for an implicit cast.
       //
@@ -643,8 +641,8 @@
       //     y = /*implicit cast*/(y + 42);
       //     /*implicit assignment cast*/y += 42;
       //
-      _checkImplicitCast(expr.leftHandSide, lhsType,
-          from: returnType, opAssign: true);
+      _checkImplicitCast(expr.leftHandSide,
+          to: expr.writeType, from: returnType, opAssign: true);
     }
   }
 
@@ -694,8 +692,9 @@
   ///
   /// If [expr] does not require an implicit cast because it is not related to
   /// [to] or is already a subtype of it, does nothing.
-  void _checkImplicitCast(Expression expr, DartType to,
-      {DartType from,
+  void _checkImplicitCast(Expression expr,
+      {@required DartType to,
+      @required DartType from,
       bool opAssign = false,
       bool forSpread = false,
       bool forSpreadKey = false,
@@ -704,9 +703,7 @@
       return;
     }
 
-    from ??= _getExpressionType(expr);
-
-    if (_needsImplicitCast(expr, to, from: from) == true) {
+    if (_needsImplicitCast(expr, to: to, from: from) == true) {
       _recordImplicitCast(expr, to,
           from: from,
           opAssign: opAssign,
@@ -730,7 +727,8 @@
     if (expression != null) checkAssignment(expression, type);
   }
 
-  void _checkUnary(Expression operand, Token op, MethodElement element) {
+  void _checkUnary(Expression operand, Token op, MethodElement element,
+      {@required DartType readType, @required DartType writeType}) {
     bool isIncrementAssign = op.type.isIncrementOperator;
     if (op.isUserDefinableOperator || isIncrementAssign) {
       if (element != null && isIncrementAssign) {
@@ -744,9 +742,8 @@
         // Refine the return type.
         var functionType = element.type;
         var rhsType = typeProvider.intType;
-        var lhsType = _getExpressionType(operand);
         var returnType = rules.refineBinaryExpressionType(
-          lhsType,
+          readType,
           TokenType.PLUS,
           rhsType,
           functionType.returnType,
@@ -763,7 +760,8 @@
         //     y = /*implicit cast*/(y + 1);
         //     /*implicit assignment cast*/y++;
         //
-        _checkImplicitCast(operand, lhsType, from: returnType, opAssign: true);
+        _checkImplicitCast(operand,
+            to: writeType, from: returnType, opAssign: true);
       }
     }
   }
@@ -827,9 +825,6 @@
     }
   }
 
-  DartType _getExpressionType(Expression expr) =>
-      getExpressionType(expr, rules, typeProvider);
-
   DartType _getInstanceTypeArgument(
       DartType expressionType, ClassElement instanceType) {
     var asInstanceType = expressionType.asInstanceOf(instanceType);
@@ -860,9 +855,8 @@
   /// downcast implicitly).
   ///
   /// If [from] is omitted, uses the static type of [expr]
-  bool _needsImplicitCast(Expression expr, DartType to, {DartType from}) {
-    from ??= _getExpressionType(expr);
-
+  bool _needsImplicitCast(Expression expr,
+      {@required DartType from, @required DartType to}) {
     // Void is considered Top, but may only be *explicitly* cast.
     if (from.isVoid) return null;
 
@@ -886,8 +880,8 @@
     if (to.isDartAsyncFutureOr) {
       var to1 = (to as InterfaceType).typeArguments[0];
       var to2 = typeProvider.futureType2(to1);
-      return _needsImplicitCast(expr, to1, from: from) == true ||
-          _needsImplicitCast(expr, to2, from: from) == true;
+      return _needsImplicitCast(expr, to: to1, from: from) == true ||
+          _needsImplicitCast(expr, to: to2, from: from) == true;
     }
 
     // Anything else is an illegal sideways cast.
@@ -1021,7 +1015,7 @@
     var sequenceElement = awaitKeyword != null
         ? typeProvider.streamElement
         : typeProvider.iterableElement;
-    var iterableType = _getExpressionType(node.iterable);
+    var iterableType = node.iterable.staticType;
     var elementType = _getInstanceTypeArgument(iterableType, sequenceElement);
 
     // If the sequence is not an Iterable (or Stream for await for) but is a
@@ -1043,8 +1037,8 @@
     if (elementType != null) {
       // Insert a cast from the sequence's element type to the loop variable's
       // if needed.
-      _checkImplicitCast(loopVariable, loopVariableElement.type,
-          from: elementType);
+      _checkImplicitCast(loopVariable,
+          to: loopVariableElement.type, from: elementType);
     }
   }
 }
diff --git a/pkg/analyzer/test/src/dart/element/element_test.dart b/pkg/analyzer/test/src/dart/element/element_test.dart
index a5956bb..c86ea47 100644
--- a/pkg/analyzer/test/src/dart/element/element_test.dart
+++ b/pkg/analyzer/test/src/dart/element/element_test.dart
@@ -1469,29 +1469,6 @@
     expect(typeA.getMethod(methodName), same(methodM));
   }
 
-  void test_getMethod_parameterized_doesNotUseTypeParameter() {
-    //
-    // class A<E> { B m() {} }
-    // class B {}
-    //
-    var classA = ElementFactory.classElement2("A", ["E"]);
-    InterfaceType typeB = interfaceTypeStar(class_(name: 'B'));
-    String methodName = "m";
-    MethodElementImpl methodM =
-        ElementFactory.methodElement(methodName, typeB, []);
-    classA.methods = <MethodElement>[methodM];
-    //
-    // A<I>
-    //
-    InterfaceType typeI = interfaceTypeStar(class_(name: 'I'));
-    InterfaceTypeImpl typeAI =
-        interfaceTypeStar(classA, typeArguments: <DartType>[typeI]);
-    MethodElement method = typeAI.getMethod(methodName);
-    expect(method, isNotNull);
-    FunctionType methodType = method.type;
-    expect(methodType.typeArguments, isEmpty);
-  }
-
   void test_getMethod_parameterized_usesTypeParameter() {
     //
     // class A<E> { E m(E p) {} }
diff --git a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
index 0c06671..155270f 100644
--- a/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/assignment_test.dart
@@ -466,21 +466,14 @@
   }
 
   test_notLValue_postfixIncrement_compound_ifNull() async {
-    await assertErrorsInCode(
-      '''
+    await assertErrorsInCode('''
 void f(num x, int y) {
   x++ ??= y;
 }
-''',
-      expectedErrorsByNullability(nullable: [
-        error(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 25, 3),
-        error(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 25, 3),
-        error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 33, 1),
-      ], legacy: [
-        error(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 25, 3),
-        error(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 25, 3),
-      ]),
-    );
+''', [
+      error(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 25, 3),
+      error(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 25, 3),
+    ]);
 
     assertAssignment(
       findNode.assignment('= y'),
@@ -557,21 +550,14 @@
   }
 
   test_notLValue_prefixIncrement_compound_ifNull() async {
-    await assertErrorsInCode(
-      '''
+    await assertErrorsInCode('''
 void f(num x, int y) {
   ++x ??= y;
 }
-''',
-      expectedErrorsByNullability(nullable: [
-        error(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 25, 3),
-        error(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 25, 3),
-        error(StaticWarningCode.DEAD_NULL_AWARE_EXPRESSION, 33, 1),
-      ], legacy: [
-        error(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 25, 3),
-        error(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 25, 3),
-      ]),
-    );
+''', [
+      error(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, 25, 3),
+      error(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, 25, 3),
+    ]);
 
     assertAssignment(
       findNode.assignment('= y'),
diff --git a/pkg/analyzer/test/src/diagnostics/default_value_in_function_typed_parameter_test.dart b/pkg/analyzer/test/src/diagnostics/default_value_in_function_typed_parameter_test.dart
deleted file mode 100644
index 746f479..0000000
--- a/pkg/analyzer/test/src/diagnostics/default_value_in_function_typed_parameter_test.dart
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
-// 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/error/codes.dart';
-import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
-import 'package:test_reflective_loader/test_reflective_loader.dart';
-
-import '../dart/resolution/context_collection_resolution.dart';
-
-main() {
-  defineReflectiveSuite(() {
-    defineReflectiveTests(DefaultValueInFunctionTypedParameterTest);
-  });
-}
-
-@reflectiveTest
-class DefaultValueInFunctionTypedParameterTest
-    extends PubPackageResolutionTest {
-  test_named() async {
-    await assertErrorsInCode('''
-f(g({p: null})) {}
-''', [
-      error(
-          CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER, 5, 7),
-      error(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 6, 1),
-    ]);
-  }
-
-  test_positional() async {
-    await assertErrorsInCode('''
-f(g([p = null])) {}
-''', [
-      error(
-          CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER, 5, 8),
-      error(ParserErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE, 7, 1),
-    ]);
-  }
-}
diff --git a/pkg/analyzer/test/src/diagnostics/test_all.dart b/pkg/analyzer/test/src/diagnostics/test_all.dart
index 0711ccb..bc65f4c 100644
--- a/pkg/analyzer/test/src/diagnostics/test_all.dart
+++ b/pkg/analyzer/test/src/diagnostics/test_all.dart
@@ -114,8 +114,6 @@
 import 'default_list_constructor_test.dart' as default_list_constructor;
 import 'default_value_in_function_type_test.dart'
     as default_value_in_function_type;
-import 'default_value_in_function_typed_parameter_test.dart'
-    as default_value_in_function_typed_parameter;
 import 'default_value_in_redirecting_factory_constructor_test.dart'
     as default_value_in_redirecting_factory_constructor;
 import 'default_value_on_required_parameter_test.dart'
@@ -725,7 +723,6 @@
     dead_null_aware_expression.main();
     default_list_constructor.main();
     default_value_in_function_type.main();
-    default_value_in_function_typed_parameter.main();
     default_value_in_redirecting_factory_constructor.main();
     default_value_on_required_parameter.main();
     deferred_import_of_extension.main();
diff --git a/pkg/analyzer/tool/diagnostics/diagnostics.md b/pkg/analyzer/tool/diagnostics/diagnostics.md
index e0b0db5..3cb4448 100644
--- a/pkg/analyzer/tool/diagnostics/diagnostics.md
+++ b/pkg/analyzer/tool/diagnostics/diagnostics.md
@@ -18,6 +18,7 @@
 This page uses the following terms.
 
 [constant context]: #constant-context
+[override inference]: #override-inference
 [potentially non-nullable]: #potentially-non-nullable
 
 ### Constant context
@@ -60,6 +61,64 @@
   }
   ```
 
+### Override inference
+
+Override inference is the process by which any missing types in a method
+declaration are inferred based on the corresponding types from the method or
+methods that it overrides.
+
+If a candidate method (the method that's missing type information) overrides a
+single inherited method, then the corresponding types from the overridden method
+are inferred. For example, consider the following code:
+
+```dart
+class A {
+  int m(String s) => 0;
+}
+
+class B extends A {
+  @override
+  m(s) => 1;
+}
+```
+
+The declaration of `m` in `B` is a candidate because it's missing both the
+return type and the parameter type. Because it overrides a single method (the
+method `m` in `A`), the types from the overridden method will be used to infer
+the missing types and it will be as if the method in `B` had been declared as
+`int m(String s) => 1;`.
+
+If a candidate method overrides multiple methods, and the function type one of
+those overridden methods, M<sub>s</sub>, is a supertype of the function types of
+all of the other overridden methods, then M<sub>s</sub> is used to infer the
+missing types. For example, consider the following code:
+
+```dart
+class A {
+  int m(num n) => 0;
+}
+
+class B {
+  num m(int i) => 0;
+}
+
+class C implements A, B {
+  @override
+  m(n) => 1;
+}
+```
+
+The declaration of `m` in `C` is a candidate for override inference because it's
+missing both the return type and the parameter type. It overrides both `m` in
+`A` and `m` in `B`, so we need to choose one of them from which the missing
+types can be inferred. But because the function type of `m` in `A`
+(`int Function(num)`) is a supertype of the function type of `m` in `B`
+(`num Function(int)`), the function in `A` is used to infer the missing types.
+The result is the same as declaring the method in `C` as `int m(num n) => 1;`.
+
+It is an error if none of the overridden methods has a function type that is a
+supertype of all the other overridden methods.
+
 ### Potentially non-nullable
 
 A type is _potentially non-nullable_ if it's either explicitly non-nullable or
@@ -576,6 +635,47 @@
 
 Rewrite the code so that there isn't an assignment to a method.
 
+### await_in_late_local_variable_initializer
+
+_The 'await' expression can't be used in a 'late' local variable's initializer._
+
+#### Description
+
+The analyzer produces this diagnostic when a local variable that has the
+'late' modifier uses an 'await' expression in the initializer.
+
+#### Example
+
+The following code produces this diagnostic because an 'await' expression
+is used in the initializer for 'v', a local variable that is marked 'late':
+
+{% prettify dart tag=pre+code %}
+Future<int> f() async {
+  late v = [!await!] 42;
+  return v;
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the initializer can be rewritten to not use 'await', then rewrite it:
+
+{% prettify dart tag=pre+code %}
+Future<int> f() async {
+  late v = 42;
+  return v;
+}
+{% endprettify %}
+
+If the initializer can't be rewritten, then remove the 'late' modifier:
+
+{% prettify dart tag=pre+code %}
+Future<int> f() async {
+  var v = await 42;
+  return v;
+}
+{% endprettify %}
+
 ### body_might_complete_normally
 
 _The body might complete normally, causing 'null' to be returned, but the return
@@ -910,6 +1010,50 @@
 }
 {% endprettify %}
 
+### const_constructor_with_field_initialized_by_non_const
+
+_Can't define the 'const' constructor because the field '{0}' is initialized
+with a non-constant value._
+
+#### Description
+
+The analyzer produces this diagnostic when a constructor has the keyword
+`const`, but a field in the class is initialized to a non-constant value.
+
+#### Example
+
+The following code produces this diagnostic because the field `s` is
+initialized to a non-constant value:
+
+{% prettify dart tag=pre+code %}
+class C {
+  final String s = 3.toString();
+  [!const!] C();
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the field can be initialized to a constant value, then change the
+initializer to a constant expression:
+
+{% prettify dart tag=pre+code %}
+class C {
+  final String s = '3';
+  const C();
+}
+{% endprettify %}
+
+If the field can't be initialized to a constant value, then remove the
+keyword `const` from the constructor:
+
+{% prettify dart tag=pre+code %}
+class C {
+  final String s = 3.toString();
+  C();
+}
+{% endprettify %}
+
 ### const_constructor_with_non_final_field
 
 _Can't define a const constructor for a class with non-final fields._
@@ -1196,6 +1340,54 @@
 C f(int i) => C(i);
 {% endprettify %}
 
+### creation_with_non_type
+
+_The name '{0}' isn't a class._
+
+_The name '{0}' isn't a class._
+
+#### Description
+
+The analyzer produces this diagnostic when an instance creation using
+either `new` or `const` specifies a name that isn't defined as a class.
+
+#### Example
+
+The following code produces this diagnostic because `f` is a function
+rather than a class:
+
+{% prettify dart tag=pre+code %}
+int f() => 0;
+
+void g() {
+  new [!f!]();
+}
+{% endprettify %}
+
+#### Common fixes
+
+If a class should be created, then replace the invalid name with the name
+of a valid class:
+
+{% prettify dart tag=pre+code %}
+int f() => 0;
+
+void g() {
+  new Object();
+}
+{% endprettify %}
+
+If the name is the name of a function and you want that function to be
+invoked, then remove the `new` or `const` keyword:
+
+{% prettify dart tag=pre+code %}
+int f() => 0;
+
+void g() {
+  f();
+}
+{% endprettify %}
+
 ### dead_code
 
 _Dead code._
@@ -1468,6 +1660,36 @@
 var l = List.generate(3, (i) => i);
 {% endprettify %}
 
+### default_value_in_function_type
+
+_Parameters in a function type can't have default values._
+
+#### Description
+
+The analyzer produces this diagnostic when a function type associated with
+a parameter includes optional parameters that have a default value. This
+isn't allowed because the default values of parameters aren't part of the
+function's type, and therefore including them doesn't provide any value.
+
+#### Example
+
+The following code produces this diagnostic because the parameter `p` has a
+default value even though it's part of the type of the parameter `g`:
+
+{% prettify dart tag=pre+code %}
+void f(void Function([int p [!=!] 0]) g) {
+}
+{% endprettify %}
+
+#### Common fixes
+
+Remove the default value from the function-type's parameter:
+
+{% prettify dart tag=pre+code %}
+void f(void Function([int p]) g) {
+}
+{% endprettify %}
+
 ### definitely_unassigned_late_local_variable
 
 _The late local variable '{0}' is definitely unassigned at this point._
@@ -2730,6 +2952,56 @@
 }
 {% endprettify %}
 
+### getter_not_subtype_setter_types
+
+_The return type of getter '{0}' is '{1}' which isn't a subtype of the type
+'{2}' of its setter '{3}'._
+
+#### Description
+
+The analyzer produces this diagnostic when the return type of a getter
+isn't a subtype of the type of the parameter of a setter with the same
+name.
+
+The subtype relationship is a requirement whether the getter and setter are
+in the same class or whether one of them is in a superclass of the other.
+
+#### Example
+
+The following code produces this diagnostic because the return type of the
+getter `x` is `num`, the parameter type of the setter `x` is `int`, and
+`num` isn't a subtype of `int`:
+
+{% prettify dart tag=pre+code %}
+class C {
+  num get [!x!] => 0;
+
+  set x(int y) {}
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the type of the getter is correct, then change the type of the setter:
+
+{% prettify dart tag=pre+code %}
+class C {
+  num get x => 0;
+
+  set x(num y) {}
+}
+{% endprettify %}
+
+If the type of the setter is correct, then change the type of the getter:
+
+{% prettify dart tag=pre+code %}
+class C {
+  int get x => 0;
+
+  set x(int y) {}
+}
+{% endprettify %}
+
 ### illegal_async_return_type
 
 _Functions marked 'async' must have a return type assignable to 'Future'._
@@ -3232,6 +3504,80 @@
 If there's a concrete subclass of the abstract class that can be used, then
 create an instance of the concrete subclass.
 
+### invalid_annotation
+
+_Annotation must be either a const variable reference or const constructor
+invocation._
+
+_Getters can't be used as annotations._
+
+#### Description
+
+The analyzer produces this diagnostic when an annotation is found that is
+using something that is neither a variable marked as `const` or the
+invocation of a `const` constructor.
+
+Getters can't be used as annotations.
+
+#### Example
+
+The following code produces this diagnostic because the variable `v` isn't
+a `const` variable:
+
+{% prettify dart tag=pre+code %}
+var v = 0;
+
+[!@v!]
+void f() {
+}
+{% endprettify %}
+
+The following code produces this diagnostic because `f` isn't a variable:
+
+{% prettify dart tag=pre+code %}
+[!@f!]
+void f() {
+}
+{% endprettify %}
+
+The following code produces this diagnostic because `f` isn't a
+constructor:
+
+{% prettify dart tag=pre+code %}
+[!@f()!]
+void f() {
+}
+{% endprettify %}
+
+The following code produces this diagnostic because `g` is a getter:
+
+{% prettify dart tag=pre+code %}
+[!@g!]
+int get g => 0;
+{% endprettify %}
+
+#### Common fixes
+
+If the annotation is referencing a variable that isn't a `const`
+constructor, add the keyword `const` to the variable's declaration:
+
+{% prettify dart tag=pre+code %}
+const v = 0;
+
+@v
+void f() {
+}
+{% endprettify %}
+
+If the annotation isn't referencing a variable, then remove it:
+
+{% prettify dart tag=pre+code %}
+int v = 0;
+
+void f() {
+}
+{% endprettify %}
+
 ### invalid_assignment
 
 _A value of type '{0}' can't be assigned to a variable of type '{1}'._
@@ -3453,7 +3799,7 @@
 #### Description
 
 The analyzer produces this diagnostic when a null-aware operator (`?.`,
-`?..`, `?[`, `?..[`, or `...?`) is used on a receiver that's known to be
+`?..`, `?[`, `?..[`, or `...?`) is used on a target that's known to be
 non-nullable.
 
 #### Example
@@ -3473,6 +3819,25 @@
 var b = [[!...?!]a];
 {% endprettify %}
 
+The following code produces this diagnostic because `s?.length` can't
+return `null`:
+
+{% prettify dart tag=pre+code %}
+void f(String? s) {
+  s?.length[!?.!]isEven;
+}
+{% endprettify %}
+
+The reason `s?.length` can't return `null` is because the null-aware
+operator following `s` short-circuits the evaluation of both `length` and
+`isEven` if `s` is `null`. In other words, if `s` is `null`, then neither
+`length` nor `isEven` will be invoked, and if `s` is non-`null`, then
+`length` can't return a `null` value. Either way, `isEven` can't be invoked
+on a `null` value, so the null-aware operator is neither necessary nor
+allowed. See
+[Understanding null safety](https://dart.dev/null-safety/understanding-null-safety#smarter-null-aware-methods)
+for more details.
+
 #### Common fixes
 
 Replace the null-aware operator with a non-null-aware equivalent; for
@@ -3828,6 +4193,104 @@
 var y = f();
 {% endprettify %}
 
+### late_final_field_with_const_constructor
+
+_Can't have a late final field in a class with a const constructor._
+
+#### Description
+
+The analyzer produces this diagnostic when a class that has at least one
+`const` constructor also has a field marked both `late` and `final`.
+
+#### Example
+
+The following code produces this diagnostic because the class `A` has a
+`const` constructor and the `final` field `f` is marked as `late`:
+
+{% prettify dart tag=pre+code %}
+class A {
+  [!late!] final int f;
+
+  const A();
+}
+{% endprettify %}
+
+#### Common fixes
+
+If the field doesn't need to be marked `late`, then remove the `late`
+modifier from the field:
+
+{% prettify dart tag=pre+code %}
+class A {
+  final int f = 0;
+
+  const A();
+}
+{% endprettify %}
+
+If the field must be marked `late`, then remove the `const` modifier from
+the constructors:
+
+{% prettify dart tag=pre+code %}
+class A {
+  late final int f;
+
+  A();
+}
+{% endprettify %}
+
+### late_final_local_already_assigned
+
+_The late final local variable is already assigned._
+
+#### Description
+
+The analyzer produces this diagnostic when the analyzer can prove that a
+local variable marked as both `late` and `final` was already assigned a
+value at the point where another assignment occurs.
+
+Because `final` variables can only be assigned once, subsequent assignments
+are guaranteed to fail, so they're flagged.
+
+#### Example
+
+The following code produces this diagnostic because the `final` variable
+`v` is assigned a value in two places:
+
+{% prettify dart tag=pre+code %}
+int f() {
+  late final int v;
+  v = 0;
+  [!v!] += 1;
+  return v;
+}
+{% endprettify %}
+
+#### Common fixes
+
+If you need to be able to reassign the variable, then remove the `final`
+keyword:
+
+{% prettify dart tag=pre+code %}
+int f() {
+  late int v;
+  v = 0;
+  v += 1;
+  return v;
+}
+{% endprettify %}
+
+If you don't need to reassign the variable, then remove all except the
+first of the assignments:
+
+{% prettify dart tag=pre+code %}
+int f() {
+  late final int v;
+  v = 0;
+  return v;
+}
+{% endprettify %}
+
 ### list_element_type_not_assignable
 
 _The element type '{0}' can't be assigned to the list type '{1}'._
@@ -5455,6 +5918,62 @@
 var x;
 {% endprettify %}
 
+### no_combined_super_signature
+
+_Can't infer missing types in '{0}' from overridden methods: {1}._
+
+#### Description
+
+The analyzer produces this diagnostic when there is a method declaration
+for which one or more types needs to be inferred, and those types can't be
+inferred because none of the overridden methods has a function type that is
+a supertype of all the other overridden methods, as specified by
+[override inference][].
+
+#### Example
+
+The following code produces this diagnostic because the method `m` declared
+in the class `C` is missing both the return type and the type of the
+parameter `a`, and neither of the missing types can be inferred for it:
+
+{% prettify dart tag=pre+code %}
+abstract class A {
+  A m(String a);
+}
+
+abstract class B {
+  B m(int a);
+}
+
+abstract class C implements A, B {
+  [!m!](a);
+}
+{% endprettify %}
+
+In this example, override inference can't be performed because the
+overridden methods are incompatible in these ways:
+- Neither parameter type (`String` and `int`) is a supertype of the other.
+- Neither return type is a subtype of the other.
+
+#### Common fixes
+
+If possible, add types to the method in the subclass that are consistent
+with the types from all the overridden methods:
+
+{% prettify dart tag=pre+code %}
+abstract class A {
+  A m(String a);
+}
+
+abstract class B {
+  B m(int a);
+}
+
+abstract class C implements A, B {
+  C m(Object a);
+}
+{% endprettify %}
+
 ### nullable_type_in_catch_clause
 
 _A potentially nullable type can't be used in an 'on' clause because it isn't
@@ -5760,6 +6279,47 @@
 import 'a.dart';
 {% endprettify %}
 
+### prefix_collides_with_top_level_member
+
+_The name '{0}' is already used as an import prefix and can't be used to name a
+top-level element._
+
+#### Description
+
+The analyzer produces this diagnostic when a name is used as both an import
+prefix and the name of a top-level declaration in the same library.
+
+#### Example
+
+The following code produces this diagnostic because `f` is used as both an
+import prefix and the name of a function:
+
+{% prettify dart tag=pre+code %}
+import 'dart:math' as f;
+
+int [!f!]() => f.min(0, 1);
+{% endprettify %}
+
+#### Common fixes
+
+If you want to use the name for the import prefix, then rename the
+top-level declaration:
+
+{% prettify dart tag=pre+code %}
+import 'dart:math' as f;
+
+int g() => f.min(0, 1);
+{% endprettify %}
+
+If you want to use the name for the top-level declaration, then rename the
+import prefix:
+
+{% prettify dart tag=pre+code %}
+import 'dart:math' as math;
+
+int f() => math.min(0, 1);
+{% endprettify %}
+
 ### prefix_identifier_not_followed_by_dot
 
 _The name '{0}' refers to an import prefix, so it must be followed by '.'._
@@ -6689,6 +7249,69 @@
 int f(C c) => c.b;
 {% endprettify %}
 
+### subtype_of_disallowed_type
+
+_''{0}' can't be used as a superclass constraint._
+
+_Classes and mixins can't implement '{0}'._
+
+_Classes can't extend '{0}'._
+
+_Classes can't mixin '{0}'._
+
+#### Description
+
+The analyzer produces this diagnostic when one of the restricted classes is
+used in either an `extends`, `implements`, `with`, or `on` clause. The
+classes `bool`, `double`, `FutureOr`, `int`, `Null`, `num`, and `String`
+are all restricted in this way, to allow for more efficient
+implementations.
+
+#### Example
+
+The following code produces this diagnostic because `String` is used in an
+`extends` clause:
+
+{% prettify dart tag=pre+code %}
+class A extends [!String!] {}
+{% endprettify %}
+
+The following code produces this diagnostic because `String` is used in an
+`implements` clause:
+
+{% prettify dart tag=pre+code %}
+class B implements [!String!] {}
+{% endprettify %}
+
+The following code produces this diagnostic because `String` is used in a
+`with` clause:
+
+{% prettify dart tag=pre+code %}
+class C with [!String!] {}
+{% endprettify %}
+
+The following code produces this diagnostic because `String` is used in an
+`on` clause:
+
+{% prettify dart tag=pre+code %}
+mixin M on [!String!] {}
+{% endprettify %}
+
+#### Common fixes
+
+If a different type should be specified, then replace the type:
+
+{% prettify dart tag=pre+code %}
+class A extends Object {}
+{% endprettify %}
+
+If there isn't a different type that would be appropriate, then remove the
+type, and possibly the whole clause:
+
+{% prettify dart tag=pre+code %}
+class B {}
+{% endprettify %}
+
 ### super_in_extension
 
 _The 'super' keyword can't be used in an extension because an extension doesn't
@@ -7819,9 +8442,9 @@
 
 #### Description
 
-The analyzer produces this diagnostic when an inherited member is
-referenced using `super`, but there’s no member with that name in the
-superclass chain.
+The analyzer produces this diagnostic when an inherited member (method,
+getter, setter, or operator) is referenced using `super`, but there’s no
+member with that name in the superclass chain.
 
 #### Examples
 
@@ -7855,8 +8478,8 @@
 If the member you intend to invoke is defined in the same class, then
 remove the `super.`.
 
-If not, then either add the member to one of the superclasses or remove the
-invocation.
+If the member isn’t defined, then either add the member to one of the
+superclasses or remove the invocation.
 
 ### unnecessary_cast
 
@@ -8126,9 +8749,14 @@
 
 #### Description
 
-The analyzer produces this diagnostic when a private class, enum, mixin,
-typedef, top level variable, top level function, or method is declared but
-never referenced.
+The analyzer produces this diagnostic when a private declaration isn't
+referenced in the library that contains the declaration. The following
+kinds of declarations are analyzed:
+- Private top-level declarations, such as classes, enums, mixins, typedefs,
+  top-level variables, and top-level functions
+- Private static and instance methods
+- Optional parameters of private functions for which a value is never
+  passed, even when the parameter doesn't have a private name
 
 #### Examples
 
@@ -8139,11 +8767,30 @@
 class [!_C!] {}
 {% endprettify %}
 
+Assuming that no code in the library passes a value for `y` in any
+invocation of `_m`, the following code produces this diagnostic:
+
+{% prettify dart tag=pre+code %}
+class C {
+  void _m(int x, [int [!y!]]) {}
+
+  void n() => _m(0);
+}
+{% endprettify %}
+
 #### Common fixes
 
-If the declaration isn't needed, then remove it.
+If the declaration isn't needed, then remove it:
 
-If the declaration was intended to be used, then add the missing code.
+{% prettify dart tag=pre+code %}
+class C {
+  void _m(int x) {}
+
+  void n() => _m(0);
+}
+{% endprettify %}
+
+If the declaration is intended to be used, then add the code to use it.
 
 ### unused_field
 
@@ -8542,6 +9189,55 @@
 void f(C<int> x) {}
 {% endprettify %}
 
+### wrong_number_of_type_arguments_method
+
+_The method '{0}' is declared with {1} type parameters, but {2} type arguments
+are given._
+
+#### Description
+
+The analyzer produces this diagnostic when a method or function is invoked
+with a different number of type arguments than the number of type
+parameters specified in its declaration. There must either be no type
+arguments or the number of arguments must match the number of parameters.
+
+#### Example
+
+The following code produces this diagnostic because the invocation of the
+method `m` has two type arguments, but the declaration of `m` only has one
+type parameter:
+
+{% prettify dart tag=pre+code %}
+class C {
+  int m<A>(A a) => 0;
+}
+
+int f(C c) => c.m[!<int, int>!](2);
+{% endprettify %}
+
+#### Common fixes
+
+If the type arguments are necessary, then make them match the number of
+type parameters by either adding or removing type arguments:
+
+{% prettify dart tag=pre+code %}
+class C {
+  int m<A>(A a) => 0;
+}
+
+int f(C c) => c.m<int>(2);
+{% endprettify %}
+
+If the type arguments aren't necessary, then remove them:
+
+{% prettify dart tag=pre+code %}
+class C {
+  int m<A>(A a) => 0;
+}
+
+int f(C c) => c.m(2);
+{% endprettify %}
+
 ### undefined_super_method
 
 See [undefined_super_member](#undefined-super-member).
diff --git a/pkg/analyzer/tool/diagnostics/generate.dart b/pkg/analyzer/tool/diagnostics/generate.dart
index 59b6c0e..7d903d9 100644
--- a/pkg/analyzer/tool/diagnostics/generate.dart
+++ b/pkg/analyzer/tool/diagnostics/generate.dart
@@ -403,6 +403,7 @@
 This page uses the following terms.
 
 [constant context]: #constant-context
+[override inference]: #override-inference
 [potentially non-nullable]: #potentially-non-nullable
 
 ### Constant context
@@ -445,6 +446,64 @@
   }
   ```
 
+### Override inference
+
+Override inference is the process by which any missing types in a method
+declaration are inferred based on the corresponding types from the method or
+methods that it overrides.
+
+If a candidate method (the method that's missing type information) overrides a
+single inherited method, then the corresponding types from the overridden method
+are inferred. For example, consider the following code:
+
+```dart
+class A {
+  int m(String s) => 0;
+}
+
+class B extends A {
+  @override
+  m(s) => 1;
+}
+```
+
+The declaration of `m` in `B` is a candidate because it's missing both the
+return type and the parameter type. Because it overrides a single method (the
+method `m` in `A`), the types from the overridden method will be used to infer
+the missing types and it will be as if the method in `B` had been declared as
+`int m(String s) => 1;`.
+
+If a candidate method overrides multiple methods, and the function type one of
+those overridden methods, M<sub>s</sub>, is a supertype of the function types of
+all of the other overridden methods, then M<sub>s</sub> is used to infer the
+missing types. For example, consider the following code:
+
+```dart
+class A {
+  int m(num n) => 0;
+}
+
+class B {
+  num m(int i) => 0;
+}
+
+class C implements A, B {
+  @override
+  m(n) => 1;
+}
+```
+
+The declaration of `m` in `C` is a candidate for override inference because it's
+missing both the return type and the parameter type. It overrides both `m` in
+`A` and `m` in `B`, so we need to choose one of them from which the missing
+types can be inferred. But because the function type of `m` in `A`
+(`int Function(num)`) is a supertype of the function type of `m` in `B`
+(`num Function(int)`), the function in `A` is used to infer the missing types.
+The result is the same as declaring the method in `C` as `int m(num n) => 1;`.
+
+It is an error if none of the overridden methods has a function type that is a
+supertype of all the other overridden methods.
+
 ### Potentially non-nullable
 
 A type is _potentially non-nullable_ if it's either explicitly non-nullable or
diff --git a/tests/language/parameter/named_aggregated_test.dart b/tests/language/parameter/named_aggregated_test.dart
index 61de489f..87e6140 100644
--- a/tests/language/parameter/named_aggregated_test.dart
+++ b/tests/language/parameter/named_aggregated_test.dart
@@ -27,8 +27,6 @@
   // Expect compile-time error as no default values
   // are allowed in closure type.
   void InstallCallback(void cb({String? msg : null})?) {
-  //                            ^^^^^^^^^^^^^^^^^^
-  // [analyzer] COMPILE_TIME_ERROR.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER
   //                                        ^
   // [analyzer] SYNTACTIC_ERROR.DEFAULT_VALUE_IN_FUNCTION_TYPE
   // [cfe] Can't have a default value in a function type.
diff --git a/tests/language_2/parameter/named_aggregated_test.dart b/tests/language_2/parameter/named_aggregated_test.dart
index 82c7c8c..1b506df 100644
--- a/tests/language_2/parameter/named_aggregated_test.dart
+++ b/tests/language_2/parameter/named_aggregated_test.dart
@@ -27,8 +27,6 @@
   // Expect compile-time error as no default values
   // are allowed in closure type.
   void InstallCallback(void cb({String msg : null})) {
-  //                            ^^^^^^^^^^^^^^^^^
-  // [analyzer] COMPILE_TIME_ERROR.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER
   //                                       ^
   // [analyzer] SYNTACTIC_ERROR.DEFAULT_VALUE_IN_FUNCTION_TYPE
   // [cfe] Can't have a default value in a function type.
diff --git a/tools/VERSION b/tools/VERSION
index 2ace34c..36662ae 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 11
 PATCH 0
-PRERELEASE 162
+PRERELEASE 163
 PRERELEASE_PATCH 0
\ No newline at end of file