diff --git a/pkg/vm/lib/transformations/ffi_native.dart b/pkg/vm/lib/transformations/ffi_native.dart
index 0752ed2..3427f28 100644
--- a/pkg/vm/lib/transformations/ffi_native.dart
+++ b/pkg/vm/lib/transformations/ffi_native.dart
@@ -103,9 +103,9 @@
         node.function.computeThisFunctionType(Nullability.nonNullable);
     // Double Function(Double)
     final nativeType = annotationConst.typeArguments[0] as FunctionType;
-    // InterfaceType(NativeFunction<Double Function(Double)>*)
-    final DartType nativeInterfaceType =
-        InterfaceType(nativeFunctionClass, Nullability.legacy, [nativeType]);
+    // InterfaceType(NativeFunction<Double Function(Double)>)
+    final DartType nativeInterfaceType = InterfaceType(
+        nativeFunctionClass, Nullability.nonNullable, [nativeType]);
 
     // Derive number of arguments from the native function signature.
     final args_n = nativeType.positionalParameters.length;
diff --git a/pkg/vm/lib/transformations/ffi_use_sites.dart b/pkg/vm/lib/transformations/ffi_use_sites.dart
index a90f1ec..2dc593a 100644
--- a/pkg/vm/lib/transformations/ffi_use_sites.dart
+++ b/pkg/vm/lib/transformations/ffi_use_sites.dart
@@ -398,7 +398,7 @@
                   env.isSubtypeOf(ffiParams[i], pointerType,
                       SubtypeCheckMode.ignoringNullabilities)) {
                 // final NativeFieldWrapperClass1 #t1 = MyNFWC1();.
-                final tmpPtr = VariableDeclaration('',
+                final tmpPtr = VariableDeclaration(null,
                     initializer: origArgs[i],
                     type: nativeFieldWrapperClassType,
                     isFinal: true);
@@ -419,7 +419,7 @@
               }
               // Note: We also evaluate, and assign temporaries for, non-wrapped
               // arguments as we need to preserve the original evaluation order.
-              final tmpArg = VariableDeclaration('',
+              final tmpArg = VariableDeclaration(null,
                   initializer: origArgs[i], isFinal: true);
               tmpsArgs.add(tmpArg);
               callArgs.add(VariableGet(tmpArg));
@@ -434,7 +434,7 @@
             //   reachabilityFence(#t1);
             // } => #t0
             final tmpResult =
-                VariableDeclaration('', type: target.function.returnType);
+                VariableDeclaration(null, type: target.function.returnType);
             return BlockExpression(
               Block([
                 tmpResult,
diff --git a/pkg/vm/test/transformations/ffinative_test.dart b/pkg/vm/test/transformations/ffinative_test.dart
new file mode 100644
index 0000000..76eba47
--- /dev/null
+++ b/pkg/vm/test/transformations/ffinative_test.dart
@@ -0,0 +1,58 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+
+import 'package:kernel/ast.dart';
+import 'package:kernel/kernel.dart';
+import 'package:kernel/reference_from_index.dart';
+import 'package:kernel/target/targets.dart';
+import 'package:kernel/verifier.dart';
+
+import 'package:test/test.dart';
+
+import 'package:vm/transformations/ffi_native.dart' show transformLibraries;
+
+import '../common_test_utils.dart';
+
+final String pkgVmDir = Platform.script.resolve('../..').toFilePath();
+
+class TestDiagnosticReporter extends DiagnosticReporter<Object, Object> {
+  @override
+  void report(Object message, int charOffset, int length, Uri? fileUri,
+      {List<Object>? context}) {/* nop */}
+}
+
+runTestCase(Uri source) async {
+  final target = TestingVmTarget(TargetFlags());
+
+  Component component = await compileTestCaseToKernelProgram(source,
+      target: target, experimentalFlags: ['generic-metadata']);
+
+  final ReferenceFromIndex? referenceFromIndex = null;
+  final DiagnosticReporter diagnosticReporter = TestDiagnosticReporter();
+
+  transformLibraries(
+      component, component.libraries, diagnosticReporter, referenceFromIndex);
+
+  verifyComponent(component);
+
+  final actual = kernelLibraryToString(component.mainMethod!.enclosingLibrary);
+
+  compareResultWithExpectationsFile(source, actual);
+}
+
+main() {
+  group('ffi-transformations', () {
+    final testCasesDir = Directory(pkgVmDir + '/testcases/transformations/ffi');
+
+    for (var entry in testCasesDir
+        .listSync(recursive: true, followLinks: false)
+        .reversed) {
+      if (entry.path.endsWith(".dart")) {
+        test(entry.path, () => runTestCase(entry.uri));
+      }
+    }
+  });
+}
diff --git a/pkg/vm/testcases/transformations/ffi/ffinative.dart b/pkg/vm/testcases/transformations/ffi/ffinative.dart
new file mode 100644
index 0000000..5cb2397
--- /dev/null
+++ b/pkg/vm/testcases/transformations/ffi/ffinative.dart
@@ -0,0 +1,27 @@
+// Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Tests for @FfiNative related transformations.
+
+// @dart=2.14
+
+import 'dart:ffi';
+import 'dart:nativewrappers';
+
+@FfiNative<IntPtr Function(IntPtr)>('ReturnIntPtr')
+external int returnIntPtr(int x);
+
+@FfiNative<IntPtr Function(IntPtr)>('ReturnIntPtr', isLeaf: true)
+external int returnIntPtrLeaf(int x);
+
+class Classy {
+  @FfiNative<IntPtr Function(IntPtr)>('ReturnIntPtr')
+  external static int returnIntPtrStatic(int x);
+}
+
+void main() {
+  returnIntPtr(13);
+  returnIntPtrLeaf(37);
+  Classy.returnIntPtrStatic(0xDE);
+}
diff --git a/pkg/vm/testcases/transformations/ffi/ffinative.dart.expect b/pkg/vm/testcases/transformations/ffi/ffinative.dart.expect
new file mode 100644
index 0000000..09cb43b
--- /dev/null
+++ b/pkg/vm/testcases/transformations/ffi/ffinative.dart.expect
@@ -0,0 +1,55 @@
+library #lib /*isNonNullableByDefault*/;
+import self as self;
+import "dart:core" as core;
+import "dart:ffi" as ffi;
+import "dart:_internal" as _in;
+
+import "dart:ffi";
+import "dart:nativewrappers";
+
+class Classy extends core::Object {
+  static final field (core::int) → core::int _@FfiNative_returnIntPtrStatic = ffi::_asFunctionInternal<(core::int) → core::int, (ffi::IntPtr*) →* ffi::IntPtr*>(ffi::_fromAddress<ffi::NativeFunction<(ffi::IntPtr*) →* ffi::IntPtr*>>(ffi::_ffi_resolver(#C1, #C2, #C3){(core::Object, core::Object, core::int) → core::int}), false)/*isLegacy*/;
+  synthetic constructor •() → self::Classy
+    : super core::Object::•()
+    ;
+  @#C5
+  static method returnIntPtrStatic(core::int x) → core::int
+    return self::Classy::_@FfiNative_returnIntPtrStatic(x){(core::int) → core::int};
+}
+static final field (core::int) → core::int _@FfiNative_returnIntPtr = ffi::_asFunctionInternal<(core::int) → core::int, (ffi::IntPtr*) →* ffi::IntPtr*>(ffi::_fromAddress<ffi::NativeFunction<(ffi::IntPtr*) →* ffi::IntPtr*>>(ffi::_ffi_resolver(#C1, #C2, #C3){(core::Object, core::Object, core::int) → core::int}), false)/*isLegacy*/;
+static final field (core::int) → core::int _@FfiNative_returnIntPtrLeaf = ffi::_asFunctionInternal<(core::int) → core::int, (ffi::IntPtr*) →* ffi::IntPtr*>(ffi::_fromAddress<ffi::NativeFunction<(ffi::IntPtr*) →* ffi::IntPtr*>>(ffi::_ffi_resolver(#C1, #C2, #C3){(core::Object, core::Object, core::int) → core::int}), true)/*isLegacy*/;
+@#C5
+static method returnIntPtr(core::int x) → core::int
+  return self::_@FfiNative_returnIntPtr(x){(core::int) → core::int};
+@#C7
+static method returnIntPtrLeaf(core::int x) → core::int
+  return self::_@FfiNative_returnIntPtrLeaf(x){(core::int) → core::int};
+static method main() → void {
+  block {
+    core::int #t1;
+    final dynamic #t2 = 13;
+    #t1 = self::returnIntPtr(#t2);
+    _in::reachabilityFence(#t2);
+  } =>#t1;
+  block {
+    core::int #t3;
+    final dynamic #t4 = 37;
+    #t3 = self::returnIntPtrLeaf(#t4);
+    _in::reachabilityFence(#t4);
+  } =>#t3;
+  block {
+    core::int #t5;
+    final dynamic #t6 = 222;
+    #t5 = self::Classy::returnIntPtrStatic(#t6);
+    _in::reachabilityFence(#t6);
+  } =>#t5;
+}
+constants  {
+  #C1 = "#lib"
+  #C2 = "ReturnIntPtr"
+  #C3 = 1
+  #C4 = false
+  #C5 = ffi::FfiNative<(ffi::IntPtr*) →* ffi::IntPtr*> {nativeName:#C2, isLeaf:#C4}
+  #C6 = true
+  #C7 = ffi::FfiNative<(ffi::IntPtr*) →* ffi::IntPtr*> {nativeName:#C2, isLeaf:#C6}
+}
diff --git a/tests/ffi/vmspecific_ffi_native_test.dart b/tests/ffi/vmspecific_ffi_native_test.dart
index 8838ebc..9caa53d 100644
--- a/tests/ffi/vmspecific_ffi_native_test.dart
+++ b/tests/ffi/vmspecific_ffi_native_test.dart
@@ -23,9 +23,6 @@
     nativeLib.lookupFunction<Void Function(Handle), void Function(Object)>(
         'SetFfiNativeResolverForTest');
 
-final triggerGC = nativeLib
-    .lookupFunction<Void Function(IntPtr), void Function(int)>('TriggerGC');
-
 @FfiNative<Handle Function(Handle, IntPtr, IntPtr)>(
     'Dart_SetNativeInstanceField')
 external Object setNativeInstanceField(Object obj, int index, int ptr);
@@ -71,38 +68,6 @@
 @FfiNative<IntPtr Function(IntPtr, Pointer<Void>)>('PassAsValueAndPointer')
 external int passAsValueAndPointer(int value, NativeFieldWrapperClass1 obj);
 
-// Allocate new native resource we can use to keep track of whether the
-// finalizer has run.
-@FfiNative<Pointer<Void> Function(IntPtr)>('AllocateResource')
-external Pointer<Void> allocateResource(int value);
-
-@FfiNative<Void Function(Pointer<Void>)>('DeleteResource')
-external void deleteResource(Pointer<Void> resource);
-
-// Set up the object's finalizer to reset the resource.
-@FfiNative<Void Function(Handle, Pointer<Void>)>('SetResourceFinalizer')
-external void setResourceFinalizer(
-    NativeFieldWrapperClass1 obj, Pointer<Void> resource);
-
-// Return the native resource's value.
-@FfiNative<IntPtr Function(Pointer<Void>)>('GetResourceValue')
-external int getResourceValue(Pointer<Void> resource);
-
-// Class which ties itself to a resource, resetting the value of the resource
-// when the instance gets collected.
-class ResourceResetter extends NativeFieldWrapperClass1 {
-  ResourceResetter(Pointer<Void> resource) {
-    setNativeInstanceField(this, 0, 0);
-    setResourceFinalizer(this, resource);
-  }
-}
-
-// Helper to embed triggerGC(..) as an expression.
-int triggerGCWrap() {
-  triggerGC(0);
-  return 0;
-}
-
 // Helpers for testing argumnent evaluation order is preserved.
 int state = 0;
 int setState(int value) {
@@ -141,22 +106,6 @@
     Expect.equals(123456, passAsPointer(cwnf));
   }
 
-  // Test that the transform to wrap NativeFieldWrapperClass1 objects in
-  // _getNativeField(..) doesn't violate the original argument's liveness.
-  final resource = allocateResource(314159);
-  Expect.equals(
-      314159,
-      passAsPointerAndValue(
-          // 1: Locally alloc. instance.
-          // If this gets wrapped in another call the instance does not live
-          // past the return of the wrapper call.
-          ResourceResetter(resource),
-          // 2: Force GC, to collect the above if it isn't being kept alive.
-          // 3: Check that the underlying (dummy) resource hasn't been
-          // "collected" (i.e. reset to 0).
-          triggerGCWrap() + getResourceValue(resource)));
-  deleteResource(resource);
-
   // Test that the order of argument evaluation is being preserved through the
   // transform wrapping NativeFieldWrapperClass1 objects.
   state = 0;