diff --git a/CHANGELOG.md b/CHANGELOG.md
index 225f1ca..3be94d5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,13 @@
 
 - Add `Finalizer` and `WeakReference` which can potentially detect when
   objects are "garbage collected".
+- Add `isMimeType` method to `UriData` class, to allow case-insensitive
+  checking of the MIME type.
+- Add `isCharset` and `isEncoding` methods to `UriData` class,
+  to allow case-insensitive and alternative-encoding-name aware checking
+  of the MIME type "charset" parameter.
+- Make `UriData.fromString` and `UriData.fromBytes` recognize and omit
+  a "text/plain" `mimeType` even if it is not all lower-case.
 
 #### `dart:ffi`
 
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/enum_from_lib_used_as_type.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/enum_from_lib_used_as_type.dart.expect
index 2f5ecea..bdf5f22 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/enum_from_lib_used_as_type.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/enum_from_lib_used_as_type.dart.expect
@@ -22,6 +22,6 @@
   synthetic constructor •() → self::Class
     : super core::Object::•()
     ;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3331,getterSelectorId:3332]  method method([@vm.inferred-type.metadata=dart.core::Null? (value: null)] self::Enum e) → core::int
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3333,getterSelectorId:3334]  method method([@vm.inferred-type.metadata=dart.core::Null? (value: null)] self::Enum e) → core::int
     return [@vm.inferred-type.metadata=!] e.{core::_Enum::index}{core::int};
 }
diff --git a/pkg/vm/testcases/transformations/type_flow/transformer/tree_shake_enum_from_lib.dart.expect b/pkg/vm/testcases/transformations/type_flow/transformer/tree_shake_enum_from_lib.dart.expect
index 512caf3..0a305ef 100644
--- a/pkg/vm/testcases/transformations/type_flow/transformer/tree_shake_enum_from_lib.dart.expect
+++ b/pkg/vm/testcases/transformations/type_flow/transformer/tree_shake_enum_from_lib.dart.expect
@@ -51,6 +51,6 @@
   synthetic constructor •() → self::ConstClass
     : super core::Object::•()
     ;
-[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3335,getterSelectorId:3336]  method method([@vm.inferred-type.metadata=dart.core::Null? (value: null)] self::ConstEnum e) → core::int
+[@vm.procedure-attributes.metadata=methodOrSetterCalledDynamically:false,getterCalledDynamically:false,hasThisUses:false,hasTearOffUses:false,methodOrSetterSelectorId:3337,getterSelectorId:3338]  method method([@vm.inferred-type.metadata=dart.core::Null? (value: null)] self::ConstEnum e) → core::int
     return [@vm.inferred-type.metadata=!] e.{core::_Enum::index}{core::int};
 }
diff --git a/sdk/lib/core/uri.dart b/sdk/lib/core/uri.dart
index d8ee831..f74f55e 100644
--- a/sdk/lib/core/uri.dart
+++ b/sdk/lib/core/uri.dart
@@ -1715,38 +1715,7 @@
     String thisScheme = this.scheme;
     if (scheme == null) return thisScheme.isEmpty;
     if (scheme.length != thisScheme.length) return false;
-    return _compareScheme(scheme, thisScheme);
-  }
-
-  /// Compares scheme characters in [scheme] and at the start of [uri].
-  ///
-  /// Returns `true` if [scheme] represents the same scheme as the start of
-  /// [uri]. That means having the same characters, but possibly different case
-  /// for letters.
-  ///
-  /// This function doesn't check that the characters are valid URI scheme
-  /// characters. The [uri] is assumed to be valid, so if [scheme] matches
-  /// it, it has to be valid too.
-  ///
-  /// The length should be tested before calling this function,
-  /// so the scheme part of [uri] is known to have the same length as [scheme].
-  static bool _compareScheme(String scheme, String uri) {
-    for (int i = 0; i < scheme.length; i++) {
-      int schemeChar = scheme.codeUnitAt(i);
-      int uriChar = uri.codeUnitAt(i);
-      int delta = schemeChar ^ uriChar;
-      if (delta != 0) {
-        if (delta == 0x20) {
-          // Might be a case difference.
-          int lowerChar = uriChar | delta;
-          if (0x61 /*a*/ <= lowerChar && lowerChar <= 0x7a /*z*/) {
-            continue;
-          }
-        }
-        return false;
-      }
-    }
-    return true;
+    return _caseInsensitiveStartsWith(scheme, thisScheme, 0);
   }
 
   /// Report a parse failure.
@@ -3481,7 +3450,7 @@
       Map<String, String>? parameters,
       StringBuffer buffer,
       List<int>? indices) {
-    if (mimeType == null || mimeType == "text/plain") {
+    if (mimeType == null || _caseInsensitiveEquals("text/plain", mimeType)) {
       mimeType = "";
     }
 
@@ -3499,11 +3468,9 @@
           _tokenCharTable, mimeType.substring(slashIndex + 1), utf8, false));
     }
     if (charsetName != null) {
-      // TODO(39209): Use ?.. when sequences are properly supported.
-      if (indices != null)
-        indices
-          ..add(buffer.length)
-          ..add(buffer.length + 8);
+      indices
+        ?..add(buffer.length)
+        ..add(buffer.length + 8);
       buffer.write(";charset=");
       buffer.write(_Uri._uriEncode(_tokenCharTable, charsetName, utf8, false));
     }
@@ -3637,6 +3604,27 @@
     return _Uri._uriDecode(_text, start, end, utf8, false);
   }
 
+  /// Whether the [UriData.mimeType] is equal to [mimeType].
+  ///
+  /// Compares the `data:` URI's MIME type to [mimeType] with a case-
+  /// insensitive comparison which ignores the case of ASCII letters.
+  ///
+  /// An empty [mimeType] is considered equivalent to `text/plain`,
+  /// both in the [mimeType] argument and in the `data:` URI itself.
+  @Since("2.17")
+  bool isMimeType(String mimeType) {
+    int start = _separatorIndices[0] + 1;
+    int end = _separatorIndices[1];
+    if (start == end) {
+      return mimeType.isEmpty ||
+          identical(mimeType, "text/plain") ||
+          _caseInsensitiveEquals(mimeType, "text/plain");
+    }
+    if (mimeType.isEmpty) mimeType = "text/plain";
+    return (mimeType.length == end - start) &&
+        _caseInsensitiveStartsWith(mimeType, _text, start);
+  }
+
   /// The charset parameter of the media type.
   ///
   /// If the parameters of the media type contains a `charset` parameter
@@ -3647,23 +3635,89 @@
   /// If the MIME type representation in the URI text contains URI escapes,
   /// they are unescaped in the returned string.
   String get charset {
-    int parameterStart = 1;
-    int parameterEnd = _separatorIndices.length - 1; // The ',' before data.
-    if (isBase64) {
-      // There is a ";base64" separator, so subtract one for that as well.
-      parameterEnd -= 1;
-    }
-    for (int i = parameterStart; i < parameterEnd; i += 2) {
-      var keyStart = _separatorIndices[i] + 1;
-      var keyEnd = _separatorIndices[i + 1];
-      if (keyEnd == keyStart + 7 && _text.startsWith("charset", keyStart)) {
-        return _Uri._uriDecode(
-            _text, keyEnd + 1, _separatorIndices[i + 2], utf8, false);
-      }
+    var charsetIndex = _findCharsetIndex();
+    if (charsetIndex >= 0) {
+      var valueStart = _separatorIndices[charsetIndex + 1] + 1;
+      var valueEnd = _separatorIndices[charsetIndex + 2];
+      return _Uri._uriDecode(_text, valueStart, valueEnd, utf8, false);
     }
     return "US-ASCII";
   }
 
+  /// Finds the index of the separator before the "charset" parameter.
+  ///
+  /// Returns the index in [_separatorIndices] of the separator before
+  /// the name of the "charset" parameter, or -1 if there is no "charset"
+  /// parameter.
+  int _findCharsetIndex() {
+    var separatorIndices = _separatorIndices;
+    // Loop over all MIME-type parameters.
+    // Check that the parameter can have two parts (key/value)
+    // to ignore a trailing base-64 marker.
+    for (int i = 3; i <= separatorIndices.length; i += 2) {
+      var keyStart = separatorIndices[i - 2] + 1;
+      var keyEnd = separatorIndices[i - 1];
+      if (keyEnd == keyStart + "charset".length &&
+          _caseInsensitiveStartsWith("charset", _text, keyStart)) {
+        return i - 2;
+      }
+    }
+    return -1;
+  }
+
+  /// Checks whether the charset parameter of the mime type is [charset].
+  ///
+  /// If this URI has no "charset" parameter, it is assumed to have a default
+  /// of `charset=US-ASCII`.
+  /// If [charset] is empty, it's treated like `"US-ASCII"`.
+  ///
+  /// Returns true if [charset] and the "charset" parameter value are
+  /// equal strings, ignoring the case of ASCII letters, or both
+  /// correspond to the same [Encoding], as given by [Encoding.getByName].
+  @Since("2.17")
+  bool isCharset(String charset) {
+    var charsetIndex = _findCharsetIndex();
+    if (charsetIndex < 0) {
+      return charset.isEmpty ||
+          _caseInsensitiveEquals(charset, "US-ASCII") ||
+          identical(Encoding.getByName(charset), ascii);
+    }
+    if (charset.isEmpty) charset = "US-ASCII";
+    var valueStart = _separatorIndices[charsetIndex + 1] + 1;
+    var valueEnd = _separatorIndices[charsetIndex + 2];
+    var length = valueEnd - valueStart;
+    if (charset.length == length &&
+        _caseInsensitiveStartsWith(charset, _text, valueStart)) {
+      return true;
+    }
+    var checkedEncoding = Encoding.getByName(charset);
+    return checkedEncoding != null &&
+        identical(
+            checkedEncoding,
+            Encoding.getByName(
+                _Uri._uriDecode(_text, valueStart, valueEnd, utf8, false)));
+  }
+
+  /// Whether the charset parameter represents [encoding].
+  ///
+  /// If the "charset" parameter is not present in the URI,
+  /// it defaults to "US-ASCII", which is the [ascii] encoding.
+  /// If present, it's converted to an [Encoding] using [Encoding.getByName],
+  /// and compared to [encoding].
+  @Since("2.17")
+  bool isEncoding(Encoding encoding) {
+    var charsetIndex = _findCharsetIndex();
+    if (charsetIndex < 0) {
+      return identical(encoding, ascii);
+    }
+    var valueStart = _separatorIndices[charsetIndex + 1] + 1;
+    var valueEnd = _separatorIndices[charsetIndex + 2];
+    return identical(
+        encoding,
+        Encoding.getByName(
+            _Uri._uriDecode(_text, valueStart, valueEnd, utf8, false)));
+  }
+
   /// Whether the data is Base64 encoded or not.
   bool get isBase64 => _separatorIndices.length.isOdd;
 
@@ -4358,7 +4412,7 @@
   bool isScheme(String scheme) {
     if (scheme == null || scheme.isEmpty) return _schemeEnd < 0;
     if (scheme.length != _schemeEnd) return false;
-    return _Uri._compareScheme(scheme, _uri);
+    return _caseInsensitiveStartsWith(scheme, _uri, 0);
   }
 
   String get scheme {
@@ -4857,3 +4911,58 @@
   }
   return -1;
 }
+
+/// Whether [string] at [start] starts with  [prefix], ignoring case.
+///
+/// Returns whether [string] at offset [start]
+/// starts with the characters of [prefix],
+/// but ignores differences in the cases of ASCII letters,
+/// so `a` and `A` are considered equal.
+///
+/// The [string] must be at least as long as [prefix].
+///
+/// When used to checks the schemes of URIs,
+/// this function doesn't check that the characters are valid URI scheme
+/// characters. The [string] is assumed to be a valid URI,
+/// so if [prefix] matches it, it has to be valid too.
+bool _caseInsensitiveStartsWith(String prefix, String string, int start) =>
+    _caseInsensitiveCompareStart(prefix, string, start) >= 0;
+
+/// Compares [string] at [start] with [prefix], ignoring case.
+///
+/// Returns 0 if [string] starts with [prefix] at offset [start].
+/// Returns 0x20 if [string] starts with [prefix] at offset [start],
+/// but some ASCII letters have different case.
+/// Returns a negative value if [string] does not start with [prefix],
+/// at offset [start] even ignoring case differences.
+///
+/// The [string] must be at least as long as `start + prefix.length`.
+int _caseInsensitiveCompareStart(String prefix, String string, int start) {
+  int result = 0;
+  for (int i = 0; i < prefix.length; i++) {
+    int prefixChar = prefix.codeUnitAt(i);
+    int stringChar = string.codeUnitAt(start + i);
+    int delta = prefixChar ^ stringChar;
+    if (delta != 0) {
+      if (delta == 0x20) {
+        // Might be a case difference.
+        int lowerChar = stringChar | delta;
+        if (0x61 /*a*/ <= lowerChar && lowerChar <= 0x7a /*z*/) {
+          result = 0x20;
+          continue;
+        }
+      }
+      return -1;
+    }
+  }
+  return result;
+}
+
+/// Checks whether two strings are equal ignoring case differences.
+///
+/// Returns whether if [string1] and [string2] has the same length
+/// and same characters, but ignores the cases of ASCII letters,
+/// so `a` and `A` are considered equal.
+bool _caseInsensitiveEquals(String string1, String string2) =>
+    string1.length == string2.length &&
+    _caseInsensitiveStartsWith(string1, string2, 0);
diff --git a/tests/corelib/data_uri_test.dart b/tests/corelib/data_uri_test.dart
index 09ff01b..e8636f3 100644
--- a/tests/corelib/data_uri_test.dart
+++ b/tests/corelib/data_uri_test.dart
@@ -34,20 +34,61 @@
 }
 
 void testMediaType() {
-  for (var mimeType in ["", "text/plain", "text/javascript"]) {
-    for (var charset in ["", ";charset=US-ASCII", ";charset=UTF-8"]) {
+  for (var mimeType in ["", "text/plain", "Text/PLAIN", "text/javascript"]) {
+    for (var charset in ["", "US-ASCII", "UTF-8"]) {
       for (var base64 in ["", ";base64"]) {
         bool isBase64 = base64.isNotEmpty;
-        var text = "data:$mimeType$charset$base64,";
+        // Parsing the URI from source:
+        var charsetParameter = charset.isEmpty ? "" : ";charset=$charset";
+        var text = "data:$mimeType$charsetParameter$base64,";
         var uri = UriData.parse(text);
 
-        String expectedCharset =
-            charset.isEmpty ? "US-ASCII" : charset.substring(9);
+        String expectedCharset = charset.isEmpty ? "US-ASCII" : charset;
         String expectedMimeType = mimeType.isEmpty ? "text/plain" : mimeType;
 
         Expect.equals(text, "$uri");
         Expect.equals(expectedMimeType, uri.mimeType);
+        Expect.isTrue(uri.isMimeType(expectedMimeType));
+        Expect.isTrue(uri.isMimeType(expectedMimeType.toUpperCase()));
+        Expect.isTrue(uri.isMimeType(expectedMimeType.toLowerCase()));
         Expect.equals(expectedCharset, uri.charset);
+        Expect.isTrue(uri.isCharset(expectedCharset));
+        Expect.isTrue(uri.isCharset(expectedCharset.toLowerCase()));
+        Expect.isTrue(uri.isCharset(expectedCharset.toUpperCase()));
+        var expectedEncoding = Encoding.getByName(expectedCharset);
+        if (expectedEncoding != null) {
+          Expect.isTrue(uri.isEncoding(expectedEncoding));
+        }
+        Expect.equals(isBase64, uri.isBase64);
+
+        // Creating the URI using a constructor:
+        var encoding = Encoding.getByName(charset);
+        uri = UriData.fromString("",
+            mimeType: mimeType, encoding: encoding, base64: isBase64);
+        expectedMimeType =
+            (mimeType.isEmpty || mimeType.toLowerCase() == "text/plain")
+                ? "text/plain"
+                : mimeType;
+        expectedEncoding = encoding;
+        expectedCharset = expectedEncoding?.name ?? "US-ASCII";
+        var expectedText = "data:"
+            "${expectedMimeType == "text/plain" ? "" : expectedMimeType}"
+            "${charset.isEmpty ? "" : ";charset=$expectedCharset"}"
+            "${isBase64 ? ";base64" : ""}"
+            ",";
+
+        Expect.equals(expectedText, "$uri");
+        Expect.equals(expectedMimeType, uri.mimeType);
+        Expect.isTrue(uri.isMimeType(expectedMimeType));
+        Expect.isTrue(uri.isMimeType(expectedMimeType.toUpperCase()));
+        Expect.isTrue(uri.isMimeType(expectedMimeType.toLowerCase()));
+        Expect.equals(expectedCharset, uri.charset);
+        Expect.isTrue(uri.isCharset(expectedCharset));
+        Expect.isTrue(uri.isCharset(expectedCharset.toLowerCase()));
+        Expect.isTrue(uri.isCharset(expectedCharset.toUpperCase()));
+        if (expectedEncoding != null) {
+          Expect.isTrue(uri.isEncoding(expectedEncoding));
+        }
         Expect.equals(isBase64, uri.isBase64);
       }
     }
@@ -236,8 +277,8 @@
   Expect.throwsFormatException(() => UriData.parse("data:type/sub;k=v;base64"));
 
   void formatError(String input) {
-    Expect.throwsFormatException(() => UriData.parse("data:;base64,$input"),
-        input);
+    Expect.throwsFormatException(
+        () => UriData.parse("data:;base64,$input"), input);
   }
 
   // Invalid base64 format (detected when parsed).
diff --git a/tests/corelib_2/data_uri_test.dart b/tests/corelib_2/data_uri_test.dart
index 4e194c1..ddff614 100644
--- a/tests/corelib_2/data_uri_test.dart
+++ b/tests/corelib_2/data_uri_test.dart
@@ -36,20 +36,61 @@
 }
 
 void testMediaType() {
-  for (var mimeType in ["", "text/plain", "text/javascript"]) {
-    for (var charset in ["", ";charset=US-ASCII", ";charset=UTF-8"]) {
+  for (var mimeType in ["", "text/plain", "Text/PLAIN", "text/javascript"]) {
+    for (var charset in ["", "US-ASCII", "UTF-8"]) {
       for (var base64 in ["", ";base64"]) {
         bool isBase64 = base64.isNotEmpty;
-        var text = "data:$mimeType$charset$base64,";
+        // Parsing the URI from source:
+        var charsetParameter = charset.isEmpty ? "" : ";charset=$charset";
+        var text = "data:$mimeType$charsetParameter$base64,";
         var uri = UriData.parse(text);
 
-        String expectedCharset =
-            charset.isEmpty ? "US-ASCII" : charset.substring(9);
+        String expectedCharset = charset.isEmpty ? "US-ASCII" : charset;
         String expectedMimeType = mimeType.isEmpty ? "text/plain" : mimeType;
 
         Expect.equals(text, "$uri");
         Expect.equals(expectedMimeType, uri.mimeType);
+        Expect.isTrue(uri.isMimeType(expectedMimeType));
+        Expect.isTrue(uri.isMimeType(expectedMimeType.toUpperCase()));
+        Expect.isTrue(uri.isMimeType(expectedMimeType.toLowerCase()));
         Expect.equals(expectedCharset, uri.charset);
+        Expect.isTrue(uri.isCharset(expectedCharset));
+        Expect.isTrue(uri.isCharset(expectedCharset.toLowerCase()));
+        Expect.isTrue(uri.isCharset(expectedCharset.toUpperCase()));
+        var expectedEncoding = Encoding.getByName(expectedCharset);
+        if (expectedEncoding != null) {
+          Expect.isTrue(uri.isEncoding(expectedEncoding));
+        }
+        Expect.equals(isBase64, uri.isBase64);
+
+        // Creating the URI using a constructor:
+        var encoding = Encoding.getByName(charset);
+        uri = UriData.fromString("",
+            mimeType: mimeType, encoding: encoding, base64: isBase64);
+        expectedMimeType =
+            (mimeType.isEmpty || mimeType.toLowerCase() == "text/plain")
+                ? "text/plain"
+                : mimeType;
+        expectedEncoding = encoding;
+        expectedCharset = expectedEncoding?.name ?? "US-ASCII";
+        var expectedText = "data:"
+            "${expectedMimeType == "text/plain" ? "" : expectedMimeType}"
+            "${charset.isEmpty ? "" : ";charset=$expectedCharset"}"
+            "${isBase64 ? ";base64" : ""}"
+            ",";
+
+        Expect.equals(expectedText, "$uri");
+        Expect.equals(expectedMimeType, uri.mimeType);
+        Expect.isTrue(uri.isMimeType(expectedMimeType));
+        Expect.isTrue(uri.isMimeType(expectedMimeType.toUpperCase()));
+        Expect.isTrue(uri.isMimeType(expectedMimeType.toLowerCase()));
+        Expect.equals(expectedCharset, uri.charset);
+        Expect.isTrue(uri.isCharset(expectedCharset));
+        Expect.isTrue(uri.isCharset(expectedCharset.toLowerCase()));
+        Expect.isTrue(uri.isCharset(expectedCharset.toUpperCase()));
+        if (expectedEncoding != null) {
+          Expect.isTrue(uri.isEncoding(expectedEncoding));
+        }
         Expect.equals(isBase64, uri.isBase64);
       }
     }
@@ -238,8 +279,8 @@
   Expect.throwsFormatException(() => UriData.parse("data:type/sub;k=v;base64"));
 
   void formatError(String input) {
-    Expect.throwsFormatException(() => UriData.parse("data:;base64,$input"),
-        input);
+    Expect.throwsFormatException(
+        () => UriData.parse("data:;base64,$input"), input);
   }
 
   // Invalid base64 format (detected when parsed).
diff --git a/tests/language/call/implicit_tearoff_local_assignment_test.dart b/tests/language/call/implicit_tearoff_local_assignment_test.dart
new file mode 100644
index 0000000..0f77761
--- /dev/null
+++ b/tests/language/call/implicit_tearoff_local_assignment_test.dart
@@ -0,0 +1,123 @@
+// Copyright (c) 2022, 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.
+
+// This test verifies that when considering whether to perform a `.call` tearoff
+// on the RHS of an assignment, the implementations use the unpromoted type of
+// the variable (rather than the promoted type).
+
+// NOTICE: This test checks the currently implemented behavior, even though the
+// implemented behavior does not match the language specification.  Until an
+// official decision has been made about whether to change the implementation to
+// match the specification, or vice versa, this regression test is intended to
+// protect against inadvertent implementation changes.
+
+import "package:expect/expect.dart";
+
+import '../static_type_helper.dart';
+
+class B {
+  Object call() => 'B.call called';
+}
+
+class C extends B {
+  String call() => 'C.call called';
+}
+
+void testClassPromoted() {
+  B x = C();
+  x as C;
+  x.expectStaticType<Exactly<C>>();
+  var y = x = C(); // No implicit tearoff of `.call`, no demotion
+  x.expectStaticType<Exactly<C>>();
+  Expect.type<C>(x);
+  Expect.equals('C.call called', x());
+  y.expectStaticType<Exactly<C>>();
+  Expect.type<C>(y);
+  Expect.equals('C.call called', y());
+}
+
+void testClassUnpromoted() {
+  B x = B();
+  var y = x = C(); // No implicit tearoff of `.call`, no promotion
+  x.expectStaticType<Exactly<B>>();
+  Expect.type<C>(x);
+  Expect.equals('C.call called', x());
+  y.expectStaticType<Exactly<C>>();
+  Expect.type<C>(y);
+  Expect.equals('C.call called', y());
+}
+
+void testFunctionPromoted() {
+  String f() => 'f called';
+  Object Function() x = f;
+  x as String Function();
+  x.expectStaticType<Exactly<String Function()>>();
+  var y = x = C(); // Implicit tearoff of `.call`, no demotion
+  x.expectStaticType<Exactly<String Function()>>();
+  Expect.type<String Function()>(x);
+  Expect.equals('C.call called', x());
+  y.expectStaticType<Exactly<String Function()>>();
+  Expect.type<String Function()>(y);
+  Expect.equals('C.call called', y());
+}
+
+void testFunctionUnpromoted() {
+  Object f() => 'f called';
+  Object Function() x = f;
+  var y = x = B(); // Implicit tearoff of `.call`, no promotion
+  x.expectStaticType<Exactly<Object Function()>>();
+  Expect.type<Object Function()>(x);
+  Expect.equals('B.call called', x());
+  y.expectStaticType<Exactly<Object Function()>>();
+  Expect.type<Object Function()>(y);
+  Expect.equals('B.call called', y());
+}
+
+void testObjectPromotedToClass() {
+  Object x = B();
+  x as B;
+  x.expectStaticType<Exactly<B>>();
+  var y = x = C(); // No implicit tearoff of `.call`, x remains promoted
+  x.expectStaticType<Exactly<B>>();
+  Expect.type<C>(x);
+  Expect.equals('C.call called', x());
+  y.expectStaticType<Exactly<C>>();
+  Expect.type<C>(y);
+  Expect.equals('C.call called', y());
+}
+
+void testObjectPromotedToFunction() {
+  Object f() => 'f called';
+  Object x = f;
+  x as Object Function();
+  x.expectStaticType<Exactly<Object Function()>>();
+  var y = x = B(); // No implicit tearoff of `.call`, demotes x
+  x.expectStaticType<Exactly<Object>>();
+  Expect.type<B>(x);
+  Expect.equals('B.call called', (x as B)());
+  y.expectStaticType<Exactly<B>>();
+  Expect.type<B>(y);
+  Expect.equals('B.call called', y());
+}
+
+void testObjectUnpromoted() {
+  Object x = 'initial value';
+  var y = x = B(); // No implicit tearoff of `.call`, no promotion
+  x.expectStaticType<Exactly<Object>>();
+  Expect.type<B>(x);
+  Expect.equals('B.call called', (x as B)());
+  y.expectStaticType<Exactly<B>>();
+  Expect.type<B>(y);
+  Expect.equals('B.call called', y());
+}
+
+main() {
+  testClassPromoted();
+  testClassUnpromoted();
+  testFunctionPromoted();
+  testFunctionUnpromoted();
+  testObjectPromotedToClass();
+  testObjectPromotedToFunction();
+  testObjectUnpromoted();
+}
diff --git a/tests/language_2/call/implicit_tearoff_local_assignment_test.dart b/tests/language_2/call/implicit_tearoff_local_assignment_test.dart
new file mode 100644
index 0000000..210ace0
--- /dev/null
+++ b/tests/language_2/call/implicit_tearoff_local_assignment_test.dart
@@ -0,0 +1,65 @@
+// Copyright (c) 2022, 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.
+
+// This test is the pre-null-safety variant of the null safety test
+// `implicit_tearoff_local_assignment_test.dart`, which verifies that when
+// considering whether to perform a `.call` tearoff on the RHS of an assignment,
+// the implementations use the unpromoted type of the variable (rather than the
+// promoted type).  For the pre-null-safety variant, the same logic doesn't
+// really apply, because a variable can't be promoted in a block that contains
+// an assignment to it.  But we can still test the unpromoted cases.
+
+// @dart = 2.9
+
+import "package:expect/expect.dart";
+
+import '../static_type_helper.dart';
+
+class B {
+  Object call() => 'B.call called';
+}
+
+class C extends B {
+  String call() => 'C.call called';
+}
+
+void testClassUnpromoted() {
+  B x = B();
+  var y = x = C(); // No implicit tearoff of `.call`, no promotion
+  x.expectStaticType<Exactly<B>>();
+  Expect.type<C>(x);
+  Expect.equals('C.call called', x());
+  y.expectStaticType<Exactly<C>>();
+  Expect.type<C>(y);
+  Expect.equals('C.call called', y());
+}
+
+void testFunctionUnpromoted() {
+  Object f() => 'f called';
+  Object Function() x = f;
+  var y = x = B(); // Implicit tearoff of `.call`, no promotion
+  x.expectStaticType<Exactly<Object Function()>>();
+  Expect.type<Object Function()>(x);
+  Expect.equals('B.call called', x());
+  y.expectStaticType<Exactly<Object Function()>>();
+  Expect.type<Object Function()>(y);
+  Expect.equals('B.call called', y());
+}
+
+void testObjectUnpromoted() {
+  Object x = 'initial value';
+  var y = x = B(); // No implicit tearoff of `.call`, no promotion
+  x.expectStaticType<Exactly<Object>>();
+  Expect.type<B>(x);
+  Expect.equals('B.call called', (x as B)());
+  y.expectStaticType<Exactly<B>>();
+  Expect.type<B>(y);
+  Expect.equals('B.call called', y());
+}
+
+main() {
+  testClassUnpromoted();
+  testFunctionUnpromoted();
+  testObjectUnpromoted();
+}
diff --git a/tools/VERSION b/tools/VERSION
index 2889eb3..029a3c9 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 137
+PRERELEASE 138
 PRERELEASE_PATCH 0
\ No newline at end of file