diff --git a/CHANGELOG.md b/CHANGELOG.md
index c2f101f..b76d62e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,201 @@
 
 ### Language
 
+- **[Constructor tearoffs][]**: **BETA PREVIEW**
+
+  Previous Dart versions allowed a method on an instance to be passed as a
+  closure, and similarly for static methods. This is commonly referred to as
+  "closurizing" or "tearing off" a method. Constructors were not previously
+  eligible for closurization, forcing users to explicitly write wrapper
+  functions when using constructors as first class functions, as in the calls to
+  `List.map` in the following example:
+
+  ```dart
+  class A {
+    int x;
+    A(this.x);
+    A.fromString(String s) : x = int.parse(s);
+  }
+
+  void main() {
+    var listOfInts = [1, 2, 3];
+    var listOfStrings = ["1", "2", "3"];
+    for(var a in listOfInts.map((x) => A(x))) {
+      print(a.x);
+    }
+    for(var a in listOfStrings.map((x) => A.fromString(x))) {
+      print(a.x);
+    }
+  }
+  ```
+
+  New in Dart 2.15, constructors are now allowed to be torn off. Named
+  constructors are closurized using their declared name (here `A.fromString`),
+  and unnamed closures are referred to for closurization using the keyword `new`
+  (here `A.new`). The example above may now be written as:
+
+  ```dart
+  class A {
+    int x;
+    A(this.x);
+    A.fromString(String s) : x = int.parse(s);
+  }
+
+  void main() {
+    var listOfInts = [1, 2, 3];
+    var listOfStrings = ["1", "2", "3"];
+    for(A a in listOfInts.map(A.new)) {
+      print(a.x);
+    }
+    for(A a in listOfStrings.map(A.fromString)) {
+      print(a.x);
+    }
+  }
+  ```
+
+  Constructors for generic classes may be torn off as generic functions, or
+  instantiated at the tear off site. So in the following code, the tear off
+  `G.new` used to initialize the variable `f` produces a generic function which
+  may be used to produce an instance of `G<T>` for any type `T` provided when
+  `f` is called. The tear off `G<String>.new` used to initialize the variable
+  `g` on the other hand produces a non-generic function which may only be used
+  to produce instances of type `G<String>`.
+
+  ```dart
+  class G<T> {
+    T x;
+    G(this.x);
+  }
+
+  void main() {
+    G<T> Function<T>(T x) f = G.new;
+    var x = f<int>(3);
+    G<String> Function(String y) g = G<String>.new;
+    var y = g("hello");
+  }
+  ```
+
+  The new constructor tearoff feature is currently in **BETA PREVIEW**. The
+  feature is enabled in beta releases only, and is still subject to breaking
+  changes. It is not fully supported by all tools and there may be known issues
+  with the tool support. Feedback on the feature is welcome, but it is not
+  recommended that production code use the feature until it has been released in
+  a stable version.
+
+  The new constructor tearoff feature is only available as part of the 2.15
+  [language version](https://dart.dev/guides/language/evolution). To use this
+  feature, you must set the lower bound on the sdk constraint for your package
+  to 2.15 or greater (if using a beta preview release, an sdk constraint of
+  `>=2.15.0-0` must be used).
+
+- **[Generic type literals][Explicit instantiation]**: **BETA PREVIEW**
+
+  Previous Dart versions allowed class names to be used as type literals. So
+  for example,`int` may be used as an expression, producing a value of type
+  `Type`. Generic classes (e.g. `List`) could be referred to by name as an
+  expression, but no type arguments could be provided and so only the `dynamic`
+  instantiation could be produced directly as an expression without using
+  indirect methods:
+
+  ```dart
+  // Workaround to capture generic type literals.
+  Type typeOf<T>() => T;
+
+  void main() {
+    var x = int; // The Type literal corresponding to `int`.
+    var y = List; // The Type literal corresponding to `List<dynamic>`.
+    // Use workaround to capture generic type literal.
+    var z = typeOf<List<int>>(); // The Type literal for `List<int>`.
+  }
+  ```
+
+  New in Dart 2.15, instantiations of generic classes may now be used as Type
+  literals:
+
+  ```dart
+  void main() {
+    var x = int; // The Type literal corresponding to `int`.
+    var y = List; // The Type literal corresponding to `List<dynamic>`.
+    var z = List<int>; // The Type literal corresponding to `List<int>`.
+  }
+  ```
+
+  The new generic type literal feature is currently in **BETA PREVIEW**. The
+  feature is enabled in beta releases only, and is still subject to breaking
+  changes. It is not fully supported by all tools and there may be known issues
+  with the tool support. Feedback on the feature is welcome, but it is not
+  recommended that production code use the feature until it has been released in
+  a stable version.
+
+  Generic type literals are only available as part of the 2.15 [language
+  version](https://dart.dev/guides/language/evolution). To use this feature, you
+  must set the lower bound on the sdk constraint for your package to 2.15 or
+  greater (if using a beta preview release, an sdk constraint of
+  `>=2.15.0-0` must be used).
+
+- **[Explicit generic method instantiations][Explicit instantiation]**: **BETA
+    PREVIEW**
+
+  Previous Dart versions allowed generic methods to be implicitly specialized
+  (or "instantiated") to non-generic versions when assigned to a location with a
+  compatible monomorphic type. Example:
+
+  ```dart
+  // The generic identity function.
+  T id<T>(T x) => x;
+
+  void main() {
+    // Initialize `intId` with a version of `id` implicitly specialized to
+    // `int`.
+    int Function(int) intId = id;
+    print(intId(3));
+    // Initialize `stringId` with a version of `id` implicitly specialized to
+    // `String`.
+    String Function(String) stringId = id;
+    print(stringId("hello"));
+  }
+  ```
+
+  New in Dart 2.15, generic methods may be explicitly instantiated using the
+  syntax `f<T>` where `f` is the generic method to specialize and `T` is the
+  type argument (in general, type arguments) to be used to specialize the
+  method. Example:
+
+  ```dart
+  // The generic identity function.
+  T id<T>(T x) => x;
+
+  void main() {
+    // Initialize `intId` with a version of `id` explicitly specialized to
+    // `int`.
+    var intId = id<int>;
+    print(intId(3));
+    // Initialize `stringId` with a version of `id` explicitly specialized to
+    // `String`.
+    var stringId = id<String>;
+    print(stringId("hello"));
+  }
+  ```
+
+  The new generic method instantation feature is currently in **BETA PREVIEW**.
+  The feature is enabled in beta releases only, and is still subject to breaking
+  changes. It is not fully supported by all tools and there may be known issues
+  with the tool support. Feedback on the feature is welcome, but it is not
+  recommended that production code use the feature until it has been released in
+  a stable version.
+
+  Explicit generic method instantiations are only available as part of the 2.15
+  [language version](https://dart.dev/guides/language/evolution). To use this
+  feature, you must set the lower bound on the sdk constraint for your package
+  to 2.15 or greater (if using a beta preview release, an sdk constraint of
+  `>=2.15.0-0` must be used).
+
+  [Constructor tearoffs]:
+        https://github.com/dart-lang/language/blob/master/accepted/future-releases/constructor-tearoffs/feature-specification.md
+
+  [Explicit instantiation]:
+        https://github.com/dart-lang/language/blob/master/accepted/future-releases/constructor-tearoffs/feature-specification.md#explicitly-instantiated-classes-and-functions
+
 - Annotations on type parameters of classes can no longer refer to class members
   without a prefix.  For example, this used to be permitted:
 
diff --git a/pkg/.gitignore b/pkg/.gitignore
index 6c1be22..b95fe80 100644
--- a/pkg/.gitignore
+++ b/pkg/.gitignore
@@ -7,5 +7,7 @@
 /*.vcxproj.user
 /*.vcxproj.filters
 /*.xcodeproj
+.dart_tool
 .idea/
+.packages
 analysis_server/language_model/
diff --git a/pkg/analysis_server/lib/src/services/correction/organize_imports.dart b/pkg/analysis_server/lib/src/services/correction/organize_imports.dart
index aacc03d..3708b48 100644
--- a/pkg/analysis_server/lib/src/services/correction/organize_imports.dart
+++ b/pkg/analysis_server/lib/src/services/correction/organize_imports.dart
@@ -350,23 +350,16 @@
   @override
   String toString() => '(priority=$priority; text=$text)';
 
+  /// Should keep these in sync! Copied from
+  /// https://github.com/dart-lang/linter/blob/658f497eef/lib/src/rules/directives_ordering.dart#L380-L387
+  /// Consider finding a way to share this code!
   static int _compareUri(String a, String b) {
-    var aList = _splitUri(a);
-    var bList = _splitUri(b);
-    int result;
-    if ((result = aList[0].compareTo(bList[0])) != 0) return result;
-    if ((result = aList[1].compareTo(bList[1])) != 0) return result;
-    return 0;
-  }
-
-  /// Split the given [uri] like `package:some.name/and/path.dart` into a list
-  /// like `[package:some.name, and/path.dart]`.
-  static List<String> _splitUri(String uri) {
-    var index = uri.indexOf('/');
-    if (index == -1) {
-      return <String>[uri, ''];
-    }
-    return <String>[uri.substring(0, index), uri.substring(index + 1)];
+    var indexA = a.indexOf('/');
+    var indexB = b.indexOf('/');
+    if (indexA == -1 || indexB == -1) return a.compareTo(b);
+    var result = a.substring(0, indexA).compareTo(b.substring(0, indexB));
+    if (result != 0) return result;
+    return a.substring(indexA + 1).compareTo(b.substring(indexB + 1));
   }
 }
 
diff --git a/pkg/analysis_server/test/src/services/correction/fix/organize_imports_test.dart b/pkg/analysis_server/test/src/services/correction/fix/organize_imports_test.dart
index 093dddd..4a54aa0 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/organize_imports_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/organize_imports_test.dart
@@ -40,4 +40,39 @@
 void f(Stream<String> args) { }
 ''');
   }
+
+  Future<void> test_organizePathImports() async {
+    newFile('/home/test/lib/a.dart', content: '''
+class A {
+  static void m() {}
+}
+''');
+    newFile('/home/test/lib/a/b.dart', content: '''
+class B {
+  static void m() {}
+}
+''');
+
+    await resolveTestCode('''
+import 'dart:async';
+import 'a/b.dart';
+import 'a.dart';
+
+void f(Stream<String> args) {
+  A.m();
+  B.m();
+}
+''');
+    await assertHasFix('''
+import 'dart:async';
+
+import 'a.dart';
+import 'a/b.dart';
+
+void f(Stream<String> args) {
+  A.m();
+  B.m();
+}
+''');
+  }
 }
diff --git a/pkg/vm/lib/transformations/type_flow/analysis.dart b/pkg/vm/lib/transformations/type_flow/analysis.dart
index 989ad83..625616f 100644
--- a/pkg/vm/lib/transformations/type_flow/analysis.dart
+++ b/pkg/vm/lib/transformations/type_flow/analysis.dart
@@ -1008,11 +1008,12 @@
       target = typeFlowAnalysis.hierarchyCache.hierarchy.getDispatchTarget(
           classNode, selector.name,
           setter: selector.isSetter);
-      if (target != null) {
-        _dispatchTargets[selector] = target;
-      }
+      target ??= _DispatchableInvocation.kNoSuchMethodMarker;
+      _dispatchTargets[selector] = target;
     }
-    return target;
+    return identical(target, _DispatchableInvocation.kNoSuchMethodMarker)
+        ? null
+        : target;
   }
 
   String dump() => "$this {supers: $supertypes}";
diff --git a/tools/VERSION b/tools/VERSION
index 7776bae..99dda00 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 15
 PATCH 0
-PRERELEASE 147
+PRERELEASE 148
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/bots/test_matrix.json b/tools/bots/test_matrix.json
index cc0f243..20a574e 100644
--- a/tools/bots/test_matrix.json
+++ b/tools/bots/test_matrix.json
@@ -2886,13 +2886,6 @@
           ],
           "shards": 6,
           "fileset": "web_platform_hostasserts_nnbd"
-        },
-        {
-          "name": "dart2js nnbd unit tests",
-          "arguments": [
-            "-nunittest-weak-asserts-no-sdk-linux",
-            "pkg//compiler/"
-          ]
         }
       ]
     },