diff --git a/DEPS b/DEPS
index a514e15..5709b47 100644
--- a/DEPS
+++ b/DEPS
@@ -656,6 +656,15 @@
       ],
           "dep_type": "cipd",
   },
+  Var("dart_root") + "/benchmarks/NativeCall/native/out/": {
+      "packages": [
+          {
+              "package": "dart/benchmarks/nativecall",
+              "version": "w1JKzCIHSfDNIjqnioMUPq0moCXKwX67aUfhyrvw4E0C",
+          },
+      ],
+          "dep_type": "cipd",
+  },
   Var("dart_root") + "/third_party/browsers/chrome": {
       "packages": [
           {
diff --git a/benchmarks/NativeCall/dart/NativeCall.dart b/benchmarks/NativeCall/dart/NativeCall.dart
new file mode 100644
index 0000000..c453038
--- /dev/null
+++ b/benchmarks/NativeCall/dart/NativeCall.dart
@@ -0,0 +1,277 @@
+// 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.
+
+// These micro benchmarks track the speed of native calls.
+
+import 'dart:ffi';
+import 'dart:io';
+
+import 'package:benchmark_harness/benchmark_harness.dart';
+
+import 'dlopen_helper.dart';
+
+// Number of benchmark iterations per function.
+const N = 1000;
+
+// The native library that holds all the native functions being called.
+final nativeFunctionsLib = dlopenPlatformSpecific('native_functions',
+    path: Platform.script.resolve('../native/out/').path);
+
+final getRootLibraryUrl = nativeFunctionsLib
+    .lookupFunction<Handle Function(), Object Function()>('GetRootLibraryUrl');
+
+final setNativeResolverForTest = nativeFunctionsLib.lookupFunction<
+    Void Function(Handle), void Function(Object)>('SetNativeResolverForTest');
+
+//
+// Benchmark fixtures.
+//
+
+abstract class NativeCallBenchmarkBase extends BenchmarkBase {
+  NativeCallBenchmarkBase(String name) : super(name);
+
+  void expectEquals(actual, expected) {
+    if (actual != expected) {
+      throw Exception('$name: Unexpected result: $actual, expected $expected');
+    }
+  }
+
+  void expectApprox(actual, expected) {
+    if (0.999 * expected > actual || actual > 1.001 * expected) {
+      throw Exception('$name: Unexpected result: $actual, expected $expected');
+    }
+  }
+
+  void expectIdentical(actual, expected) {
+    if (!identical(actual, expected)) {
+      throw Exception('$name: Unexpected result: $actual, expected $expected');
+    }
+  }
+}
+
+class Uint8x01 extends NativeCallBenchmarkBase {
+  Uint8x01() : super('NativeCall.Uint8x01');
+
+  @pragma('vm:external-name', 'Function1Uint8')
+  external static int f(int a);
+
+  @override
+  void run() {
+    int x = 0;
+    for (int i = 0; i < N; i++) {
+      x += f(17);
+    }
+    expectEquals(x, N * 17 + N * 42);
+  }
+}
+
+class Int64x20 extends NativeCallBenchmarkBase {
+  Int64x20() : super('NativeCall.Int64x20');
+
+  @pragma('vm:external-name', 'Function20Int64')
+  external static int f(
+      int a,
+      int b,
+      int c,
+      int d,
+      int e,
+      int f,
+      int g,
+      int h,
+      int i,
+      int j,
+      int k,
+      int l,
+      int m,
+      int n,
+      int o,
+      int p,
+      int q,
+      int r,
+      int s,
+      int t);
+
+  @override
+  void run() {
+    int x = 0;
+    for (int i = 0; i < N; i++) {
+      x += f(i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i);
+    }
+    expectEquals(x, N * (N - 1) * 20 / 2);
+  }
+}
+
+class Doublex01 extends NativeCallBenchmarkBase {
+  Doublex01() : super('NativeCall.Doublex01');
+
+  @pragma('vm:external-name', 'Function1Double')
+  external static double f(double a);
+
+  @override
+  void run() {
+    double x = 0.0;
+    for (int i = 0; i < N; i++) {
+      x += f(17.0);
+    }
+    final double expected = N * (17.0 + 42.0);
+    expectApprox(x, expected);
+  }
+}
+
+class Doublex20 extends NativeCallBenchmarkBase {
+  Doublex20() : super('NativeCall.Doublex20');
+
+  @pragma('vm:external-name', 'Function20Double')
+  external static double f(
+      double a,
+      double b,
+      double c,
+      double d,
+      double e,
+      double f,
+      double g,
+      double h,
+      double i,
+      double j,
+      double k,
+      double l,
+      double m,
+      double n,
+      double o,
+      double p,
+      double q,
+      double r,
+      double s,
+      double t);
+
+  @override
+  void run() {
+    double x = 0;
+    for (int i = 0; i < N; i++) {
+      x += f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0,
+          13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0);
+    }
+    final double expected = N *
+        (1.0 +
+            2.0 +
+            3.0 +
+            4.0 +
+            5.0 +
+            6.0 +
+            7.0 +
+            8.0 +
+            9.0 +
+            10.0 +
+            11.0 +
+            12.0 +
+            13.0 +
+            14.0 +
+            15.0 +
+            16.0 +
+            17.0 +
+            18.0 +
+            19.0 +
+            20.0);
+    expectApprox(x, expected);
+  }
+}
+
+class MyClass {
+  int a;
+  MyClass(this.a);
+}
+
+class Handlex01 extends NativeCallBenchmarkBase {
+  Handlex01() : super('NativeCall.Handlex01');
+
+  @pragma('vm:external-name', 'Function1Handle')
+  external static Object f(Object a);
+
+  @override
+  void run() {
+    final p1 = MyClass(123);
+    Object x = p1;
+    for (int i = 0; i < N; i++) {
+      x = f(x);
+    }
+    expectIdentical(x, p1);
+  }
+}
+
+class Handlex20 extends NativeCallBenchmarkBase {
+  Handlex20() : super('NativeCall.Handlex20');
+
+  @pragma('vm:external-name', 'Function20Handle')
+  external static Object f(
+      Object a,
+      Object b,
+      Object c,
+      Object d,
+      Object e,
+      Object f,
+      Object g,
+      Object h,
+      Object i,
+      Object j,
+      Object k,
+      Object l,
+      Object m,
+      Object n,
+      Object o,
+      Object p,
+      Object q,
+      Object r,
+      Object s,
+      Object t);
+
+  @override
+  void run() {
+    final p1 = MyClass(123);
+    final p2 = MyClass(2);
+    final p3 = MyClass(3);
+    final p4 = MyClass(4);
+    final p5 = MyClass(5);
+    final p6 = MyClass(6);
+    final p7 = MyClass(7);
+    final p8 = MyClass(8);
+    final p9 = MyClass(9);
+    final p10 = MyClass(10);
+    final p11 = MyClass(11);
+    final p12 = MyClass(12);
+    final p13 = MyClass(13);
+    final p14 = MyClass(14);
+    final p15 = MyClass(15);
+    final p16 = MyClass(16);
+    final p17 = MyClass(17);
+    final p18 = MyClass(18);
+    final p19 = MyClass(19);
+    final p20 = MyClass(20);
+    Object x = p1;
+    for (int i = 0; i < N; i++) {
+      x = f(x, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15,
+          p16, p17, p18, p19, p20);
+    }
+    expectIdentical(x, p1);
+  }
+}
+
+//
+// Main driver.
+//
+
+void main() {
+  setNativeResolverForTest(getRootLibraryUrl());
+
+  final benchmarks = [
+    () => Uint8x01(),
+    () => Int64x20(),
+    () => Doublex01(),
+    () => Doublex20(),
+    () => Handlex01(),
+    () => Handlex20(),
+  ];
+  for (final benchmark in benchmarks) {
+    benchmark().report();
+  }
+}
diff --git a/benchmarks/NativeCall/dart/dlopen_helper.dart b/benchmarks/NativeCall/dart/dlopen_helper.dart
new file mode 100644
index 0000000..7e6129e
--- /dev/null
+++ b/benchmarks/NativeCall/dart/dlopen_helper.dart
@@ -0,0 +1,61 @@
+// 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 'dart:ffi';
+import 'dart:io';
+
+const arm = 'arm';
+const arm64 = 'arm64';
+const ia32 = 'ia32';
+const x64 = 'x64';
+
+// https://stackoverflow.com/questions/45125516/possible-values-for-uname-m
+final _unames = {
+  'arm': arm,
+  'aarch64_be': arm64,
+  'aarch64': arm64,
+  'armv8b': arm64,
+  'armv8l': arm64,
+  'i386': ia32,
+  'i686': ia32,
+  'x86_64': x64,
+};
+
+String _checkRunningMode(String architecture) {
+  // Check if we're running in 32bit mode.
+  final int pointerSize = sizeOf<IntPtr>();
+  if (pointerSize == 4 && architecture == x64) return ia32;
+  if (pointerSize == 4 && architecture == arm64) return arm;
+
+  return architecture;
+}
+
+String _architecture() {
+  final String uname = Process.runSync('uname', ['-m']).stdout.trim();
+  final String? architecture = _unames[uname];
+  if (architecture == null) {
+    throw Exception('Unrecognized architecture: "$uname"');
+  }
+
+  // Check if we're running in 32bit mode.
+  return _checkRunningMode(architecture);
+}
+
+String _platformPath(String name, String path) {
+  if (Platform.isMacOS || Platform.isIOS) {
+    return '${path}mac/${_architecture()}/lib$name.dylib';
+  }
+
+  if (Platform.isWindows) {
+    return '${path}win/${_checkRunningMode(x64)}/$name.dll';
+  }
+
+  // Unknown platforms default to Unix implementation.
+  return '${path}linux/${_architecture()}/lib$name.so';
+}
+
+DynamicLibrary dlopenPlatformSpecific(String name, {String path = ''}) {
+  final String fullPath = _platformPath(name, path);
+  return DynamicLibrary.open(fullPath);
+}
diff --git a/benchmarks/NativeCall/dart2/NativeCall.dart b/benchmarks/NativeCall/dart2/NativeCall.dart
new file mode 100644
index 0000000..c2dbf13
--- /dev/null
+++ b/benchmarks/NativeCall/dart2/NativeCall.dart
@@ -0,0 +1,279 @@
+// 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.
+
+// These micro benchmarks track the speed of native calls.
+
+// @dart=2.9
+
+import 'dart:ffi';
+import 'dart:io';
+
+import 'package:benchmark_harness/benchmark_harness.dart';
+
+import 'dlopen_helper.dart';
+
+// Number of benchmark iterations per function.
+const N = 1000;
+
+// The native library that holds all the native functions being called.
+final nativeFunctionsLib = dlopenPlatformSpecific('native_functions',
+    path: Platform.script.resolve('../native/out/').path);
+
+final getRootLibraryUrl = nativeFunctionsLib
+    .lookupFunction<Handle Function(), Object Function()>('GetRootLibraryUrl');
+
+final setNativeResolverForTest = nativeFunctionsLib.lookupFunction<
+    Void Function(Handle), void Function(Object)>('SetNativeResolverForTest');
+
+//
+// Benchmark fixtures.
+//
+
+abstract class NativeCallBenchmarkBase extends BenchmarkBase {
+  NativeCallBenchmarkBase(String name) : super(name);
+
+  void expectEquals(actual, expected) {
+    if (actual != expected) {
+      throw Exception('$name: Unexpected result: $actual, expected $expected');
+    }
+  }
+
+  void expectApprox(actual, expected) {
+    if (0.999 * expected > actual || actual > 1.001 * expected) {
+      throw Exception('$name: Unexpected result: $actual, expected $expected');
+    }
+  }
+
+  void expectIdentical(actual, expected) {
+    if (!identical(actual, expected)) {
+      throw Exception('$name: Unexpected result: $actual, expected $expected');
+    }
+  }
+}
+
+class Uint8x01 extends NativeCallBenchmarkBase {
+  Uint8x01() : super('NativeCall.Uint8x01');
+
+  @pragma('vm:external-name', 'Function1Uint8')
+  external static int f(int a);
+
+  @override
+  void run() {
+    int x = 0;
+    for (int i = 0; i < N; i++) {
+      x += f(17);
+    }
+    expectEquals(x, N * 17 + N * 42);
+  }
+}
+
+class Int64x20 extends NativeCallBenchmarkBase {
+  Int64x20() : super('NativeCall.Int64x20');
+
+  @pragma('vm:external-name', 'Function20Int64')
+  external static int f(
+      int a,
+      int b,
+      int c,
+      int d,
+      int e,
+      int f,
+      int g,
+      int h,
+      int i,
+      int j,
+      int k,
+      int l,
+      int m,
+      int n,
+      int o,
+      int p,
+      int q,
+      int r,
+      int s,
+      int t);
+
+  @override
+  void run() {
+    int x = 0;
+    for (int i = 0; i < N; i++) {
+      x += f(i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i, i);
+    }
+    expectEquals(x, N * (N - 1) * 20 / 2);
+  }
+}
+
+class Doublex01 extends NativeCallBenchmarkBase {
+  Doublex01() : super('NativeCall.Doublex01');
+
+  @pragma('vm:external-name', 'Function1Double')
+  external static double f(double a);
+
+  @override
+  void run() {
+    double x = 0.0;
+    for (int i = 0; i < N; i++) {
+      x += f(17.0);
+    }
+    final double expected = N * (17.0 + 42.0);
+    expectApprox(x, expected);
+  }
+}
+
+class Doublex20 extends NativeCallBenchmarkBase {
+  Doublex20() : super('NativeCall.Doublex20');
+
+  @pragma('vm:external-name', 'Function20Double')
+  external static double f(
+      double a,
+      double b,
+      double c,
+      double d,
+      double e,
+      double f,
+      double g,
+      double h,
+      double i,
+      double j,
+      double k,
+      double l,
+      double m,
+      double n,
+      double o,
+      double p,
+      double q,
+      double r,
+      double s,
+      double t);
+
+  @override
+  void run() {
+    double x = 0;
+    for (int i = 0; i < N; i++) {
+      x += f(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0,
+          13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0);
+    }
+    final double expected = N *
+        (1.0 +
+            2.0 +
+            3.0 +
+            4.0 +
+            5.0 +
+            6.0 +
+            7.0 +
+            8.0 +
+            9.0 +
+            10.0 +
+            11.0 +
+            12.0 +
+            13.0 +
+            14.0 +
+            15.0 +
+            16.0 +
+            17.0 +
+            18.0 +
+            19.0 +
+            20.0);
+    expectApprox(x, expected);
+  }
+}
+
+class MyClass {
+  int a;
+  MyClass(this.a);
+}
+
+class Handlex01 extends NativeCallBenchmarkBase {
+  Handlex01() : super('NativeCall.Handlex01');
+
+  @pragma('vm:external-name', 'Function1Handle')
+  external static Object f(Object a);
+
+  @override
+  void run() {
+    final p1 = MyClass(123);
+    Object x = p1;
+    for (int i = 0; i < N; i++) {
+      x = f(x);
+    }
+    expectIdentical(x, p1);
+  }
+}
+
+class Handlex20 extends NativeCallBenchmarkBase {
+  Handlex20() : super('NativeCall.Handlex20');
+
+  @pragma('vm:external-name', 'Function20Handle')
+  external static Object f(
+      Object a,
+      Object b,
+      Object c,
+      Object d,
+      Object e,
+      Object f,
+      Object g,
+      Object h,
+      Object i,
+      Object j,
+      Object k,
+      Object l,
+      Object m,
+      Object n,
+      Object o,
+      Object p,
+      Object q,
+      Object r,
+      Object s,
+      Object t);
+
+  @override
+  void run() {
+    final p1 = MyClass(123);
+    final p2 = MyClass(2);
+    final p3 = MyClass(3);
+    final p4 = MyClass(4);
+    final p5 = MyClass(5);
+    final p6 = MyClass(6);
+    final p7 = MyClass(7);
+    final p8 = MyClass(8);
+    final p9 = MyClass(9);
+    final p10 = MyClass(10);
+    final p11 = MyClass(11);
+    final p12 = MyClass(12);
+    final p13 = MyClass(13);
+    final p14 = MyClass(14);
+    final p15 = MyClass(15);
+    final p16 = MyClass(16);
+    final p17 = MyClass(17);
+    final p18 = MyClass(18);
+    final p19 = MyClass(19);
+    final p20 = MyClass(20);
+    Object x = p1;
+    for (int i = 0; i < N; i++) {
+      x = f(x, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15,
+          p16, p17, p18, p19, p20);
+    }
+    expectIdentical(x, p1);
+  }
+}
+
+//
+// Main driver.
+//
+
+void main() {
+  setNativeResolverForTest(getRootLibraryUrl());
+
+  final benchmarks = [
+    () => Uint8x01(),
+    () => Int64x20(),
+    () => Doublex01(),
+    () => Doublex20(),
+    () => Handlex01(),
+    () => Handlex20(),
+  ];
+  for (final benchmark in benchmarks) {
+    benchmark().report();
+  }
+}
diff --git a/benchmarks/NativeCall/dart2/dlopen_helper.dart b/benchmarks/NativeCall/dart2/dlopen_helper.dart
new file mode 100644
index 0000000..e6e3bfa
--- /dev/null
+++ b/benchmarks/NativeCall/dart2/dlopen_helper.dart
@@ -0,0 +1,63 @@
+// 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.
+
+// @dart=2.9
+
+import 'dart:ffi';
+import 'dart:io';
+
+const arm = 'arm';
+const arm64 = 'arm64';
+const ia32 = 'ia32';
+const x64 = 'x64';
+
+// https://stackoverflow.com/questions/45125516/possible-values-for-uname-m
+final _unames = {
+  'arm': arm,
+  'aarch64_be': arm64,
+  'aarch64': arm64,
+  'armv8b': arm64,
+  'armv8l': arm64,
+  'i386': ia32,
+  'i686': ia32,
+  'x86_64': x64,
+};
+
+String _checkRunningMode(String architecture) {
+  // Check if we're running in 32bit mode.
+  final int pointerSize = sizeOf<IntPtr>();
+  if (pointerSize == 4 && architecture == x64) return ia32;
+  if (pointerSize == 4 && architecture == arm64) return arm;
+
+  return architecture;
+}
+
+String _architecture() {
+  final String uname = Process.runSync('uname', ['-m']).stdout.trim();
+  final String architecture = _unames[uname];
+  if (architecture == null) {
+    throw Exception('Unrecognized architecture: "$uname"');
+  }
+
+  // Check if we're running in 32bit mode.
+  return _checkRunningMode(architecture);
+}
+
+String _platformPath(String name, {String path = ''}) {
+  if (Platform.isMacOS || Platform.isIOS) {
+    return '${path}mac/${_architecture()}/lib$name.dylib';
+  }
+
+  if (Platform.isWindows) {
+    return '${path}win/${_checkRunningMode(x64)}/$name.dll';
+  }
+
+  // Unknown platforms default to Unix implementation.
+  return '${path}linux/${_architecture()}/lib$name.so';
+}
+
+DynamicLibrary dlopenPlatformSpecific(String name, {String path}) {
+  final String fullPath = _platformPath(name, path: path);
+  return DynamicLibrary.open(fullPath);
+}
diff --git a/benchmarks/NativeCall/native/.gitignore b/benchmarks/NativeCall/native/.gitignore
new file mode 100644
index 0000000..e778c6f
--- /dev/null
+++ b/benchmarks/NativeCall/native/.gitignore
@@ -0,0 +1,5 @@
+# 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.
+
+out/
diff --git a/benchmarks/NativeCall/native/Makefile b/benchmarks/NativeCall/native/Makefile
new file mode 100644
index 0000000..9a2eb44
--- /dev/null
+++ b/benchmarks/NativeCall/native/Makefile
@@ -0,0 +1,57 @@
+# 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.
+
+# TODO(37531): Remove this makefile and build with sdk instead when
+# benchmark runner gets support for that.
+
+CC=gcc
+CCARM=arm-linux-gnueabihf-gcc
+CCARM64=aarch64-linux-gnu-gcc
+CFLAGS=-Wall -g -O -fPIC -I../../../runtime/
+
+.PHONY: all clean
+
+all: out/linux/x64/libnative_functions.so out/linux/ia32/libnative_functions.so out/linux/arm64/libnative_functions.so out/linux/arm/libnative_functions.so
+
+cipd:
+	cipd create -name dart/benchmarks/nativecall -in out -install-mode copy
+
+clean:
+	rm -rf *.o *.so out
+
+out/linux/x64:
+	mkdir -p out/linux/x64
+
+out/linux/x64/native_functions.o: native_functions.c | out/linux/x64
+	$(CC) $(CFLAGS) -c -o $@ native_functions.c
+
+out/linux/x64/libnative_functions.so: out/linux/x64/native_functions.o
+	$(CC) $(CFLAGS) -s -shared -o $@ out/linux/x64/native_functions.o
+
+out/linux/ia32:
+	mkdir -p out/linux/ia32
+
+out/linux/ia32/native_functions.o: native_functions.c | out/linux/ia32
+	$(CC) $(CFLAGS) -m32 -c -o $@ native_functions.c
+
+out/linux/ia32/libnative_functions.so: out/linux/ia32/native_functions.o
+	$(CC) $(CFLAGS) -m32 -s -shared -o $@ out/linux/ia32/native_functions.o
+
+out/linux/arm64:
+	mkdir -p out/linux/arm64
+
+out/linux/arm64/native_functions.o: native_functions.c | out/linux/arm64
+	$(CCARM64) $(CFLAGS) -c -o $@ native_functions.c
+
+out/linux/arm64/libnative_functions.so: out/linux/arm64/native_functions.o
+	$(CCARM64) $(CFLAGS) -s -shared -o $@ out/linux/arm64/native_functions.o
+
+out/linux/arm:
+	mkdir -p out/linux/arm
+
+out/linux/arm/native_functions.o: native_functions.c | out/linux/arm
+	$(CCARM) $(CFLAGS) -c -o $@ native_functions.c
+
+out/linux/arm/libnative_functions.so: out/linux/arm/native_functions.o
+	$(CCARM) $(CFLAGS) -s -shared -o $@ out/linux/arm/native_functions.o
diff --git a/benchmarks/NativeCall/native/native_functions.c b/benchmarks/NativeCall/native/native_functions.c
new file mode 100644
index 0000000..c19251d
--- /dev/null
+++ b/benchmarks/NativeCall/native/native_functions.c
@@ -0,0 +1,119 @@
+// 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.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// TODO(dartbug.com/40579): This requires static linking to either link
+// dart.exe or dart_precompiled_runtime.exe on Windows.
+// The sample currently fails on Windows in AOT mode.
+#include "include/dart_api.h"
+
+#define ENSURE(X)                                                              \
+  if (!(X)) {                                                                  \
+    fprintf(stderr, "%s:%d: %s\n", __FILE__, __LINE__, "Check failed: " #X);   \
+    exit(1);                                                                   \
+  }
+
+#define ENSURE_VALID(X) ENSURE(!Dart_IsError(X))
+
+//
+// Functions under test.
+//
+
+void Function1Uint8(Dart_NativeArguments args) {
+  int64_t arg = 0;
+  Dart_GetNativeIntegerArgument(args, /*index=*/0, &arg);
+  Dart_SetIntegerReturnValue(args, arg + 42);
+}
+
+void Function20Int64(Dart_NativeArguments args) {
+  int64_t arg = 0;
+  int64_t result = 0;
+  for (int i = 0; i < 20; i++) {
+    Dart_GetNativeIntegerArgument(args, /*index=*/i, &arg);
+    result += arg;
+  }
+  Dart_SetIntegerReturnValue(args, result);
+}
+
+void Function1Double(Dart_NativeArguments args) {
+  double arg = 0.0;
+  Dart_GetNativeDoubleArgument(args, /*index=*/0, &arg);
+  Dart_SetDoubleReturnValue(args, arg + 42.0);
+}
+
+void Function20Double(Dart_NativeArguments args) {
+  double arg = 0;
+  double result = 0;
+  for (int i = 0; i < 20; i++) {
+    Dart_GetNativeDoubleArgument(args, /*index=*/i, &arg);
+    result += arg;
+  }
+  Dart_SetDoubleReturnValue(args, result);
+}
+
+void Function1Handle(Dart_NativeArguments args) {
+  Dart_Handle arg = Dart_GetNativeArgument(args, /*index=*/0);
+  Dart_SetReturnValue(args, arg);
+}
+
+void Function20Handle(Dart_NativeArguments args) {
+  Dart_Handle arg = Dart_GetNativeArgument(args, /*index=*/0);
+  Dart_SetReturnValue(args, arg);
+}
+
+//
+// Test helpers.
+//
+
+DART_EXPORT Dart_Handle GetRootLibraryUrl() {
+  Dart_Handle root_lib = Dart_RootLibrary();
+  Dart_Handle lib_url = Dart_LibraryUrl(root_lib);
+  ENSURE_VALID(lib_url);
+  return lib_url;
+}
+
+Dart_NativeFunction NativeEntryResolver(Dart_Handle name,
+                                        int num_of_arguments,
+                                        bool* auto_setup_scope) {
+  ENSURE(Dart_IsString(name));
+
+  ENSURE(auto_setup_scope != NULL);
+  *auto_setup_scope = true;
+
+  const char* name_str = NULL;
+  ENSURE_VALID(Dart_StringToCString(name, &name_str));
+
+  if (strcmp(name_str, "Function1Uint8") == 0 && num_of_arguments == 1) {
+    return &Function1Uint8;
+  } else if (strcmp(name_str, "Function20Int64") == 0 &&
+             num_of_arguments == 20) {
+    return &Function20Int64;
+  } else if (strcmp(name_str, "Function1Double") == 0 &&
+             num_of_arguments == 1) {
+    return &Function1Double;
+  } else if (strcmp(name_str, "Function20Double") == 0 &&
+             num_of_arguments == 20) {
+    return &Function20Double;
+  } else if (strcmp(name_str, "Function1Handle") == 0 &&
+             num_of_arguments == 1) {
+    return &Function1Handle;
+  } else if (strcmp(name_str, "Function20Handle") == 0 &&
+             num_of_arguments == 20) {
+    return &Function20Handle;
+  }
+
+  // Unreachable in benchmark.
+  ENSURE(false);
+}
+
+DART_EXPORT void SetNativeResolverForTest(Dart_Handle url) {
+  Dart_Handle library = Dart_LookupLibrary(url);
+  ENSURE_VALID(library);
+  Dart_Handle result =
+      Dart_SetNativeResolver(library, &NativeEntryResolver, NULL);
+  ENSURE_VALID(result);
+}
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/abstract_producer.dart b/pkg/analysis_server/lib/src/services/correction/dart/abstract_producer.dart
index 56442ae..96389a0 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/abstract_producer.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/abstract_producer.dart
@@ -239,6 +239,10 @@
 
   final AstNode node;
 
+  /// A map keyed by lock names whose value is a list of the ranges for which a
+  /// lock has already been acquired.
+  final Map<String, List<SourceRange>> _lockRanges = {};
+
   CorrectionProducerContext._({
     required this.resolvedResult,
     required this.workspace,
@@ -454,6 +458,26 @@
 
   CorrectionUtils get utils => _context.utils;
 
+  /// Return `true` if this is the first request to lock the given [range] for
+  /// the lock with the given [lockName], or false if a lock for that range has
+  /// already been acquired.
+  ///
+  /// This method is used to allow correction producers to guard against
+  /// repeating changes that have already been made. For example, if multiple
+  /// arguments in an argument list have diagnostics reported against them and
+  /// the fix will fix all of the arguments, then the fix should be applied for
+  /// the first diagnostic and not for the others. A correction producer can
+  /// ensure this behavior by attempting to acquire a lock prior to creating any
+  /// edits, and only create the edits if a lock could be acquired.
+  bool acquireLockOnRange(String lockName, SourceRange range) {
+    var ranges = _context._lockRanges.putIfAbsent(lockName, () => []);
+    if (ranges.contains(range)) {
+      return false;
+    }
+    ranges.add(range);
+    return true;
+  }
+
   /// Configure this producer based on the [context].
   void configure(CorrectionProducerContext context) {
     _context = context;
diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/modify_parameters.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/modify_parameters.dart
index c71ea13..6ea735c 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/modify_parameters.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/modify_parameters.dart
@@ -59,6 +59,9 @@
       // This should only happen if `validate` didn't check this case.
       return;
     }
+    if (!fix.acquireLockOnRange('ModifyParameters', range.node(argumentList))) {
+      return;
+    }
     var arguments = argumentList.arguments;
     var argumentCount = arguments.length;
     var templateContext = TemplateContext(invocation, fix.utils);
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index 32ea11f..f0cabd7 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -29,6 +29,7 @@
 import 'package:analyzer/src/dart/analysis/session.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
 import 'package:analyzer/src/dart/analysis/testing_data.dart';
+import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/diagnostic/diagnostic.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/exception/exception.dart';
@@ -42,6 +43,7 @@
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary2/ast_binary_flags.dart';
 import 'package:analyzer/src/util/file_paths.dart' as file_paths;
+import 'package:analyzer/src/util/performance/operation_performance.dart';
 import 'package:meta/meta.dart';
 
 /// This class computes [AnalysisResult]s for Dart files.
@@ -1281,6 +1283,62 @@
     }
   }
 
+  ResolvedForCompletionResultImpl? resolveForCompletion({
+    required String path,
+    required int offset,
+    required OperationPerformanceImpl performance,
+  }) {
+    if (!_isAbsolutePath(path)) {
+      return null;
+    }
+
+    if (!_fsState.hasUri(path)) {
+      return null;
+    }
+
+    // Process pending changes.
+    while (_fileTracker.verifyChangedFilesIfNeeded()) {}
+
+    var file = _fsState.getFileForPath(path);
+
+    var library = file.isPart ? file.library : file;
+    if (library == null) {
+      return null;
+    }
+
+    libraryContext.load2(library);
+    var unitElement = libraryContext.computeUnitElement(library, file)
+        as CompilationUnitElementImpl;
+
+    var analyzer = LibraryAnalyzer(
+        analysisOptions as AnalysisOptionsImpl,
+        declaredVariables,
+        sourceFactory,
+        libraryContext.analysisContext,
+        libraryContext.elementFactory.libraryOfUri2(library.uriStr),
+        libraryContext.analysisSession.inheritanceManager,
+        library,
+        testingData: testingData);
+
+    var analysisResult = analyzer.analyzeForCompletion(
+      file: file,
+      offset: offset,
+      unitElement: unitElement,
+      performance: performance,
+    );
+
+    return ResolvedForCompletionResultImpl(
+      path: path,
+      uri: file.uri,
+      exists: file.exists,
+      content: file.content,
+      lineInfo: file.lineInfo,
+      parsedUnit: analysisResult.parsedUnit,
+      unitElement: unitElement,
+      resolvedNodes: analysisResult.resolvedNodes,
+    );
+  }
+
   void _addDeclaredVariablesToSignature(ApiSignature buffer) {
     var variableNames = declaredVariables.variableNames;
     buffer.addInt(variableNames.length);
diff --git a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
index 315b856..588e474 100644
--- a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
@@ -47,6 +47,7 @@
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/task/strong/checker.dart';
+import 'package:analyzer/src/util/performance/operation_performance.dart';
 import 'package:pub_semver/pub_semver.dart';
 
 var timerLibraryAnalyzer = Stopwatch();
@@ -56,6 +57,16 @@
 var timerLibraryAnalyzerSplicer = Stopwatch();
 var timerLibraryAnalyzerVerify = Stopwatch();
 
+class AnalysisForCompletionResult {
+  final CompilationUnit parsedUnit;
+  final List<AstNode> resolvedNodes;
+
+  AnalysisForCompletionResult({
+    required this.parsedUnit,
+    required this.resolvedNodes,
+  });
+}
+
 /// Analyzer of a single library.
 class LibraryAnalyzer {
   /// A marker object used to prevent the initialization of
@@ -191,6 +202,84 @@
     return results;
   }
 
+  AnalysisForCompletionResult analyzeForCompletion({
+    required FileState file,
+    required int offset,
+    required CompilationUnitElementImpl unitElement,
+    required OperationPerformanceImpl performance,
+  }) {
+    var parsedUnit = performance.run('parse', (performance) {
+      return _parse(file);
+    });
+
+    var node = NodeLocator(offset).searchWithin(parsedUnit);
+
+    if (_hasEmptyCompletionContext(node)) {
+      return AnalysisForCompletionResult(
+        parsedUnit: parsedUnit,
+        resolvedNodes: [],
+      );
+    }
+
+    var errorListener = RecordingErrorListener();
+
+    return performance.run('resolve', (performance) {
+      // TODO(scheglov) We don't need to do this for the whole unit.
+      parsedUnit.accept(
+        ResolutionVisitor(
+          unitElement: unitElement,
+          errorListener: errorListener,
+          featureSet: _libraryElement.featureSet,
+          nameScope: _libraryElement.scope,
+          elementWalker: ElementWalker.forCompilationUnit(
+            unitElement,
+            libraryFilePath: _library.path,
+            unitFilePath: file.path,
+          ),
+        ),
+      );
+
+      // TODO(scheglov) We don't need to do this for the whole unit.
+      parsedUnit.accept(ScopeResolverVisitor(
+          _libraryElement, file.source, _typeProvider, errorListener,
+          nameScope: _libraryElement.scope));
+
+      FlowAnalysisHelper flowAnalysisHelper = FlowAnalysisHelper(
+          _typeSystem, _testingData != null, _libraryElement.featureSet);
+      _testingData?.recordFlowAnalysisDataForTesting(
+          file.uri, flowAnalysisHelper.dataForTesting!);
+
+      var resolverVisitor = ResolverVisitor(_inheritance, _libraryElement,
+          file.source, _typeProvider, errorListener,
+          featureSet: _libraryElement.featureSet,
+          flowAnalysisHelper: flowAnalysisHelper);
+
+      var nodeToResolve = node?.thisOrAncestorMatching((e) {
+        return e.parent is ClassDeclaration ||
+            e.parent is CompilationUnit ||
+            e.parent is ExtensionDeclaration ||
+            e.parent is MixinDeclaration;
+      });
+      if (nodeToResolve != null) {
+        var can = resolverVisitor.prepareForResolving(nodeToResolve);
+        if (can) {
+          nodeToResolve.accept(resolverVisitor);
+          return AnalysisForCompletionResult(
+            parsedUnit: parsedUnit,
+            resolvedNodes: [nodeToResolve],
+          );
+        }
+      }
+
+      var resolvedUnits = analyze();
+      var resolvedUnit = resolvedUnits[file]!;
+      return AnalysisForCompletionResult(
+        parsedUnit: resolvedUnit.unit,
+        resolvedNodes: [resolvedUnit.unit],
+      );
+    });
+  }
+
   void _checkForInconsistentLanguageVersionOverride(
     Map<FileState, CompilationUnit> units,
   ) {
@@ -813,6 +902,54 @@
       }
     }
   }
+
+  static bool _hasEmptyCompletionContext(AstNode? node) {
+    if (node is DoubleLiteral || node is IntegerLiteral) {
+      return true;
+    }
+
+    if (node is SimpleIdentifier) {
+      var parent = node.parent;
+
+      if (parent is ConstructorDeclaration && parent.name == node) {
+        return true;
+      }
+
+      if (parent is ConstructorFieldInitializer && parent.fieldName == node) {
+        return true;
+      }
+
+      // We have a contributor that looks at the type, but it is syntactic.
+      if (parent is FormalParameter && parent.identifier == node) {
+        return true;
+      }
+
+      if (parent is FunctionDeclaration && parent.name == node) {
+        return true;
+      }
+
+      if (parent is MethodDeclaration && parent.name == node) {
+        return true;
+      }
+
+      // The name of a NamedType does not provide any context.
+      // So, we don't need to resolve anything.
+      if (parent is NamedType) {
+        return true;
+      }
+
+      if (parent is TypeParameter && parent.name == node) {
+        return true;
+      }
+
+      // We have a contributor that looks at the type, but it is syntactic.
+      if (parent is VariableDeclaration && parent.name == node) {
+        return true;
+      }
+    }
+
+    return false;
+  }
 }
 
 /// Analysis result for single file.
diff --git a/pkg/analyzer/lib/src/dart/analysis/results.dart b/pkg/analyzer/lib/src/dart/analysis/results.dart
index 4856a55..cc7a673 100644
--- a/pkg/analyzer/lib/src/dart/analysis/results.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/results.dart
@@ -167,6 +167,46 @@
   LineInfo get lineInfo => unit.lineInfo!;
 }
 
+class ResolvedForCompletionResultImpl {
+  final String path;
+  final Uri uri;
+  final bool exists;
+  final String content;
+  final LineInfo lineInfo;
+
+  /// The full parsed unit.
+  final CompilationUnit parsedUnit;
+
+  /// The full element for the unit.
+  final CompilationUnitElement unitElement;
+
+  /// Nodes from [parsedUnit] that were resolved to provide enough context
+  /// to perform completion. How much is enough depends on the location
+  /// where resolution for completion was requested, and our knowledge
+  /// how completion contributors work and what information they expect.
+  ///
+  /// This is usually a small subset of the whole unit - a method, a field.
+  /// It could be even empty if the location does not provide any context
+  /// information for any completion contributor, e.g. a type annotation.
+  /// But it could be the whole unit as well, if the location is not something
+  /// we have an optimization for.
+  ///
+  /// If this list is not empty, then the last node contains the requested
+  /// offset. Other nodes are provided mostly FYI.
+  final List<AstNode> resolvedNodes;
+
+  ResolvedForCompletionResultImpl({
+    required this.path,
+    required this.uri,
+    required this.exists,
+    required this.content,
+    required this.lineInfo,
+    required this.parsedUnit,
+    required this.unitElement,
+    required this.resolvedNodes,
+  });
+}
+
 class ResolvedLibraryResultImpl extends AnalysisResultImpl
     implements ResolvedLibraryResult {
   @override
diff --git a/pkg/analyzer/lib/src/generated/resolver.dart b/pkg/analyzer/lib/src/generated/resolver.dart
index 5f87d47..4bc6cdc 100644
--- a/pkg/analyzer/lib/src/generated/resolver.dart
+++ b/pkg/analyzer/lib/src/generated/resolver.dart
@@ -800,8 +800,10 @@
 
     if (parent is CompilationUnit) {
       return node is ClassDeclaration ||
+          node is Directive ||
           node is ExtensionDeclaration ||
-          node is FunctionDeclaration;
+          node is FunctionDeclaration ||
+          node is TopLevelVariableDeclaration;
     }
 
     void forClassElement(ClassElement parentElement) {
@@ -813,6 +815,11 @@
       return true;
     }
 
+    if (parent is ExtensionDeclaration) {
+      enclosingExtension = parent.declaredElement!;
+      return true;
+    }
+
     if (parent is MixinDeclaration) {
       forClassElement(parent.declaredElement!);
       return true;
diff --git a/pkg/analyzer/test/src/dart/analysis/resolve_for_completion_test.dart b/pkg/analyzer/test/src/dart/analysis/resolve_for_completion_test.dart
new file mode 100644
index 0000000..e241371
--- /dev/null
+++ b/pkg/analyzer/test/src/dart/analysis/resolve_for_completion_test.dart
@@ -0,0 +1,546 @@
+// 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:analyzer/src/dart/analysis/driver.dart';
+import 'package:analyzer/src/dart/analysis/results.dart';
+import 'package:analyzer/src/util/performance/operation_performance.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../resolution/context_collection_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(ResolveForCompletionTest);
+  });
+}
+
+@reflectiveTest
+class ResolveForCompletionTest extends PubPackageResolutionTest {
+  AnalysisDriver get testDriver {
+    return driverFor(testFilePathPlatform);
+  }
+
+  String get testFilePathPlatform => convertPath(testFilePath);
+
+  test_class__fieldDeclaration_type_namedType_name() async {
+    var result = _resolveTestCode(r'''
+class A {
+  var f1 = 0;
+  doub^ f2 = null;
+  var f3 = 1;
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_class__fieldDeclaration_type_namedType_typeArgument_name() async {
+    var result = _resolveTestCode(r'''
+class A {
+  var f1 = 0;
+  List<doub^>? f2 = null;
+  var f3 = 1;
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_class_extends_name() async {
+    var result = _resolveTestCode(r'''
+class A extends foo^ {}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_class_fieldDeclaration_initializer() async {
+    var result = _resolveTestCode(r'''
+class A {
+  var f1 = 0;
+  var f2 = foo^;
+  var f3 = 1;
+}
+''');
+
+    result.assertResolvedNodes([
+      'var f2 = foo;',
+    ]);
+  }
+
+  test_class_implements_name() async {
+    var result = _resolveTestCode(r'''
+class A implements foo^ {}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_class_methodDeclaration_body() async {
+    var result = _resolveTestCode(r'''
+class A {}
+
+class B {
+  void foo1() {}
+
+  void foo2() {
+    print(0);
+    bar^;
+    print(1);
+  }
+
+  void foo3() {}
+}
+''');
+
+    result.assertResolvedNodes([
+      'void foo2() {print(0); bar; print(1);}',
+    ]);
+  }
+
+  test_class_methodDeclaration_name() async {
+    var result = _resolveTestCode(r'''
+class A {
+  void foo^() {
+    print(0);
+  }
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_class_methodDeclaration_returnType_name() async {
+    var result = _resolveTestCode(r'''
+class A {
+  doub^ foo() {}
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_class_with_name() async {
+    var result = _resolveTestCode(r'''
+class A with foo^ {}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_constructorDeclaration_body() async {
+    var result = _resolveTestCode(r'''
+class A {}
+
+class B {
+  void foo1() {}
+
+  B() {
+    print(0);
+    bar^;
+    print(1);
+  }
+
+  void foo2() {}
+}
+''');
+
+    result.assertResolvedNodes([
+      'B() {print(0); bar; print(1);}',
+    ]);
+  }
+
+  test_constructorDeclaration_fieldInitializer_name() async {
+    var result = _resolveTestCode(r'''
+class A {}
+
+class B {
+  var f;
+
+  void foo1() {}
+
+  B(int a) : bar^ = 0 {
+    print(0);
+  }
+
+  void foo2() {}
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_constructorDeclaration_fieldInitializer_value() async {
+    var result = _resolveTestCode(r'''
+class A {
+  var f;
+
+  A(int a) : f = a + bar^ {
+    print(0);
+  }
+}
+''');
+
+    // TODO(scheglov) Resolve only the initializer.
+    result.assertResolvedNodes([
+      'A(int a) : f = a + bar {print(0);}',
+    ]);
+  }
+
+  test_constructorDeclaration_name() async {
+    var result = _resolveTestCode(r'''
+class A {
+  A.foo^() {
+    print(0);
+  }
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_doubleLiteral() async {
+    var result = _resolveTestCode(r'''
+var v = 1.2^;
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_extension_methodDeclaration_body() async {
+    var result = _resolveTestCode(r'''
+extension E on int {
+  void foo1() {}
+
+  void foo2() {
+    print(0);
+    bar^;
+    print(1);
+  }
+
+  void foo3() {}
+}
+''');
+
+    result.assertResolvedNodes([
+      'void foo2() {print(0); bar; print(1);}',
+    ]);
+  }
+
+  test_extension_methodDeclaration_name() async {
+    var result = _resolveTestCode(r'''
+extension E on int {
+  void foo^() {
+    print(0);
+  }
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_extension_methodDeclaration_returnType_name() async {
+    var result = _resolveTestCode(r'''
+extension E on int {
+  doub^ foo() {}
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_extension_on_name() async {
+    var result = _resolveTestCode(r'''
+extension E on int^ {
+  void foo() {}
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_functionDeclaration_body() async {
+    var result = _resolveTestCode(r'''
+void foo1() {}
+
+void foo2() {
+  print(0);
+  bar^;
+  print(1);
+}
+
+void foo3() {}
+''');
+
+    result.assertResolvedNodes([
+      'void foo2() {print(0); bar; print(1);}',
+    ]);
+  }
+
+  test_functionDeclaration_name() async {
+    var result = _resolveTestCode(r'''
+void foo^() {
+  print(0);
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_functionDeclaration_returnType_name() async {
+    var result = _resolveTestCode(r'''
+doub^ f() {}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_importDirective_show_name() async {
+    var result = _resolveTestCode(r'''
+import 'dart:async';
+import 'dart:math' show ^;
+import 'dart:io';
+''');
+
+    result.assertResolvedNodes([
+      "import 'dart:math' show ;",
+    ]);
+  }
+
+  test_importDirective_uri() async {
+    var result = _resolveTestCode(r'''
+import 'dart:async';
+import 'dart:ma^'
+import 'dart:io';
+''');
+
+    result.assertResolvedNodes([
+      "import 'dart:ma';",
+    ]);
+  }
+
+  test_integerLiteral() async {
+    var result = _resolveTestCode(r'''
+var v = 0^;
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_localVariableDeclaration_name() async {
+    var result = _resolveTestCode(r'''
+void f() {
+  var foo^
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_localVariableDeclaration_type_name() async {
+    var result = _resolveTestCode(r'''
+void f() {
+  doub^ a;
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_mixin_implements_name() async {
+    var result = _resolveTestCode(r'''
+mixin M implements foo^ {}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_mixin_methodDeclaration_body() async {
+    var result = _resolveTestCode(r'''
+class A {}
+
+mixin M {
+  void foo1() {}
+
+  void foo2() {
+    print(0);
+    bar^;
+    print(1);
+  }
+
+  void foo3() {}
+}
+''');
+
+    result.assertResolvedNodes([
+      'void foo2() {print(0); bar; print(1);}',
+    ]);
+  }
+
+  test_mixin_methodDeclaration_name() async {
+    var result = _resolveTestCode(r'''
+mixin M {
+  void foo^() {
+    print(0);
+  }
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_mixin_methodDeclaration_returnType_name() async {
+    var result = _resolveTestCode(r'''
+mixin M {
+  doub^ foo() {}
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_mixin_on_name() async {
+    var result = _resolveTestCode(r'''
+mixin M on foo^ {}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_processPendingChanges() async {
+    newFile(testFilePath, content: 'class A {}');
+
+    // Read the file.
+    testDriver.getFileSync(testFilePathPlatform);
+
+    // Should call `changeFile()`, and the driver must re-read the file.
+    var result = _resolveTestCode(r'''
+var v1 = 0;
+var v2 = v1.^;
+''');
+
+    result.assertResolvedNodes([
+      'var v2 = v1.;',
+    ]);
+  }
+
+  test_simpleFormalParameter_name() async {
+    var result = _resolveTestCode(r'''
+void f(doub^) {}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_simpleFormalParameter_type_name() async {
+    var result = _resolveTestCode(r'''
+void f(doub^ a) {}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_topLevelVariable_initializer() async {
+    var result = _resolveTestCode(r'''
+var v1 = 0;
+var v2 = foo^;
+var v3 = 1;
+''');
+
+    result.assertResolvedNodes([
+      'var v2 = foo;',
+    ]);
+  }
+
+  test_topLevelVariable_name() async {
+    var result = _resolveTestCode(r'''
+var v1 = 0;
+var v2^
+var v3 = 0;
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_topLevelVariable_type_namedType_name() async {
+    var result = _resolveTestCode(r'''
+var v1 = 0;
+doub^ v2 = null;
+var v3 = 1;
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_topLevelVariable_type_namedType_typeArgument_name() async {
+    var result = _resolveTestCode(r'''
+var v1 = 0;
+List<doub^>? v2 = null;
+var v3 = 1;
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  test_typedef_name_nothing() async {
+    var result = _resolveTestCode(r'''
+typedef F^
+''');
+
+    _assertWholeUnitResolved(result);
+  }
+
+  test_typeParameter_name() async {
+    var result = _resolveTestCode(r'''
+void f<T^>() {
+  print(0);
+}
+''');
+
+    result.assertResolvedNodes([]);
+  }
+
+  int _newFileWithOffset(String path, String content) {
+    var offset = content.indexOf('^');
+    expect(offset, isNot(equals(-1)), reason: 'missing ^');
+
+    var nextOffset = content.indexOf('^', offset + 1);
+    expect(nextOffset, equals(-1), reason: 'too many ^');
+
+    var before = content.substring(0, offset);
+    var after = content.substring(offset + 1);
+    newFile(path, content: before + after);
+
+    return offset;
+  }
+
+  ResolvedForCompletionResultImpl _resolveTestCode(String content) {
+    var path = testFilePathPlatform;
+    var offset = _newFileWithOffset(path, content);
+    testDriver.changeFile(path);
+
+    var performance = OperationPerformanceImpl('<root>');
+    var result = testDriver.resolveForCompletion(
+      path: path,
+      offset: offset,
+      performance: performance,
+    );
+    return result!;
+  }
+
+  static void _assertWholeUnitResolved(
+    ResolvedForCompletionResultImpl result,
+  ) {
+    expect(result.resolvedNodes, [result.parsedUnit]);
+  }
+}
+
+extension ResolvedForCompletionResultImplExtension
+    on ResolvedForCompletionResultImpl {
+  void assertResolvedNodes(List<String> expected) {
+    var actual = resolvedNodes.map((e) => '$e').toList();
+    expect(actual, expected);
+  }
+}
diff --git a/pkg/analyzer/test/src/dart/analysis/test_all.dart b/pkg/analyzer/test/src/dart/analysis/test_all.dart
index fbbd8d5..2c5030d 100644
--- a/pkg/analyzer/test/src/dart/analysis/test_all.dart
+++ b/pkg/analyzer/test/src/dart/analysis/test_all.dart
@@ -24,6 +24,7 @@
 import 'index_test.dart' as index;
 import 'mutex_test.dart' as mutex;
 import 'referenced_names_test.dart' as referenced_names;
+import 'resolve_for_completion_test.dart' as resolve_for_completion;
 import 'results/test_all.dart' as results;
 import 'search_test.dart' as search;
 import 'session_helper_test.dart' as session_helper;
@@ -53,6 +54,7 @@
     index.main();
     mutex.main();
     referenced_names.main();
+    resolve_for_completion.main();
     results.main();
     search.main();
     session.main();
diff --git a/runtime/vm/compiler/backend/flow_graph.cc b/runtime/vm/compiler/backend/flow_graph.cc
index 27ab909..a98f355 100644
--- a/runtime/vm/compiler/backend/flow_graph.cc
+++ b/runtime/vm/compiler/backend/flow_graph.cc
@@ -129,20 +129,6 @@
   }
 }
 
-Representation FlowGraph::UnboxedFieldRepresentationOf(const Field& field) {
-  switch (field.UnboxedFieldCid()) {
-    case kDoubleCid:
-      return kUnboxedDouble;
-    case kFloat32x4Cid:
-      return kUnboxedFloat32x4;
-    case kFloat64x2Cid:
-      return kUnboxedFloat64x2;
-    default:
-      RELEASE_ASSERT(field.is_non_nullable_integer());
-      return kUnboxedInt64;
-  }
-}
-
 void FlowGraph::ReplaceCurrentInstruction(ForwardInstructionIterator* iterator,
                                           Instruction* current,
                                           Instruction* replacement) {
diff --git a/runtime/vm/compiler/backend/flow_graph.h b/runtime/vm/compiler/backend/flow_graph.h
index 5aeec58..fe59272 100644
--- a/runtime/vm/compiler/backend/flow_graph.h
+++ b/runtime/vm/compiler/backend/flow_graph.h
@@ -155,8 +155,6 @@
 
   static Representation ReturnRepresentationOf(const Function& function);
 
-  static Representation UnboxedFieldRepresentationOf(const Field& field);
-
   // The number of variables (or boxes) inside the functions frame - meaning
   // below the frame pointer.  This does not include the expression stack.
   intptr_t num_stack_locals() const {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index 3531dec..d8ce910 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -203,30 +203,6 @@
   ArchSpecificInitialization();
 }
 
-bool FlowGraphCompiler::IsUnboxedField(const Field& field) {
-  // The `field.is_non_nullable_integer()` is set in the kernel loader and can
-  // only be set if we consume a AOT kernel (annotated with inferred types).
-  ASSERT(!field.is_non_nullable_integer() || FLAG_precompiled_mode);
-  const bool valid_class =
-      ((SupportsUnboxedDoubles() && (field.guarded_cid() == kDoubleCid)) ||
-       (SupportsUnboxedSimd128() && (field.guarded_cid() == kFloat32x4Cid)) ||
-       (SupportsUnboxedSimd128() && (field.guarded_cid() == kFloat64x2Cid)) ||
-       field.is_non_nullable_integer());
-  return field.is_unboxing_candidate() && !field.is_nullable() && valid_class;
-}
-
-bool FlowGraphCompiler::IsPotentialUnboxedField(const Field& field) {
-  if (FLAG_precompiled_mode) {
-    // kernel_loader.cc:ReadInferredType sets the guarded cid for fields based
-    // on inferred types from TFA (if available). The guarded cid is therefore
-    // proven to be correct.
-    return IsUnboxedField(field);
-  }
-  return field.is_unboxing_candidate() &&
-         (FlowGraphCompiler::IsUnboxedField(field) ||
-          (field.guarded_cid() == kIllegalCid));
-}
-
 void FlowGraphCompiler::InitCompiler() {
   compressed_stackmaps_builder_ =
       new (zone()) CompressedStackMapsBuilder(zone());
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.h b/runtime/vm/compiler/backend/flow_graph_compiler.h
index 25b699c..7669e78 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.h
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.h
@@ -465,9 +465,6 @@
   static bool SupportsHardwareDivision();
   static bool CanConvertInt64ToDouble();
 
-  static bool IsUnboxedField(const Field& field);
-  static bool IsPotentialUnboxedField(const Field& field);
-
   // Accessors.
   compiler::Assembler* assembler() const { return assembler_; }
   const ParsedFunction& parsed_function() const { return parsed_function_; }
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index 30240ef..2ba0335 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -894,17 +894,17 @@
 
 bool LoadFieldInstr::IsUnboxedDartFieldLoad() const {
   return slot().representation() == kTagged && slot().IsDartField() &&
-         FlowGraphCompiler::IsUnboxedField(slot().field());
+         slot().IsUnboxed();
 }
 
 bool LoadFieldInstr::IsPotentialUnboxedDartFieldLoad() const {
   return slot().representation() == kTagged && slot().IsDartField() &&
-         FlowGraphCompiler::IsPotentialUnboxedField(slot().field());
+         slot().IsPotentialUnboxed();
 }
 
 Representation LoadFieldInstr::representation() const {
   if (IsUnboxedDartFieldLoad() && CompilerState::Current().is_optimizing()) {
-    return FlowGraph::UnboxedFieldRepresentationOf(slot().field());
+    return slot().UnboxedRepresentation();
   }
   return slot().representation();
 }
@@ -963,12 +963,12 @@
 
 bool StoreInstanceFieldInstr::IsUnboxedDartFieldStore() const {
   return slot().representation() == kTagged && slot().IsDartField() &&
-         FlowGraphCompiler::IsUnboxedField(slot().field());
+         slot().IsUnboxed();
 }
 
 bool StoreInstanceFieldInstr::IsPotentialUnboxedDartFieldStore() const {
   return slot().representation() == kTagged && slot().IsDartField() &&
-         FlowGraphCompiler::IsPotentialUnboxedField(slot().field());
+         slot().IsPotentialUnboxed();
 }
 
 Representation StoreInstanceFieldInstr::RequiredInputRepresentation(
@@ -979,7 +979,7 @@
     return kTagged;
   }
   if (IsUnboxedDartFieldStore() && CompilerState::Current().is_optimizing()) {
-    return FlowGraph::UnboxedFieldRepresentationOf(slot().field());
+    return slot().UnboxedRepresentation();
   }
   return slot().representation();
 }
@@ -6145,7 +6145,7 @@
 }
 
 bool Utf8ScanInstr::IsScanFlagsUnboxed() const {
-  return FlowGraphCompiler::IsUnboxedField(scan_flags_field_.field());
+  return scan_flags_field_.IsUnboxed();
 }
 
 InvokeMathCFunctionInstr::InvokeMathCFunctionInstr(
diff --git a/runtime/vm/compiler/backend/slot.cc b/runtime/vm/compiler/backend/slot.cc
index b4b9920..75afb9a 100644
--- a/runtime/vm/compiler/backend/slot.cc
+++ b/runtime/vm/compiler/backend/slot.cc
@@ -331,6 +331,58 @@
   return SlotCache::Instance(thread).Canonicalize(slot);
 }
 
+FieldGuardState::FieldGuardState(const Field& field)
+    : state_(GuardedCidBits::encode(field.guarded_cid()) |
+             IsNonNullableIntegerBit::encode(field.is_non_nullable_integer()) |
+             IsUnboxingCandidateBit::encode(field.is_unboxing_candidate()) |
+             IsNullableBit::encode(field.is_nullable())) {}
+
+bool FieldGuardState::IsUnboxed() const {
+  ASSERT(!is_non_nullable_integer() || FLAG_precompiled_mode);
+  const bool valid_class = ((FlowGraphCompiler::SupportsUnboxedDoubles() &&
+                             (guarded_cid() == kDoubleCid)) ||
+                            (FlowGraphCompiler::SupportsUnboxedSimd128() &&
+                             (guarded_cid() == kFloat32x4Cid)) ||
+                            (FlowGraphCompiler::SupportsUnboxedSimd128() &&
+                             (guarded_cid() == kFloat64x2Cid)) ||
+                            is_non_nullable_integer());
+  return is_unboxing_candidate() && !is_nullable() && valid_class;
+}
+
+bool FieldGuardState::IsPotentialUnboxed() const {
+  if (FLAG_precompiled_mode) {
+    // kernel_loader.cc:ReadInferredType sets the guarded cid for fields based
+    // on inferred types from TFA (if available). The guarded cid is therefore
+    // proven to be correct.
+    return IsUnboxed();
+  }
+
+  return is_unboxing_candidate() &&
+         (IsUnboxed() || (guarded_cid() == kIllegalCid));
+}
+
+bool Slot::IsUnboxed() const {
+  return field_guard_state().IsUnboxed();
+}
+
+bool Slot::IsPotentialUnboxed() const {
+  return field_guard_state().IsPotentialUnboxed();
+}
+
+Representation Slot::UnboxedRepresentation() const {
+  switch (field_guard_state().guarded_cid()) {
+    case kDoubleCid:
+      return kUnboxedDouble;
+    case kFloat32x4Cid:
+      return kUnboxedFloat32x4;
+    case kFloat64x2Cid:
+      return kUnboxedFloat64x2;
+    default:
+      RELEASE_ASSERT(field_guard_state().is_non_nullable_integer());
+      return kUnboxedInt64;
+  }
+}
+
 const Slot& Slot::Get(const Field& field,
                       const ParsedFunction* parsed_function) {
   Thread* thread = Thread::Current();
@@ -354,16 +406,18 @@
     is_nullable = false;
   }
 
+  FieldGuardState field_guard_state(field);
+
   bool used_guarded_state = false;
-  if (field.guarded_cid() != kIllegalCid &&
-      field.guarded_cid() != kDynamicCid) {
+  if (field_guard_state.guarded_cid() != kIllegalCid &&
+      field_guard_state.guarded_cid() != kDynamicCid) {
     // Use guarded state if it is more precise then what we already have.
     if (nullable_cid == kDynamicCid) {
-      nullable_cid = field.guarded_cid();
+      nullable_cid = field_guard_state.guarded_cid();
       used_guarded_state = true;
     }
 
-    if (is_nullable && !field.is_nullable()) {
+    if (is_nullable && !field_guard_state.is_nullable()) {
       is_nullable = false;
       used_guarded_state = true;
     }
@@ -377,10 +431,10 @@
     used_guarded_state = false;
   }
 
-  if (field.is_non_nullable_integer()) {
+  if (field_guard_state.is_non_nullable_integer()) {
     ASSERT(FLAG_precompiled_mode);
     is_nullable = false;
-    if (FlowGraphCompiler::IsUnboxedField(field)) {
+    if (field_guard_state.IsUnboxed()) {
       rep = kUnboxedInt64;
     }
   }
@@ -397,7 +451,7 @@
           IsSentinelVisibleBit::encode(field.is_late() && field.is_final() &&
                                        !field.has_initializer()),
       nullable_cid, compiler::target::Field::OffsetOf(field), &field, &type,
-      rep));
+      rep, field_guard_state));
 
   // If properties of this slot were based on the guarded state make sure
   // to add the field to the list of guarded fields. Note that during background
diff --git a/runtime/vm/compiler/backend/slot.h b/runtime/vm/compiler/backend/slot.h
index a31e9a9..88c1dd8 100644
--- a/runtime/vm/compiler/backend/slot.h
+++ b/runtime/vm/compiler/backend/slot.h
@@ -166,6 +166,35 @@
   NONNULLABLE_BOXED_NATIVE_SLOTS_LIST(V)                                       \
   UNBOXED_NATIVE_SLOTS_LIST(V)
 
+class FieldGuardState {
+ public:
+  FieldGuardState() : state_(0) {}
+  explicit FieldGuardState(const Field& field);
+
+  intptr_t guarded_cid() const { return GuardedCidBits::decode(state_); }
+  bool is_non_nullable_integer() const {
+    return IsNonNullableIntegerBit::decode(state_);
+  }
+  bool is_unboxing_candidate() const {
+    return IsUnboxingCandidateBit::decode(state_);
+  }
+  bool is_nullable() const { return IsNullableBit::decode(state_); }
+
+  bool IsUnboxed() const;
+  bool IsPotentialUnboxed() const;
+
+ private:
+  using GuardedCidBits = BitField<int32_t, ClassIdTagType, 0, 16>;
+  using IsNonNullableIntegerBit =
+      BitField<int32_t, bool, GuardedCidBits::kNextBit, 1>;
+  using IsUnboxingCandidateBit =
+      BitField<int32_t, bool, IsNonNullableIntegerBit::kNextBit, 1>;
+  using IsNullableBit =
+      BitField<int32_t, bool, IsUnboxingCandidateBit::kNextBit, 1>;
+
+  const int32_t state_;
+};
+
 // Slot is an abstraction that describes an readable (and possibly writeable)
 // location within an object.
 //
@@ -298,6 +327,10 @@
     return kind() == Kind::kCapturedVariable || kind() == Kind::kContext_parent;
   }
 
+  bool IsUnboxed() const;
+  bool IsPotentialUnboxed() const;
+  Representation UnboxedRepresentation() const;
+
  private:
   friend class FlowGraphDeserializer;  // For GetNativeSlot.
 
@@ -307,12 +340,14 @@
        intptr_t offset_in_bytes,
        const void* data,
        const AbstractType* static_type,
-       Representation representation)
+       Representation representation,
+       const FieldGuardState& field_guard_state = FieldGuardState())
       : kind_(kind),
         flags_(bits),
         cid_(cid),
         offset_in_bytes_(offset_in_bytes),
         representation_(representation),
+        field_guard_state_(field_guard_state),
         data_(data),
         static_type_(static_type) {}
 
@@ -323,7 +358,8 @@
              other.offset_in_bytes_,
              other.data_,
              other.static_type_,
-             other.representation_) {}
+             other.representation_,
+             other.field_guard_state_) {}
 
   using IsImmutableBit = BitField<int8_t, bool, 0, 1>;
   using IsNullableBit = BitField<int8_t, bool, IsImmutableBit::kNextBit, 1>;
@@ -342,6 +378,10 @@
   static AcqRelAtomic<Slot*> native_fields_;
   static const Slot& GetNativeSlot(Kind kind);
 
+  const FieldGuardState& field_guard_state() const {
+    return field_guard_state_;
+  }
+
   const Kind kind_;
   const int8_t flags_;        // is_immutable, is_nullable
   const ClassIdTagType cid_;  // Concrete cid of a value or kDynamicCid.
@@ -349,6 +389,8 @@
   const intptr_t offset_in_bytes_;
   const Representation representation_;
 
+  const FieldGuardState field_guard_state_;
+
   // Kind dependent data:
   //   - name as a Dart String object for local variables;
   //   - name as a C string for native slots;
diff --git a/runtime/vm/compiler/graph_intrinsifier.cc b/runtime/vm/compiler/graph_intrinsifier.cc
index 85ed2b5..a0da87b 100644
--- a/runtime/vm/compiler/graph_intrinsifier.cc
+++ b/runtime/vm/compiler/graph_intrinsifier.cc
@@ -1050,7 +1050,8 @@
   // [Intrinsifier::CanIntrinsifyFieldAccessor])
   auto zone = flow_graph->zone();
   const auto& function = flow_graph->function();
-  ASSERT(Intrinsifier::CanIntrinsifyFieldAccessor(function));
+  ASSERT(
+      Intrinsifier::CanIntrinsifyFieldAccessor(flow_graph->parsed_function()));
 
   auto& field = Field::Handle(zone, function.accessor_field());
   if (CompilerState::Current().should_clone_fields()) {
@@ -1072,12 +1073,10 @@
 
   // We only support cases where we do not have to create a box (whose
   // allocation could fail).
-  ASSERT(function.HasUnboxedReturnValue() ||
-         !FlowGraphCompiler::IsUnboxedField(field));
+  ASSERT(function.HasUnboxedReturnValue() || !slot.IsUnboxed());
 
   // We might need to unbox the field value before returning.
-  if (function.HasUnboxedReturnValue() &&
-      !FlowGraphCompiler::IsUnboxedField(field)) {
+  if (function.HasUnboxedReturnValue() && !slot.IsUnboxed()) {
     ASSERT(FLAG_precompiled_mode);
     field_value = builder.AddUnboxInstr(
         FlowGraph::ReturnRepresentationOf(flow_graph->function()),
@@ -1093,21 +1092,19 @@
   // [Intrinsifier::CanIntrinsifyFieldAccessor])
   auto zone = flow_graph->zone();
   const auto& function = flow_graph->function();
-  ASSERT(Intrinsifier::CanIntrinsifyFieldAccessor(function));
+  ASSERT(
+      Intrinsifier::CanIntrinsifyFieldAccessor(flow_graph->parsed_function()));
 
   auto& field = Field::Handle(zone, function.accessor_field());
   if (CompilerState::Current().should_clone_fields()) {
     field = field.CloneFromOriginal();
   }
   ASSERT(field.is_instance() && !field.is_final());
-  ASSERT(!function.HasUnboxedParameters() ||
-         FlowGraphCompiler::IsUnboxedField(field));
-
   const auto& slot = Slot::Get(field, &flow_graph->parsed_function());
+  ASSERT(!function.HasUnboxedParameters() || slot.IsUnboxed());
 
-  const auto barrier_mode = FlowGraphCompiler::IsUnboxedField(field)
-                                ? kNoStoreBarrier
-                                : kEmitStoreBarrier;
+  const auto barrier_mode =
+      slot.IsUnboxed() ? kNoStoreBarrier : kEmitStoreBarrier;
 
   flow_graph->CreateCommonConstants();
   GraphEntryInstr* graph_entry = flow_graph->graph_entry();
@@ -1118,14 +1115,13 @@
   auto value = builder.AddParameter(1, /*with_frame=*/false);
   VerifyParameterIsBoxed(&builder, 0);
 
-  if (!function.HasUnboxedParameters() &&
-      FlowGraphCompiler::IsUnboxedField(field)) {
+  if (!function.HasUnboxedParameters() && slot.IsUnboxed()) {
     // We do not support storing to possibly guarded fields in JIT in graph
     // intrinsics.
     ASSERT(FLAG_precompiled_mode);
-    value = builder.AddUnboxInstr(
-        FlowGraph::UnboxedFieldRepresentationOf(field), new Value(value),
-        /*is_checked=*/true);
+    value =
+        builder.AddUnboxInstr(slot.UnboxedRepresentation(), new Value(value),
+                              /*is_checked=*/true);
   }
 
   builder.AddInstruction(new (zone) StoreInstanceFieldInstr(
diff --git a/runtime/vm/compiler/intrinsifier.cc b/runtime/vm/compiler/intrinsifier.cc
index f343f73..4ba80d9f 100644
--- a/runtime/vm/compiler/intrinsifier.cc
+++ b/runtime/vm/compiler/intrinsifier.cc
@@ -25,7 +25,9 @@
 
 namespace compiler {
 
-bool Intrinsifier::CanIntrinsify(const Function& function) {
+bool Intrinsifier::CanIntrinsify(const ParsedFunction& parsed_function) {
+  const Function& function = parsed_function.function();
+
   if (FLAG_trace_intrinsifier) {
     THR_Print("CanIntrinsify %s ->", function.ToQualifiedCString());
   }
@@ -45,7 +47,8 @@
     }
     return false;
   }
-  if (!function.is_intrinsic() && !CanIntrinsifyFieldAccessor(function)) {
+  if (!function.is_intrinsic() &&
+      !CanIntrinsifyFieldAccessor(parsed_function)) {
     if (FLAG_trace_intrinsifier) {
       THR_Print("No, not intrinsic function.\n");
     }
@@ -73,7 +76,10 @@
   return true;
 }
 
-bool Intrinsifier::CanIntrinsifyFieldAccessor(const Function& function) {
+bool Intrinsifier::CanIntrinsifyFieldAccessor(
+    const ParsedFunction& parsed_function) {
+  const Function& function = parsed_function.function();
+
   const bool is_getter = function.IsImplicitGetterFunction();
   const bool is_setter = function.IsImplicitSetterFunction();
   if (!is_getter && !is_setter) return false;
@@ -97,11 +103,13 @@
   // We only graph intrinsify implicit instance getters/setter for now.
   if (!field.is_instance()) return false;
 
+  const auto& slot = Slot::Get(field, &parsed_function);
+
   if (is_getter) {
     // We don't support complex getter cases.
     if (field.is_late() || field.needs_load_guard()) return false;
 
-    if (FlowGraphCompiler::IsPotentialUnboxedField(field)) {
+    if (slot.IsPotentialUnboxed()) {
       if (function.HasUnboxedReturnValue()) {
         // In AOT mode: Unboxed fields contain the unboxed value and can be
         // returned in unboxed form.
@@ -136,7 +144,7 @@
     // avoid the need for boxing (which we cannot do in the intrinsic).
     if (function.HasUnboxedParameters()) {
       ASSERT(FLAG_precompiled_mode);
-      if (!FlowGraphCompiler::IsUnboxedField(field)) {
+      if (!slot.IsUnboxed()) {
         return false;
       }
     }
@@ -253,8 +261,7 @@
 // Returns true if fall-through code can be omitted.
 bool Intrinsifier::Intrinsify(const ParsedFunction& parsed_function,
                               FlowGraphCompiler* compiler) {
-  const Function& function = parsed_function.function();
-  if (!CanIntrinsify(function)) {
+  if (!CanIntrinsify(parsed_function)) {
     return false;
   }
 
@@ -262,6 +269,7 @@
     return compiler->intrinsic_slow_path_label()->IsUnused();
   }
 
+  const Function& function = parsed_function.function();
 #if !defined(HASH_IN_OBJECT_HEADER)
   // These two are more complicated on 32 bit platforms, where the
   // identity hash is not stored in the header of the object.  We
diff --git a/runtime/vm/compiler/intrinsifier.h b/runtime/vm/compiler/intrinsifier.h
index 835f73f..681b606 100644
--- a/runtime/vm/compiler/intrinsifier.h
+++ b/runtime/vm/compiler/intrinsifier.h
@@ -35,8 +35,8 @@
 
  private:
   friend class GraphIntrinsifier;  // For CanIntrinsifyFieldAccessor.
-  static bool CanIntrinsify(const Function& function);
-  static bool CanIntrinsifyFieldAccessor(const Function& function);
+  static bool CanIntrinsify(const ParsedFunction& parsed_function);
+  static bool CanIntrinsifyFieldAccessor(const ParsedFunction& parsed_function);
 };
 
 }  // namespace compiler
diff --git a/tools/VERSION b/tools/VERSION
index 8abe925..e9eadd2 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 15
 PATCH 0
-PRERELEASE 286
+PRERELEASE 287
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/bots/try_benchmarks.sh b/tools/bots/try_benchmarks.sh
index 75f7375..d8ed384 100755
--- a/tools/bots/try_benchmarks.sh
+++ b/tools/bots/try_benchmarks.sh
@@ -184,6 +184,8 @@
     out/ReleaseIA32/run_vm_tests --dfe=out/ReleaseIA32/kernel-service.dart.snapshot --sound-null-safety UseDartApi
     out/ReleaseIA32/dart --profile-period=10000 --packages=.packages benchmarks/Example/dart2/Example.dart
     out/ReleaseIA32/dart --sound-null-safety --profile-period=10000 --packages=.packages benchmarks/Example/dart/Example.dart
+    out/ReleaseIA32/dart benchmarks/NativeCall/dart2/NativeCall.dart
+    out/ReleaseIA32/dart --sound-null-safety benchmarks/NativeCall/dart/NativeCall.dart
     out/ReleaseIA32/dart benchmarks/FfiBoringssl/dart2/FfiBoringssl.dart
     out/ReleaseIA32/dart --sound-null-safety benchmarks/FfiBoringssl/dart/FfiBoringssl.dart
     out/ReleaseIA32/dart benchmarks/FfiCall/dart2/FfiCall.dart