diff --git a/DEPS b/DEPS
index 434e57a..74b90b2 100644
--- a/DEPS
+++ b/DEPS
@@ -79,8 +79,8 @@
   "bazel_worker_rev": "ceeba0982d4ff40d32371c9d35f3d2dc1868de20",
   "benchmark_harness_rev": "c546dbd9f639f75cd2f75de8df2eb9f8ea15e8e7",
   "boolean_selector_rev": "665e6921ab246569420376f827bff4585dff0b14",
-  "boringssl_gen_rev": "7322fc15cc065d8d2957fccce6b62a509dc4d641",
-  "boringssl_rev" : "1607f54fed72c6589d560254626909a64124f091",
+  "boringssl_gen_rev": "ced85ef0a00bbca77ce5a91261a5f2ae61b1e62f",
+  "boringssl_rev" : "87f316d7748268eb56f2dc147bd593254ae93198",
   "browser-compat-data_tag": "v1.0.22",
   "browser_launcher_rev": "c6cc1025d6901926cf022e144ba109677e3548f1",
   "characters_rev": "6ec389c4dfa8fce14820dc5cbf6e693202e7e052",
diff --git a/pkg/analysis_server/lib/src/services/completion/yaml/fix_data_generator.dart b/pkg/analysis_server/lib/src/services/completion/yaml/fix_data_generator.dart
index 15ef594..d57592a 100644
--- a/pkg/analysis_server/lib/src/services/completion/yaml/fix_data_generator.dart
+++ b/pkg/analysis_server/lib/src/services/completion/yaml/fix_data_generator.dart
@@ -16,27 +16,7 @@
       'title': EmptyProducer(),
       'date': EmptyProducer(),
       'bulkApply': BooleanProducer(),
-      'element': MapProducer({
-        // TODO(brianwilkerson) Support suggesting uris.
-        'uris': EmptyProducer(),
-        'class': EmptyProducer(),
-        'constant': EmptyProducer(),
-        'constructor': EmptyProducer(),
-        'enum': EmptyProducer(),
-        'extension': EmptyProducer(),
-        'field': EmptyProducer(),
-        'function': EmptyProducer(),
-        'getter': EmptyProducer(),
-        'method': EmptyProducer(),
-        'mixin': EmptyProducer(),
-        'setter': EmptyProducer(),
-        'typedef': EmptyProducer(),
-        'variable': EmptyProducer(),
-        'inClass': EmptyProducer(),
-        'inEnum': EmptyProducer(),
-        'inExtension': EmptyProducer(),
-        'inMixin': EmptyProducer(),
-      }),
+      'element': _elementProducer,
       'changes': _changesProducer,
       'oneOf': ListProducer(MapProducer({
         'if': EmptyProducer(),
@@ -56,6 +36,7 @@
       'removeParameter',
       'rename',
       'renameParameter',
+      'replacedBy',
     ]),
     'index': EmptyProducer(),
     'name': EmptyProducer(),
@@ -69,8 +50,32 @@
     'extends': EmptyProducer(),
     'oldName': EmptyProducer(),
     'newName': EmptyProducer(),
+    'newElement': _elementProducer,
   }));
 
+  /// The producer representing the known valid structure of an element.
+  static const MapProducer _elementProducer = MapProducer({
+    // TODO(brianwilkerson) Support suggesting uris.
+    'uris': EmptyProducer(),
+    'class': EmptyProducer(),
+    'constant': EmptyProducer(),
+    'constructor': EmptyProducer(),
+    'enum': EmptyProducer(),
+    'extension': EmptyProducer(),
+    'field': EmptyProducer(),
+    'function': EmptyProducer(),
+    'getter': EmptyProducer(),
+    'method': EmptyProducer(),
+    'mixin': EmptyProducer(),
+    'setter': EmptyProducer(),
+    'typedef': EmptyProducer(),
+    'variable': EmptyProducer(),
+    'inClass': EmptyProducer(),
+    'inEnum': EmptyProducer(),
+    'inExtension': EmptyProducer(),
+    'inMixin': EmptyProducer(),
+  });
+
   /// Initialize a newly created suggestion generator for fix data files.
   FixDataGenerator(ResourceProvider resourceProvider)
       : super(resourceProvider, null);
diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_kind.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_kind.dart
index a3fb8b1..4da8683 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_kind.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_kind.dart
@@ -20,6 +20,38 @@
 }
 
 extension ElementKindUtilities on ElementKind {
+  /// Return a human readable name for the kind.
+  String get displayName {
+    switch (this) {
+      case ElementKind.classKind:
+        return 'class';
+      case ElementKind.constantKind:
+        return 'constant';
+      case ElementKind.constructorKind:
+        return 'constructor';
+      case ElementKind.enumKind:
+        return 'enum';
+      case ElementKind.extensionKind:
+        return 'extension';
+      case ElementKind.fieldKind:
+        return 'field';
+      case ElementKind.functionKind:
+        return 'function';
+      case ElementKind.getterKind:
+        return 'getter';
+      case ElementKind.methodKind:
+        return 'method';
+      case ElementKind.mixinKind:
+        return 'mixin';
+      case ElementKind.setterKind:
+        return 'setter';
+      case ElementKind.typedefKind:
+        return 'typedef';
+      case ElementKind.variableKind:
+        return 'variable';
+    }
+  }
+
   /// Return the element kind corresponding to the given [name].
   static ElementKind? fromName(String name) {
     for (var kind in ElementKind.values) {
diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
index 49751f1..837025a 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
@@ -342,20 +342,27 @@
           // If the old class has been removed then this might have been a
           // constructor invocation.
           ElementKind.constructorKind,
+          ElementKind.functionKind, // tear-off
           ElementKind.getterKind,
           ElementKind.setterKind,
           ElementKind.variableKind
         ];
       }
       return const [
+        ElementKind.constantKind,
         ElementKind.fieldKind,
+        ElementKind.functionKind, // tear-off
         ElementKind.getterKind,
+        ElementKind.methodKind, // tear-off
         ElementKind.setterKind
       ];
     } else if (node is PropertyAccess) {
       return const [
+        ElementKind.constantKind,
         ElementKind.fieldKind,
+        ElementKind.functionKind, // tear-off, prefixed
         ElementKind.getterKind,
+        ElementKind.methodKind, // tear-off, prefixed
         ElementKind.setterKind
       ];
     } else if (node is SimpleIdentifier) {
diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/replaced_by.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/replaced_by.dart
new file mode 100644
index 0000000..92e23b9
--- /dev/null
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/replaced_by.dart
@@ -0,0 +1,140 @@
+// Copyright (c) 2021, 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:analysis_server/src/services/correction/dart/data_driven.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/change.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/element_descriptor.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/source/source_range.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_dart.dart';
+import 'package:analyzer_plugin/utilities/range_factory.dart';
+
+/// The data related to an element that has been replaced by another element.
+class ReplacedBy extends Change<_Data> {
+  /// The replacing element.
+  final ElementDescriptor newElement;
+
+  /// Initialize a newly created transform to describe a replacement of an old
+  /// element by a [newElement].
+  ReplacedBy({required this.newElement});
+
+  @override
+  void apply(DartFileEditBuilder builder, DataDrivenFix fix, _Data data) {
+    var referenceRange = data.referenceRange;
+    builder.addSimpleReplacement(referenceRange, _referenceTo(newElement));
+  }
+
+  @override
+  _Data? validate(DataDrivenFix fix) {
+    var node = fix.node;
+    if (node is SimpleIdentifier) {
+      var components = fix.element.components;
+      if (components.isEmpty) {
+        return null;
+      } else if (components.length == 1) {
+        if (components[0] != node.name) {
+          return null;
+        }
+        // We have an '<element>' pattern, so we replace the name.
+        return _Data(range.node(node));
+      }
+      // The element being replaced is a member in a top-level element.
+      var containerName = components[1];
+      if (components[0].isEmpty && containerName == node.name) {
+        // We have a '<className>()' pattern, so we replace the class name.
+        return _Data(range.node(node));
+      }
+      var parent = node.parent;
+      if (parent is MethodInvocation) {
+        var target = parent.target;
+        if (target == null) {
+          // We have a '<member>()' pattern, so we replace the member name.
+          return _Data(range.node(node));
+        } else if (target is SimpleIdentifier && target.name == containerName) {
+          // We have a '<container>.<member>()' pattern, so we replace both parts.
+          return _Data(range.startEnd(target, node));
+        } else if (target is PrefixedIdentifier) {
+          if (target.prefix.staticElement is PrefixElement &&
+              target.identifier.name == containerName) {
+            // We have a '<prefix>.<container>.<member>()' pattern so we leave
+            // the prefix while replacing the rest.
+            return _Data(range.startEnd(target.identifier, node));
+          }
+          // We shouldn't get here.
+          return null;
+        }
+      } else if (parent is PrefixedIdentifier) {
+        if (parent.prefix.staticElement is PrefixElement) {
+          // We have a '<prefix>.<topLevel>' pattern so we leave the prefix
+          // while replacing the rest.
+          return _Data(range.node(node));
+        }
+        // We have a '<container>.<member>' pattern so we replace both parts.
+        return _Data(range.node(parent));
+      } else if (parent is PropertyAccess) {
+        var target = parent.target;
+        if (target is PrefixedIdentifier) {
+          // We have a '<prefix>.<container>.<member>' pattern so we leave the
+          // prefix while replacing the rest.
+          return _Data(range.startEnd(target.identifier, node));
+        }
+        // We have a '<container>.<member>' pattern so we replace both parts.
+        return _Data(range.node(parent));
+      }
+      // We have a '<member>' pattern so we replace the member name.
+      return _Data(range.node(node));
+    } else if (node is PrefixedIdentifier) {
+      var parent = node.parent;
+      if (parent is NamedType) {
+        var identifier = node.identifier;
+        var components = fix.element.components;
+        if (components.length > 1 &&
+            components[0].isEmpty &&
+            components[1] == identifier.name) {
+          // We have a '<prefix>.<className>' pattern, so we replace only the
+          // class name.
+          return _Data(range.node(identifier));
+        }
+      }
+    } else if (node is ConstructorName) {
+      var typeName = node.type2.name;
+      SimpleIdentifier classNameNode;
+      if (typeName is SimpleIdentifier) {
+        classNameNode = typeName;
+      } else if (typeName is PrefixedIdentifier) {
+        classNameNode = typeName.identifier;
+      } else {
+        return null;
+      }
+      var constructorNameNode = node.name;
+      var constructorName = constructorNameNode?.name ?? '';
+      var components = fix.element.components;
+      if (components.length == 2 &&
+          constructorName == components[0] &&
+          classNameNode.name == components[1]) {
+        if (constructorNameNode != null) {
+          return _Data(range.startEnd(classNameNode, constructorNameNode));
+        }
+        return _Data(range.node(classNameNode));
+      }
+    }
+    return null;
+  }
+
+  String _referenceTo(ElementDescriptor element) {
+    var components = element.components;
+    if (components[0].isEmpty) {
+      return components[1];
+    }
+    return components.reversed.join('.');
+  }
+}
+
+/// The data about a reference to an element that's been replaced.
+class _Data {
+  final SourceRange referenceRange;
+
+  _Data(this.referenceRange);
+}
diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_error_code.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_error_code.dart
index 1c992e0..42aeba2 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_error_code.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_error_code.dart
@@ -25,6 +25,26 @@
 
   /**
    * Parameters:
+   * 0: the old kind
+   * 1: the new kind
+   */
+  static const TransformSetErrorCode incompatibleElementKind =
+      TransformSetErrorCode(
+          'incompatible_element_kind',
+          "An element of kind '{0}' can't be replaced by "
+              "an element of kind '{1}'.");
+
+  /**
+   * Parameters:
+   * 0: the change kind that is invalid
+   * 1: the element kind for the transform
+   */
+  static const TransformSetErrorCode invalidChangeForKind =
+      TransformSetErrorCode('invalid_change_for_kind',
+          "A change of type '{0}' can't be used for an element of kind '{1}'.");
+
+  /**
+   * Parameters:
    * 0: the character that is invalid
    */
   static const TransformSetErrorCode invalidCharacter =
@@ -136,6 +156,14 @@
   /**
    * No parameters.
    */
+  static const TransformSetErrorCode unsupportedUriChange = TransformSetErrorCode(
+      'unsupported_uri_change',
+      "The set of URIs for the replacement element must match the transformed "
+          "element.");
+
+  /**
+   * No parameters.
+   */
   static const TransformSetErrorCode unsupportedVersion = TransformSetErrorCode(
       'unsupported_version', "Only version '1' is supported at this time.");
 
diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
index 4605bd6..dc8184c 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
@@ -14,6 +14,7 @@
 import 'package:analysis_server/src/services/correction/fix/data_driven/parameter_reference.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/rename.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/rename_parameter.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/replaced_by.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/transform.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/transform_set.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/transform_set_error_code.dart';
@@ -64,6 +65,7 @@
   static const String _methodKey = 'method';
   static const String _mixinKey = 'mixin';
   static const String _nameKey = 'name';
+  static const String _newElementKey = 'newElement';
   static const String _newNameKey = 'newName';
   static const String _oldNameKey = 'oldName';
   static const String _oneOfKey = 'oneOf';
@@ -97,6 +99,7 @@
   static const String _removeParameterKind = 'removeParameter';
   static const String _renameKind = 'rename';
   static const String _renameParameterKind = 'renameParameter';
+  static const String _replacedByKind = 'replacedBy';
 
   /// The valid values for the [_styleKey] in an [_addParameterKind] change.
   static const List<String> validStyles = [
@@ -106,6 +109,11 @@
     'required_positional'
   ];
 
+  /// A table mapping the kinds of elements that can be replaced by a different
+  /// element to a set of the kinds of elements with which they can be replaced.
+  static final Map<ElementKind, Set<ElementKind>> compatibleReplacementTypes =
+      _createCompatibleReplacementTypes();
+
   static const String _openComponent = '{%';
   static const String _closeComponent = '%}';
 
@@ -125,6 +133,12 @@
   /// found.
   final String packageName;
 
+  /// The description of the element that is being transformed by the current
+  /// transformation, or `null` if we are not in the process of parsing a
+  /// transformation or if the element associated with the transformation is not
+  /// valid.
+  ElementDescriptor? elementBeingTransformed;
+
   /// The variable scope defined for the current transform.
   VariableScope transformVariableScope = VariableScope.empty;
 
@@ -147,6 +161,13 @@
     return _translateTransformSet(map);
   }
 
+  bool _equalUris(List<Uri> oldUris, List<Uri> newUris) {
+    var oldSet = oldUris.toSet();
+    var newSet = newUris.toSet();
+    return oldSet.difference(newSet).isEmpty &&
+        newSet.difference(oldSet).isEmpty;
+  }
+
   /// Convert the given [template] into a list of components. Variable
   /// references in the template are looked up in the map of [generators].
   List<TemplateComponent> _extractTemplateComponents(
@@ -446,6 +467,8 @@
         return _translateRenameChange(node);
       } else if (kind == _renameParameterKind) {
         return _translateRenameParameterChange(node);
+      } else if (kind == _replacedByKind) {
+        return _translateReplacedByChange(node);
       }
       return _reportInvalidValueOneOf(kindNode, kindContext, [
         _addParameterKind,
@@ -453,6 +476,7 @@
         _removeParameterKind,
         _renameKind,
         _renameParameterKind,
+        _replacedByKind,
       ]);
     } else {
       return _reportInvalidValue(node, context, 'Map');
@@ -821,6 +845,41 @@
     return RenameParameter(newName: newName, oldName: oldName);
   }
 
+  /// Translate the [node] into a replaced_by change. Return the resulting
+  /// change, or `null` if the [node] does not represent a valid replaced_by
+  /// change.
+  ReplacedBy? _translateReplacedByChange(YamlMap node) {
+    _reportUnsupportedKeys(node, const {_kindKey, _newElementKey});
+    var newElement = _translateElement(node.valueAt(_newElementKey),
+        ErrorContext(key: _newElementKey, parentNode: node));
+    if (newElement == null) {
+      // The error has already been reported.
+      return null;
+    }
+    var oldElement = elementBeingTransformed;
+    if (oldElement != null) {
+      if (!_equalUris(oldElement.libraryUris, newElement.libraryUris)) {
+        _reportError(TransformSetErrorCode.unsupportedUriChange,
+            (node.valueAt(_newElementKey) as YamlMap).valueAt(_urisKey)!);
+      }
+      var compatibleTypes = compatibleReplacementTypes[oldElement.kind];
+      if (compatibleTypes == null) {
+        _reportError(
+            TransformSetErrorCode.invalidChangeForKind,
+            node.valueAt(_newElementKey)!,
+            [_replacedByKind, oldElement.kind.displayName]);
+        return null;
+      } else if (!compatibleTypes.contains(newElement.kind)) {
+        _reportError(
+            TransformSetErrorCode.incompatibleElementKind,
+            node.valueAt(_newElementKey)!,
+            [oldElement.kind.displayName, newElement.kind.displayName]);
+        return null;
+      }
+    }
+    return ReplacedBy(newElement: newElement);
+  }
+
   /// Translate the [node] into a string. Return the resulting string, or `null`
   /// if the [node] doesn't represent a valid string. If the [node] isn't valid,
   /// use the [context] to report the error. If the [node] doesn't exist and
@@ -893,6 +952,7 @@
           true;
       var element = _translateElement(node.valueAt(_elementKey),
           ErrorContext(key: _elementKey, parentNode: node));
+      elementBeingTransformed = element;
       transformVariableScope = _translateTemplateVariables(
           node.valueAt(_variablesKey),
           ErrorContext(key: _variablesKey, parentNode: node));
@@ -1032,4 +1092,43 @@
       return _reportInvalidValue(node, context, 'Map');
     }
   }
+
+  static Map<ElementKind, Set<ElementKind>>
+      _createCompatibleReplacementTypes() {
+    var types = <ElementKind, Set<ElementKind>>{};
+
+    void addSet(Set<ElementKind> set) {
+      for (var kind in set) {
+        types.putIfAbsent(kind, () => {}).addAll(set);
+      }
+    }
+
+    // Constructors can replace constructors.
+    addSet({
+      ElementKind.constructorKind,
+    });
+    // Static methods and top-level functions can replace each other.
+    addSet({
+      ElementKind.functionKind,
+      ElementKind.methodKind,
+    });
+    // Static getters and getter-inducing elements can replace each other.
+    addSet({
+      ElementKind.constantKind,
+      ElementKind.fieldKind,
+      ElementKind.getterKind,
+      ElementKind.variableKind,
+    });
+    // Static setters and setter-inducing elements can replace each other.
+    // TODO(brianwilkerson) We can't currently distinguish between final and
+    //  non-final elements, but we don't support replacing setters with final
+    //  elements, nor vice versa. We need a way to distinguish these cases if we
+    //  want to be able to report an error.
+    addSet({
+      ElementKind.fieldKind,
+      ElementKind.setterKind,
+      ElementKind.variableKind,
+    });
+    return types;
+  }
 }
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/incompatible_element_kind_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/incompatible_element_kind_test.dart
new file mode 100644
index 0000000..4561ddd
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/incompatible_element_kind_test.dart
@@ -0,0 +1,37 @@
+// Copyright (c) 2021, 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:analysis_server/src/services/correction/fix/data_driven/transform_set_error_code.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../transform_set_parser_test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(IncompatibleElementKindTest);
+  });
+}
+
+@reflectiveTest
+class IncompatibleElementKindTest extends AbstractTransformSetParserTest {
+  void test_integer() {
+    assertErrors('''
+version: 1
+transforms:
+- title: 'Replace'
+  date: 2021-11-30
+  element:
+    uris: ['test.dart']
+    method: 'm'
+    inClass: 'C'
+  changes:
+    - kind: 'replacedBy'
+      newElement:
+        uris: ['test.dart']
+        variable: 'v'
+''', [
+      error(TransformSetErrorCode.incompatibleElementKind, 191, 42),
+    ]);
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/invalid_change_for_kind_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/invalid_change_for_kind_test.dart
new file mode 100644
index 0000000..ee118e9
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/invalid_change_for_kind_test.dart
@@ -0,0 +1,36 @@
+// Copyright (c) 2021, 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:analysis_server/src/services/correction/fix/data_driven/transform_set_error_code.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../transform_set_parser_test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(InvalidChangeForKindTest);
+  });
+}
+
+@reflectiveTest
+class InvalidChangeForKindTest extends AbstractTransformSetParserTest {
+  void test_integer() {
+    assertErrors('''
+version: 1
+transforms:
+- title: 'Replace'
+  date: 2021-11-30
+  element:
+    uris: ['test.dart']
+    class: 'C'
+  changes:
+    - kind: 'replacedBy'
+      newElement:
+        uris: ['test.dart']
+        class: 'D'
+''', [
+      error(TransformSetErrorCode.invalidChangeForKind, 173, 39),
+    ]);
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/test_all.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/test_all.dart
index bb2464ae..375c983 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/test_all.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/test_all.dart
@@ -6,6 +6,8 @@
 
 import 'conflicting_key_test.dart' as conflicting_key;
 import 'expected_primary_test.dart' as expected_primary;
+import 'incompatible_element_kind_test.dart' as incompatible_element_kind;
+import 'invalid_change_for_kind_test.dart' as invalid_change_for_kind;
 import 'invalid_character_test.dart' as invalid_character;
 import 'invalid_key_test.dart' as invalid_key;
 import 'invalid_parameter_style_test.dart' as invalid_parameter_style;
@@ -21,6 +23,7 @@
 import 'unexpected_token_test.dart' as unexpected_token;
 import 'unknown_accessor_test.dart' as unknown_accessor;
 import 'unsupported_key_test.dart' as unsupported_key;
+import 'unsupported_uri_change_test.dart' as unsupported_uri_change;
 import 'unsupported_version_test.dart' as unsupported_version;
 import 'wrong_token_test.dart' as wrong_token;
 import 'yaml_syntax_error_test.dart' as yaml_syntax_error;
@@ -29,6 +32,8 @@
   defineReflectiveSuite(() {
     conflicting_key.main();
     expected_primary.main();
+    incompatible_element_kind.main();
+    invalid_change_for_kind.main();
     invalid_character.main();
     invalid_key.main();
     invalid_parameter_style.main();
@@ -44,6 +49,7 @@
     unexpected_token.main();
     unknown_accessor.main();
     unsupported_key.main();
+    unsupported_uri_change.main();
     unsupported_version.main();
     wrong_token.main();
     yaml_syntax_error.main();
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/unsupported_uri_change_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/unsupported_uri_change_test.dart
new file mode 100644
index 0000000..ecc493a
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/diagnostics/unsupported_uri_change_test.dart
@@ -0,0 +1,36 @@
+// Copyright (c) 2021, 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:analysis_server/src/services/correction/fix/data_driven/transform_set_error_code.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../transform_set_parser_test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(UnsupportedUriChangeTest);
+  });
+}
+
+@reflectiveTest
+class UnsupportedUriChangeTest extends AbstractTransformSetParserTest {
+  void test_integer() {
+    assertErrors('''
+version: 1
+transforms:
+- title: 'Replace'
+  date: 2021-11-30
+  element:
+    uris: ['test.dart']
+    function: 'f'
+  changes:
+    - kind: 'replacedBy'
+      newElement:
+        uris: ['other.dart']
+        function: 'g'
+''', [
+      error(TransformSetErrorCode.unsupportedUriChange, 182, 14),
+    ]);
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/element_matcher_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/element_matcher_test.dart
index e9e0363..16ec4ae 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/element_matcher_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/element_matcher_test.dart
@@ -41,8 +41,11 @@
 class ElementMatcherComponentAndKindTest extends AbstractElementMatcherTest {
   /// The kinds that are expected where a getter or setter is allowed.
   static List<ElementKind> accessorKinds = [
+    ElementKind.constantKind,
     ElementKind.fieldKind,
+    ElementKind.functionKind, // tear-off
     ElementKind.getterKind,
+    ElementKind.methodKind, // tear-off
     ElementKind.setterKind,
   ];
 
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/replaced_by_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/replaced_by_test.dart
new file mode 100644
index 0000000..03d89fe
--- /dev/null
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/replaced_by_test.dart
@@ -0,0 +1,1069 @@
+// Copyright (c) 2021, 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:analysis_server/src/services/correction/fix/data_driven/changes_selector.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/element_descriptor.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/element_kind.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/replaced_by.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/transform.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'data_driven_test_support.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ReplacedByTest);
+  });
+}
+
+@reflectiveTest
+class ReplacedByTest extends DataDrivenFixProcessorTest {
+  Future<void> test_defaultConstructor_defaultConstructor() async {
+    await _assertReplacement(
+      _Element.defaultConstructor(isDeprecated: true, isOld: true),
+      _Element.defaultConstructor(),
+      isInvocation: true,
+    );
+  }
+
+  Future<void> test_defaultConstructor_defaultConstructor_prefixed() async {
+    await _assertReplacement(
+      _Element.defaultConstructor(isDeprecated: true, isOld: true),
+      _Element.defaultConstructor(),
+      isInvocation: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_defaultConstructor_namedConstructor() async {
+    await _assertReplacement(
+      _Element.defaultConstructor(isDeprecated: true, isOld: true),
+      _Element.namedConstructor(),
+      isInvocation: true,
+    );
+  }
+
+  Future<void> test_defaultConstructor_namedConstructor_prefixed() async {
+    await _assertReplacement(
+      _Element.defaultConstructor(isDeprecated: true, isOld: true),
+      _Element.namedConstructor(),
+      isInvocation: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_enumConstant_enumConstant() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.constant(),
+    );
+  }
+
+  Future<void> test_enumConstant_enumConstant_prefixed() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.constant(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_enumConstant_staticField() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.field(isStatic: true),
+    );
+  }
+
+  Future<void> test_enumConstant_staticField_prefixed() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.field(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_enumConstant_staticGetter() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.getter(isStatic: true),
+    );
+  }
+
+  Future<void> test_enumConstant_staticGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.getter(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_enumConstant_topLevelGetter() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.topLevelGetter(),
+    );
+  }
+
+  Future<void> test_enumConstant_topLevelGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.topLevelGetter(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_enumConstant_topLevelVariable() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.topLevelVariable(),
+    );
+  }
+
+  Future<void> test_enumConstant_topLevelVariable_prefixed() async {
+    await _assertReplacement(
+      _Element.constant(isDeprecated: true, isOld: true),
+      _Element.topLevelVariable(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_function_function_invocation() async {
+    await _assertReplacement(
+      _Element.topLevelFunction(isDeprecated: true, isOld: true),
+      _Element.topLevelFunction(),
+      isInvocation: true,
+    );
+  }
+
+  Future<void> test_function_function_invocation_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelFunction(isDeprecated: true, isOld: true),
+      _Element.topLevelFunction(),
+      isInvocation: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_function_function_tearoff() async {
+    await _assertReplacement(
+      _Element.topLevelFunction(isDeprecated: true, isOld: true),
+      _Element.topLevelFunction(),
+    );
+  }
+
+  Future<void> test_function_function_tearoff_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelFunction(isDeprecated: true, isOld: true),
+      _Element.topLevelFunction(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_function_staticMethod_invocation() async {
+    await _assertReplacement(
+      _Element.topLevelFunction(isDeprecated: true, isOld: true),
+      _Element.method(isStatic: true),
+      isInvocation: true,
+    );
+  }
+
+  Future<void> test_function_staticMethod_invocation_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelFunction(isDeprecated: true, isOld: true),
+      _Element.method(isStatic: true),
+      isInvocation: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_function_staticMethod_tearoff() async {
+    await _assertReplacement(
+      _Element.topLevelFunction(isDeprecated: true, isOld: true),
+      _Element.method(isStatic: true),
+    );
+  }
+
+  Future<void> test_function_staticMethod_tearoff_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelFunction(isDeprecated: true, isOld: true),
+      _Element.method(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_namedConstructor_defaultConstructor() async {
+    await _assertReplacement(
+      _Element.namedConstructor(isDeprecated: true, isOld: true),
+      _Element.defaultConstructor(),
+      isInvocation: true,
+    );
+  }
+
+  Future<void> test_namedConstructor_defaultConstructor_prefixed() async {
+    await _assertReplacement(
+      _Element.namedConstructor(isDeprecated: true, isOld: true),
+      _Element.defaultConstructor(),
+      isInvocation: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_namedConstructor_namedConstructor() async {
+    await _assertReplacement(
+      _Element.namedConstructor(isDeprecated: true, isOld: true),
+      _Element.namedConstructor(),
+      isInvocation: true,
+    );
+  }
+
+  Future<void> test_namedConstructor_namedConstructor_prefixed() async {
+    await _assertReplacement(
+      _Element.namedConstructor(isDeprecated: true, isOld: true),
+      _Element.namedConstructor(),
+      isInvocation: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticField_enumConstant() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.constant(),
+    );
+  }
+
+  Future<void> test_staticField_enumConstant_prefixed() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.constant(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticField_staticField() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.field(isStatic: true),
+    );
+  }
+
+  Future<void> test_staticField_staticField_prefixed() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.field(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticField_staticGetter() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.getter(isStatic: true),
+    );
+  }
+
+  Future<void> test_staticField_staticGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.getter(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticField_staticSetter() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.setter(isStatic: true),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_staticField_staticSetter_prefixed() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.setter(isStatic: true),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticField_topLevelGetter() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelGetter(),
+    );
+  }
+
+  Future<void> test_staticField_topLevelGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelGetter(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticField_topLevelSetter() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelSetter(),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_staticField_topLevelSetter_prefixed() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelSetter(),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticField_topLevelVariable() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelVariable(),
+    );
+  }
+
+  Future<void> test_staticField_topLevelVariable_prefixed() async {
+    await _assertReplacement(
+      _Element.field(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelVariable(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticGetter_enumConstant() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.constant(),
+    );
+  }
+
+  Future<void> test_staticGetter_enumConstant_prefixed() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.constant(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticGetter_staticField() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.field(isStatic: true),
+    );
+  }
+
+  Future<void> test_staticGetter_staticField_prefixed() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.field(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticGetter_staticGetter() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.getter(isStatic: true),
+    );
+  }
+
+  Future<void> test_staticGetter_staticGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.getter(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticGetter_topLevelGetter() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelGetter(),
+    );
+  }
+
+  Future<void> test_staticGetter_topLevelGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelGetter(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticGetter_topLevelVariable() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelVariable(),
+    );
+  }
+
+  Future<void> test_staticGetter_topLevelVariable_prefixed() async {
+    await _assertReplacement(
+      _Element.getter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelVariable(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticMethod_function_invocation() async {
+    await _assertReplacement(
+      _Element.method(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelFunction(),
+      isInvocation: true,
+    );
+  }
+
+  Future<void> test_staticMethod_function_invocation_prefixed() async {
+    await _assertReplacement(
+      _Element.method(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelFunction(),
+      isInvocation: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticMethod_function_tearoff() async {
+    await _assertReplacement(
+      _Element.method(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelFunction(),
+    );
+  }
+
+  Future<void> test_staticMethod_function_tearoff_prefixed() async {
+    await _assertReplacement(
+      _Element.method(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelFunction(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticMethod_staticMethod_invocation() async {
+    await _assertReplacement(
+      _Element.method(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.method(isStatic: true),
+      isInvocation: true,
+    );
+  }
+
+  Future<void> test_staticMethod_staticMethod_invocation_prefixed() async {
+    await _assertReplacement(
+      _Element.method(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.method(isStatic: true),
+      isInvocation: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticMethod_staticMethod_tearoff() async {
+    await _assertReplacement(
+      _Element.method(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.method(isStatic: true),
+    );
+  }
+
+  Future<void> test_staticMethod_staticMethod_tearoff_prefixed() async {
+    await _assertReplacement(
+      _Element.method(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.method(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticSetter_staticField() async {
+    await _assertReplacement(
+      _Element.setter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.field(isStatic: true),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_staticSetter_staticField_prefixed() async {
+    await _assertReplacement(
+      _Element.setter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.field(isStatic: true),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticSetter_staticSetter() async {
+    await _assertReplacement(
+      _Element.setter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.setter(isStatic: true),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_staticSetter_staticSetter_prefixed() async {
+    await _assertReplacement(
+      _Element.setter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.setter(isStatic: true),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticSetter_topLevelSetter() async {
+    await _assertReplacement(
+      _Element.setter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelSetter(),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_staticSetter_topLevelSetter_prefixed() async {
+    await _assertReplacement(
+      _Element.setter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelSetter(),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_staticSetter_topLevelVariable() async {
+    await _assertReplacement(
+      _Element.setter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelVariable(),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_staticSetter_topLevelVariable_prefixed() async {
+    await _assertReplacement(
+      _Element.setter(isDeprecated: true, isOld: true, isStatic: true),
+      _Element.topLevelVariable(),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelGetter_enumConstant() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.constant(),
+    );
+  }
+
+  Future<void> test_topLevelGetter_enumConstant_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.constant(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelGetter_staticField() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.field(isStatic: true),
+    );
+  }
+
+  Future<void> test_topLevelGetter_staticField_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.field(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelGetter_staticGetter() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.getter(isStatic: true),
+    );
+  }
+
+  Future<void> test_topLevelGetter_staticGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.getter(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelGetter_topLevelGetter() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.topLevelGetter(),
+    );
+  }
+
+  Future<void> test_topLevelGetter_topLevelGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.topLevelGetter(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelGetter_topLevelVariable() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.topLevelVariable(),
+    );
+  }
+
+  Future<void> test_topLevelGetter_topLevelVariable_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelGetter(isDeprecated: true, isOld: true),
+      _Element.topLevelVariable(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelSetter_staticField() async {
+    await _assertReplacement(
+      _Element.topLevelSetter(isDeprecated: true, isOld: true),
+      _Element.field(isStatic: true),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_topLevelSetter_staticField_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelSetter(isDeprecated: true, isOld: true),
+      _Element.field(isStatic: true),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelSetter_staticSetter() async {
+    await _assertReplacement(
+      _Element.topLevelSetter(isDeprecated: true, isOld: true),
+      _Element.setter(isStatic: true),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_topLevelSetter_staticSetter_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelSetter(isDeprecated: true, isOld: true),
+      _Element.setter(isStatic: true),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelSetter_topLevelSetter() async {
+    await _assertReplacement(
+      _Element.topLevelSetter(isDeprecated: true, isOld: true),
+      _Element.topLevelSetter(),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_topLevelSetter_topLevelSetter_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelSetter(isDeprecated: true, isOld: true),
+      _Element.topLevelSetter(),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelSetter_topLevelVariable() async {
+    await _assertReplacement(
+      _Element.topLevelSetter(isDeprecated: true, isOld: true),
+      _Element.topLevelVariable(),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_topLevelSetter_topLevelVariable_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelSetter(isDeprecated: true, isOld: true),
+      _Element.topLevelVariable(),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_enumConstant() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.constant(),
+    );
+  }
+
+  Future<void> test_topLevelVariable_enumConstant_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.constant(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_staticField() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.field(isStatic: true),
+    );
+  }
+
+  Future<void> test_topLevelVariable_staticField_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.field(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_staticGetter() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.getter(isStatic: true),
+    );
+  }
+
+  Future<void> test_topLevelVariable_staticGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.getter(isStatic: true),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_staticSetter() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.setter(isStatic: true),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_staticSetter_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.setter(isStatic: true),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_topLevelGetter() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.topLevelGetter(),
+    );
+  }
+
+  Future<void> test_topLevelVariable_topLevelGetter_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.topLevelGetter(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_topLevelSetter() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.topLevelSetter(),
+      isAssignment: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_topLevelSetter_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.topLevelSetter(),
+      isAssignment: true,
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> test_topLevelVariable_topLevelVariable() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.topLevelVariable(),
+    );
+  }
+
+  Future<void> test_topLevelVariable_topLevelVariable_prefixed() async {
+    await _assertReplacement(
+      _Element.topLevelVariable(isDeprecated: true, isOld: true),
+      _Element.topLevelVariable(),
+      isPrefixed: true,
+    );
+  }
+
+  Future<void> _assertReplacement(_Element oldElement, _Element newElement,
+      {bool isAssignment = false,
+      bool isInvocation = false,
+      bool isPrefixed = false}) async {
+    assert(!(isAssignment && isInvocation));
+    setPackageContent('''
+${oldElement.declaration}
+${newElement.declaration}
+''');
+    setPackageData(_replacedBy(oldElement.kind, oldElement.components,
+        newElement.kind, newElement.components));
+    var prefixDeclaration = isPrefixed ? ' as p' : '';
+    var prefixReference = isPrefixed ? 'p.' : '';
+    var invocation = isInvocation ? '()' : '';
+    if (isAssignment) {
+      await resolveTestCode('''
+import '$importUri'$prefixDeclaration;
+
+void g() {
+  $prefixReference${oldElement.reference} = 0;
+}
+''');
+      await assertHasFix('''
+import '$importUri'$prefixDeclaration;
+
+void g() {
+  $prefixReference${newElement.reference} = 0;
+}
+''');
+      return;
+    }
+    await resolveTestCode('''
+import '$importUri'$prefixDeclaration;
+
+var x = $prefixReference${oldElement.reference}$invocation;
+''');
+    await assertHasFix('''
+import '$importUri'$prefixDeclaration;
+
+var x = $prefixReference${newElement.reference}$invocation;
+''');
+  }
+
+  Transform _replacedBy(ElementKind oldKind, List<String> oldComponents,
+      ElementKind newKind, List<String> newComponents) {
+    var uris = [Uri.parse(importUri)];
+    var oldElement = ElementDescriptor(
+        libraryUris: uris, kind: oldKind, components: oldComponents);
+    var newElement2 = ElementDescriptor(
+        libraryUris: uris, kind: newKind, components: newComponents);
+    return Transform(
+        title: 'title',
+        date: DateTime.now(),
+        element: oldElement,
+        bulkApply: true,
+        changesSelector: UnconditionalChangesSelector([
+          ReplacedBy(newElement: newElement2),
+        ]));
+  }
+}
+
+class _Element {
+  final ElementKind kind;
+  final List<String> components;
+  final String declaration;
+
+  _Element(this.kind, this.components, this.declaration);
+
+  // ignore: unused_element
+  factory _Element.class_({bool isDeprecated = false, bool isOld = false}) {
+    var name = isOld ? 'C_old' : 'C_new';
+    var annotation = _annotation(isDeprecated: isDeprecated, isTopLevel: true);
+    return _Element(
+      ElementKind.classKind,
+      [name],
+      '''
+${annotation}class $name {}''',
+    );
+  }
+
+  factory _Element.constant({bool isDeprecated = false, bool isOld = false}) {
+    var enumName = isOld ? 'E_old' : 'E_new';
+    var constantName = isOld ? 'c_old' : 'c_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    return _Element(
+      ElementKind.constantKind,
+      [constantName, enumName],
+      '''
+enum $enumName {
+  $annotation$constantName
+}''',
+    );
+  }
+
+  factory _Element.defaultConstructor(
+      {bool isDeprecated = false, bool isOld = false}) {
+    var className = isOld ? 'C_old' : 'C_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    return _Element(
+      ElementKind.constructorKind,
+      ['', className],
+      '''
+class $className {
+  $annotation$className();
+}''',
+    );
+  }
+
+  // ignore: unused_element
+  factory _Element.enum_({bool isDeprecated = false, bool isOld = false}) {
+    var enumName = isOld ? 'E_old' : 'E_new';
+    var constantName = isOld ? 'c_old' : 'c_new';
+    var annotation = _annotation(isDeprecated: isDeprecated, isTopLevel: true);
+    return _Element(
+      ElementKind.enumKind,
+      [enumName],
+      '''
+${annotation}enum $enumName { $constantName }''',
+    );
+  }
+
+  factory _Element.field(
+      {bool isDeprecated = false, bool isOld = false, bool isStatic = false}) {
+    var fieldName = isOld ? 'sf_old' : 'sf_new';
+    var className = isOld ? 'C_old' : 'C_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    var keyword = isStatic ? 'static ' : '';
+    return _Element(
+      ElementKind.fieldKind,
+      [fieldName, className],
+      '''
+class $className {
+  $annotation${keyword}int $fieldName = 0;
+}''',
+    );
+  }
+
+  factory _Element.getter(
+      {bool isDeprecated = false, bool isOld = false, bool isStatic = false}) {
+    var getterName = isOld ? 'g_old' : 'g_new';
+    var className = isOld ? 'C_old' : 'C_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    var keyword = isStatic ? 'static ' : '';
+    return _Element(
+      ElementKind.getterKind,
+      [getterName, className],
+      '''
+class $className {
+  $annotation${keyword}int get $getterName => 0;
+}''',
+    );
+  }
+
+  factory _Element.method(
+      {bool isDeprecated = false, bool isOld = false, bool isStatic = false}) {
+    var methodName = isOld ? 'm_old' : 'm_new';
+    var className = isOld ? 'C_old' : 'C_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    var keyword = isStatic ? 'static ' : '';
+    return _Element(
+      ElementKind.methodKind,
+      [methodName, className],
+      '''
+class $className {
+  $annotation${keyword}int $methodName() => 0;
+}''',
+    );
+  }
+
+  factory _Element.namedConstructor(
+      {bool isDeprecated = false, bool isOld = false}) {
+    var constructorName = isOld ? 'c_old' : 'c_new';
+    var className = isOld ? 'C_old' : 'C_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    return _Element(
+      ElementKind.constructorKind,
+      [constructorName, className],
+      '''
+class $className {
+  $annotation$className.$constructorName();
+}''',
+    );
+  }
+
+  factory _Element.setter(
+      {bool isDeprecated = false, bool isOld = false, bool isStatic = false}) {
+    var setterName = isOld ? 's_old' : 's_new';
+    var className = isOld ? 'C_old' : 'C_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    var keyword = isStatic ? 'static ' : '';
+    return _Element(
+      ElementKind.setterKind,
+      [setterName, className],
+      '''
+class $className {
+  $annotation${keyword}set $setterName(int v) {}
+}''',
+    );
+  }
+
+  factory _Element.topLevelFunction(
+      {bool isDeprecated = false, bool isOld = false}) {
+    var name = isOld ? 'f_old' : 'f_new';
+    var annotation = _annotation(isDeprecated: isDeprecated, isTopLevel: true);
+    return _Element(
+      ElementKind.functionKind,
+      [name],
+      '''
+${annotation}int $name() => 0;''',
+    );
+  }
+
+  factory _Element.topLevelGetter(
+      {bool isDeprecated = false, bool isOld = false}) {
+    var getterName = isOld ? 'g_old' : 'g_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    return _Element(
+      ElementKind.getterKind,
+      [getterName],
+      '''
+${annotation}int get $getterName => 0;''',
+    );
+  }
+
+  factory _Element.topLevelSetter(
+      {bool isDeprecated = false, bool isOld = false}) {
+    var setterName = isOld ? 's_old' : 's_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    return _Element(
+      ElementKind.setterKind,
+      [setterName],
+      '''
+${annotation}set $setterName(int v) {}''',
+    );
+  }
+
+  factory _Element.topLevelVariable(
+      {bool isDeprecated = false, bool isOld = false}) {
+    var name = isOld ? 'v_old' : 'v_new';
+    var annotation = _annotation(isDeprecated: isDeprecated, isTopLevel: true);
+    return _Element(
+      ElementKind.variableKind,
+      [name],
+      '''
+${annotation}int $name = 0;''',
+    );
+  }
+
+  // ignore: unused_element
+  factory _Element.typedef({bool isDeprecated = false, bool isOld = false}) {
+    var name = isOld ? 'T_old' : 'T_new';
+    var annotation = _annotation(isDeprecated: isDeprecated);
+    return _Element(
+      ElementKind.typedefKind,
+      [name],
+      '''
+${annotation}typedef $name = int Function();''',
+    );
+  }
+
+  String get reference {
+    if (components[0].isEmpty) {
+      return components[1];
+    }
+    return components.reversed.join('.');
+  }
+
+  static String _annotation(
+      {required bool isDeprecated, bool isTopLevel = false}) {
+    var indent = isTopLevel ? '' : '  ';
+    return isDeprecated ? '@deprecated\n$indent' : '';
+  }
+}
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/test_all.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/test_all.dart
index 64cffa2..544f27c 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/test_all.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/test_all.dart
@@ -15,6 +15,7 @@
 import 'modify_parameters_test.dart' as modify_parameters;
 import 'rename_parameter_test.dart' as rename_parameter;
 import 'rename_test.dart' as rename;
+import 'replaced_by_test.dart' as replaced_by;
 import 'sdk_fix_test.dart' as sdk_fix;
 import 'transform_override_set_parser_test.dart'
     as transform_override_set_parser;
@@ -34,6 +35,7 @@
     modify_parameters.main();
     rename_parameter.main();
     rename.main();
+    replaced_by.main();
     sdk_fix.main();
     transform_override_set_parser.main();
     transform_set_manager.main();
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/transform_set_parser_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/transform_set_parser_test.dart
index 08c69d5..51421b4 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/transform_set_parser_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/transform_set_parser_test.dart
@@ -7,11 +7,13 @@
 import 'package:analysis_server/src/services/correction/fix/data_driven/change.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/changes_selector.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/code_template.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/element_kind.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/element_matcher.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/expression.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/modify_parameters.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/parameter_reference.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/rename.dart';
+import 'package:analysis_server/src/services/correction/fix/data_driven/replaced_by.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/transform.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/transform_set_error_code.dart';
 import 'package:analysis_server/src/services/correction/fix/data_driven/value_generator.dart';
@@ -673,6 +675,34 @@
     expect(rename.newName, 'B');
   }
 
+  void test_replacedBy() {
+    assertNoErrors('''
+version: 1
+transforms:
+- title: 'Replace'
+  date: 2021-11-30
+  element:
+    uris: ['test.dart']
+    function: 'f'
+  changes:
+    - kind: 'replacedBy'
+      newElement:
+        uris: ['test.dart']
+        method: 'm'
+        inClass: 'C'
+''');
+    var transforms = _transforms('f');
+    expect(transforms, hasLength(1));
+    var transform = transforms[0];
+    expect(transform.title, 'Replace');
+    var changes = _changes(transform);
+    expect(changes, hasLength(1));
+    var change = changes[0] as ReplacedBy;
+    var newElement = change.newElement;
+    expect(newElement.kind, ElementKind.methodKind);
+    expect(newElement.components, ['m', 'C']);
+  }
+
   void test_requiredIf() {
     assertNoErrors('''
 version: 1
diff --git a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
index 1f513c1..beabb03 100644
--- a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
@@ -335,7 +335,7 @@
   /// Compute [_constants] in all units.
   void _computeConstants() {
     computeConstants(_typeProvider, _typeSystem, _declaredVariables,
-        _constants.toList(), _analysisOptions.experimentStatus);
+        _constants.toList(), _libraryElement.featureSet);
   }
 
   void _computeHints(FileState file, CompilationUnit unit) {
diff --git a/pkg/analyzer/lib/src/dart/constant/compute.dart b/pkg/analyzer/lib/src/dart/constant/compute.dart
index 295c41c..cb56ffe 100644
--- a/pkg/analyzer/lib/src/dart/constant/compute.dart
+++ b/pkg/analyzer/lib/src/dart/constant/compute.dart
@@ -3,8 +3,8 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/analysis/declared_variables.dart';
+import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/element/type_provider.dart';
-import 'package:analyzer/src/dart/analysis/experiments.dart';
 import 'package:analyzer/src/dart/constant/evaluation.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
@@ -17,8 +17,8 @@
     TypeSystemImpl typeSystem,
     DeclaredVariables declaredVariables,
     List<ConstantEvaluationTarget> constants,
-    ExperimentStatus experimentStatus) {
-  var walker = _ConstantWalker(declaredVariables, experimentStatus);
+    FeatureSet featureSet) {
+  var walker = _ConstantWalker(declaredVariables, featureSet);
 
   for (var constant in constants) {
     var node = walker._getNode(constant);
@@ -47,10 +47,10 @@
 /// [graph.DependencyWalker] for computing constants and detecting cycles.
 class _ConstantWalker extends graph.DependencyWalker<_ConstantNode> {
   final DeclaredVariables declaredVariables;
-  final ExperimentStatus experimentStatus;
+  final FeatureSet featureSet;
   final Map<ConstantEvaluationTarget, _ConstantNode> nodeMap = {};
 
-  _ConstantWalker(this.declaredVariables, this.experimentStatus);
+  _ConstantWalker(this.declaredVariables, this.featureSet);
 
   @override
   void evaluate(_ConstantNode node) {
@@ -79,7 +79,7 @@
   ConstantEvaluationEngine _getEvaluationEngine(_ConstantNode node) {
     return ConstantEvaluationEngine(
       declaredVariables: declaredVariables,
-      isNonNullableByDefault: experimentStatus.non_nullable,
+      isNonNullableByDefault: featureSet.isEnabled(Feature.non_nullable),
     );
   }
 
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 4a949fb..d491590 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -34,8 +34,7 @@
     show Namespace, NamespaceBuilder;
 import 'package:analyzer/src/dart/resolver/variance.dart';
 import 'package:analyzer/src/generated/element_type_provider.dart';
-import 'package:analyzer/src/generated/engine.dart'
-    show AnalysisContext, AnalysisOptionsImpl;
+import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
@@ -1572,9 +1571,8 @@
   /// of formal parameters, are evaluated.
   void computeConstantDependencies() {
     if (!isConstantEvaluated) {
-      var analysisOptions = context.analysisOptions as AnalysisOptionsImpl;
       computeConstants(library.typeProvider, library.typeSystem,
-          context.declaredVariables, [this], analysisOptions.experimentStatus);
+          context.declaredVariables, [this], library.featureSet);
     }
   }
 }
@@ -1650,9 +1648,8 @@
   /// of this variable could not be computed because of errors.
   DartObject? computeConstantValue() {
     if (evaluationResult == null) {
-      var analysisOptions = context.analysisOptions as AnalysisOptionsImpl;
       computeConstants(library!.typeProvider, library!.typeSystem,
-          context.declaredVariables, [this], analysisOptions.experimentStatus);
+          context.declaredVariables, [this], library!.featureSet);
     }
     return evaluationResult?.value;
   }
@@ -1982,10 +1979,9 @@
   @override
   DartObject? computeConstantValue() {
     if (evaluationResult == null) {
-      var analysisOptions = context.analysisOptions as AnalysisOptionsImpl;
       var library = compilationUnit.library;
       computeConstants(library.typeProvider, library.typeSystem,
-          context.declaredVariables, [this], analysisOptions.experimentStatus);
+          context.declaredVariables, [this], library.featureSet);
     }
     return evaluationResult?.value;
   }
diff --git a/pkg/analyzer/lib/src/dart/micro/library_analyzer.dart b/pkg/analyzer/lib/src/dart/micro/library_analyzer.dart
index e904ee0..0b096be 100644
--- a/pkg/analyzer/lib/src/dart/micro/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/micro/library_analyzer.dart
@@ -197,7 +197,7 @@
   /// Compute [_constants] in all units.
   void _computeConstants() {
     computeConstants(_typeProvider, _typeSystem, _declaredVariables,
-        _constants.toList(), _analysisOptions.experimentStatus);
+        _constants.toList(), _libraryElement.featureSet);
   }
 
   void _computeDiagnostics({
diff --git a/pkg/analyzer/lib/src/lint/linter.dart b/pkg/analyzer/lib/src/lint/linter.dart
index 95f08a1..8b32896 100644
--- a/pkg/analyzer/lib/src/lint/linter.dart
+++ b/pkg/analyzer/lib/src/lint/linter.dart
@@ -16,7 +16,6 @@
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart' as file_system;
-import 'package:analyzer/src/dart/analysis/experiments.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/token.dart';
 import 'package:analyzer/src/dart/constant/compute.dart';
@@ -29,11 +28,7 @@
 import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart'
-    show
-        AnalysisErrorInfo,
-        AnalysisErrorInfoImpl,
-        AnalysisOptions,
-        AnalysisOptionsImpl;
+    show AnalysisErrorInfo, AnalysisErrorInfoImpl, AnalysisOptions;
 import 'package:analyzer/src/generated/resolver.dart' show ScopeResolverVisitor;
 import 'package:analyzer/src/generated/source.dart' show LineInfo;
 import 'package:analyzer/src/lint/analysis.dart';
@@ -384,7 +379,7 @@
       typeSystem,
       declaredVariables,
       dependencies,
-      libraryElement.featureSet as ExperimentStatus,
+      libraryElement.featureSet,
     );
 
     var visitor = ConstantVisitor(
@@ -492,7 +487,7 @@
       typeSystem,
       declaredVariables,
       dependenciesFinder.dependencies.toList(),
-      (analysisOptions as AnalysisOptionsImpl).experimentStatus,
+      libraryElement.featureSet,
     );
 
     var listener = _ConstantAnalysisErrorListener();
diff --git a/pkg/analyzer/lib/src/workspace/bazel.dart b/pkg/analyzer/lib/src/workspace/bazel.dart
index 13f0edb..e8f24d5 100644
--- a/pkg/analyzer/lib/src/workspace/bazel.dart
+++ b/pkg/analyzer/lib/src/workspace/bazel.dart
@@ -140,7 +140,7 @@
         String pathInLib = components.skip(4).join('/');
         return [packageName, pathInLib];
       } else {
-        for (int i = 2; i < components.length - 1; i++) {
+        for (int i = components.length - 2; i >= 2; i--) {
           String component = components[i];
           if (component == 'lib') {
             String packageName = components.getRange(0, i).join('.');
diff --git a/pkg/analyzer/test/src/dart/analysis/index_test.dart b/pkg/analyzer/test/src/dart/analysis/index_test.dart
index cecd83d..29798f2 100644
--- a/pkg/analyzer/test/src/dart/analysis/index_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/index_test.dart
@@ -1155,6 +1155,18 @@
     assertThat(element)..isReferencedAt('test: 0', true);
   }
 
+  test_isReferencedBy_ParameterElement_optionalNamed_ofTopFunction_anywhere() async {
+    await _indexTestUnit('''
+void foo(int a, int b, {int? test}) {}
+
+void() {
+  foo(1, test: 0, 2);
+}
+''');
+    Element element = findElement.parameter('test');
+    assertThat(element)..isReferencedAt('test: 0', true);
+  }
+
   test_isReferencedBy_ParameterElement_optionalPositional() async {
     await _indexTestUnit('''
 foo([p]) {
diff --git a/pkg/analyzer/test/src/dart/analysis/search_test.dart b/pkg/analyzer/test/src/dart/analysis/search_test.dart
index 2140a33..612ac02 100644
--- a/pkg/analyzer/test/src/dart/analysis/search_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/search_test.dart
@@ -1417,6 +1417,25 @@
     await _verifyReferences(element, expected);
   }
 
+  test_searchReferences_ParameterElement_optionalNamed_anywhere() async {
+    await resolveTestCode('''
+foo(int a, int b, {p}) {
+  p;
+}
+main() {
+  foo(0, p: 1, 2);
+}
+''');
+    var element = findElement.parameter('p');
+    var foo = findElement.function('foo');
+    var main = findElement.function('main');
+    var expected = [
+      _expectId(foo, SearchResultKind.READ, 'p;'),
+      _expectIdQ(main, SearchResultKind.REFERENCE, 'p: 1')
+    ];
+    await _verifyReferences(element, expected);
+  }
+
   test_searchReferences_ParameterElement_optionalPositional() async {
     await resolveTestCode('''
 foo([p]) {
diff --git a/pkg/analyzer/test/src/dart/constant/evaluation_test.dart b/pkg/analyzer/test/src/dart/constant/evaluation_test.dart
index 652108c..09360c4 100644
--- a/pkg/analyzer/test/src/dart/constant/evaluation_test.dart
+++ b/pkg/analyzer/test/src/dart/constant/evaluation_test.dart
@@ -1524,11 +1524,7 @@
       'c',
       errorCodes: [CompileTimeErrorCode.INVALID_CONSTANT],
     );
-    if (analysisOptions.experimentStatus.constant_update_2018) {
-      expect(result.toIntValue(), 1);
-    } else {
-      expect(result, isNull);
-    }
+    expect(result.toIntValue(), 1);
   }
 
   test_visitConditionalExpression_eager_true_invalid_int() async {
diff --git a/pkg/analyzer/test/src/diagnostics/const_eval_type_bool_num_string_test.dart b/pkg/analyzer/test/src/diagnostics/const_eval_type_bool_num_string_test.dart
index 8acf4e9..b4bcb41 100644
--- a/pkg/analyzer/test/src/diagnostics/const_eval_type_bool_num_string_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/const_eval_type_bool_num_string_test.dart
@@ -2,7 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'package:analyzer/src/dart/analysis/experiments.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -17,21 +16,14 @@
 @reflectiveTest
 class ConstEvalTypeBoolNumStringTest extends PubPackageResolutionTest {
   test_equal() async {
-    await assertErrorsInCode(
-        r'''
+    await assertNoErrorsInCode(r'''
 class A {
   const A();
 }
 
 const num a = 0;
 const b = a == const A();
-''',
-        IsEnabledByDefault.constant_update_2018
-            ? []
-            : [
-                error(CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING, 53,
-                    14),
-              ]);
+''');
   }
 
   test_notEqual() async {
diff --git a/pkg/analyzer/test/src/workspace/bazel_test.dart b/pkg/analyzer/test/src/workspace/bazel_test.dart
index 0177638..bdfa730 100644
--- a/pkg/analyzer/test/src/workspace/bazel_test.dart
+++ b/pkg/analyzer/test/src/workspace/bazel_test.dart
@@ -545,6 +545,15 @@
         'package:third_party.something/foo.dart');
   }
 
+  void test_restoreAbsolute_workspace_nestedLib() {
+    _addResources([
+      '/workspace/WORKSPACE',
+      '/workspace/my/components/lib/src/foo/lib/foo.dart',
+    ]);
+    _assertRestore('/workspace/my/components/lib/src/foo/lib/foo.dart',
+        'package:my.components.lib.src.foo/foo.dart');
+  }
+
   void _addResources(List<String> paths,
       {String workspacePath = '/workspace'}) {
     for (String path in paths) {
diff --git a/runtime/vm/BUILD.gn b/runtime/vm/BUILD.gn
index 69dfc4b..1b03265 100644
--- a/runtime/vm/BUILD.gn
+++ b/runtime/vm/BUILD.gn
@@ -56,6 +56,9 @@
     if (!is_android) {
       libs += [ "pthread" ]
     }
+    if (!is_mac) {
+      libs += [ "atomic" ]
+    }
   }
 }
 
diff --git a/tools/VERSION b/tools/VERSION
index aaeea35..02dcfb9 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 16
 PATCH 0
-PRERELEASE 73
+PRERELEASE 74
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/bots/flutter/analyze_flutter_flutter.sh b/tools/bots/flutter/analyze_flutter_flutter.sh
index d040021..cd50561 100755
--- a/tools/bots/flutter/analyze_flutter_flutter.sh
+++ b/tools/bots/flutter/analyze_flutter_flutter.sh
@@ -36,9 +36,7 @@
 $dart --enable-asserts dev/bots/analyze.dart --dart-sdk $sdk
 
 # Test flutter's use of data-driven fixes.
-pushd packages/flutter/test_fixes
-../../../bin/dart fix --compare-to-golden
-popd
+$dart fix packages/flutter/test_fixes --compare-to-golden
 
 # Analyze the sample code in dartdoc snippets.
-./bin/dart dev/bots/analyze_sample_code.dart
+$dart dev/bots/analyze_sample_code.dart